/home/fayn/OpenKraken-dev/OpenKN-controller/src/LIN_DVCam.hpp

Go to the documentation of this file.

/***************************************************************************\
 * Copyright (C) by University Paris-Est - MISS team   
 * LIN_DVCam.hpp created in 03 2009.
 * Mail : biri@univ-mlv.fr                                        
 *                                                                                                         
 * This file is part of the OpenKraken-controller.
 *
 * The OpenKraken-controller is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * The OpenKraken-controller is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.      If not, see <http://www.gnu.org/licenses/>.
 *
\***************************************************************************/

/*
 * Anti-doublon
 */
#ifndef __OPENKN_CONTROLLER__LIN_DVCAM_HPP__
#define __OPENKN_CONTROLLER__LIN_DVCAM_HPP__

/*
 * Internal Includes
 */
#include "CameraController.hpp"

/*
 * External Includes
 */
#include <libiec61883/iec61883.h>
#include <boost/thread.hpp>

#include <libdv/dv_types.h>
#include <libdv/dv.h>

/*
 * Namespace
 */
namespace kn{

    struct DVCamParams : CameraParams
        {
        
        int port;

                DVCamParams(const int& p = 0,
                    const std::string& dn = "", 
                    const size_t& expectedwidth = 720, 
                    const size_t& expectedheight = 576)
                        :CameraParams(dn,expectedwidth,expectedheight),port(p) {}
        
        };



        class DVCam :CameraController
        {
        private:

                iec61883_dv_fb_t frame;

                raw1394handle_t handle;

                dv_decoder_t *td;

                unsigned int currentframe;

                static const size_t maxframe = 10;

                int pitches[1];

                unsigned char ***pixels;
                        
                bool isgrabbing;        

                bool isenable;

                boost::thread *thrd;
                        
                boost::mutex dvmutex;

                void Handler(void);

                int ReadFrame(unsigned char *data);

                static int callbackReadFrame(unsigned char *data, 
                                                                         int length, 
                                                                         int complete, 
                                                                         void *callback_data);

        void ResetHandler( void );
 
        static int ResetHandlerProxy( raw1394handle_t handle, unsigned int generation );

        public:

                        
                DVCam(void):CameraController(){
                        handle = 0;
                        isenable=false;
                        isgrabbing=false;
                        td=0;
                        pitches[0]=720*3;
                        pitches[1]=pitches[2]=0;
                        pixels = new unsigned char** [maxframe];
                        for(unsigned int i = 0; i < maxframe; ++i){
                                pixels[i] = new unsigned char* [3];
                                pixels[i][0] = new unsigned char [720*576*3];
                        }
                        thrd=0;
                        currentframe = 0;
                }

                ~DVCam(void){
                        closeDevice();
                        if(pixels){
                                for(unsigned int i = 0; i < maxframe; ++i){
                                        if(pixels[i]){
                                                if(pixels[i][0])
                                                        delete[] pixels[i][0];
                                                delete[] pixels[i];
                                        }
                                }
                                delete[] pixels;
                        }
                }

                void openDevice(const DVCamParams& params);

                void openDevice(void){openDevice(DVCamParams());}

                void closeDevice(void);

                void start(void);

                void stop();

                unsigned char* getImage(void);

                inline size_t width(void) const {return this->camwidth;}

                inline size_t height(void) const {return this->camheight;}

                inline bool isStarted(void) const {return isgrabbing;}

                inline bool isOpen(void) const {return isenable;}


        };
}

#endif

---