ps.c

这不是一个完整的工程

}

/*****************************************************************************
 * Mux: Call each time there is new data for at least one stream
 *****************************************************************************/
static int Mux( sout_mux_t *p_mux )
{
    sout_mux_sys_t *p_sys = p_mux->p_sys;

    for( ;; )
    {
        sout_input_t *p_input;
        ps_stream_t *p_stream;

        sout_buffer_t *p_ps, *p_data;

        mtime_t        i_dts;
        int            i_stream;

        /* Choose which stream to mux */
        if( MuxGetStream( p_mux, &i_stream, &i_dts ) )
        {
            return VLC_SUCCESS;
        }
        p_input  = p_mux->pp_inputs[i_stream];
        p_stream = (ps_stream_t*)p_input->p_sys;
        p_ps     = NULL;

        /* Write regulary PackHeader */
        if( p_sys->i_pes_count % 30 == 0)
        {
            MuxWritePackHeader( p_mux, &p_ps, i_dts );
        }

        /* Write regulary SystemHeader */
        if( p_sys->i_pes_count % 300 == 0 )
        {
            sout_buffer_t *p_pk;

            MuxWriteSystemHeader( p_mux, &p_ps );

            /* For MPEG1 streaming, set HEADER flag */
            for( p_pk = p_ps; p_pk != NULL; p_pk = p_pk->p_next )
            {
                p_pk->i_flags |= SOUT_BUFFER_FLAGS_HEADER;
            }
        }

        /* Get and mux a packet */
        p_data = sout_FifoGet( p_input->p_fifo );
        E_( EStoPES )( p_mux->p_sout,
                       &p_data, p_data,
                       p_stream->i_stream_id,
                       p_mux->p_sys->b_mpeg2 );

        sout_BufferChain( &p_ps, p_data );
        sout_AccessOutWrite( p_mux->p_access, p_ps );

        /* Increase counter */
        p_sys->i_pes_count++;
    }

    return VLC_SUCCESS;
}


/*****************************************************************************
 *
 *****************************************************************************/
static void StreamIdInit   ( vlc_bool_t *id, int i_range )
{
    int i;

    for( i = 0; i < i_range; i++ )
    {
        id[i] = VLC_TRUE;
    }
}
static int  StreamIdGet    ( vlc_bool_t *id, int i_id_min, int i_id_max )
{
    int i;

    for( i = 0; i <= i_id_max - i_id_min; i++ )
    {
        if( id[i] )
        {
            id[i] = VLC_FALSE;

            return i_id_min + i;
        }
    }
    return -1;
}
static void StreamIdRelease( vlc_bool_t *id, int i_id_min, int i_id )
{
    id[i_id - i_id_min] = VLC_TRUE;
}

static void MuxWritePackHeader( sout_mux_t *p_mux, sout_buffer_t **p_buf,
                               mtime_t i_dts )
{
    sout_buffer_t   *p_hdr;
    bits_buffer_t   bits;
    mtime_t         i_src;

    i_src = i_dts * 9 / 100;

    p_hdr = sout_BufferNew( p_mux->p_sout, 18 );
    bits_initwrite( &bits, 14, p_hdr->p_buffer );
    bits_write( &bits, 32, 0x01ba );

    if( p_mux->p_sys->b_mpeg2 )
    {
        bits_write( &bits, 2, 0x01 );
    }
    else
    {
        bits_write( &bits, 4, 0x02 );
    }

    bits_write( &bits, 3, ( i_src >> 30 )&0x07 );
    bits_write( &bits, 1,  1 );
    bits_write( &bits, 15, ( i_src >> 15 )&0x7fff );
    bits_write( &bits, 1,  1 );
    bits_write( &bits, 15, i_src&0x7fff );
    bits_write( &bits, 1,  1 );

    if( p_mux->p_sys->b_mpeg2 )
    {
        bits_write( &bits, 9,  0 ); // src extention
    }
    bits_write( &bits, 1,  1 );

    bits_write( &bits, 22,  1000/8/50); // FIXME mux rate
    bits_write( &bits, 1,  1 );

    if( p_mux->p_sys->b_mpeg2 )
    {
        bits_write( &bits, 1,  1 );
        bits_write( &bits, 5,  0x1f );  // FIXME reserved
        bits_write( &bits, 3,  0 );     // stuffing bytes
    }

    p_hdr->i_size = p_mux->p_sys->b_mpeg2 ? 14: 12;

    sout_BufferChain( p_buf, p_hdr );
}

static void MuxWriteSystemHeader( sout_mux_t *p_mux, sout_buffer_t **p_buf )
{
    sout_mux_sys_t  *p_sys = p_mux->p_sys;
    sout_buffer_t   *p_hdr;
    bits_buffer_t   bits;
    vlc_bool_t      b_private;
    int             i_nb_private, i_nb_stream;
    int i;

    /* Count the number of private stream */
    for( i = 0, i_nb_private = 0; i < p_mux->i_nb_inputs; i++ )
    {
        ps_stream_t *p_stream;

        p_stream = (ps_stream_t*)p_mux->pp_inputs[i]->p_sys;

        if( ( p_stream->i_stream_id&0xff00 ) == 0xbd00 )
        {
            i_nb_private++;
        }
    }

    /* Private stream are declared only one time */
    i_nb_stream = p_mux->i_nb_inputs - ( i_nb_private > 0 ? i_nb_private - 1 : 0 );

    p_hdr = sout_BufferNew( p_mux->p_sout, 12 + i_nb_stream * 3 );

    bits_initwrite( &bits, 12 + i_nb_stream * 3, p_hdr->p_buffer );
    bits_write( &bits, 32, 0x01bb );
    bits_write( &bits, 16, 12 - 6 + i_nb_stream * 3 );
    bits_write( &bits, 1,  1 );
    bits_write( &bits, 22, 0 ); // FIXME rate bound
    bits_write( &bits, 1,  1 );

    bits_write( &bits, 6,  p_sys->i_audio_bound );
    bits_write( &bits, 1,  0 ); // fixed flag
    bits_write( &bits, 1,  0 ); // CSPS flag
    bits_write( &bits, 1,  0 ); // system audio lock flag
    bits_write( &bits, 1,  0 ); // system video lock flag

    bits_write( &bits, 1,  1 ); // marker bit

    bits_write( &bits, 5,  p_sys->i_video_bound );
    bits_write( &bits, 1,  1 ); // packet rate restriction flag (1 for mpeg1)
    bits_write( &bits, 7,  0xff ); // reserved bits

    /* stream_id table */
    for( i = 0, b_private = VLC_FALSE; i < p_mux->i_nb_inputs; i++ )
    {
        sout_input_t *p_input;
        ps_stream_t *p_stream;

        p_input = p_mux->pp_inputs[i];
        p_stream = (ps_stream_t *)p_input->p_sys;

        if( ( p_stream->i_stream_id&0xff00 ) == 0xbd00 )
        {
            if( b_private )
            {
                continue;
            }
            b_private = VLC_TRUE;
            /* Write stream id */
            bits_write( &bits, 8, 0xbd );
        }
        else
        {
            /* Write stream id */
            bits_write( &bits, 8, p_stream->i_stream_id&0xff );
        }
        bits_write( &bits, 2, 0x03 );
        if( p_input->p_fmt->i_cat == AUDIO_ES )
        {
            bits_write( &bits, 1, 0 );
            bits_write( &bits, 13, /* stream->max_buffer_size */ 0 / 128 );
        }
        else if( p_input->p_fmt->i_cat == VIDEO_ES )
        {
            bits_write( &bits, 1, 1 );
            bits_write( &bits, 13, /* stream->max_buffer_size */ 0 / 1024);
        }
        else
        {
            /* FIXME */
            bits_write( &bits, 1, 0 );
            bits_write( &bits, 13, /* stream->max_buffer_size */ 0 );
        }
    }

    sout_BufferChain( p_buf, p_hdr );
}

/*
 * Find stream to be muxed.
 */
static int MuxGetStream( sout_mux_t *p_mux,
                         int        *pi_stream,
                         mtime_t    *pi_dts )
{
    mtime_t i_dts;
    int     i_stream;
    int     i;

    for( i = 0, i_dts = 0, i_stream = -1; i < p_mux->i_nb_inputs; i++ )
    {
        sout_input_t  *p_input = p_mux->pp_inputs[i];
        sout_buffer_t *p_data;

        if( p_input->p_fifo->i_depth <= 0 )
        {
            if( p_input->p_fmt->i_cat == AUDIO_ES ||
                p_input->p_fmt->i_cat == VIDEO_ES )
            {
                /* We need that audio+video fifo contain at least 1 packet */
                return VLC_EGENERIC;
            }
            /* SPU */
            continue;
        }

        p_data = sout_FifoShow( p_input->p_fifo );
        if( i_stream == -1 ||
            p_data->i_dts < i_dts )
        {
            i_stream = i;
            i_dts    = p_data->i_dts;
        }
    }

    *pi_stream = i_stream;
    *pi_dts = i_dts;

    return VLC_SUCCESS;
}