break;                    }                    i_size = p_pes->i_size * 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_buffer_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_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 )            {                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 )            {                p_ts->i_flags |= SOUT_BUFFER_FLAGS_PRIVATE_CSA;            }            i_packet_pos++;            /* */            BufferChainAppend( &chain_ts, p_ts );        }        /* 4: date and send */        i_packet_count = chain_ts.i_depth;        /* msg_Dbg( p_mux, "real pck=%d", i_packet_count ); */        for( i = 0; i < i_packet_count; i++ )        {            sout_buffer_t *p_ts = BufferChainGet( &chain_ts );            p_ts->i_dts    = i_pcr_dts + i_pcr_length * i / i_packet_count;            p_ts->i_length = i_pcr_length / i_packet_count;            if( p_ts->i_flags&SOUT_BUFFER_FLAGS_PRIVATE_PCR )            {                /* 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&SOUT_BUFFER_FLAGS_PRIVATE_CSA )            {                csa_Encrypt( p_sys->csa, p_ts->p_buffer, 0 );            }            /* latency */            p_ts->i_dts += 3*p_sys->i_caching_delay/2;            sout_AccessOutWrite( p_mux->p_access, p_ts );        }    }}static sout_buffer_t *TSNew( sout_mux_t *p_mux, ts_stream_t *p_stream, vlc_bool_t b_pcr ){    sout_buffer_t *p_pes = p_stream->chain_pes.p_first;    sout_buffer_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_size - p_stream->i_pes_used, i_payload_max );    if( b_pcr || i_payload < i_payload_max )    {        b_adaptation_field = VLC_TRUE;    }    p_ts = sout_BufferNew( p_mux->p_sout, 188 );    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;            p_ts->i_flags |= SOUT_BUFFER_FLAGS_PRIVATE_PCR;            p_ts->p_buffer[4] = 7 + i_stuffing;            p_ts->p_buffer[5] = 0x10;   /* flags */            p_ts->p_buffer[6] = ( 0 )&0xff;            p_ts->p_buffer[7] = ( 0 )&0xff;            p_ts->p_buffer[8] = ( 0 )&0xff;            p_ts->p_buffer[9] = ( 0 )&0xff;            p_ts->p_buffer[10]= ( 0 )&0x80;            p_ts->p_buffer[11]= 0;            for( i = 12; i < 12 + i_stuffing; i++ )            {                p_ts->p_buffer[i] = 0xff;            }        }        else        {            int i_stuffing = i_payload_max - i_payload;            p_ts->p_buffer[4] = i_stuffing - 1;            if( i_stuffing > 1 )            {                p_ts->p_buffer[5] = 0x00;                for( i = 6; i < 6 + i_stuffing - 2; i++ )                {                    p_ts->p_buffer[i] = 0xff;                }            }        }    }    /* copy payload */    memcpy( &p_ts->p_buffer[188 - i_payload], &p_pes->p_buffer[p_stream->i_pes_used], i_payload );    p_stream->i_pes_used += i_payload;    p_stream->i_pes_dts      = p_pes->i_dts + p_pes->i_length * p_stream->i_pes_used / p_pes->i_size;    p_stream->i_pes_length  -= p_pes->i_length * i_payload / p_pes->i_size;    if( p_stream->i_pes_used >= (int)p_pes->i_size )    {        p_pes = BufferChainGet( &p_stream->chain_pes );        sout_BufferDelete( p_mux->p_sout, p_pes );        p_pes = p_stream->chain_pes.p_first;        if( p_pes )        {            p_stream->i_pes_dts    = p_pes->i_dts;            p_stream->i_pes_length = 0;            while( p_pes )            {                p_stream->i_pes_length += p_pes->i_length;                p_pes = p_pes->p_next;            }        }        else        {            p_stream->i_pes_dts = 0;            p_stream->i_pes_length = 0;        }        p_stream->i_pes_used = 0;    }    return p_ts;}static void TSSetPCR( sout_buffer_t *p_ts, mtime_t i_dts ){    mtime_t i_pcr = 9 * i_dts / 100;    p_ts->p_buffer[6]  = ( i_pcr >> 25 )&0xff;    p_ts->p_buffer[7]  = ( i_pcr >> 17 )&0xff;    p_ts->p_buffer[8]  = ( i_pcr >> 9  )&0xff;    p_ts->p_buffer[9]  = ( i_pcr >> 1  )&0xff;    p_ts->p_buffer[10]|= ( i_pcr << 7  )&0x80;}#if 0static void TSSetConstraints( sout_mux_t *p_mux, sout_buffer_chain_t *c, mtime_t i_length, int i_bitrate_min, int i_bitrate_max ){    sout_mux_sys_t  *p_sys = p_mux->p_sys;    sout_buffer_chain_t s = *c;    int i_packets = 0;    int i_packets_min = 0;    int i_packets_max = 0;    if( i_length <= 0 )    {        return;    }    i_packets     = c->i_depth;    i_packets_min = ( (int64_t)i_bitrate_min * i_length / 8 / 1000000  + 187 ) / 188;    i_packets_max = ( (int64_t)i_bitrate_max * i_length / 8 / 1000000  + 187 ) / 188;    if( i_packets < i_packets_min && i_packets_min > 0 )    {        sout_buffer_t *p_pk;        int i_div = ( i_packets_min - i_packets ) / i_packets;        int i_mod = ( i_packets_min - i_packets ) % i_packets;        int i_rest = 0;        /* We need to pad with null packets (pid=0x1fff)         * We try to melt null packets with true packets */        msg_Dbg( p_mux,                 "packets=%d but min=%d -> adding %d packets of padding",                 i_packets, i_packets_min, i_packets_min - i_packets );        BufferChainInit( c );        while( ( p_pk = BufferChainGet( &s ) ) )        {            int i, i_null;            BufferChainAppend( c, p_pk );            i_null = i_div + ( i_rest + i_mod ) / i_packets;            for( i = 0; i < i_null; i++ )            {                sout_buffer_t *p_null;                p_null = sout_BufferNew( p_mux->p_sout, 188 );                p_null->p_buffer[0] = 0x47;                p_null->p_buffer[1] = 0x1f;                p_null->p_buffer[2] = 0xff;                p_null->p_buffer[3] = 0x10 | p_sys->i_null_continuity_counter;                memset( &p_null->p_buffer[4], 0, 184 );                p_sys->i_null_continuity_counter =                    ( p_sys->i_null_continuity_counter + 1 ) % 16;                BufferChainAppend( c, p_null );            }            i_rest = ( i_rest + i_mod ) % i_packets;        }    }    else if( i_packets > i_packets_max && i_packets_max > 0 )    {        sout_buffer_t *p_pk;        int           i;        /* Arg, we need to drop packets, I don't do something clever (like         * dropping complete pid, b frames, ... ), I just get the right amount         * of packets and discard the others */        msg_Warn( p_mux,                  "packets=%d but max=%d -> removing %d packets -> stream broken",                  i_packets, i_packets_max, i_packets - i_packets_max );        BufferChainInit( c );        for( i = 0; i < i_packets_max; i++ )        {            BufferChainAppend( c, BufferChainGet( &s ) );        }        while( ( p_pk = BufferChainGet( &s ) ) )        {            sout_BufferDelete( p_mux->p_sout, p_pk );        }    }}#endifstatic void PEStoTS( sout_instance_t *p_sout,                     sout_buffer_chain_t *c, sout_buffer_t *p_pes,                     ts_stream_t *p_stream ){    uint8_t *p_data;    int     i_size;    int     b_new_pes;    /* get PES total size */    i_size = p_pes->i_size;    p_data = p_pes->p_buffer;    b_new_pes = VLC_TRUE;    for( ;; )    {        int           b_adaptation_field;        int           i_copy;        sout_buffer_t *p_ts;        p_ts = sout_BufferNew( p_sout, 188 );        /* write header         * 8b   0x47    sync byte         * 1b           transport_error_indicator         * 1b           payload_unit_start         * 1b           transport_priority         * 13b          pid         * 2b           transport_scrambling_control         * 2b           if adaptation_field 0x03 else 0x01         * 4b           continuity_counter         */        i_copy    = __MIN( i_size, 184 );        b_adaptation_field = i_size < 184 ? VLC_TRUE : VLC_FALSE;        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;        b_new_pes = VLC_FALSE;        p_stream->i_continuity_counter = (p_stream->i_continuity_counter+1)%16;        if( b_adaptation_field )        {            int i_stuffing = 184 - i_copy;            int i;            p_ts->p_buffer[4] = i_stuffing - 1;            if( i_stuffing > 1 )            {                p_ts->p_buffer[5] = 0x00;                for( i = 6; i < 6 + i_stuffing - 2; i++ )                {                    p_ts->p_buffer[i] = 0xff;                }            }        }        /* copy payload */        memcpy( &p_ts->p_buffer[188 - i_copy], p_data, i_copy );        p_data += i_copy;        i_size -= i_copy;        BufferChainAppend( c, p_ts );        if( i_size <= 0 )        {            sout_buffer_t *p_next = p_pes->p_next;            p_pes->p_next = NULL;            sout_BufferDelete( p_sout, p_pes );            if( p_next == NULL )            {                break;            }            b_new_pes = VLC_TRUE;            p_pes = p_next;            i_size = p_pes->i_size;            p_data = p_pes->p_buffer;        }    }    return;}#if defined MODULE_NAME_IS_mux_tsstatic uint32_t CalculateCRC( uint8_t *p_begin, int i_count ){    static uint32_t CRC32[256] =    {        0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9,        0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,        0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,        0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,        0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9,        0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,        0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011,        0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,        0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,        0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,        0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81,        0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,        0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49,        0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,        0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,        0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,        0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae,        0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,        0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,        0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,        0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,        0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,        0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066,        0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,        0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e,        0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,        0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,        0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,        0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,        0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,        0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686,