receiver_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.
 */

#include "receiver_ctrl.h"

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

ReceiverCtrlThread::ReceiverCtrlThread( MainFrame * main_frame_instance ) :
                                _fmod_initialized( false ),
                                _main_frame_pointer( main_frame_instance ),
                                _receiving_status( false ),
                                _shutting_down( false ),
                                _gcard_use( false ),
                                _ctrl_initialized( false ),
                                _receiver( NULL )
{
}

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

ReceiverCtrlThread::~ReceiverCtrlThread() 
{
        if ( _receiver )
                delete _receiver;
}

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

void ReceiverCtrlThread::Create( const wxString destRTSPUrl, bool is_multi_stream /* = false */ ) 
{
        // let's create the thread
        wxThread::Create();

        _is_multi_stream = is_multi_stream;

        _receiver = new OStreamReceiver( (const char*)wxConvCurrent->cWX2MB(destRTSPUrl),
                ReceiverCtrlThread::onImageReceivedFromNet, this,
                ReceiverCtrlThread::onAudioFrameReceivedFromNet, this );

        _gcard_use = _main_frame_pointer->GetGCardUseStatus();
}


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

bool ReceiverCtrlThread::isReceiving() 
{
        return _receiving_status;
}

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

bool ReceiverCtrlThread::isShuttingDown() 
{
        return _shutting_down;
}

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

void ReceiverCtrlThread::StopReceiving() 
{
        _shutting_down = true;
        _receiver->stopReceiving();
}


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

void ReceiverCtrlThread::parseErrorStatus( int err_status ) 
{
        if ( err_status != ERROR_NORMAL_STATUS ) {

                wxString error;

                switch (err_status){

                        case ERROR_FAILED_SDP_DESCRIPTION:
                                error = wxT( "Error getting SDP description from URL." );
                                break;
                        case ERROR_FAILED_FILE_SINK_CREATION:
                                error = wxT( "Failed to create Filesink for this URL." );
                                break;
                        case ERROR_FAILED_TO_CREATE_RECEIVER:
                                error = wxT( "Unable to create receiver for this stream." );
                                break;  
                        case ERROR_FAILED_CREATE_RTSP_CLIENT:
                                error = wxT( "Error creating the stream client." );
                                break;
                        case ERROR_FAILED_CREATE_MEDIASESSION:
                                error = wxT( "Error creating MediaSession." );
                                break;
                        case ERROR_FAILED_SETUP_STREAMS:
                                error = wxT( "Failed to setup this media stream." );
                                break;
                        case ERROR_UNKOWN_ERROR:
                                error = wxT( "An error occurred preparing the stream to receive. STREAM CLOSED!!!" );
                                break;
                }

        // create any type of command event here
        wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, WORKER_EVENT );
        event.SetString( error );

        // send in a thread-safe way
        wxPostEvent( this->_main_frame_pointer, event );
        }
}


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

void *ReceiverCtrlThread::Entry() 
{
        int err_status;
        _receiving_status = true;

        if ( ( err_status = _receiver->isReadyToStream() ) == ERROR_NORMAL_STATUS ) {
                printf("gonna start receiving....\n");
                err_status = _receiver->startReceiving();
        }
        else {
                printf("some error occurred checking for ready to stream\n");
        }

        _receiving_status = false;
        _shutting_down = false;

        parseErrorStatus( err_status );

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

        return 0;
}


void ReceiverCtrlThread::notifyMainThread( IplImage* image_received, int stream_id )
{

        image_received_data_t *img_data = new image_received_data_t;

        // create any type of command event here
    wxCommandEvent event( wxEVT_COMMAND_MENU_SELECTED, IMAGE_RECEIVED_EVENT );

        img_data->image = image_received;
        img_data->stream_id = stream_id;

    event.SetClientData( img_data );

    // send in a thread-safe way
    wxPostEvent( _main_frame_pointer, event );

}


void ReceiverCtrlThread::fake_destroy_image_context( char*, void* ) 
{
}

void ReceiverCtrlThread::fake_create_image_context( char*, void* )
{
}

void ReceiverCtrlThread::ready_to_send_image( IplImage *image, int stream_id, char* __unused__, 
                                                                                void* callback_data )
{
        ReceiverCtrlThread *recv;
        
        recv = (ReceiverCtrlThread*)callback_data;

        recv->notifyMainThread( image, stream_id );
}


void ReceiverCtrlThread::initializeOmniStuff( IplImage *image_to_parse ) 
{
        if ( _gcard_use == false ) {
                OmniConversion<OmniFastLookupTable, int, IplImage, CvPoint> *conv;
                OmniFastLookupTable *fast_lookup;
                                        
                DEBUG_PRINT ("creating OmniFastLookupTable from receiver thread\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( ReceiverCtrlThread::fake_create_image_context, 
                                                                                                                ReceiverCtrlThread::ready_to_send_image,
                                                                                                                ReceiverCtrlThread::fake_destroy_image_context,
                                                                                                                this );
                }
                else {
                        _ctrl_vr_lookup = new OmniAlgoVRFilterDetection
                                                                <OmniFastLookupTable, int, IplImage, CvPoint> ( conv, image_to_parse );

                        _ctrl_vr_lookup->register_all_image_callbacks(  ReceiverCtrlThread::fake_create_image_context, 
                                                                                                                        ReceiverCtrlThread::ready_to_send_image,
                                                                                                                        ReceiverCtrlThread::fake_destroy_image_context,
                                                                                                                        this );
                }

                _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(  ReceiverCtrlThread::fake_create_image_context, 
                                                                                                                ReceiverCtrlThread::ready_to_send_image,
                                                                                                                ReceiverCtrlThread::fake_destroy_image_context,
                                                                                                                this );
                }
                else {
                        _ctrl_vr_gcard = new OmniAlgoVRFilterDetection
                                <OmniGCardConverter, double, IplImage, CvPoint>( conv, image_to_parse );

                        _ctrl_vr_gcard->register_all_image_callbacks(  ReceiverCtrlThread::fake_create_image_context, 
                                                                                                                ReceiverCtrlThread::ready_to_send_image,
                                                                                                                ReceiverCtrlThread::fake_destroy_image_context,
                                                                                                                this );
                }
                _ctrl_initialized = true;
        }
}

void ReceiverCtrlThread::doOmniStuffParsing( IplImage* image_to_parse, int stream_id ) 
{
        if ( image_to_parse == NULL ) {
                DEBUG_PRINT ("image_to_parse from void StreamerCtrlThread::onParsableImage is NULL\n");
                return;
        }
        
        if ( _ctrl_initialized == false ) {
                initializeOmniStuff( image_to_parse );
        }
        
        if ( _gcard_use == true ) {
                if ( _main_frame_pointer->GetAlgoSimpleStatus() ) {
            _ctrl_gcard->loop_next_frame( image_to_parse );
                }
                else {
                        _ctrl_vr_gcard->loop_next_frame( image_to_parse );
                }
        }
        else {
                if ( _main_frame_pointer->GetAlgoSimpleStatus() ) {
                        _ctrl_lookup->loop_next_frame( image_to_parse );
                }
                else {
                        _ctrl_vr_lookup->loop_next_frame( image_to_parse );
                }
        }
}

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

bool ReceiverCtrlThread::onImageReceivedFromNet( IplImage* image_received, 
                                                                                                int stream_id, const void *client_data ) 
{
        ReceiverCtrlThread *recv;
        
        recv = (ReceiverCtrlThread*)client_data;

        // image_received is an omnidirectional frame?
        if ( recv->_main_frame_pointer->is_face_detect_options_set()
                && recv->_is_multi_stream == false ) {
                recv->doOmniStuffParsing( image_received, stream_id );

                cvReleaseImage( &image_received );
        }
        else {
                // other kind of stream: multi or direct.
                recv->notifyMainThread( image_received, stream_id );
        }

        return true;
}



#define DROP_PACKET_BOUND               200000

//           +----- _read_data_prt;
//           |
//           v
//  [________#######################___]
//                                 ^-------g_prebuff_ptr
//                                  
//

static  int g_read_data_ptr;
static  int g_prebuff_ptr;
                
// the circular buffer
static  unsigned char *g_shared_buffer;
        
// size of circular buffer
static  unsigned int g_shared_buffer_size;
                
// it's (g_prebuff_ptr - _read_data_prt) in a circular fashion.
static  unsigned int g_available_bytes;

static  wxMutex *g_mutex_sound;

void ReceiverCtrlThread::ERRCHECK(FMOD_RESULT result)
{
        char buf[0xffff];
    if (result != FMOD_OK)
    {
        sprintf(buf, "FMOD error! (%d) %s\n", result, FMOD_ErrorString(result));
    }
}

FMOD_RESULT F_CALLBACK ReceiverCtrlThread::fmod_read_cb(void *handle, void *buffer, 
                                                                                   unsigned int requested_bytes, 
                                                                                   unsigned int *bytesread, void *userdata)
{
        DEBUG_PRINT("myread...");       
        wxMutexLocker lock(*g_mutex_sound);

        // this should never happen.
        if ( g_available_bytes <= 0 ) {
                                
                *bytesread = 0;
                // has the sound end?
                DEBUG_PRINT("TODO SPECIAL CASE!!\n");
                return FMOD_ERR_FILE_EOF;
        } 
        else if ( requested_bytes > g_available_bytes ) {               // better to return the available bytes 
                                                                                                                        // and then sleep a bit
                DEBUG_PRINT ("sizebytes > g_available_bytes\n");
                
                if ( (g_prebuff_ptr < g_read_data_ptr) && 
                        (g_available_bytes > g_shared_buffer_size - g_read_data_ptr)) {

                        int tmp_written = g_shared_buffer_size - g_read_data_ptr;
                        memcpy( buffer, &g_shared_buffer[g_read_data_ptr], tmp_written );
                        
                        // just to clarify the if(s)  :-)
                        g_read_data_ptr = 0;
                        
                        memcpy( buffer, &g_shared_buffer[0], g_available_bytes - tmp_written );
                                                
                        *bytesread = g_available_bytes;
                        
                        // we use all of them
                        g_available_bytes = 0;
                        
                        // update the _read_data_prt. We cyclic here.
                        g_read_data_ptr += g_available_bytes - tmp_written;
                        
                }
                else {
                        memcpy( buffer, &g_shared_buffer[g_read_data_ptr], g_available_bytes );
                        *bytesread = g_available_bytes;
                        g_read_data_ptr += g_available_bytes;
                        
                        g_available_bytes = 0;
                }               
        }
        else {          
                // the normal case
                DEBUG_PRINT (" requested sizebytes %d\n", requested_bytes );
                
                if ( (g_prebuff_ptr < g_read_data_ptr) && (requested_bytes > g_shared_buffer_size - g_read_data_ptr)) {
                        
                        int tmp_written = g_shared_buffer_size - g_read_data_ptr;
                        
                        memcpy( buffer, &g_shared_buffer[g_read_data_ptr], tmp_written );
                        
                        // just to clarify the if(s)  :-)
                        g_read_data_ptr = 0;
                        
                        memcpy( &((unsigned char*)buffer)[tmp_written], &g_shared_buffer[0], requested_bytes - tmp_written );

                        *bytesread = requested_bytes;
                        g_available_bytes -= requested_bytes;
                        
                        // update the _read_data_prt. We cyclic here.
                        g_read_data_ptr += requested_bytes - tmp_written;
                }
                else {
                        memcpy( buffer, &g_shared_buffer[g_read_data_ptr], requested_bytes );
                        *bytesread = requested_bytes;
                        g_available_bytes -= requested_bytes;
                        
                        g_read_data_ptr += requested_bytes;
                }               
        }

        
    return FMOD_OK;
}


FMOD_RESULT F_CALLBACK ReceiverCtrlThread::fmod_open_cb(const char *name, int unicode, 
                                                                                           unsigned int *filesize, void **handle, 
                                                                                           void **userdata)
{
        DEBUG_PRINT("myopen\n");
        
        *filesize = 10000000;
    return FMOD_OK;
}

FMOD_RESULT F_CALLBACK ReceiverCtrlThread::fmod_close_cb(void *handle, void *userdata)
{
        DEBUG_PRINT("myclose\n");       

        return FMOD_OK;
}

FMOD_RESULT F_CALLBACK ReceiverCtrlThread::fmod_seek_cb( void * handle, unsigned int pos, void * userdata )
{
        DEBUG_PRINT("myseek to pos %d\n", pos);
        return FMOD_OK;
}

void ReceiverCtrlThread::fmod_init ()
{
        _channel = 0;
    /*
        Create a System object and initialize.
    */
    _result = FMOD::System_Create(&_system);
    ERRCHECK( _result );

    _result = _system->getVersion(&_version);
    ERRCHECK( _result );

    if (_version < FMOD_VERSION)
    {
        DEBUG_PRINT("Error!  You are using an old version of FMOD %08x.  This program requires %08x\n", 
                           _version, FMOD_VERSION);
        return;
    }
        
                
    _result = _system->init( 32, FMOD_INIT_NORMAL, 0 );
    ERRCHECK( _result );

    _result = _system->setFileSystem( ReceiverCtrlThread::fmod_open_cb, 
                                                                          ReceiverCtrlThread::fmod_close_cb, 
                                                                          ReceiverCtrlThread::fmod_read_cb, 
                                                                          ReceiverCtrlThread::fmod_seek_cb,
                                                                          80000 );
        ERRCHECK( _result );

        g_mutex_sound = new wxMutex();

    
}


// will manage all the circular buffer stuff
void ReceiverCtrlThread::add_available_bytes( unsigned char* bytes_to_add_buff, unsigned int bytes_to_add_size )
{
        wxMutexLocker lock(*g_mutex_sound);

        // it can happen that the available_bytes collected are too much.
        // In that case we will drop them.
        if ( g_available_bytes > DROP_PACKET_BOUND )
                return;


        //           +----- g_prebuff_ptr
        //           |
        //           v
        //  [#########___________________########]
        //                              ^------- _read_data_prt
        //                                  
        //
        
        if ( g_prebuff_ptr < g_read_data_ptr ) {
                // we should not warning about the override ot the remaining g_read_data_ptr    
                // if we take a big g_shared_buffer. I.e. 1MB or more.
                memcpy( &g_shared_buffer[g_prebuff_ptr], bytes_to_add_buff, bytes_to_add_size );
                
                g_prebuff_ptr += bytes_to_add_size;
                g_available_bytes += bytes_to_add_size;
        }
        
        //           +----- _read_data_prt
        //           |                  __________  bytes_to_add_size > g_shared_buffer_size - g_prebuff_ptr
        //           v                  vvv 
        //  [________###################___]
        //                             ^------- g_prebuff_ptr
        //                                  
        //
        
        else if ( (g_prebuff_ptr > g_read_data_ptr) && 
                         (bytes_to_add_size > g_shared_buffer_size - g_prebuff_ptr) ) {
                                
                int tmp_written = g_shared_buffer_size - g_prebuff_ptr;
                memcpy( &g_shared_buffer[g_prebuff_ptr], bytes_to_add_buff, tmp_written );
                                 
                // cyclic here
                g_prebuff_ptr = 0;
                                 
                memcpy( &g_shared_buffer[g_prebuff_ptr], &bytes_to_add_buff[tmp_written], bytes_to_add_size - tmp_written );
                                 
                g_prebuff_ptr = bytes_to_add_size - tmp_written;
                g_available_bytes += bytes_to_add_size;
        }

        //           +----- _read_data_prt
        //           |      
        //           v      
        //  [________#############_________]
        //                       ^------- g_prebuff_ptr
        //                                  
        //
        
        else {          // the normal case
        
                memcpy( &g_shared_buffer[g_prebuff_ptr], bytes_to_add_buff, bytes_to_add_size );
                
                g_prebuff_ptr += bytes_to_add_size;     
                g_available_bytes += bytes_to_add_size;
        }
        
        DEBUG_PRINT ("g_read_data_ptr %d - g_prebuff_ptr %d [+bytes %d] - difference %d\n", 
                                 g_read_data_ptr, g_prebuff_ptr, bytes_to_add_size, g_available_bytes );
}


void ReceiverCtrlThread::doAudioParsing( unsigned char* audio_received_buf, int audio_received_size, 
                                                                                int stream_id ) 
{
        DEBUG_PRINT ("doAudioParsing\n");
        // we should use fmod here.
        if ( _fmod_initialized == false ) {
                fmod_init ();

                g_shared_buffer_size = 1000000;

                g_shared_buffer = new unsigned char[g_shared_buffer_size];
                                
                g_read_data_ptr = 0;
                g_prebuff_ptr = 0;                              
                                
                _channel = 0;
                _sound = 0;
                _fmod_initialized = true;
        }
                
        add_available_bytes( audio_received_buf, audio_received_size );
        if ( g_available_bytes >= 131070 ) {
                if ( _sound == NULL ) {

                        DEBUG_PRINT ("created new sound.....\n");
                    _result = _system->createSound( "dummy_file", FMOD_SOFTWARE | 
                                                                                 FMOD_CREATESTREAM, 0, &_sound );
                        ERRCHECK(_result);
                        _result = _sound->setMode( FMOD_LOOP_OFF );
                        ERRCHECK( _result );
                                        
                        DEBUG_PRINT ("playing it....\n");
                        _result = _system->playSound(FMOD_CHANNEL_FREE, _sound, false, &_channel);
                }
        }
}


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

bool ReceiverCtrlThread::onAudioFrameReceivedFromNet( unsigned char* audio_buf, int audio_buf_size, 
                                                                                        int stream_id, const void *client_data ) 
{
        ReceiverCtrlThread *recv;
        
        recv = (ReceiverCtrlThread*)client_data;

        recv->doAudioParsing( audio_buf, audio_buf_size, stream_id );
        return true;    
}

---