/home/fwph/code/wurde/rde/utils/PlaybackCamera.cpp

Go to the documentation of this file.

#include <PlaybackCamera.H>
#include <Logger.H>
#include <signal.h>
#include <opencv/highgui.h>

using namespace std;
using namespace WURDE;
using namespace WURDEVision;

/**************************************************************************************/

WURDEPlaybackCamera::WURDEPlaybackCamera(std::string name, std::map<std::string,std::string> options)
        :WURDECamera(name,options){


       m_init=false;

       buffMutex[0]=(pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
       buffMutex[1]=(pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
       buffMutex[2]=(pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;

       buffers[0]=NULL;
       buffers[1]=NULL;
       buffers[2]=NULL;
       currentBuffer=0;
       nextFrame=0;
       m_timer.setFrequency(30.0);
       g_logdebug << "Done loading. " << endl;
}

bool WURDEPlaybackCamera::init(){
        g_logdebug << "in init. " << endl;
       m_init=true;
       if(m_options.find("imageDirectory")!=m_options.end()){
               m_frameLoader.setPath(m_options["imageDirectory"]);
       }else{
               g_logerror << "Couldn't find playback directory." << endl;
               m_init=false;
               return false;
       }

       if(m_options.find("imageSuffix")!=m_options.end()){
               m_frameLoader.addPattern(m_options["imageSuffix"]);
       }else{
               g_logwarn << "No playbackImageSuffix, assuming .ppm" << endl;
               m_frameLoader.addPattern(".ppm");
       }

       if(m_options.find("imagePrefix")!=m_options.end()){
               m_frameLoader.addPattern(m_options["imagePrefix"]);           
       }

       if(m_options.find("imageDevice")!=m_options.end()){
               m_frameLoader.addPattern(m_options["imageDevice"]);
       }

       g_logdebug << "Opening directory " << endl;
       m_frameLoader.openDirectory();
       g_logdebug << "Done. " << endl;
       m_frameList=m_frameLoader.getSortedFileList();

       return true;
  
}

bool WURDEPlaybackCamera::startCapture(){
        init();
        g_logdebug << " starting capture. " << endl;
        m_timer.setFakeZeroTime(m_frameList[0].timestamp);
        thread_state=STATE_RUN;
        pthread_create(&m_captureThread,NULL,runPlaybackCameraCaptureThread,(void *)this);
        m_capturing=true;
        return true;
}

void WURDEPlaybackCamera::stopCapture(){
        m_capturing=false;
        thread_state=STATE_QUIT;
        pthread_join(m_captureThread,NULL);
        if(buffers[0]) cvReleaseImage(&buffers[0]);
        if(buffers[1]) cvReleaseImage(&buffers[1]);
        if(buffers[2]) cvReleaseImage(&buffers[2]);
        currentBuffer=0;
        nextFrame=0;
}

WURDEImage WURDEPlaybackCamera::captureRGB(){
        if(!m_haveRGB&&m_capturing){            
                pthread_mutex_lock(&buffMutex[currentBuffer]);
                m_imageRGB.first=timestamps[currentBuffer];
                m_imageRGB.second=buffers[currentBuffer];               
                m_haveRGB=true;
        }
        if(!m_imageRGB.second||!m_capturing){
                m_imageRGB.second=NULL;
                g_wurdeCamErrno=ERROR_IMAGE_NOT_AVAILABLE;
        }else{
                g_wurdeCamErrno=ERROR_NOERROR;
        }
        return m_imageRGB;
}


void WURDEPlaybackCamera::resetFrame(){
        m_haveRGB=false;
        pthread_mutex_unlock(&buffMutex[currentBuffer]);
}

void WURDEPlaybackCamera::captureThread(){
        unsigned int activeBuffer;
        bool haveLock;
        IplImage *readImage;
        while(thread_state==STATE_RUN){
                if(m_capturing){
                        if(nextFrame>=m_frameList.size()){
                                
                                m_capturing=false;
                        }else{
                                haveLock=false;
                                activeBuffer=currentBuffer+1;

                                // try to get a buffer mutex until we succeed on one 
                                // of them.
                                while(!haveLock){
                                        if(activeBuffer>2){
                                                activeBuffer=0;
                                        }
                                        if(pthread_mutex_trylock(&buffMutex[activeBuffer])==0){
                                                haveLock=true;
                                        }else{
                                                activeBuffer++;
                                        }
                                }

                                //free the old buffer
                                /*                              if(buffers[activeBuffer]){
                                        cvReleaseImage(&buffers[activeBuffer]);
                                        buffers[activeBuffer]=NULL;
                                        }*/
                                if(!buffers[activeBuffer]){
                                        buffers[activeBuffer]=cvCreateImage(cvSize(320, 240), IPL_DEPTH_8U, 3);
                                }
                                //                              g_logdebug << "Reading image " << m_frameList[nextFrame].filename.c_str() << endl;
                                readImage=cvLoadImage(m_frameList[nextFrame].filename.c_str());
                                cvConvertImage(readImage, buffers[activeBuffer], CV_CVTIMG_SWAP_RB);
                                cvReleaseImage(&readImage);
                                readImage=NULL;
                                timestamps[activeBuffer]=m_frameList[nextFrame].timestamp;
                                nextFrame++;
                                currentBuffer=activeBuffer;
                                pthread_mutex_unlock(&buffMutex[activeBuffer]);
                        }
                }
                m_timer.sleep();
                
        }
}

extern "C" {
        void *runPlaybackCameraCaptureThread(void *ptr){
                WURDEVision::WURDEPlaybackCamera *theCamera=(WURDEVision::WURDEPlaybackCamera *)ptr;
                theCamera->captureThread();
                pthread_exit(NULL);
        }
}

---