ts.c 64.6 KB
Newer Older
1
/*****************************************************************************
2
 * ts.c: MPEG-II TS Muxer
3 4
 *****************************************************************************
 * Copyright (C) 2001, 2002 VideoLAN
5
 * $Id$
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
 *
 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
 *          Eric Petit <titer@videolan.org>
 *
 * 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
 *****************************************************************************/

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

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

34 35
#include "iso_lang.h"

36 37
#include "bits.h"
#include "pes.h"
38
#include "csa.h"
39

40 41 42 43 44 45 46 47 48 49 50 51 52 53
#ifdef HAVE_DVBPSI_DR_H
#   include <dvbpsi/dvbpsi.h>
#   include <dvbpsi/descriptor.h>
#   include <dvbpsi/pat.h>
#   include <dvbpsi/pmt.h>
#   include <dvbpsi/dr.h>
#   include <dvbpsi/psi.h>
#else
#   include "dvbpsi.h"
#   include "descriptor.h"
#   include "tables/pat.h"
#   include "tables/pmt.h"
#   include "descriptors/dr.h"
#   include "psi.h"
54 55
#endif

56 57 58 59 60
/*
 * TODO:
 *  - check PCR frequency requirement
 *  - check PAT/PMT  "        "
 *  - check PCR/PCR "soft"
61 62
 *  - check if "registration" descriptor : "AC-3" should be a program
 *    descriptor or an es one. (xine want an es one)
63 64 65 66 67 68 69 70 71 72 73 74 75 76
 *
 *  - remove creation of PAT/PMT without dvbpsi
 *  - ?
 * FIXME:
 *  - subtitle support is far from perfect. I expect some subtitles drop
 *    if they arrive a bit late
 *    (We cannot rely on the fact that the fifo should be full)
 */
/*****************************************************************************
 * Module descriptor
 *****************************************************************************/
static int     Open   ( vlc_object_t * );
static void    Close  ( vlc_object_t * );

zorglub's avatar
zorglub committed
77
#define VPID_TEXT N_("Video PID")
78 79
#define VPID_LONGTEXT N_("Assigns a fixed PID to the video stream. The PCR " \
  "PID will automatically be the video.")
zorglub's avatar
zorglub committed
80
#define APID_TEXT N_("Audio PID")
81
#define APID_LONGTEXT N_("Assigns a fixed PID to the audio stream.")
zorglub's avatar
zorglub committed
82 83

#define SHAPING_TEXT N_("Shaping delay (ms)")
84 85 86 87
#define SHAPING_LONGTEXT N_("If enabled, the TS muxer will cut the " \
  "stream in slices of the given duration, and ensure a constant bitrate " \
  "between the two boundaries. This avoids having huge bitrate peaks for " \
  "reference frames, in particular.")
88
#define KEYF_TEXT N_("Use keyframes")
89 90 91 92 93 94
#define KEYF_LONGTEXT N_("If enabled, and shaping is specified, " \
  "the TS muxer will place the boundaries at the end of I pictures. In " \
  "that case, the shaping duration given by the user is a worse case " \
  "used when no reference frame is available. This enhances the efficiency " \
  "of the shaping algorithm, since I frames are usually the biggest " \
  "frames in the stream.")
zorglub's avatar
zorglub committed
95 96

#define PCR_TEXT N_("PCR delay (ms)")
97 98 99
#define PCR_LONGTEXT N_("This option allows you to set at which interval " \
  "PCRs (Program Clock Reference) will be sent. " \
  "This value should be below 100ms. (default is 30)")
zorglub's avatar
zorglub committed
100 101

#define DTS_TEXT N_("DTS delay (ms)")
102 103 104 105
#define DTS_LONGTEXT N_("This option will delay the DTS (decoding time " \
  "stamps) and PTS (presentation timestamps) of the data in the " \
  "stream, compared to the PCRs. This allows for some buffering inside " \
  "the client decoder.")
zorglub's avatar
zorglub committed
106 107 108 109 110 111

#define ACRYPT_TEXT N_("Crypt audio")
#define ACRYPT_LONGTEXT N_("Crypt audio using CSA")

#define CK_TEXT N_("CSA Key")
#define CK_LONGTEXT N_("Defines the CSA encryption key. This must be a " \
112 113 114 115 116 117 118 119
  "16 char string (8 hexadecimal bytes).")

#define SOUT_CFG_PREFIX "sout-ts-"

vlc_module_begin();
    set_description( _("TS muxer (libdvbpsi)") );
    set_capability( "sout mux", 120 );
    add_shortcut( "ts" );
zorglub's avatar
zorglub committed
120 121 122

    add_integer( SOUT_CFG_PREFIX "pid-video", 0, NULL,VPID_TEXT, VPID_LONGTEXT,
                                  VLC_TRUE );
123 124
    add_integer( SOUT_CFG_PREFIX "pid-audio", 0, NULL, APID_TEXT,
                 APID_LONGTEXT, VLC_TRUE );
zorglub's avatar
zorglub committed
125 126

    add_integer( SOUT_CFG_PREFIX "shaping", 200, NULL,SHAPING_TEXT,
127
                 SHAPING_LONGTEXT, VLC_TRUE );
zorglub's avatar
zorglub committed
128
    add_bool( SOUT_CFG_PREFIX "use-key-frames", VLC_FALSE, NULL, KEYF_TEXT,
129 130 131 132 133 134
              KEYF_LONGTEXT, VLC_TRUE );

    add_integer( SOUT_CFG_PREFIX "pcr", 30, NULL, PCR_TEXT, PCR_LONGTEXT,
                 VLC_TRUE );
    add_integer( SOUT_CFG_PREFIX "dts-delay", 200, NULL, DTS_TEXT,
                 DTS_LONGTEXT, VLC_TRUE );
zorglub's avatar
zorglub committed
135 136

    add_bool( SOUT_CFG_PREFIX "crypt-audio", VLC_TRUE, NULL, ACRYPT_TEXT,
137
              ACRYPT_LONGTEXT, VLC_TRUE );
zorglub's avatar
zorglub committed
138

139 140
    add_string( SOUT_CFG_PREFIX "csa-ck", NULL, NULL, CK_TEXT, CK_LONGTEXT,
                VLC_TRUE );
141

142 143 144 145
    set_callbacks( Open, Close );
vlc_module_end();

/*****************************************************************************
146
 * Local data structures
147
 *****************************************************************************/
148
static const char *ppsz_sout_options[] = {
149 150
    "pid-video", "pid-audio", "shaping", "pcr",
    "use-key-frames", "dts-delay", "csa-ck", "crypt-audio", NULL
151 152
};

153 154
#define SOUT_BUFFER_FLAGS_PRIVATE_PCR  ( 1 << BLOCK_FLAG_PRIVATE_SHIFT )
#define SOUT_BUFFER_FLAGS_PRIVATE_CSA  ( 2 << BLOCK_FLAG_PRIVATE_SHIFT )
155 156
typedef struct
{
157
    int     i_depth;
158 159
    block_t *p_first;
    block_t **pp_last;
160 161 162 163 164 165 166 167
} sout_buffer_chain_t;

static inline void BufferChainInit  ( sout_buffer_chain_t *c )
{
    c->i_depth = 0;
    c->p_first = NULL;
    c->pp_last = &c->p_first;
}
168
static inline void BufferChainAppend( sout_buffer_chain_t *c, block_t *b )
169 170 171 172 173 174 175 176 177 178 179
{
    *c->pp_last = b;
    c->i_depth++;

    while( b->p_next )
    {
        b = b->p_next;
        c->i_depth++;
    }
    c->pp_last = &b->p_next;
}
180
static inline block_t *BufferChainGet( sout_buffer_chain_t *c )
181
{
182
    block_t *b = c->p_first;
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197

    if( b )
    {
        c->i_depth--;
        c->p_first = b->p_next;

        if( c->p_first == NULL )
        {
            c->pp_last = &c->p_first;
        }

        b->p_next = NULL;
    }
    return b;
}
198
static inline block_t *BufferChainPeek( sout_buffer_chain_t *c )
199
{
200
    block_t *b = c->p_first;
201 202 203

    return b;
}
204 205
static inline void BufferChainClean( sout_instance_t *p_sout,
                                     sout_buffer_chain_t *c )
206
{
207
    block_t *b;
208 209 210

    while( ( b = BufferChainGet( c ) ) )
    {
211
        block_Release( b );
212 213 214
    }
    BufferChainInit( c );
}
215

216
typedef struct ts_stream_t
217 218
{
    int             i_pid;
219 220
    vlc_fourcc_t    i_codec;

221 222 223
    int             i_stream_type;
    int             i_stream_id;
    int             i_continuity_counter;
224

225 226 227 228
    /* to be used for carriege of DIV3 */
    vlc_fourcc_t    i_bih_codec;
    int             i_bih_width, i_bih_height;

229 230 231
    /* Specific to mpeg4 in mpeg2ts */
    int             i_es_id;

232
    int             i_decoder_specific_info;
233
    uint8_t         *p_decoder_specific_info;
234

235 236 237
    /* language is iso639-2T */
    uint8_t         lang[3];

238 239 240 241
    sout_buffer_chain_t chain_pes;
    mtime_t             i_pes_dts;
    mtime_t             i_pes_length;
    int                 i_pes_used;
242
    vlc_bool_t          b_key_frame;
243

244 245
} ts_stream_t;

246
struct sout_mux_sys_t
247 248
{
    int             i_pcr_pid;
249 250
    sout_input_t    *p_pcr_input;

251 252 253
    int             i_audio_bound;
    int             i_video_bound;

Christophe Massiot's avatar
Christophe Massiot committed
254 255
    int             i_pid_video;
    int             i_pid_audio;
256 257 258 259 260 261 262 263
    int             i_pid_free; // first usable pid

    int             i_pat_version_number;
    ts_stream_t     pat;

    int             i_pmt_version_number;
    ts_stream_t     pmt;        // Up to now only one program

264 265
    int             i_mpeg4_streams;

266
    int             i_null_continuity_counter;  /* Needed ? */
267

268 269 270
    /* for TS building */
    int64_t             i_bitrate_min;
    int64_t             i_bitrate_max;
271

272
    int64_t             i_shaping_delay;
273
    int64_t             i_pcr_delay;
Laurent Aimar's avatar
Laurent Aimar committed
274

275 276
    int64_t             i_dts_delay;

277 278
    vlc_bool_t          b_use_key_frames;

279
    mtime_t             i_pcr;  /* last PCR emited */
280 281

    csa_t               *csa;
282
    vlc_bool_t          b_crypt_audio;
283
};
284 285


286
/* Reserve a pid and return it */
Christophe Massiot's avatar
Christophe Massiot committed
287
static int  AllocatePID( sout_mux_sys_t *p_sys, int i_cat )
288
{
Christophe Massiot's avatar
Christophe Massiot committed
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
    int i_pid;
    if ( i_cat == VIDEO_ES && p_sys->i_pid_video )
    {
        i_pid = p_sys->i_pid_video;
        p_sys->i_pid_video = 0;
    }
    else if ( i_cat == AUDIO_ES && p_sys->i_pid_audio )
    {
        i_pid = p_sys->i_pid_audio;
        p_sys->i_pid_audio = 0;
    }
    else
    {
        i_pid = ++p_sys->i_pid_free;
    }
    return i_pid;
305 306
}

307 308 309
/*****************************************************************************
 * Local prototypes
 *****************************************************************************/
310 311 312 313
static int Control  ( sout_mux_t *, int, va_list );
static int AddStream( sout_mux_t *, sout_input_t * );
static int DelStream( sout_mux_t *, sout_input_t * );
static int Mux      ( sout_mux_t * );
314 315 316 317 318

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 );
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 );
319 320
static void GetPAT( sout_mux_t *p_mux, sout_buffer_chain_t *c );
static void GetPMT( sout_mux_t *p_mux, sout_buffer_chain_t *c );
321

322 323
static block_t *TSNew( sout_mux_t *p_mux, ts_stream_t *p_stream, vlc_bool_t b_pcr );
static void TSSetPCR( block_t *p_ts, mtime_t i_dts );
324

325
static void PEStoTS  ( sout_instance_t *, sout_buffer_chain_t *, block_t *, ts_stream_t * );
326

327 328 329 330 331
/*****************************************************************************
 * Open:
 *****************************************************************************/
static int Open( vlc_object_t *p_this )
{
332 333
    sout_mux_t          *p_mux =(sout_mux_t*)p_this;
    sout_mux_sys_t      *p_sys;
334
    vlc_value_t         val;
335

336
    msg_Dbg( p_mux, "Open" );
337
    sout_CfgParse( p_mux, SOUT_CFG_PREFIX, ppsz_sout_options, p_mux->p_cfg );
338

339
    p_sys = malloc( sizeof( sout_mux_sys_t ) );
340

341
    p_mux->pf_control   = Control;
342 343 344 345
    p_mux->pf_addstream = AddStream;
    p_mux->pf_delstream = DelStream;
    p_mux->pf_mux       = Mux;
    p_mux->p_sys        = p_sys;
346

347 348
    srand( (uint32_t)mdate() );

349 350
    p_sys->i_audio_bound = 0;
    p_sys->i_video_bound = 0;
351

352 353 354
    p_sys->i_pat_version_number = rand() % 32;
    p_sys->pat.i_pid = 0;
    p_sys->pat.i_continuity_counter = 0;
355

356
    p_sys->i_pmt_version_number = rand() % 32;
357
    p_sys->pmt.i_pid = 0x42;
358
    p_sys->pmt.i_continuity_counter = 0;
359

360
    p_sys->i_pid_free = 0x43;
361

362 363 364
    var_Get( p_mux, SOUT_CFG_PREFIX "pid-video", &val );
    p_sys->i_pid_video = val.i_int;
    if ( p_sys->i_pid_video > p_sys->i_pid_free )
Christophe Massiot's avatar
Christophe Massiot committed
365
    {
366
        p_sys->i_pid_free = p_sys->i_pid_video + 1;
Christophe Massiot's avatar
Christophe Massiot committed
367
    }
368 369 370 371

    var_Get( p_mux, SOUT_CFG_PREFIX "pid-audio", &val );
    p_sys->i_pid_audio = val.i_int;
    if ( p_sys->i_pid_audio > p_sys->i_pid_free )
Christophe Massiot's avatar
Christophe Massiot committed
372
    {
373
        p_sys->i_pid_free = p_sys->i_pid_audio + 1;
Christophe Massiot's avatar
Christophe Massiot committed
374 375
    }

376
    p_sys->i_pcr_pid = 0x1fff;
377
    p_sys->p_pcr_input = NULL;
378

379
    p_sys->i_mpeg4_streams = 0;
380

381 382 383
    p_sys->i_null_continuity_counter = 0;

    /* Allow to create constrained stream */
384
    var_Get( p_mux, SOUT_CFG_PREFIX "bmin", &val );
385
    p_sys->i_bitrate_min = 0;/*val.i_int;*/
386 387

    var_Get( p_mux, SOUT_CFG_PREFIX "bmax", &val );
388
    p_sys->i_bitrate_max = 0;/*val.i_int;*/
389

390 391 392
    if( p_sys->i_bitrate_min > 0 && p_sys->i_bitrate_max > 0 &&
        p_sys->i_bitrate_min > p_sys->i_bitrate_max )
    {
gbazin's avatar
 
gbazin committed
393 394
        msg_Err( p_mux, "incompatible minimum and maximum bitrate, "
                 "disabling bitrate control" );
395 396 397
        p_sys->i_bitrate_min = 0;
        p_sys->i_bitrate_max = 0;
    }
398
    if( p_sys->i_bitrate_min > 0 || p_sys->i_bitrate_max > 0 )
399
    {
400 401
        msg_Err( p_mux, "bmin and bmax no more supported "
                 "(if you need them report it)" );
402 403
    }

404 405 406
    var_Get( p_mux, SOUT_CFG_PREFIX "shaping", &val );
    p_sys->i_shaping_delay = (int64_t)val.i_int * 1000;
    if( p_sys->i_shaping_delay <= 0 )
407
    {
408
        msg_Err( p_mux,
409
                 "invalid shaping ("I64Fd"ms) resetting to 200ms",
410 411
                 p_sys->i_shaping_delay / 1000 );
        p_sys->i_shaping_delay = 200000;
412
    }
gbazin's avatar
 
gbazin committed
413

414 415 416 417
    var_Get( p_mux, SOUT_CFG_PREFIX "pcr", &val );
    p_sys->i_pcr_delay = (int64_t)val.i_int * 1000;
    if( p_sys->i_pcr_delay <= 0 ||
        p_sys->i_pcr_delay >= p_sys->i_shaping_delay )
418
    {
419
        msg_Err( p_mux,
420
                 "invalid pcr delay ("I64Fd"ms) resetting to 30ms",
421 422
                 p_sys->i_pcr_delay / 1000 );
        p_sys->i_pcr_delay = 30000;
423 424
    }

425 426 427
    var_Get( p_mux, SOUT_CFG_PREFIX "dts-delay", &val );
    p_sys->i_dts_delay = (int64_t)val.i_int * 1000;

428 429 430
    msg_Dbg( p_mux, "shaping="I64Fd" pcr="I64Fd" dts_delay="I64Fd,
             p_sys->i_shaping_delay, p_sys->i_pcr_delay, p_sys->i_dts_delay );

431 432 433
    var_Get( p_mux, SOUT_CFG_PREFIX "use-key-frames", &val );
    p_sys->b_use_key_frames = val.b_bool;

Christophe Massiot's avatar
Christophe Massiot committed
434
    /* for TS generation */
435
    p_sys->i_pcr    = 0;
436 437

    p_sys->csa      = NULL;
438 439
    var_Get( p_mux, SOUT_CFG_PREFIX "csa-ck", &val );
    if( val.psz_string )
440
    {
441 442
        char *psz = val.psz_string;

443
        /* skip 0x */
444
        if( psz[0] == '0' && ( psz[1] == 'x' || psz[1] == 'X' ) )
445
        {
446
            psz += 2;
447
        }
448
        if( strlen( psz ) != 16 )
449 450 451 452 453
        {
            msg_Dbg( p_mux, "invalid csa ck (it must be 16 chars long)" );
        }
        else
        {
454
            uint64_t i_ck = strtoll( psz, NULL, 16 );
gbazin's avatar
gbazin committed
455 456 457
            uint8_t  ck[8];
            int      i;

458 459 460 461 462 463 464 465 466 467 468 469
            for( i = 0; i < 8; i++ )
            {
                ck[i] = ( i_ck >> ( 56 - 8*i) )&0xff;
            }

            msg_Dbg( p_mux, "using CSA scrambling with ck=%x:%x:%x:%x:%x:%x:%x:%x",
                     ck[0], ck[1], ck[2], ck[3], ck[4], ck[5], ck[6], ck[7] );

            p_sys->csa = csa_New();
            csa_SetCW( p_sys->csa, ck, ck );
        }
    }
470 471 472 473
    if( val.psz_string ) free( val.psz_string );

    var_Get( p_mux, SOUT_CFG_PREFIX "crypt-audio", &val );
    p_sys->b_crypt_audio = val.b_bool;
474

475 476 477 478 479 480 481 482
    return VLC_SUCCESS;
}

/*****************************************************************************
 * Close:
 *****************************************************************************/
static void Close( vlc_object_t * p_this )
{
483 484
    sout_mux_t          *p_mux = (sout_mux_t*)p_this;
    sout_mux_sys_t      *p_sys = p_mux->p_sys;
485

486
    msg_Dbg( p_mux, "Close" );
487 488 489 490
    if( p_sys->csa )
    {
        csa_Delete( p_sys->csa );
    }
491

492
    free( p_sys );
493 494
}

495
/*****************************************************************************
496
 * Control:
497
 *****************************************************************************/
498
static int Control( sout_mux_t *p_mux, int i_query, va_list args )
499
{
500 501 502
    vlc_bool_t *pb_bool;
    char **ppsz;

503 504
   switch( i_query )
   {
505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
       case MUX_CAN_ADD_STREAM_WHILE_MUXING:
           pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t * );
           *pb_bool = VLC_TRUE;
           return VLC_SUCCESS;

       case MUX_GET_ADD_STREAM_WAIT:
           pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t * );
           *pb_bool = VLC_FALSE;
           return VLC_SUCCESS;

       case MUX_GET_MIME:
           ppsz = (char**)va_arg( args, char ** );
           *ppsz = strdup( "video/mpeg" );  /* FIXME not sure */
           return VLC_SUCCESS;

520
        default:
521
            return VLC_EGENERIC;
522 523
   }
}
524

525 526 527
/*****************************************************************************
 * AddStream: called for each stream addition
 *****************************************************************************/
528
static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input )
529
{
530
    sout_mux_sys_t      *p_sys = p_mux->p_sys;
531 532
    ts_stream_t         *p_stream;

Laurent Aimar's avatar
Laurent Aimar committed
533
    p_input->p_sys = p_stream = malloc( sizeof( ts_stream_t ) );
534

535
    /* Init this new stream */
Christophe Massiot's avatar
Christophe Massiot committed
536
    p_stream->i_pid = AllocatePID( p_sys, p_input->p_fmt->i_cat );
537
    p_stream->i_codec = p_input->p_fmt->i_codec;
538 539 540
    p_stream->i_continuity_counter    = 0;
    p_stream->i_decoder_specific_info = 0;
    p_stream->p_decoder_specific_info = NULL;
541

542 543
    msg_Dbg( p_mux, "adding input codec=%4.4s pid=%d",
             (char*)&p_input->p_fmt->i_codec, p_stream->i_pid );
544

545
    /* All others fields depand on codec */
546
    switch( p_input->p_fmt->i_cat )
547 548
    {
        case VIDEO_ES:
549
            switch( p_input->p_fmt->i_codec )
550 551
            {
                case VLC_FOURCC( 'm', 'p','g', 'v' ):
552
                    /* TODO: do we need to check MPEG-I/II ? */
553
                    p_stream->i_stream_type = 0x02;
554
                    p_stream->i_stream_id = 0xe0;
555 556 557 558
                    break;
                case VLC_FOURCC( 'm', 'p','4', 'v' ):
                    p_stream->i_stream_type = 0x10;
                    p_stream->i_stream_id = 0xfa;
559
                    p_sys->i_mpeg4_streams++;
560
                    p_stream->i_es_id = p_stream->i_pid;
561
                    break;
562 563 564 565
                case VLC_FOURCC( 'h', '2','6', '4' ):
                    p_stream->i_stream_type = 0x1b;
                    p_stream->i_stream_id = 0xe0;
                    break;
566 567
                /* XXX dirty dirty but somebody want that:
                 *     using crapy MS-codec XXX */
568 569 570
                /* I didn't want to do that :P */
                case VLC_FOURCC( 'H', '2', '6', '3' ):
                case VLC_FOURCC( 'I', '2', '6', '3' ):
571
                case VLC_FOURCC( 'W', 'M', 'V', '3' ):
572
                case VLC_FOURCC( 'W', 'M', 'V', '2' ):
573 574 575 576
                case VLC_FOURCC( 'W', 'M', 'V', '1' ):
                case VLC_FOURCC( 'D', 'I', 'V', '3' ):
                case VLC_FOURCC( 'D', 'I', 'V', '2' ):
                case VLC_FOURCC( 'D', 'I', 'V', '1' ):
577
                case VLC_FOURCC( 'M', 'J', 'P', 'G' ):
578 579
                    p_stream->i_stream_type = 0xa0; // private
                    p_stream->i_stream_id = 0xa0;   // beurk
580 581 582
                    p_stream->i_bih_codec  = p_input->p_fmt->i_codec;
                    p_stream->i_bih_width  = p_input->p_fmt->video.i_width;
                    p_stream->i_bih_height = p_input->p_fmt->video.i_height;
583
                    break;
584
                default:
585 586
                    free( p_stream );
                    return VLC_EGENERIC;
587
            }
588
            p_sys->i_video_bound++;
589
            break;
590

591
        case AUDIO_ES:
592
            switch( p_input->p_fmt->i_codec )
593
            {
594
                case VLC_FOURCC( 'm', 'p','g', 'a' ):
595 596
                    p_stream->i_stream_type =
                        p_input->p_fmt->audio.i_rate >= 32000 ? 0x03 : 0x04;
597
                    p_stream->i_stream_id = 0xc0;
598
                    break;
599 600
                case VLC_FOURCC( 'a', '5','2', ' ' ):
                    p_stream->i_stream_type = 0x81;
601
                    p_stream->i_stream_id = 0xbd;
602
                    break;
603 604 605 606 607
                case VLC_FOURCC( 'l', 'p','c', 'm' ):
                    p_stream->i_stream_type = 0x83;
                    p_stream->i_stream_id = 0xbd;
                    break;
                case VLC_FOURCC( 'd', 't','s', ' ' ):
608
                    p_stream->i_stream_type = 0x06;
609 610 611
                    p_stream->i_stream_id = 0xbd;
                    break;

612 613 614
                case VLC_FOURCC( 'm', 'p','4', 'a' ):
                    p_stream->i_stream_type = 0x11;
                    p_stream->i_stream_id = 0xfa;
615
                    p_sys->i_mpeg4_streams++;
616
                    p_stream->i_es_id = p_stream->i_pid;
617 618
                    break;
                default:
619 620
                    free( p_stream );
                    return VLC_EGENERIC;
621
            }
622
            p_sys->i_audio_bound++;
623
            break;
624

625
        case SPU_ES:
626
            switch( p_input->p_fmt->i_codec )
627
            {
628 629
                case VLC_FOURCC( 's', 'p','u', ' ' ):
                    p_stream->i_stream_type = 0x82;
630
                    p_stream->i_stream_id = 0xbd;
631
                    break;
632 633 634 635 636 637
                case VLC_FOURCC( 's', 'u','b', 't' ):
                    p_stream->i_stream_type = 0x12;
                    p_stream->i_stream_id = 0xfa;
                    p_sys->i_mpeg4_streams++;
                    p_stream->i_es_id = p_stream->i_pid;
                    break;
638 639 640 641 642
                case VLC_FOURCC('d','v','b','s'):
                    p_stream->i_stream_type = 0x06;
                    p_stream->i_es_id = p_input->p_fmt->subs.dvb.i_id;
                    p_stream->i_stream_id = 0xa0;
                    break;
643 644 645
                default:
                    free( p_stream );
                    return VLC_EGENERIC;
646
            }
647
            break;
648

649
        default:
650 651
            free( p_stream );
            return VLC_EGENERIC;
652 653
    }

654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
    p_stream->lang[0] =
    p_stream->lang[1] =
    p_stream->lang[2] = '\0';
    if( p_input->p_fmt->psz_language )
    {
        char *psz = p_input->p_fmt->psz_language;
        const iso639_lang_t *pl = NULL;

        if( strlen( psz ) == 2 )
        {
            pl = GetLang_1( psz );
        }
        else if( strlen( psz ) == 3 )
        {
            pl = GetLang_2B( psz );
            if( !strcmp( pl->psz_iso639_1, "??" ) )
            {
                pl = GetLang_2T( psz );
            }
        }
        if( pl && strcmp( pl->psz_iso639_1, "??" ) )
        {
            p_stream->lang[0] = pl->psz_iso639_2T[0];
            p_stream->lang[1] = pl->psz_iso639_2T[1];
            p_stream->lang[2] = pl->psz_iso639_2T[2];

            msg_Dbg( p_mux, "    - lang=%c%c%c",
681
                     p_stream->lang[0], p_stream->lang[1], p_stream->lang[2] );
682 683 684 685
        }
    }


686
    /* Copy extra data (VOL for MPEG-4 and extra BitMapInfoHeader for VFW */
687
    p_stream->i_decoder_specific_info = p_input->p_fmt->i_extra;
688 689 690 691 692
    if( p_stream->i_decoder_specific_info > 0 )
    {
        p_stream->p_decoder_specific_info =
            malloc( p_stream->i_decoder_specific_info );
        memcpy( p_stream->p_decoder_specific_info,
693 694
                p_input->p_fmt->p_extra,
                p_input->p_fmt->i_extra );
695
    }
696

697 698 699 700 701 702
    /* Create decoder specific info for subt */
    if( p_stream->i_codec == VLC_FOURCC( 's', 'u','b', 't' ) )
    {
        uint8_t *p;

        p_stream->i_decoder_specific_info = 55;
703 704
        p_stream->p_decoder_specific_info = p =
            malloc( p_stream->i_decoder_specific_info );
705 706 707 708 709 710 711 712 713 714 715

        p[0] = 0x10;    /* textFormat, 0x10 for 3GPP TS 26.245 */
        p[1] = 0x00;    /* flags: 1b: associated video info flag
                                  3b: reserved
                                  1b: duration flag
                                  3b: reserved */
        p[2] = 52;      /* remaining size */

        p += 3;

        p[0] = p[1] = p[2] = p[3] = 0; p+=4;    /* display flags */
716 717
        *p++ = 0;  /* horizontal justification (-1: left, 0 center, 1 right) */
        *p++ = 1;  /* vertical   justification (-1: top, 0 center, 1 bottom) */
718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744

        p[0] = p[1] = p[2] = 0x00; p+=3;/* background rgb */
        *p++ = 0xff;                    /* background a */

        p[0] = p[1] = 0; p += 2;        /* text box top */
        p[0] = p[1] = 0; p += 2;        /* text box left */
        p[0] = p[1] = 0; p += 2;        /* text box bottom */
        p[0] = p[1] = 0; p += 2;        /* text box right */

        p[0] = p[1] = 0; p += 2;        /* start char */
        p[0] = p[1] = 0; p += 2;        /* end char */
        p[0] = p[1] = 0; p += 2;        /* default font id */

        *p++ = 0;                       /* font style flags */
        *p++ = 12;                      /* font size */

        p[0] = p[1] = p[2] = 0x00; p+=3;/* foreground rgb */
        *p++ = 0x00;                    /* foreground a */

        p[0] = p[1] = p[2] = 0; p[3] = 22; p += 4;
        memcpy( p, "ftab", 4 ); p += 4;
        *p++ = 0; *p++ = 1;             /* entry count */
        p[0] = p[1] = 0; p += 2;        /* font id */
        *p++ = 9;                       /* font name length */
        memcpy( p, "Helvetica", 9 );    /* font name */
    }

745 746 747 748 749
    /* Init pes chain */
    BufferChainInit( &p_stream->chain_pes );
    p_stream->i_pes_dts    = 0;
    p_stream->i_pes_length = 0;
    p_stream->i_pes_used   = 0;
750
    p_stream->b_key_frame  = 0;
751 752 753 754 755 756 757 758 759 760 761

    /* We only change PMT version (PAT isn't changed) */
    p_sys->i_pmt_version_number = ( p_sys->i_pmt_version_number + 1 )%32;

    /* Update pcr_pid */
    if( p_input->p_fmt->i_cat != SPU_ES &&
        ( p_sys->i_pcr_pid == 0x1fff || p_input->p_fmt->i_cat == VIDEO_ES ) )
    {
        if( p_sys->p_pcr_input )
        {
            /* There was already a PCR stream, so clean context */
762
            /* FIXME */
763 764 765
        }
        p_sys->i_pcr_pid   = p_stream->i_pid;
        p_sys->p_pcr_input = p_input;
766 767

        msg_Dbg( p_mux, "new PCR PID is %d", p_sys->i_pcr_pid );
768 769 770
    }

    return VLC_SUCCESS;
771 772
}

773 774 775
/*****************************************************************************
 * DelStream: called before a stream deletion
 *****************************************************************************/
776
static int DelStream( sout_mux_t *p_mux, sout_input_t *p_input )
777
{
778 779
    sout_mux_sys_t  *p_sys = p_mux->p_sys;
    ts_stream_t     *p_stream;
780
    vlc_value_t     val;
781

782
    p_stream = (ts_stream_t*)p_input->p_sys;
783
    msg_Dbg( p_mux, "removing input pid=%d", p_stream->i_pid );
784

785 786 787 788 789 790
    if( p_sys->i_pcr_pid == p_stream->i_pid )
    {
        int i;

        /* Find a new pcr stream (Prefer Video Stream) */
        p_sys->i_pcr_pid = 0x1fff;
791
        p_sys->p_pcr_input = NULL;
792 793 794 795 796 797 798 799 800
        for( i = 0; i < p_mux->i_nb_inputs; i++ )
        {
            if( p_mux->pp_inputs[i] == p_input )
            {
                continue;
            }

            if( p_mux->pp_inputs[i]->p_fmt->i_cat == VIDEO_ES )
            {
801 802
                p_sys->i_pcr_pid  =
                    ((ts_stream_t*)p_mux->pp_inputs[i]->p_sys)->i_pid;
803 804 805
                p_sys->p_pcr_input= p_mux->pp_inputs[i];
                break;
            }
806 807
            else if( p_mux->pp_inputs[i]->p_fmt->i_cat != SPU_ES &&
                     p_sys->i_pcr_pid == 0x1fff )
808
            {
809 810
                p_sys->i_pcr_pid  =
                    ((ts_stream_t*)p_mux->pp_inputs[i]->p_sys)->i_pid;
811 812 813 814 815 816
                p_sys->p_pcr_input= p_mux->pp_inputs[i];
            }
        }
        if( p_sys->p_pcr_input )
        {
            /* Empty TS buffer */
817
            /* FIXME */
818
        }
819
        msg_Dbg( p_mux, "new PCR PID is %d", p_sys->i_pcr_pid );
820 821
    }

822 823 824
    /* Empty all data in chain_pes */
    BufferChainClean( p_mux->p_sout, &p_stream->chain_pes );

825 826 827 828
    if( p_stream->p_decoder_specific_info )
    {
        free( p_stream->p_decoder_specific_info );
    }
829 830 831
    if( p_stream->i_stream_id == 0xfa ||
        p_stream->i_stream_id == 0xfb ||
        p_stream->i_stream_id == 0xfe )
832
    {
833
        p_sys->i_mpeg4_streams--;
834
    }
835 836 837

    var_Get( p_mux, SOUT_CFG_PREFIX "pid-video", &val );
    if( val.i_int > 0 )
838
    {
839
        int i_pid_video = val.i_int;
840 841 842
        if ( i_pid_video == p_stream->i_pid )
        {
            p_sys->i_pid_video = i_pid_video;
843
            msg_Dbg( p_mux, "freeing video PID %d", i_pid_video );
844 845
        }
    }
846 847
    var_Get( p_mux, SOUT_CFG_PREFIX "pid-audio", &val );
    if( val.i_int > 0 )
848
    {
849
        int i_pid_audio = val.i_int;
850 851 852
        if ( i_pid_audio == p_stream->i_pid )
        {
            p_sys->i_pid_audio = i_pid_audio;
853
            msg_Dbg( p_mux, "freeing audio PID %d", i_pid_audio );
854 855
        }
    }
Laurent Aimar's avatar
Laurent Aimar committed
856 857
    free( p_stream );

858
    /* We only change PMT version (PAT isn't changed) */
859
    p_sys->i_pmt_version_number++; p_sys->i_pmt_version_number %= 32;
860

861
    return VLC_SUCCESS;
862 863
}

864 865 866 867 868 869 870 871
/*****************************************************************************
 * 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;
872
    ts_stream_t     *p_pcr_stream;
873

874 875
    if( p_sys->i_pcr_pid == 0x1fff )
    {
876
        msg_Dbg( p_mux, "waiting for PCR streams" );