ts.c

video linux conference

                                i_header_size = 0x24;
                                b_data_alignment = 1;
                            }
                        }
                        else if( p_data->i_length < 0 ||
                                 p_data->i_length > 2000000 )
                        {
                            /* FIXME choose a better value, but anyway we
                             * should never have to do that */
                            p_data->i_length = 1000;
                        }

                        p_stream->i_pes_length += p_data->i_length;
                        if( p_stream->i_pes_dts == 0 )
                        {
                            p_stream->i_pes_dts = p_data->i_dts;
                        }

                        /* Convert to pes */
                        if( p_stream->i_stream_id == 0xa0 &&
                            p_data->i_pts <= 0 )
                        {
                            /* XXX yes I know, it's awfull, but it's needed,
                             * so don't remove it ... */
                            p_data->i_pts = p_data->i_dts;
                        }
                        E_( EStoPES )( p_mux->p_sout, &p_data, p_data,
                                       p_input->p_fmt, p_stream->i_stream_id,
                                       1, b_data_alignment, i_header_size, 0 );

                        BufferChainAppend( &p_stream->chain_pes, p_data );

                        if( p_sys->b_use_key_frames && p_stream == p_pcr_stream
                            && (p_data->i_flags & BLOCK_FLAG_TYPE_I)
                            && !(p_data->i_flags & BLOCK_FLAG_NO_KEYFRAME)
                            && (p_stream->i_pes_length > 400000) )
                        {
                            i_shaping_delay = p_stream->i_pes_length;
                            p_stream->b_key_frame = 1;
                        }
                    }
                }
            }

            if( b_ok )
            {
                break;
            }
        }

        /* save */
        i_pcr_dts      = p_pcr_stream->i_pes_dts;
        i_pcr_length   = p_pcr_stream->i_pes_length;
        p_pcr_stream->b_key_frame = 0;

        /* msg_Dbg( p_mux, "starting muxing %lldms", i_pcr_length / 1000 ); */
        /* 2: calculate non accurate total size of muxed ts */
        i_packet_count = 0;
        for( i = 0; i < p_mux->i_nb_inputs; i++ )
        {
            ts_stream_t *p_stream = (ts_stream_t*)p_mux->pp_inputs[i]->p_sys;
            block_t *p_pes;

            /* False for pcr stream but it will be enough to do PCR algo */
            for( p_pes = p_stream->chain_pes.p_first; p_pes != NULL;
                 p_pes = p_pes->p_next )
            {
                int i_size = p_pes->i_buffer;
                if( p_pes->i_dts + p_pes->i_length >
                    p_pcr_stream->i_pes_dts + p_pcr_stream->i_pes_length )
                {
                    mtime_t i_frag = p_pcr_stream->i_pes_dts +
                        p_pcr_stream->i_pes_length - p_pes->i_dts;
                    if( i_frag < 0 )
                    {
                        /* Next stream */
                        break;
                    }
                    i_size = p_pes->i_buffer * i_frag / p_pes->i_length;
                }
                i_packet_count += ( i_size + 183 ) / 184;
            }
        }
        /* add overhead for PCR (not really exact) */
        i_packet_count += (8 * i_pcr_length / p_sys->i_pcr_delay + 175) / 176;

        /* 3: mux PES into TS */
        BufferChainInit( &chain_ts );
        /* append PAT/PMT  -> FIXME with big pcr delay it won't have enough pat/pmt */
        GetPAT( p_mux, &chain_ts );
        GetPMT( p_mux, &chain_ts );
        i_packet_pos = 0;
        i_packet_count += chain_ts.i_depth;
        /* msg_Dbg( p_mux, "estimated pck=%d", i_packet_count ); */

        for( ;; )
        {
            int         i_stream;
            mtime_t     i_dts;
            ts_stream_t *p_stream;
            sout_input_t *p_input;
            block_t *p_ts;
            vlc_bool_t   b_pcr;

            /* Select stream (lowest dts) */
            for( i = 0, i_stream = -1, i_dts = 0; i < p_mux->i_nb_inputs; i++ )
            {
                p_input = p_mux->pp_inputs[i];
                p_stream = (ts_stream_t*)p_mux->pp_inputs[i]->p_sys;

                if( p_stream->i_pes_dts == 0 )
                {
                    continue;
                }

                if( i_stream == -1 ||
                    p_stream->i_pes_dts < i_dts )
                {
                    i_stream = i;
                    i_dts = p_stream->i_pes_dts;
                }
            }
            if( i_stream == -1 || i_dts > i_pcr_dts + i_pcr_length )
            {
                break;
            }
            p_stream = (ts_stream_t*)p_mux->pp_inputs[i_stream]->p_sys;

            /* do we need to issue pcr */
            b_pcr = VLC_FALSE;
            if( p_stream == p_pcr_stream &&
                i_pcr_dts + i_packet_pos * i_pcr_length / i_packet_count >=
                p_sys->i_pcr + p_sys->i_pcr_delay )
            {
                b_pcr = VLC_TRUE;
                p_sys->i_pcr = i_pcr_dts + i_packet_pos *
                    i_pcr_length / i_packet_count;
            }

            /* Build the TS packet */
            p_ts = TSNew( p_mux, p_stream, b_pcr );
            if( p_sys->csa != NULL &&
                 (p_input->p_fmt->i_cat != AUDIO_ES || p_sys->b_crypt_audio) )
            {
                p_ts->i_flags |= BLOCK_FLAG_SCRAMBLED;
            }
            i_packet_pos++;

            /* */
            BufferChainAppend( &chain_ts, p_ts );
        }

        /* 4: date and send */
        TSSchedule( p_mux, &chain_ts, i_pcr_length, i_pcr_dts );
    }
}

#define STD_PES_PAYLOAD 170
static block_t *FixPES( sout_mux_t *p_mux, block_fifo_t *p_fifo )
{
    block_t *p_data;
    int i_size;

    p_data = block_FifoShow( p_fifo );
    i_size = p_data->i_buffer;

    if( i_size == STD_PES_PAYLOAD )
    {
        return block_FifoGet( p_fifo );
    }
    else if( i_size > STD_PES_PAYLOAD )
    {
        block_t *p_new = block_New( p_mux, STD_PES_PAYLOAD );
        p_mux->p_vlc->pf_memcpy( p_new->p_buffer, p_data->p_buffer, STD_PES_PAYLOAD );
        p_new->i_pts = p_data->i_pts;
        p_new->i_dts = p_data->i_dts;
        p_new->i_length = p_data->i_length * STD_PES_PAYLOAD
                            / p_data->i_buffer;
        p_data->i_buffer -= STD_PES_PAYLOAD;
        p_data->p_buffer += STD_PES_PAYLOAD;
        p_data->i_pts += p_new->i_length;
        p_data->i_dts += p_new->i_length;
        p_data->i_length -= p_new->i_length;
        p_data->i_flags |= BLOCK_FLAG_NO_KEYFRAME;
        return p_new;
    }
    else
    {
        block_t *p_next;
        int i_copy;

        p_data = block_FifoGet( p_fifo );
        p_data = block_Realloc( p_data, 0, STD_PES_PAYLOAD );
        p_next = block_FifoShow( p_fifo );
        if ( p_data->i_flags & BLOCK_FLAG_NO_KEYFRAME )
        {
            p_data->i_flags &= ~BLOCK_FLAG_NO_KEYFRAME;
            p_data->i_pts = p_next->i_pts;
            p_data->i_dts = p_next->i_dts;
        }
        i_copy = __MIN( STD_PES_PAYLOAD - i_size, p_next->i_buffer );

        p_mux->p_vlc->pf_memcpy( &p_data->p_buffer[i_size], p_next->p_buffer,
                                 i_copy );
        p_next->i_pts += p_next->i_length * i_copy / p_next->i_buffer;
        p_next->i_dts += p_next->i_length * i_copy / p_next->i_buffer;
        p_next->i_length -= p_next->i_length * i_copy / p_next->i_buffer;
        p_next->i_buffer -= i_copy;
        p_next->p_buffer += i_copy;
        p_next->i_flags |= BLOCK_FLAG_NO_KEYFRAME;

        if( !p_next->i_buffer )
        {
            p_next = block_FifoGet( p_fifo );
            block_Release( p_next );
        }
        return p_data;
    }
}

static void TSSchedule( sout_mux_t *p_mux, sout_buffer_chain_t *p_chain_ts,
                        mtime_t i_pcr_length, mtime_t i_pcr_dts )
{
    sout_mux_sys_t  *p_sys = p_mux->p_sys;
    sout_buffer_chain_t new_chain;
    int i_packet_count = p_chain_ts->i_depth;
    int i;

    BufferChainInit( &new_chain );

    if ( i_pcr_length <= 0 )
    {
        i_pcr_length = i_packet_count;
    }

    for( i = 0; i < i_packet_count; i++ )
    {
        block_t *p_ts = BufferChainGet( p_chain_ts );
        mtime_t i_new_dts = i_pcr_dts + i_pcr_length * i / i_packet_count;

        BufferChainAppend( &new_chain, p_ts );

        if( p_ts->i_dts &&
            p_ts->i_dts + p_sys->i_dts_delay * 2/3 < i_new_dts )
        {
            mtime_t i_max_diff = i_new_dts - p_ts->i_dts;
            mtime_t i_cut_dts = p_ts->i_dts;

            p_ts = BufferChainPeek( p_chain_ts );
            i++;
            i_new_dts = i_pcr_dts + i_pcr_length * i / i_packet_count;
            while ( p_ts != NULL && i_new_dts - p_ts->i_dts >= i_max_diff )
            {
                p_ts = BufferChainGet( p_chain_ts );
                i_max_diff = i_new_dts - p_ts->i_dts;
                i_cut_dts = p_ts->i_dts;
                BufferChainAppend( &new_chain, p_ts );

                p_ts = BufferChainPeek( p_chain_ts );
                i++;
                i_new_dts = i_pcr_dts + i_pcr_length * i / i_packet_count;
            }
            msg_Dbg( p_mux, "adjusting rate at "I64Fd"/"I64Fd" (%d/%d)",
                     i_cut_dts - i_pcr_dts, i_pcr_length, new_chain.i_depth,
                     p_chain_ts->i_depth );
            if ( new_chain.i_depth )
                TSDate( p_mux, &new_chain,
                        i_cut_dts - i_pcr_dts,
                        i_pcr_dts );
            if ( p_chain_ts->i_depth )
                TSSchedule( p_mux,
                            p_chain_ts, i_pcr_dts + i_pcr_length - i_cut_dts,
                            i_cut_dts );
            return;
        }
    }

    if ( new_chain.i_depth )
        TSDate( p_mux, &new_chain, i_pcr_length, i_pcr_dts );
}

static void TSDate( sout_mux_t *p_mux, sout_buffer_chain_t *p_chain_ts,
                    mtime_t i_pcr_length, mtime_t i_pcr_dts )
{
    sout_mux_sys_t  *p_sys = p_mux->p_sys;
    int i_packet_count = p_chain_ts->i_depth;
    int i;

    if ( i_pcr_length / 1000 > 0 )
    {
        int i_bitrate = ((uint64_t)i_packet_count * 188 * 8000)
                          / (uint64_t)(i_pcr_length / 1000);
        if ( p_sys->i_bitrate_max && p_sys->i_bitrate_max < i_bitrate )
        {
            msg_Warn( p_mux, "max bitrate exceeded at "I64Fd
                      " (%d bi/s for %d pkt in "I64Fd" us)",
                      i_pcr_dts + p_sys->i_shaping_delay * 3 / 2 - mdate(),
                      i_bitrate, i_packet_count, i_pcr_length);
        }
#if 0
        else
        {
            msg_Dbg( p_mux, "starting at "I64Fd
                     " (%d bi/s for %d packets in "I64Fd" us)",
                     i_pcr_dts + p_sys->i_shaping_delay * 3 / 2 - mdate(),
                     i_bitrate, i_packet_count, i_pcr_length);
        }
#endif
    }
    else
    {
        /* This shouldn't happen, but happens in some rare heavy load
         * and packet losses conditions. */
        i_pcr_length = i_packet_count;
    }

    /* msg_Dbg( p_mux, "real pck=%d", i_packet_count ); */
    for( i = 0; i < i_packet_count; i++ )
    {
        block_t *p_ts = BufferChainGet( p_chain_ts );
        mtime_t i_new_dts = i_pcr_dts + i_pcr_length * i / i_packet_count;

        p_ts->i_dts    = i_new_dts;
        p_ts->i_length = i_pcr_length / i_packet_count;

        if( p_ts->i_flags & BLOCK_FLAG_CLOCK )
        {
            /* msg_Dbg( p_mux, "pcr=%lld ms", p_ts->i_dts / 1000 ); */
            TSSetPCR( p_ts, p_ts->i_dts - p_sys->i_dts_delay );
        }
        if( p_ts->i_flags & BLOCK_FLAG_SCRAMBLED )
        {
            csa_Encrypt( p_sys->csa, p_ts->p_buffer, 0 );
        }

        /* latency */
        p_ts->i_dts += p_sys->i_shaping_delay * 3 / 2;

        sout_AccessOutWrite( p_mux->p_access, p_ts );
    }
}

static block_t *TSNew( sout_mux_t *p_mux, ts_stream_t *p_stream,
                       vlc_bool_t b_pcr )
{
    block_t *p_pes = p_stream->chain_pes.p_first;
    block_t *p_ts;

    vlc_bool_t b_new_pes = VLC_FALSE;
    vlc_bool_t b_adaptation_field = VLC_FALSE;

    int        i_payload_max = 184 - ( b_pcr ? 8 : 0 );
    int        i_payload;

    if( p_stream->i_pes_used <= 0 )
    {
        b_new_pes = VLC_TRUE;
    }
    i_payload = __MIN( (int)p_pes->i_buffer - p_stream->i_pes_used,
                       i_payload_max );

    if( b_pcr || i_payload < i_payload_max )
    {
        b_adaptation_field = VLC_TRUE;
    }

    p_ts = block_New( p_mux, 188 );
    p_ts->i_dts = p_pes->i_dts;

    p_ts->p_buffer[0] = 0x47;
    p_ts->p_buffer[1] = ( b_new_pes ? 0x40 : 0x00 ) |
        ( ( p_stream->i_pid >> 8 )&0x1f );
    p_ts->p_buffer[2] = p_stream->i_pid & 0xff;
    p_ts->p_buffer[3] = ( b_adaptation_field ? 0x30 : 0x10 ) |
        p_stream->i_continuity_counter;

    p_stream->i_continuity_counter = (p_stream->i_continuity_counter+1)%16;

    if( b_adaptation_field )
    {
        int i;

        if( b_pcr )
        {
            int     i_stuffing = i_payload_max - i_payload;