streamer_ctrl.cpp

Go to the documentation of this file.

/*
 *  Copyright (C) Massimo Cora' 2005 <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 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.
 */

//
// This class will be an interface between the gui and the Streaming part
// of the project.
// It will be a thread, using wxWidgets thread features
//


#include <wx/wx.h>
#include "streamer_ctrl.h"

//--------------------------------------------------------------------------
//

StreamerCtrlThread::StreamerCtrlThread( MainFrame * main_frame_instance ) :
                                        _main_frame_pointer( main_frame_instance ),
                                        _streaming_status( false ),
                                        _sub_session( NULL ),
                                        _streamerUCast( NULL ),
                                        _algo_simple( false ),
                                        _file_path( NULL ),
                                        _ctrl_lookup( NULL ),
                                        _ctrl_gcard( NULL )
{

}

//--------------------------------------------------------------------------
//

StreamerCtrlThread::~StreamerCtrlThread() {

        if ( _sub_session )
                delete _sub_session;

        if ( _streamerUCast )
                delete _streamerUCast;

        if ( _file_path )
                free( _file_path );
}

//--------------------------------------------------------------------------
// create the thread and initialize some useful data

void StreamerCtrlThread::Create(bool gcard_use, 
                                                                const wxString proto,
                                                                const wxString file_path,
                                                                int cam_num,
                                                                int num_of_streams /* = 1 */,
                                                                int audio_num /* = -1 */,
                                                                const wxString sub_session /* = "testStream" */, 
                                                                unsigned short port_rtsp /* = 8554 */,
                                                                unsigned int fps /* = 25 */) 
{
        // let's create the thread
        wxThread::Create();

        _cam_num = cam_num;
        _gcard_use = gcard_use;
        _num_of_streams = num_of_streams;
        _audio_num = audio_num;
        

        if ( proto.CompareTo( wxT("H263+") ) == 0) {
                _enc_proto = OSTREAM_ENCODING_H263P;
        }
        else if ( proto.CompareTo( wxT("MJPEG") ) == 0) {
                _enc_proto = OSTREAM_ENCODING_MJPEG;
        }
        else {
                _enc_proto = OSTREAM_ENCODING_NONE;
        }

        if ( file_path.IsEmpty () ) {
                _file_path = NULL;
        }
        else {
                _file_path = strdup( wxConvCurrent->cWX2MB(file_path) );
        }

        _sub_session = new wxString( sub_session );
        _port_rtsp = port_rtsp;
        _fps = fps;

        
        _streamerUCast = new OStreamUCast( StreamerCtrlThread::onParsableImage, this, num_of_streams );
        _ctrl_initialized = false;
}

//--------------------------------------------------------------------------
//

bool StreamerCtrlThread::isStreaming() 
{
        return _streaming_status;
}


//--------------------------------------------------------------------------
//

void StreamerCtrlThread::stopStreaming() 
{
        _streamerUCast->stopStreaming();
}


//--------------------------------------------------------------------------
// Thread entry: will be called after a Run() on this object

void *StreamerCtrlThread::Entry() {
        
        _streaming_status = true;
        _streamerUCast->startStreaming ( _enc_proto, 
                                                                         _file_path,
                                                                         _cam_num,
                                                                         _audio_num,
                                                                         wxConvCurrent->cWX2MB(*(_sub_session)), 
                                                                         _port_rtsp, 
                                                                         _fps );
        
        _streaming_status = false;

        // let's notify main_frame class that we are exiting.
        _main_frame_pointer->OnStreamerCtrlThreadEnd();

        return 0;
}

void StreamerCtrlThread::initializeOmniStuff( IplImage *image_to_parse,
                                                                                         void* buffered_image_multi_vstream_callback_data ) 
{
        if ( _gcard_use == false ) {
                OmniConversion<OmniFastLookupTable, int, IplImage, CvPoint> *conv;
                OmniFastLookupTable *fast_lookup;
                                        
                DEBUG_PRINT ("creating OmniFastLookupTable\n");

                // create the fastlookup table
                if ( !_main_frame_pointer->is_face_detect_options_set () ) {
                        DEBUG_PRINT("WARNING! !_main_frame_pointer->is_face_detect_options_set () \n");
                        return;
                }

                fast_lookup = new OmniFastLookupTable( _main_frame_pointer->GetMinRadius (),
                                                                                           _main_frame_pointer->GetMaxRadius (),
                                                                                           _main_frame_pointer->GetCenterX (),
                                                                                           _main_frame_pointer->GetCenterY (),
                                                                                           0,
                                                                                           _main_frame_pointer->GetFlippedModeStatus() );

                // conversion
                conv = new OmniConversion<OmniFastLookupTable, int, IplImage, CvPoint>( fast_lookup );
                if ( !conv->is_initialized () ) {
                        wxMessageDialog dlg1( NULL, 
                        wxT("Error initializing OmniFastLookupTable.") , wxT( "Error" ), wxOK );
                        dlg1.ShowModal();
                        return;
                }

                if ( _main_frame_pointer->GetAlgoSimpleStatus() ) {
                        const char **c_array;
                        wxArrayString *wx_array = _main_frame_pointer->GetCascadeArray ();
                        int c_size = _main_frame_pointer->GetCascadeSize ();

                        if ( c_size <= 0 ) {
                                wxMessageDialog dlg1( NULL, 
                                wxT("No cascade selected. You need at least one") , wxT( "Error" ), wxOK );
                                dlg1.ShowModal();
                                return;
                        }
                        c_array = (const char**)calloc(c_size, sizeof(char*));

                        for ( int i = 0; i < c_size; i++ ) {
                                c_array[i] = strdup( wxConvCurrent->cWX2MB( wx_array->Item(i) ) );
                        }


                        // instantiate the algorithm
                        _ctrl_lookup = new OmniAlgoSimpleDetection<OmniFastLookupTable, int, IplImage, CvPoint>( conv, 
                                                                                                image_to_parse, 
                                                                                                (const char**)c_array,
                                                                                                c_size,
                                                                                                _main_frame_pointer->GetFreezeFrameBound (),
                                                                                                _main_frame_pointer->GetTrackWindowHitrate ()
                                                                                                );

                        _ctrl_lookup->register_all_image_callbacks( StreamerCtrlThread::fake_create_image_context, 
                                                                                                          BufferedImageMultiVideoSource::add_image_by_stream_id,
                                                                                                          StreamerCtrlThread::fake_destroy_image_context,
                                                                                                          buffered_image_multi_vstream_callback_data
                                                                                                          );
                }
                else {
                        _ctrl_vr_lookup = new OmniAlgoVRFilterDetection
                                                                <OmniFastLookupTable, int, IplImage, CvPoint> ( conv, image_to_parse );

                        _ctrl_vr_lookup->register_all_image_callbacks( StreamerCtrlThread::fake_create_image_context,
                                                                                                                   BufferedImageMultiVideoSource::add_image_by_stream_id,
                                                                                                                   StreamerCtrlThread::fake_destroy_image_context,
                                                                                                               buffered_image_multi_vstream_callback_data
                                                                                                                   );
                }

                _ctrl_initialized = true;
        }
        else {          // we have a compatible graphic card and we want to use it
                OmniConversion<OmniGCardConverter, double, IplImage, CvPoint> *conv;
                OmniGCardConverter *gcard_converter;
                
                DEBUG_PRINT ("creating OmniGCardConverter\n");
                
                // create the gcard_converter class
                gcard_converter = new OmniGCardConverter( _main_frame_pointer->GetMinRadius(), 
                                                                                          _main_frame_pointer->GetMaxRadius(), 
                                                                                          _main_frame_pointer->GetCenterX(), 
                                                                                          _main_frame_pointer->GetCenterY(), 
                                                                                          image_to_parse->width,
                                                                                          image_to_parse->height,
                                                                                          "omnigcard",
                                                                                          "omnistuff/data/shaders/vertex_shader.cg",
                                                                                          "vertex_shader_main",
                                                                                          "omnistuff/data/shaders/pixel_shader.cg",
                                                                                          "pixel_shader_main",
                                                                                          _main_frame_pointer->GetFlippedModeStatus());

                // conversion
                conv = new OmniConversion<OmniGCardConverter, double, IplImage, CvPoint>( gcard_converter );
                if ( !conv->is_initialized () ) {
                        DEBUG_PRINT("Error initializing OmniGCardConverter");
                        delete conv;
                        gcard_converter = NULL;
                        return;
                }

                if ( _main_frame_pointer->GetAlgoSimpleStatus() ) {
                        const char **c_array;
                        wxArrayString *wx_array = _main_frame_pointer->GetCascadeArray ();
                        int c_size = _main_frame_pointer->GetCascadeSize ();

                        if ( c_size <= 0 ) {
                                DEBUG_PRINT("ERROR: bad number of cascaded selected");
                                return;
                        }
                        c_array = (const char**)calloc(c_size, sizeof(char*));

                        for ( int i = 0; i < c_size; i++ ) 
                                c_array[i] = strdup( wxConvCurrent->cWX2MB( wx_array->Item(i) ) );

                        // instantiate the algorithm
                        _ctrl_gcard = new OmniAlgoSimpleDetection<OmniGCardConverter, double, IplImage, CvPoint>( conv, 
                                                                                                        image_to_parse, 
                                                                                                        (const char**)c_array,
                                                                                                        c_size,
                                                                                                        _main_frame_pointer->GetFreezeFrameBound(),
                                                                                                        _main_frame_pointer->GetTrackWindowHitrate());

                        _ctrl_gcard->register_all_image_callbacks( StreamerCtrlThread::fake_create_image_context,
                                                                                                           BufferedImageMultiVideoSource::add_image_by_stream_id,
                                                                                                           StreamerCtrlThread::fake_destroy_image_context,
                                                                                                           buffered_image_multi_vstream_callback_data
                                                                                                          );
                }
                else {
                        _ctrl_vr_gcard = new OmniAlgoVRFilterDetection
                                <OmniGCardConverter, double, IplImage, CvPoint>( conv, image_to_parse );

                        _ctrl_vr_gcard->register_all_image_callbacks( StreamerCtrlThread::fake_create_image_context, 
                                                                                                                  BufferedImageMultiVideoSource::add_image_by_stream_id,
                                                                                                                  StreamerCtrlThread::fake_destroy_image_context,
                                                                                                              buffered_image_multi_vstream_callback_data
                                                                                                                 );
                }
                _ctrl_initialized = true;
        }
}

void StreamerCtrlThread::onParsableImage( IplImage* image_to_parse,
                                                                                void* buffered_image_multi_vstream_callback_data,
                                                                                void* callback_data )
{
        StreamerCtrlThread* klass;
        
        if ( image_to_parse == NULL ) {
                DEBUG_PRINT ("image_to_parse from void StreamerCtrlThread::onParsableImage is NULL\n");
                return;
        }
        
        if ( callback_data == NULL ) {
                DEBUG_PRINT ("WARNING: callback_data data is NULL into StreamerCtrlThread::onParsableImage\n");
                return;
        }

        klass = (StreamerCtrlThread*)callback_data;
        
        if ( klass->_ctrl_initialized == false ) {
                klass->initializeOmniStuff( image_to_parse, 
                                                                   buffered_image_multi_vstream_callback_data );
        }
        
        if ( klass->_gcard_use == true ) {
                if ( klass->_main_frame_pointer->GetAlgoSimpleStatus() ) {
            klass->_ctrl_gcard->loop_next_frame( image_to_parse );
                }
                else {
                        klass->_ctrl_vr_gcard->loop_next_frame( image_to_parse );
                }
        }
        else {
                if ( klass->_main_frame_pointer->GetAlgoSimpleStatus() ) {
                        klass->_ctrl_lookup->loop_next_frame( image_to_parse );
                }
                else {
                        klass->_ctrl_vr_lookup->loop_next_frame( image_to_parse );
                }
        }
}


void StreamerCtrlThread::fake_destroy_image_context( char* win_id, void* cb_data )
{
}

void StreamerCtrlThread::fake_create_image_context( char* win_id, void* cb_data )
{
}

---