bridge.c

uclinux 下的vlc播放器源代码

/*****************************************************************************
 * bridge.c: bridge stream output module
 *****************************************************************************
 * Copyright (C) 2005 the VideoLAN team
 * $Id: bridge.c 16767 2006-09-21 14:32:45Z hartman $
 *
 * Authors: Christophe Massiot <[e-mail]>
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 *****************************************************************************/

/*****************************************************************************
 * Preamble
 *****************************************************************************/
#include <stdlib.h>
#include <string.h>

#include <vlc/vlc.h>
#include <vlc/sout.h>

/*****************************************************************************
 * Module descriptor
 *****************************************************************************/
#define ID_TEXT N_("ID")
#define ID_LONGTEXT N_( \
    "Integer identifier for this elementary stream. This will be used to " \
    "\"find\" this stream later." )

#define DELAY_TEXT N_("Delay")
#define DELAY_LONGTEXT N_("Pictures coming from the picture video outputs " \
        "will be delayed according to this value (in milliseconds, should be "\
        ">= 100 ms). For high values, you will need to raise caching values." )

#define ID_OFFSET_TEXT N_("ID Offset")
#define ID_OFFSET_LONGTEXT N_("Offset to add to the stream IDs specified in " \
        "bridge_out to obtain the stream IDs bridge_in will register.")

static int  OpenOut ( vlc_object_t * );
static void CloseOut( vlc_object_t * );
static int  OpenIn  ( vlc_object_t * );
static void CloseIn ( vlc_object_t * );

#define SOUT_CFG_PREFIX_OUT "sout-bridge-out-"
#define SOUT_CFG_PREFIX_IN "sout-bridge-in-"

vlc_module_begin();
    set_shortname( _("Bridge"));
    set_description( _("Bridge stream output"));
    add_submodule();
    set_section( N_("Bridge out"), NULL );
    set_capability( "sout stream", 50 );
    add_shortcut( "bridge-out" );
    /* Only usable with VLM. No category so not in gui preferences
    set_category( CAT_SOUT );
    set_subcategory( SUBCAT_SOUT_STREAM );*/
    add_integer( SOUT_CFG_PREFIX_OUT "id", 0, NULL, ID_TEXT, ID_LONGTEXT,
                 VLC_FALSE );
    set_callbacks( OpenOut, CloseOut );

    add_submodule();
    set_section( N_("Bridge in"), NULL );
    set_capability( "sout stream", 50 );
    add_shortcut( "bridge-in" );
    /*set_category( CAT_SOUT );
    set_subcategory( SUBCAT_SOUT_STREAM );*/
    add_integer( SOUT_CFG_PREFIX_IN "delay", 0, NULL, DELAY_TEXT,
                 DELAY_LONGTEXT, VLC_FALSE );
    add_integer( SOUT_CFG_PREFIX_IN "id-offset", 8192, NULL, ID_OFFSET_TEXT,
                 ID_OFFSET_LONGTEXT, VLC_FALSE );
    set_callbacks( OpenIn, CloseIn );

    var_Create( p_module->p_libvlc, "bridge-lock", VLC_VAR_MUTEX );
vlc_module_end();


/*****************************************************************************
 * Local prototypes
 *****************************************************************************/
static const char *ppsz_sout_options_out[] = {
    "id", NULL
};

static const char *ppsz_sout_options_in[] = {
    "delay", "id-offset", NULL
};

static sout_stream_id_t *AddOut ( sout_stream_t *, es_format_t * );
static int               DelOut ( sout_stream_t *, sout_stream_id_t * );
static int               SendOut( sout_stream_t *, sout_stream_id_t *, block_t * );

static sout_stream_id_t *AddIn ( sout_stream_t *, es_format_t * );
static int               DelIn ( sout_stream_t *, sout_stream_id_t * );
static int               SendIn( sout_stream_t *, sout_stream_id_t *, block_t * );

typedef struct bridged_es_t
{
    es_format_t fmt;
    block_t *p_block;
    block_t **pp_last;
    vlc_bool_t b_empty;

    /* bridge in part */
    sout_stream_id_t *id;
    mtime_t i_last;
    vlc_bool_t b_changed;
} bridged_es_t;

typedef struct bridge_t
{
    bridged_es_t **pp_es;
    int i_es_num;
} bridge_t;

#define GetBridge(a) __GetBridge( VLC_OBJECT(a) )
static bridge_t *__GetBridge( vlc_object_t *p_object )
{
    libvlc_t *p_libvlc = p_object->p_libvlc;
    bridge_t *p_bridge;
    vlc_value_t val;

    if( var_Get( p_libvlc, "bridge-struct", &val ) != VLC_SUCCESS )
    {
        p_bridge = NULL;
    }
    else
    {
        p_bridge = val.p_address;
    }

    return p_bridge;
}


/*
 * Bridge out
 */

typedef struct out_sout_stream_sys_t
{
    vlc_mutex_t *p_lock;
    bridged_es_t *p_es;
    int i_id;
    vlc_bool_t b_inited;
} out_sout_stream_sys_t;

/*****************************************************************************
 * OpenOut:
 *****************************************************************************/
static int OpenOut( vlc_object_t *p_this )
{
    sout_stream_t     *p_stream = (sout_stream_t *)p_this;
    out_sout_stream_sys_t *p_sys;
    vlc_value_t val;

    sout_CfgParse( p_stream, SOUT_CFG_PREFIX_OUT, ppsz_sout_options_out,
                   p_stream->p_cfg );

    p_sys          = malloc( sizeof( out_sout_stream_sys_t ) );
    p_sys->b_inited = VLC_FALSE;

    var_Get( p_this->p_libvlc, "bridge-lock", &val );
    p_sys->p_lock = val.p_address;

    var_Get( p_stream, SOUT_CFG_PREFIX_OUT "id", &val );
    p_sys->i_id = val.i_int;

    p_stream->pf_add    = AddOut;
    p_stream->pf_del    = DelOut;
    p_stream->pf_send   = SendOut;

    p_stream->p_sys     = (sout_stream_sys_t *)p_sys;

    p_stream->p_sout->i_out_pace_nocontrol++;

    return VLC_SUCCESS;
}

/*****************************************************************************
 * CloseOut:
 *****************************************************************************/
static void CloseOut( vlc_object_t * p_this )
{
    sout_stream_t     *p_stream = (sout_stream_t*)p_this;
    out_sout_stream_sys_t *p_sys = (out_sout_stream_sys_t *)p_stream->p_sys;

    p_stream->p_sout->i_out_pace_nocontrol--;

    free( p_sys );
}

static sout_stream_id_t * AddOut( sout_stream_t *p_stream, es_format_t *p_fmt )
{
    out_sout_stream_sys_t *p_sys = (out_sout_stream_sys_t *)p_stream->p_sys;
    bridge_t *p_bridge;
    bridged_es_t *p_es;
    int i;

    if ( p_sys->b_inited )
    {
        return NULL;
    }
    p_sys->b_inited = VLC_TRUE;

    vlc_mutex_lock( p_sys->p_lock );

    p_bridge = GetBridge( p_stream );
    if ( p_bridge == NULL )
    {
        libvlc_t *p_libvlc = p_stream->p_libvlc;
        vlc_value_t val;

        p_bridge = malloc( sizeof( bridge_t ) );

        var_Create( p_libvlc, "bridge-struct", VLC_VAR_ADDRESS );
        val.p_address = p_bridge;
        var_Set( p_libvlc, "bridge-struct", val );

        p_bridge->i_es_num = 0;
        p_bridge->pp_es = NULL;
    }

    for ( i = 0; i < p_bridge->i_es_num; i++ )
    {
        if ( p_bridge->pp_es[i]->b_empty && !p_bridge->pp_es[i]->b_changed )
            break;
    }

    if ( i == p_bridge->i_es_num )
    {
        p_bridge->pp_es = realloc( p_bridge->pp_es,
                                   (p_bridge->i_es_num + 1)
                                     * sizeof(bridged_es_t *) );
        p_bridge->i_es_num++;
        p_bridge->pp_es[i] = malloc( sizeof(bridged_es_t) );
    }

    p_sys->p_es = p_es = p_bridge->pp_es[i];

    p_es->fmt = *p_fmt;
    p_es->fmt.i_id = p_sys->i_id;
    p_es->p_block = NULL;
    p_es->pp_last = &p_es->p_block;
    p_es->b_empty = VLC_FALSE;

    p_es->id = NULL;
    p_es->i_last = 0;
    p_es->b_changed = VLC_TRUE;

    msg_Dbg( p_stream, "bridging out input codec=%4.4s id=%d pos=%d",
             (char*)&p_es->fmt.i_codec, p_es->fmt.i_id, i );

    vlc_mutex_unlock( p_sys->p_lock );

    return (sout_stream_id_t *)p_sys;
}