OStreamUCast.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 "OStreamUCast.hh"

using namespace std;

//--------------------------------------------------------------------------
// unicast streamer constructor

OStreamUCast::OStreamUCast( on_parsable_image_cb *f, void *parsable_image_callback_data,
                                                   int num_of_streams /* = 1 */ ) :
                        f_parsable_image_cb ( f ),
                        _parsable_image_callback_data( parsable_image_callback_data ),
                        _num_of_streams( num_of_streams )
{
        if ( _num_of_streams > 1 )
                _multi_stream_mode = true;
        else
                _multi_stream_mode = false;
        
        _scheduler = BasicTaskScheduler::createNew( );
        _env = BasicUsageEnvironment::createNew( *_scheduler );

        _dms_list = new list<OStreamOnDemandSMS *>;
        
        _watchVariable = 0;
}


OStreamUCast::~OStreamUCast() 
{
        _env->reclaim();
        delete _scheduler;
}


//--------------------------------------------------------------------------
// raise up a RTSP server and start streaming session

bool OStreamUCast::startStreaming( int encoding_type,
                                                                   char* file_path,                             /* = NULL */
                                                                   int camera_num,                              /* = 0 */
                                                                   int audio_port,                              /* = -1 */
                                                                   const char* subsession_url,  /* = "testStream" */
                                                                   unsigned short port_rtsp,    /* = 8554 */
                                                                   unsigned int fps                     /* = 25 */
                                                                  )  
{
        char *subsession_str = strdup( subsession_url );
        Port port_to_listen( port_rtsp );
        
        _fps = fps;

        createRTSPInstance( port_to_listen );
        createServerMediaSession( encoding_type, subsession_str, file_path, camera_num, audio_port );

        // Finally, start the streaming on demand:

        // returns when the watch variable is != 0 as from 
        // http://www.live.com/liveMedia/doxygen/html/UsageEnvironment_8hh-source.html
        // FIXME BUG: when there are other clients listening in unicast there's a crash here
        _env->taskScheduler().doEventLoop( &_watchVariable ); 

        // we reach this point after stopStreaming(), 
        // which set the watchVariable to 1: the doEventLoop returns.

        free ( subsession_str );
        
        return true;
}


//--------------------------------------------------------------------------
// will stop the streaming

bool OStreamUCast::stopStreaming() {

        // remove the _sms server, along with the *VideoSource inside it.
        _rtspServer->removeServerMediaSession( _sms );

        // close the rtsp server
        Medium::close( _rtspServer );

        _watchVariable = 1;
        return true;
}


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

void OStreamUCast::createRTSPInstance( Port &port_to_listen ) {

        // create a new server.
        _rtspServer = RTSPServer::createNew( *_env, port_to_listen, NULL, 0 );

        if ( _rtspServer == NULL ) {
                *_env << "Failed to create RTSP server: " << _env->getResultMsg() << "\n";
                exit(1);
        }
}


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

void OStreamUCast::createServerMediaSession( int encoding_type, char *sub_url,
                                                                                         char* file_path, int camera_num, int audio_num ) 
{
        bool using_file = (file_path != NULL) ? true : false;
        bool using_audio = (audio_num != -1) ? true : false;
        bool using_video = (encoding_type != OSTREAM_ENCODING_NONE) ? true : false;
                                                                                                         
        // create a new server
        _sms = ServerMediaSession::createNew( *_env, sub_url, 0,
                   "Session streamed by Omnimeeting",  true );

        OStreamOnDemandSMS *on_demand_sms;
        // single mode
        if ( using_video ) {
                if ( _multi_stream_mode == false ) {            
                        BaseInputVideo *input_video;
                
                        if ( using_file )
                                input_video = new FileSingleVideoSource( file_path );
                        else
                                input_video = new HardwareSingleVideoSource( camera_num );
                
                        DEBUG_PRINT("initializing single-stream mode...\n");
                
                        on_demand_sms = OStreamOnDemandSMS::createNew( *_env, false, input_video, encoding_type, -1 );

                        // add it to ServerMediaSession
                        _sms->addSubsession( on_demand_sms );
                
                        // push back on the list
                        _dms_list->push_back( on_demand_sms );
                
                        DEBUG_PRINT("done, connect here for the stream %s\n", _rtspServer->rtspURL(_sms) );
                }
                else {  // multi mode
                        // BufferedImageMultiVideoSource  will use single video sources internally. 
                        BufferedImageMultiVideoSource *buff_vid_source;
                        BaseInputVideo *input_single_video;
                
                        if ( using_file )
                                input_single_video = new FileSingleVideoSource( file_path );
                        else
                                input_single_video = new HardwareSingleVideoSource( camera_num );

                        DEBUG_PRINT("initializing multi-stream mode...\n");
                
                        // a container for all the streams: the tracked faces will be queued in this class
                        // till when a "personalized" OStreamOnDemandSMS instance will retrieve the 
                        // single queue based on a stream_id
                        buff_vid_source = new BufferedImageMultiVideoSource( _num_of_streams, f_parsable_image_cb,
                                                                                                                          _parsable_image_callback_data, input_single_video );
                
                        // do it once for every stream
                        for (unsigned int i=0; i < _num_of_streams; i++) {
                                // add it to ServerMediaSession         
                                on_demand_sms = OStreamOnDemandSMS::createNew( *_env, false, buff_vid_source, encoding_type, -1, i );
                                _sms->addSubsession( on_demand_sms );

                                // push back on the list
                                _dms_list->push_back( on_demand_sms );
                        }

                        DEBUG_PRINT("done, connect here for streams %s\n", _rtspServer->rtspURL(_sms) );
                }
        }

        // audio parsing stuff
        if ( using_audio ) {
                on_demand_sms = OStreamOnDemandSMS::createNew( *_env, false, NULL, OSTREAM_ENCODING_MP3,  audio_num );
                _sms->addSubsession( on_demand_sms );
                _dms_list->push_back( on_demand_sms );
        }

        // finally add it to rtsp server
        _rtspServer->addServerMediaSession( _sms );
}


//--------------------------------------------------------------------------
// return the effective url to play the rtsp stream

char* OStreamUCast::getUrlToPlay() 
{
        return _rtspServer->rtspURL(_sms);
}

---