BufferedImageMultiVideoSource.cpp

Go to the documentation of this file.

/*
 *  Copyright (C) Massimo Cora' 2006 <maxcvs@email.it>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 Library General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */


#include "BufferedImageMultiVideoSource.hh"

using namespace std;

BufferedImageMultiVideoSource::BufferedImageMultiVideoSource( unsigned int streams_num,
                                                                                                                         on_parsable_image_cb *f, 
                                                                                                                         void* parsable_image_callback_data,
                                                                                                                         BaseInputVideo *input_single_video ) : BaseInputVideo(),
                                                                                        _streams_num( streams_num ),
                                                                                        f_parsable_cb( f ),
                                                                                        _parsable_image_callback_data( parsable_image_callback_data ),
                                                                                        _input_single_video( input_single_video )
{
        _initialized = false;
        _streams_vector = NULL;

        // initialize single video device
        if ( _input_single_video->init_device () == true ) {
                DEBUG_PRINT("ERROR: _input_single_video->init_device () failed from BufferedImageMultiVideoSource ctor" );
        }
}

BufferedImageMultiVideoSource::~BufferedImageMultiVideoSource()
{
        list<IplImage*>* tmp_list;

        while ( (tmp_list = _streams_vector->back()) != NULL ) {

                // free the images stored in the list
                if ( !tmp_list->empty() ) {
                        IplImage *tmp_image;

                        while ( (tmp_image = tmp_list->front ()) != NULL ) {
                                cvReleaseImage( &tmp_image );
                                tmp_list->pop_front ();
                        }
                }

                delete tmp_list;
                _streams_vector->pop_back ();
        }

        delete _streams_vector;

        _initialized = false;
}

bool BufferedImageMultiVideoSource::init_device () 
{
        if ( _initialized )
                return true;

        _streams_vector = NULL;

        // initialize the streams accordingly to the streams_num
        if ( _streams_vector == NULL ) {
                _streams_vector = new vector< list<IplImage*>* >;
                for ( unsigned int i=0; i < _streams_num; i++ ) {
                        list<IplImage*> *tmp_stream = new list<IplImage*>;
                        _streams_vector->push_back( tmp_stream );
                }
        }

        _initialized = true;
        return true;
}

void BufferedImageMultiVideoSource::add_image_by_stream_id( IplImage *image, 
                                                                                        int stream_id, char* __unused__, void* callback_data )
{
        BufferedImageMultiVideoSource* klass;
        
        if ( callback_data != NULL )
                klass = (BufferedImageMultiVideoSource*)callback_data;
        else
                return;
        
        if ( !klass->_initialized ) {
                if ( klass->init_device () == false ) {
                        return;
                }
        }
                
//      DEBUG_PRINT("add_image_by_stream_id %d with size %d x %d\n", stream_id, image->width, image->height);
        klass->_streams_vector->at( stream_id )->push_back( image );
        return;
}

IplImage *BufferedImageMultiVideoSource::get_next_frame_by_stream_id ( int stream_id )
{
        IplImage *tmp_image, *res_image;

        if ( !_initialized ) {
                if ( init_device () == false ) {
                        DEBUG_PRINT ("device not initialized, returnning NULL from"
                                "IplImage *BufferedImageMultiVideoSource::get_next_frame_by_stream_id\n");
                        return NULL;
                }
        }

        // have we a available image? return it immediately!
        // check whether the list is empty
        if ( _streams_vector->at( stream_id )->empty () == false ) {
                list<IplImage*> *tmp_stream;

                tmp_stream = _streams_vector->at( stream_id );
                // retrieve the image and remove it from the list
                tmp_image = tmp_stream->front ();

                tmp_stream->pop_front ();
                return tmp_image;
        }

        // ok, that's not all. 
        // To avoid our queues to grow so much, we should check the number of their elements.
        // Say, if we found a list that has more than 5 elements, we should return NULL
        // here, so that others can be parsed, avoiding long-term memleaks.
        for ( int i = 0; i < (int)_streams_vector->size(); i++ ) {
                if ( _streams_vector->at(i)->size() > 5 )
                        return NULL;
        }

        // ok: now there will be three steps left to accomplish this method.
        // #1: grab an image from our single video source
        res_image = _input_single_video->get_next_frame();
        
        if ( res_image == NULL ) {
                DEBUG_PRINT ("ERROR: falied to retrieve frame from device.\n");
                return NULL;
        }

        // #2: pass the frame to the callback function which will parse it.
        // the callback can be some face detecting library. e.g. OmniStuff :)
        f_parsable_cb( res_image, this, _parsable_image_callback_data );

        cvReleaseImage( &res_image );

        // #3 meanwhile the face detecting library can have added some images throught
        // add_image_by_stream_id (). We will check this and perform the required tasks.
        
        // check whether the list is empty
        if ( _streams_vector->at( stream_id )->empty () ) {
                return NULL;
        }

        list<IplImage*> *tmp_stream;
        tmp_stream = _streams_vector->at( stream_id );

        // retrieve the image and remove it from the list
        tmp_image = tmp_stream->front ();

        tmp_stream->pop_front ();
        return tmp_image;
}

bool BufferedImageMultiVideoSource::is_multi_stream ()
{
        return true;
}

IplImage * BufferedImageMultiVideoSource::get_next_frame ()
{
        // well.. try to return something
        if ( _streams_num > 0 )
                return get_next_frame_by_stream_id( 0 );
        else
                return NULL;
}

---