vlc 调用live555的源码分析--vlc v2.1.1版本

最新推荐文章于 2023-04-18 17:56:55 发布
最新推荐文章于 2023-04-18 17:56:55 发布
阅读量5.2k 收藏 7
点赞数
分类专栏： VLC Live555 流媒体开源技术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smilestone_322/article/details/18035487
版权
流媒体开源技术 同时被 3 个专栏收录
39 篇文章 25 订阅
订阅专栏
Live555
33 篇文章 10 订阅
订阅专栏
VLC
9 篇文章 0 订阅
订阅专栏
VLC调用Live555源码解析
 以前在看live555的源码和例子的时，发现live555的例子都是回调，这样我们根本无法判断命令是否发送成功，也无法判断发送是否超时；网上搜索，也没有看到有用的资料；于是就分析了VLC的live555.cpp文件，对该问题恍然大悟，于是记下vlc live555的Rtsp连接建立过程，供大家参考，我们可以从vlc怎么调用live555.cpp中看到vlc 是如何结合live555的，这样对我们调用live555写客户端等等有很大的帮助！

 

源码见：

http://blog.csdn.net/smilestone_322/article/details/17504909

1）  连接RTSP服务器
/*****************************************************************************
 * Connect: connects to the RTSP server to setup the session DESCRIBE
 *****************************************************************************/
static int Connect( demux_t *p_demux )
{
    demux_sys_t *p_sys = p_demux->p_sys;
    Authenticator authenticator;
    char *psz_user    = NULL;
    char *psz_pwd     = NULL;
    char *psz_url     = NULL;
    int  i_http_port  = 0;
int  i_ret        = VLC_SUCCESS;
 
//获取超时的时间
    const int i_timeout = var_InheritInteger( p_demux, "ipv4-timeout" );
 
/* Get the user name and password */
//获取RTSP的URL的用户名和密码;
    if( p_sys->url.psz_username || p_sys->url.psz_password )
    {
        /* Create the URL by stripping away the username/password part */
        if( p_sys->url.i_port == 0 )
            p_sys->url.i_port = 554;
        if( asprintf( &psz_url, "rtsp://%s:%d%s",
                      strempty( p_sys->url.psz_host ),
                      p_sys->url.i_port,
                      strempty( p_sys->url.psz_path ) ) == -1 )
            return VLC_ENOMEM;
 
        psz_user = strdup( strempty( p_sys->url.psz_username ) );
        psz_pwd  = strdup( strempty( p_sys->url.psz_password ) );
    }
    else
    {
        if( asprintf( &psz_url, "rtsp://%s", p_sys->psz_path ) == -1 )
            return VLC_ENOMEM;
 
        psz_user = var_InheritString( p_demux, "rtsp-user" );
        psz_pwd  = var_InheritString( p_demux, "rtsp-pwd" );
    }
 
createnew:
    if( !vlc_object_alive (p_demux) )
    {
        i_ret = VLC_EGENERIC;
        goto bailout;
    }
       //判断是否走http隧道
    if( var_CreateGetBool( p_demux, "rtsp-http" ) )
        i_http_port = var_InheritInteger( p_demux, "rtsp-http-port" );
 
//创建一个RTSPClient客户端, RTSPClientVlc继承自live555的RTSPClient
    p_sys->rtsp = new RTSPClientVlc( *p_sys->env, psz_url,
                                     var_InheritInteger( p_demux, "verbose" ) > 1 ? 1 : 0,
                                     "LibVLC/"VERSION, i_http_port, p_sys );
    if( !p_sys->rtsp )
    {
        msg_Err( p_demux, "RTSPClient::createNew failed (%s)",
                 p_sys->env->getResultMsg() );
        i_ret = VLC_EGENERIC;
        goto bailout;
    }
 
    /* Kasenna enables KeepAlive by analysing the User-Agent string.
     * Appending _KA to the string should be enough to enable this feature,
     * however, there is a bug where the _KA doesn't get parsed from the
     * default User-Agent as created by VLC/Live555 code. This is probably due
     * to spaces in the string or the string being too long. Here we override
     * the default string with a more compact version.
     */
    if( var_InheritBool( p_demux, "rtsp-kasenna" ))
    {
        p_sys->rtsp->setUserAgentString( "VLC_MEDIA_PLAYER_KA" );
    }
 
describe:
    authenticator.setUsernameAndPassword( psz_user, psz_pwd );
      
       //往服务器发送sendOptionsCommand请求，continueAfterOPTIONS和live555的例子一样，是一个回调，在发送完sendOptionsCommand请求，收到它的应答后调用该回调函数，在continueAfterOPTIONS函数中发送Describe请求；
    p_sys->rtsp->sendOptionsCommand( &continueAfterOPTIONS, &authenticator );
      
       // wait_Live555_response 用来判断发送命令是否超时，相当重要，Live555给的例子中都没有这个，这样我们是不好判断我们发送的命令是否失败，比如发送命令超时了，程序就没有响应了，都不能给个提示，VLC使用该函数解决了Live555的这个问题；
    if( !wait_Live555_response( p_demux, i_timeout ) )
    {
        int i_code = p_sys->i_live555_ret;
        if( i_code == 401 )
        {
            msg_Dbg( p_demux, "authentication failed" );
 
            free( psz_user );
            free( psz_pwd );
            dialog_Login( p_demux, &psz_user, &psz_pwd,
                          _("RTSP authentication"), "%s",
                        _("Please enter a valid login name and a password.") );
            if( psz_user != NULL && psz_pwd != NULL )
            {
                            //鉴权失败，转到describe再次发送Opinion请求
                msg_Dbg( p_demux, "retrying with user=%s", psz_user );
                goto describe;
            }
        }
        else if( i_code > 0 && i_code != 404 && !var_GetBool( p_demux, "rtsp-http" ) )
        {
            /* Perhaps a firewall is being annoying. Try HTTP tunneling mode */
                     //失败，转http 隧道模式
            msg_Dbg( p_demux, "we will now try HTTP tunneling mode" );
            var_SetBool( p_demux, "rtsp-http", true );
            if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
            p_sys->rtsp = NULL;
            goto createnew;
        }
        else
        {
                     // i_code=0表示连接超时
            if( i_code == 0 )
                msg_Dbg( p_demux, "connection timeout" );
            else
            {
                            //连接失败
                msg_Dbg( p_demux, "connection error %d", i_code );
                if( i_code == 403 )
                    dialog_Fatal( p_demux, _("RTSP connection failed"),
                                  _("Access to the stream is denied by the server configuration.") );
            }
            if( p_sys->rtsp ) RTSPClient::close( p_sys->rtsp );
            p_sys->rtsp = NULL;
        }
        i_ret = VLC_EGENERIC;
    }
 
bailout:
    /* malloc-ated copy */
    free( psz_url );
    free( psz_user );
    free( psz_pwd );
 
    return i_ret;
}
 
其中：
static void continueAfterOPTIONS( RTSPClient* client, int result_code,
                                  char* result_string )
{
    RTSPClientVlc *client_vlc = static_cast<RTSPClientVlc *> (client);
    demux_sys_t *p_sys = client_vlc->p_sys;
    p_sys->b_get_param =
      // If OPTIONS fails, assume GET_PARAMETER is not supported but
      // still continue on with the stream.  Some servers (foscam)
      // return 501/not implemented for OPTIONS.
      result_code == 0
      && result_string != NULL
      && strstr( result_string, "GET_PARAMETER" ) != NULL;
    client->sendDescribeCommand( continueAfterDESCRIBE );
    delete[] result_string;
}
 
在continueAfterOPTIONS函数中，调用sendDescribeCommand函数发送Describe命令；continueAfterDESCRIBE为sendDescribeCommand命令发送后调用的回调函数；
 
continueAfterDESCRIBE函数如下：
static void continueAfterDESCRIBE( RTSPClient* client, int result_code,
                                   char* result_string )
{
    RTSPClientVlc *client_vlc = static_cast<RTSPClientVlc *> ( client );
    demux_sys_t *p_sys = client_vlc->p_sys;
    p_sys->i_live555_ret = result_code;
    if ( result_code == 0 )
    {
        char* sdpDescription = result_string;
        free( p_sys->p_sdp );
        p_sys->p_sdp = NULL;
        if( sdpDescription )
        {
            p_sys->p_sdp = strdup( sdpDescription );
            p_sys->b_error = false;
        }
    }
    else
        p_sys->b_error = true;
    delete[] result_string;
    p_sys->event_rtsp = 1;
}
 
回调函数中的result_code和result_string还是挺重要的，可以从其中判断发送的命令是否错误；
 
判断超时的函数如下：
/* return true if the RTSP command succeeded */
static bool wait_Live555_response( demux_t *p_demux, int i_timeout = 0 /* ms */ )
{
    TaskToken task;
    demux_sys_t * p_sys = p_demux->p_sys;
    p_sys->event_rtsp = 0;
    if( i_timeout > 0 )
    {
        /* Create a task that will be called if we wait more than timeout ms */
        task = p_sys->scheduler->scheduleDelayedTask( i_timeout*1000,
                                                      TaskInterruptRTSP,
                                                      p_demux );
    }
    p_sys->event_rtsp = 0;
    p_sys->b_error = true;
p_sys->i_live555_ret = 0;
//
    p_sys->scheduler->doEventLoop( &p_sys->event_rtsp );
    //here, if b_error is true and i_live555_ret = 0 we didn't receive a response
    if( i_timeout > 0 )
    {
        /* remove the task */
        p_sys->scheduler->unscheduleDelayedTask( task );
    }
    return !p_sys->b_error;
}
 
如果超时：那么调用TaskInterruptRTSP函数；当超时时，在TaskInterruptRTSP将event_rtsp置为非0；这样doEventLoop里面的while循环会顺利退出；如果没有超时，在continueAfterDESCRIBE函数中也将event_rtsp置为非0；DoEventLoop的线程也会顺利退出，这样在根据p_sys->b_error;判断是否成功还是失败；
 
*****************************************************************************/
static void TaskInterruptRTSP( void *p_private )
{
    demux_t *p_demux = (demux_t*)p_private;
 
    /* Avoid lock */
    p_demux->p_sys->event_rtsp = 0xff;
}
 
2）  发送Setup建立会话；
 
/*****************************************************************************
 * SessionsSetup: prepares the subsessions and does the SETUP
 *****************************************************************************/
static int SessionsSetup( demux_t *p_demux )
{
    demux_sys_t             *p_sys  = p_demux->p_sys;
    MediaSubsessionIterator *iter   = NULL;
    MediaSubsession         *sub    = NULL;
 
    bool           b_rtsp_tcp;
    int            i_client_port;
    int            i_return = VLC_SUCCESS;
    unsigned int   i_receive_buffer = 0;
    int            i_frame_buffer = DEFAULT_FRAME_BUFFER_SIZE;
    unsigned const thresh = 200000; /* RTP reorder threshold .2 second (default .1) */
 
    b_rtsp_tcp    = var_CreateGetBool( p_demux, "rtsp-tcp" ) ||
                    var_GetBool( p_demux, "rtsp-http" );
    i_client_port = var_InheritInteger( p_demux, "rtp-client-port" );
 
 
    /* Create the session from the SDP */
    if( !( p_sys->ms = MediaSession::createNew( *p_sys->env, p_sys->p_sdp ) ) )
    {
        msg_Err( p_demux, "Could not create the RTSP Session: %s",
            p_sys->env->getResultMsg() );
        return VLC_EGENERIC;
    }
 
    /* Initialise each media subsession */
    iter = new MediaSubsessionIterator( *p_sys->ms );
    while( ( sub = iter->next() ) != NULL )
    {
        Boolean bInit;
        live_track_t *tk;
 
        if( !vlc_object_alive (p_demux) )
        {
            delete iter;
            return VLC_EGENERIC;
        }
 
        /* Value taken from mplayer */
        if( !strcmp( sub->mediumName(), "audio" ) )
            i_receive_buffer = 100000;
        else if( !strcmp( sub->mediumName(), "video" ) )
        {
            int i_var_buf_size = var_InheritInteger( p_demux, "rtsp-frame-buffer-size" );
            if( i_var_buf_size > 0 )
                i_frame_buffer = i_var_buf_size;
            i_receive_buffer = 2000000;
        }
        else if( !strcmp( sub->mediumName(), "text" ) )
            ;
        else continue;
 
        if( i_client_port != -1 )
        {
            sub->setClientPortNum( i_client_port );
            i_client_port += 2;
        }
 
        if( strcasestr( sub->codecName(), "REAL" ) )
        {
            msg_Info( p_demux, "real codec detected, using real-RTSP instead" );
            p_sys->b_real = true; /* This is a problem, we'll handle it later */
            continue;
        }
 
        if( !strcmp( sub->codecName(), "X-ASF-PF" ) )
            bInit = sub->initiate( 0 );
        else
            bInit = sub->initiate();
 
        if( !bInit )
        {
            msg_Warn( p_demux, "RTP subsession '%s/%s' failed (%s)",
                      sub->mediumName(), sub->codecName(),
                      p_sys->env->getResultMsg() );
        }
        else
        {
            if( sub->rtpSource() != NULL )
            {
                int fd = sub->rtpSource()->RTPgs()->socketNum();
 
                /* Increase the buffer size */
                if( i_receive_buffer > 0 )
                    increaseReceiveBufferTo( *p_sys->env, fd, i_receive_buffer );
 
                /* Increase the RTP reorder timebuffer just a bit */
                sub->rtpSource()->setPacketReorderingThresholdTime(thresh);
            }
            msg_Dbg( p_demux, "RTP subsession '%s/%s'", sub->mediumName(),
                     sub->codecName() );
 
            /* Issue the SETUP */
            if( p_sys->rtsp )
            {
       //发送Setup命令，建立会话；default_live555_callback为sendSetupCommand函数的回调函数；其主要作用是判断SetUp命令是否发送成功，置为DoEvent的线程标志，使得线程顺利退出，从而wait_Live555_response函数能够顺利退出；
                p_sys->rtsp->sendSetupCommand( *sub, default_live555_callback, False,
                                               toBool( b_rtsp_tcp ),
                                               toBool( p_sys->b_force_mcast && !b_rtsp_tcp ) );
//判断Setup命令是否发送成功
                if( !wait_Live555_response( p_demux ) )
                {
                    /* if we get an unsupported transport error, toggle TCP
                     * use and try again */
                    if( p_sys->i_live555_ret == 461 )
                        p_sys->rtsp->sendSetupCommand( *sub, default_live555_callback, False,
                                                       !toBool( b_rtsp_tcp ), False );
                    if( p_sys->i_live555_ret != 461 || !wait_Live555_response( p_demux ) )
                    {
                        msg_Err( p_demux, "SETUP of'%s/%s' failed %s",
                                 sub->mediumName(), sub->codecName(),
                                 p_sys->env->getResultMsg() );
                        continue;
                    }
                    else
                    {
                        var_SetBool( p_demux, "rtsp-tcp", true );
                        b_rtsp_tcp = true;
                    }
                }
            }
 
            /* Check if we will receive data from this subsession for
             * this track */
            if( sub->readSource() == NULL ) continue;
            if( !p_sys->b_multicast )
            {
                /* We need different rollover behaviour for multicast */
                p_sys->b_multicast = IsMulticastAddress( sub->connectionEndpointAddress() );
            }
 
            tk = (live_track_t*)malloc( sizeof( live_track_t ) );
            if( !tk )
            {
                delete iter;
                return VLC_ENOMEM;
            }
            tk->p_demux     = p_demux;
            tk->sub         = sub;
            tk->p_es        = NULL;
            tk->b_quicktime = false;
            tk->b_asf       = false;
            tk->p_asf_block = NULL;
            tk->b_muxed     = false;
            tk->b_discard_trunc = false;
            tk->p_out_muxed = NULL;
            tk->waiting     = 0;
            tk->b_rtcp_sync = false;
            tk->i_pts       = VLC_TS_INVALID;
            tk->f_npt       = 0.;
            tk->b_selected  = true;
            tk->i_buffer    = i_frame_buffer;
            tk->p_buffer    = (uint8_t *)malloc( i_frame_buffer );
 
            if( !tk->p_buffer )
            {
                free( tk );
                delete iter;
                return VLC_ENOMEM;
            }
 
            /* Value taken from mplayer */
            if( !strcmp( sub->mediumName(), "audio" ) )
            {
                es_format_Init( &tk->fmt, AUDIO_ES, VLC_FOURCC('u','n','d','f') );
                tk->fmt.audio.i_channels = sub->numChannels();
                tk->fmt.audio.i_rate = sub->rtpTimestampFrequency();
 
                if( !strcmp( sub->codecName(), "MPA" ) ||
                    !strcmp( sub->codecName(), "MPA-ROBUST" ) ||
                    !strcmp( sub->codecName(), "X-MP3-DRAFT-00" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_MPGA;
                    tk->fmt.audio.i_rate = 0;
                }
                else if( !strcmp( sub->codecName(), "AC3" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_A52;
                    tk->fmt.audio.i_rate = 0;
                }
                else if( !strcmp( sub->codecName(), "L16" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_S16B;
                    tk->fmt.audio.i_bitspersample = 16;
                }
                else if( !strcmp( sub->codecName(), "L20" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_S20B;
                    tk->fmt.audio.i_bitspersample = 20;
                }
                else if( !strcmp( sub->codecName(), "L24" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_S24B;
                    tk->fmt.audio.i_bitspersample = 24;
                }
                else if( !strcmp( sub->codecName(), "L8" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_U8;
                    tk->fmt.audio.i_bitspersample = 8;
                }
                else if( !strcmp( sub->codecName(), "DAT12" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_DAT12;
                    tk->fmt.audio.i_bitspersample = 12;
                }
                else if( !strcmp( sub->codecName(), "PCMU" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_MULAW;
                    tk->fmt.audio.i_bitspersample = 8;
                }
                else if( !strcmp( sub->codecName(), "PCMA" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_ALAW;
                    tk->fmt.audio.i_bitspersample = 8;
                }
                else if( !strncmp( sub->codecName(), "G726", 4 ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_ADPCM_G726;
                    tk->fmt.audio.i_rate = 8000;
                    tk->fmt.audio.i_channels = 1;
                    if( !strcmp( sub->codecName()+5, "40" ) )
                        tk->fmt.i_bitrate = 40000;
                    else if( !strcmp( sub->codecName()+5, "32" ) )
                        tk->fmt.i_bitrate = 32000;
                    else if( !strcmp( sub->codecName()+5, "24" ) )
                        tk->fmt.i_bitrate = 24000;
                    else if( !strcmp( sub->codecName()+5, "16" ) )
                        tk->fmt.i_bitrate = 16000;
                }
                else if( !strcmp( sub->codecName(), "AMR" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_AMR_NB;
                }
                else if( !strcmp( sub->codecName(), "AMR-WB" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_AMR_WB;
                }
                else if( !strcmp( sub->codecName(), "MP4A-LATM" ) )
                {
                    unsigned int i_extra;
                    uint8_t      *p_extra;
 
                    tk->fmt.i_codec = VLC_CODEC_MP4A;
 
                    if( ( p_extra = parseStreamMuxConfigStr( sub->fmtp_config(),
                                                             i_extra ) ) )
                    {
                        tk->fmt.i_extra = i_extra;
                        tk->fmt.p_extra = xmalloc( i_extra );
                        memcpy( tk->fmt.p_extra, p_extra, i_extra );
                        delete[] p_extra;
                    }
                    /* Because the "faad" decoder does not handle the LATM
                     * data length field at the start of each returned LATM
                     * frame, tell the RTP source to omit. */
                    ((MPEG4LATMAudioRTPSource*)sub->rtpSource())->omitLATMDataLengthField();
                }
                else if( !strcmp( sub->codecName(), "MPEG4-GENERIC" ) )
                {
                    unsigned int i_extra;
                    uint8_t      *p_extra;
 
                    tk->fmt.i_codec = VLC_CODEC_MP4A;
 
                    if( ( p_extra = parseGeneralConfigStr( sub->fmtp_config(),
                                                           i_extra ) ) )
                    {
                        tk->fmt.i_extra = i_extra;
                        tk->fmt.p_extra = xmalloc( i_extra );
                        memcpy( tk->fmt.p_extra, p_extra, i_extra );
                        delete[] p_extra;
                    }
                }
                else if( !strcmp( sub->codecName(), "X-ASF-PF" ) )
                {
                    tk->b_asf = true;
                    if( p_sys->p_out_asf == NULL )
                        p_sys->p_out_asf = stream_DemuxNew( p_demux, "asf",
                                                            p_demux->out );
                }
                else if( !strcmp( sub->codecName(), "X-QT" ) ||
                         !strcmp( sub->codecName(), "X-QUICKTIME" ) )
                {
                    tk->b_quicktime = true;
                }
                else if( !strcmp( sub->codecName(), "SPEEX" ) )
                {
                    tk->fmt.i_codec = VLC_FOURCC( 's', 'p', 'x', 'r' );
                    if ( tk->fmt.audio.i_rate == 0 )
                    {
                        msg_Warn( p_demux,"Using 8kHz as default sample rate." );
                        tk->fmt.audio.i_rate = 8000;
                    }
                }
                else if( !strcmp( sub->codecName(), "VORBIS" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_VORBIS;
                    unsigned int i_extra;
                    unsigned char *p_extra;
                    if( ( p_extra=parseVorbisConfigStr( sub->fmtp_config(),
                                                        i_extra ) ) )
                    {
                        tk->fmt.i_extra = i_extra;
                        tk->fmt.p_extra = p_extra;
                    }
                    else
                        msg_Warn( p_demux,"Missing or unsupported vorbis header." );
                }
            }
            else if( !strcmp( sub->mediumName(), "video" ) )
            {
                es_format_Init( &tk->fmt, VIDEO_ES, VLC_FOURCC('u','n','d','f') );
                if( !strcmp( sub->codecName(), "MPV" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_MPGV;
                    tk->fmt.b_packetized = false;
                }
                else if( !strcmp( sub->codecName(), "H263" ) ||
                         !strcmp( sub->codecName(), "H263-1998" ) ||
                         !strcmp( sub->codecName(), "H263-2000" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_H263;
                }
                else if( !strcmp( sub->codecName(), "H261" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_H261;
                }
                else if( !strcmp( sub->codecName(), "H264" ) )
                {
                    unsigned int i_extra = 0;
                    uint8_t      *p_extra = NULL;
 
                    tk->fmt.i_codec = VLC_CODEC_H264;
                    tk->fmt.b_packetized = false;
 
                    if((p_extra=parseH264ConfigStr( sub->fmtp_spropparametersets(),
                                                    i_extra ) ) )
                    {
                        tk->fmt.i_extra = i_extra;
                        tk->fmt.p_extra = xmalloc( i_extra );
                        memcpy( tk->fmt.p_extra, p_extra, i_extra );
 
                        delete[] p_extra;
                    }
                }
                else if( !strcmp( sub->codecName(), "JPEG" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_MJPG;
                }
                else if( !strcmp( sub->codecName(), "MP4V-ES" ) )
                {
                    unsigned int i_extra;
                    uint8_t      *p_extra;
 
                    tk->fmt.i_codec = VLC_CODEC_MP4V;
 
                    if( ( p_extra = parseGeneralConfigStr( sub->fmtp_config(),
                                                           i_extra ) ) )
                    {
                        tk->fmt.i_extra = i_extra;
                        tk->fmt.p_extra = xmalloc( i_extra );
                        memcpy( tk->fmt.p_extra, p_extra, i_extra );
                        delete[] p_extra;
                    }
                }
                else if( !strcmp( sub->codecName(), "X-QT" ) ||
                         !strcmp( sub->codecName(), "X-QUICKTIME" ) ||
                         !strcmp( sub->codecName(), "X-QDM" ) ||
                         !strcmp( sub->codecName(), "X-SV3V-ES" )  ||
                         !strcmp( sub->codecName(), "X-SORENSONVIDEO" ) )
                {
                    tk->b_quicktime = true;
                }
                else if( !strcmp( sub->codecName(), "MP2T" ) )
                {
                    tk->b_muxed = true;
                    tk->p_out_muxed = stream_DemuxNew( p_demux, "ts", p_demux->out );
                }
                else if( !strcmp( sub->codecName(), "MP2P" ) ||
                         !strcmp( sub->codecName(), "MP1S" ) )
                {
                    tk->b_muxed = true;
                    tk->p_out_muxed = stream_DemuxNew( p_demux, "ps",
                                                       p_demux->out );
                }
                else if( !strcmp( sub->codecName(), "X-ASF-PF" ) )
                {
                    tk->b_asf = true;
                    if( p_sys->p_out_asf == NULL )
                        p_sys->p_out_asf = stream_DemuxNew( p_demux, "asf",
                                                            p_demux->out );;
                }
                else if( !strcmp( sub->codecName(), "DV" ) )
                {
                    tk->b_muxed = true;
                    tk->b_discard_trunc = true;
                    tk->p_out_muxed = stream_DemuxNew( p_demux, "rawdv",
                                                       p_demux->out );
                }
                else if( !strcmp( sub->codecName(), "VP8" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_VP8;
                }
            }
            else if( !strcmp( sub->mediumName(), "text" ) )
            {
                es_format_Init( &tk->fmt, SPU_ES, VLC_FOURCC('u','n','d','f') );
 
                if( !strcmp( sub->codecName(), "T140" ) )
                {
                    tk->fmt.i_codec = VLC_CODEC_ITU_T140;
                }
            }
 
            if( !tk->b_quicktime && !tk->b_muxed && !tk->b_asf )
            {
                tk->p_es = es_out_Add( p_demux->out, &tk->fmt );
            }
 
            if( sub->rtcpInstance() != NULL )
            {
                sub->rtcpInstance()->setByeHandler( StreamClose, tk );
            }
 
            if( tk->p_es || tk->b_quicktime || ( tk->b_muxed && tk->p_out_muxed ) ||
                ( tk->b_asf && p_sys->p_out_asf ) )
            {
                TAB_APPEND_CAST( (live_track_t **), p_sys->i_track, p_sys->track, tk );
            }
            else
            {
                /* BUG ??? */
                msg_Err( p_demux, "unusable RTSP track. this should not happen" );
                es_format_Clean( &tk->fmt );
                free( tk );
            }
        }
    }
    delete iter;
    if( p_sys->i_track <= 0 ) i_return = VLC_EGENERIC;
 
    /* Retrieve the starttime if possible */
    p_sys->f_npt_start = p_sys->ms->playStartTime();
 
    /* Retrieve the duration if possible */
    p_sys->f_npt_length = p_sys->ms->playEndTime();
 
    /* */
    msg_Dbg( p_demux, "setup start: %f stop:%f", p_sys->f_npt_start, p_sys->f_npt_length );
 
    /* */
    p_sys->b_no_data = true;
    p_sys->i_no_data_ti = 0;
 
    return i_return;
}
 
其中default_live555_callback函数定义如下，该函数也是挺重要的：
 
static void default_live555_callback( RTSPClient* client, int result_code, char* result_string )
{
    RTSPClientVlc *client_vlc = static_cast<RTSPClientVlc *> ( client );
    demux_sys_t *p_sys = client_vlc->p_sys;
    delete []result_string;
    p_sys->i_live555_ret = result_code;
    p_sys->b_error = p_sys->i_live555_ret != 0;
    p_sys->event_rtsp = 1;
}
 
3）  发送Play请求；
 
static int Play( demux_t *p_demux )
{
    demux_sys_t *p_sys = p_demux->p_sys;
 
    if( p_sys->rtsp )
    {
        /* The PLAY */
              //发送sendPlayCommand命令，default_live555_callback为其回调函数
        p_sys->rtsp->sendPlayCommand( *p_sys->ms, default_live555_callback, p_sys->f_npt_start, -1, 1 );
 
              //判断Play命令是否发送超时
        if( !wait_Live555_response(p_demux) )
        {
            msg_Err( p_demux, "RTSP PLAY failed %s", p_sys->env->getResultMsg() );
            return VLC_EGENERIC;
        }
 
        /* Retrieve the timeout value and set up a timeout prevention thread */
        p_sys->i_timeout = p_sys->rtsp->sessionTimeoutParameter();
        if( p_sys->i_timeout <= 0 )
            p_sys->i_timeout = 60; /* default value from RFC2326 */
 
        /* start timeout-thread only if GET_PARAMETER is supported by the server */
        /* or start it if wmserver dialect, since they don't report that GET_PARAMETER is supported correctly */
        if( !p_sys->p_timeout && ( p_sys->b_get_param || var_InheritBool( p_demux, "rtsp-wmserver" ) ) )
        {
            msg_Dbg( p_demux, "We have a timeout of %d seconds",  p_sys->i_timeout );
            p_sys->p_timeout = (timeout_thread_t *)malloc( sizeof(timeout_thread_t) );
            if( p_sys->p_timeout )
            {
                memset( p_sys->p_timeout, 0, sizeof(timeout_thread_t) );
                p_sys->p_timeout->p_sys = p_demux->p_sys; /* lol, object recursion :D */
                if( vlc_clone( &p_sys->p_timeout->handle,  TimeoutPrevention,
                               p_sys->p_timeout, VLC_THREAD_PRIORITY_LOW ) )
                {
                    msg_Err( p_demux, "cannot spawn liveMedia timeout thread" );
                    free( p_sys->p_timeout );
                    p_sys->p_timeout = NULL;
                }
                else
                    msg_Dbg( p_demux, "spawned timeout thread" );
            }
            else
                msg_Err( p_demux, "cannot spawn liveMedia timeout thread" );
        }
    }
    p_sys->i_pcr = 0;
 
    /* Retrieve the starttime if possible */
    p_sys->f_npt_start = p_sys->ms->playStartTime();
    if( p_sys->ms->playEndTime() > 0 )
        p_sys->f_npt_length = p_sys->ms->playEndTime();
 
    msg_Dbg( p_demux, "play start: %f stop:%f", p_sys->f_npt_start, p_sys->f_npt_length );
    return VLC_SUCCESS;
}
 
 
 
smilestone322
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
vlc-android 移植live555到android
wowdd1
03-31 9382
先下载vlc-android的源码,并编译成功修改~/code/vlc-android/extras/contrib 下的distro.mak   增加.liveall: .zlib /     .a52 .mpeg2 .mad .ogg .vorbis .vorbisenc .theora /     .flac .speex .faad .lame .ffmpeg /     .twolame /     .png .dvbpsi /     .dca .kate .live终端执行如下命令:cd vl
linux环境下vlc+live555编译
zjw0304的博客
02-17 681
linux环境下vlc+live555编译 1.cd vlc-3.0.12 2.cd contrib 3.mkdir native 4.../bootstrap 5.make .live555 //会在tarballs文件夹下，自动下载live555对应得包，并自动编译 live555添加完成后 6.../configure --prefix=/home/zhang/workspace/package/vlc-3.0.12/output --enable-realrtsp --enable-live55
移植vlc+live555到s3c2410
Allen
11-12 2813
一、交叉编译live555 live555.2009.04.20 注意：需要live版本和vlc版本需要符合，否则容易出现错误 1、解压live555.2009.04.20.tar.gz tar -zxvf live555.2009.04.20.tar.gz 2、修改配置文件 cd live vi config.armlinux 将第一行修改为arm-none-linux-gnue
C# 编写VLC视频事件处理程序 libvlc libvlc_event_attach libvlc_event_manager libvlc_event_type ibvlc_event_e用法
b07lxh的博客
04-18 1199
C# VLC视频事件 libvlc libvlc_event_attach libvlc_event_manager libvlc_event_type ibvlc_event_e libvlc_callback
RTSP协议详解
qyjandroid的专栏
05-20 785
关于 RTSP. RTSP协议是一个非常类似HTTP协议的流控制协议。它们都使用纯文本来发送信息，而且rtsp协议的语法也和HTTP类似。Rtsp一开始这样设计，也是为了能够兼容使用以前写的HTTP协议分析代码 。这是个好消息。 它们主要的区别是HTTP协议是没有状态的， http协议在发送一个命令后，连接会断开，而且命令之间没有依赖性。不同的是RTSP的命令需要知道现在正处于一个什么状态，也
vlc-pause-click-plugin-windows-64bit
04-09
"vlc-pause-click-plugin-windows-64bit" 是一个专为VLC媒体播放器设计的插件，适用于Windows操作系统64位版本。这个插件的核心功能是通过点击屏幕来实现播放和暂停的操作，提供了更加便捷的交互方式。 对于VLC媒体...
vlc-android官方源码 2014-08.01
08-01
2014年8月版本的“vlc-android官方源码”是Android平台上VLC播放器的一个重要里程碑，允许开发者深入研究并自定义其功能，比如在Android设备上实现屏幕截图和录制视频。 1. **VLC for Android核心概念** - **跨...
qt-vlc源码和库和demo
03-14
通过这个源码，开发者可以研究VLC-Qt的内部实现，学习如何调用libVLC接口，以及如何将Qt的事件驱动模型与VLC的播放机制相结合。 最后，`examples-master.zip`是一系列示例程序，这些示例展示了如何在实际项目中使用...
流媒体测试使用视频FFMpeg-live555-vlc player.rar
01-26
FFmpeg、Live555和VLC Player是流媒体处理中的三个重要工具，它们在视频传输、播放和处理中扮演着关键角色。 FFmpeg是一款强大的开源多媒体处理工具，它可以进行音视频的编码、解码、转换、封装以及流化操作。在流...
vlc-android官方源码 2014-07.21
07-22
2014年7月的源码版本可能包含了当时最新的技术改进和优化，确保在Android设备上流畅地播放多媒体内容。 在源码结构上，VLC for Android通常分为以下几个关键部分： 1. **Java层**：这部分代码负责与Android系统...
vlc-源码分析--rtsp服务端-单线程IO复用模型
Canok
07-16 396
vlc使用了live555开源库，但是只是播放网络视频流的时候用live555作为 接受，对于串流rtsp功能，为自行实现的一个服务端程序，单线程IO复用服务端模型。这里分析下这个服务端的源码 位于 src/network/httpd.c 这里仅仅rtsp的服务端，不涉及到rtp具体的传输视频，rtp传输数据是另外的线程。 看这个rtsp服务端的大概模型，使用单线程，io复用的方式，处理所有连接...
libVLC 事件机制
青春不老，奋斗不止！
07-18 1456
在前面的章节中，我们曾说过 libVLC 是异步播放的。也就是说，无法立刻得到要想的结果（例如：媒体时长），倘若要获取这些信息，必须通过事件通知和回调来实现。
Live555学习之(六)---------- 在Live555中实现录像
05-03 366
　　Live555还提供了录像的示例程序，在testProgs目录下的playCommon.cpp中，Live555录像的基本原理就是创建一个RTSPClient去请求指定rtsp地址的视频，然后保存到文件里。 　　playCommon.cpp打开一看就发现首先是各种全局函数的声明，然后是各种全局变量的声明，然后是main函数和各个函数的实现。main函数中首先还是创建TaskSche...
live555学习笔记【6】---客户端（一）
王木木
10-06 1038
之前已经阅读了live555服务器的部分代码，其中也讲解了服务器对客户端各个RTSP命令的处理过程，下面我们来看看客户端是如何发送这些命令。testProgs中的OpenRTSP是典型的RTSPClient示例，所以分析它吧。 main()函数在playCommon.cpp文件中。main()的流程比较简单，跟服务端差别不大：建立任务计划对象－－建立环境对象－－处理用户输入的参数(RTSP地址...
基于libvlc实现断线重连功能
Leonardo_11的博客
06-05 2862
思路：利用libvlc中添加事件，当遇到播放错误再次开启播放。 1.添加libvlc中事件（事件种类很多，我就用了这两个) void chDialog::AttachEvents(libvlc_event_manager_t *EventManager) //用于添加libvlc中的事件 { int i = 0; vector <libvlc_event_e> events = { libvlc_MediaPlayerEncounteredError, ...
面向对象四大特征----继承（Inherit）
LsLoo的博客
05-21 419
“继承”是面上对象中的第二特征，体现了类与类之间的“is-a”关系。当两个类进行继承关联绑定的时候，子类自动具备来自于父类的属性和行为，做到代码的复用和设计的分离。 Java继承的机制 类Object Class Object is the root of the class hierarchy.Every class has Object as a superclass.All Objects，includeing arrays，implement the methods of this cl
使用live555客户端源码遇到的问题及解决方法
博客
05-15 2629
使用live555客户端源码拉rtsp流遇到两个问题，正常测试拉取海康摄像头没问题； 1.拉有些厂商的rtsp流会间隔一段时间断开连接； 2.与大华摄像头建立连接时，发送DESCRIBE命令后很长时间服务器端才返回； 问题一： 问题描述：rtsp流间隔一段时间后总是中断，因为有断开重连机制，所以画面一直是卡住，然后正常播放一段时间，这样循环。 原因描述：由于没有与服务器端建立心跳导致；有...
vlcj-java8 版本和vlc版本的对应关系
最新发布
05-23
VLCJ 是一个 Java 绑定库，用于在 Java 应用程序中使用 VLC 媒体播放器的功能。VLCJ 与 VLC 版本之间的对应关系如下： | vlcj-java8 版本 | 支持的 VLC 版本 | | --------------- | --------------- | | 3.10.x | 2.2.x - 2.2.8 | | 3.11.x | 2.2.x - 2.2.8 | | 3.12.x | 2.2.x - 2.2.8 | | 4.0.x | 3.0.x - 3.0.12 | | 4.1.x | 3.0.x - 3.0.12 | | 4.2.x | 3.0.x - 3.0.12 | 请注意，这里列出的仅是 vlcj-java8 版本与 VLC 版本的基本兼容性，实际上还可能存在其他因素导致不兼容。建议在使用前查看 vlcj 和 VLC 官方文档以获取更多详细信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值