input.c 55.6 KB
Newer Older
1 2
/*****************************************************************************
 * input.c: input thread
Michel Kaempf's avatar
Michel Kaempf committed
3 4
 * Read an MPEG2 stream, demultiplex and parse it before sending it to
 * decoders.
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 *****************************************************************************
 * Copyright (C) 1998, 1999, 2000 VideoLAN
 *
 * Authors:
 *
 * 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-1307, USA.
24
 *****************************************************************************/
Michel Kaempf's avatar
Michel Kaempf committed
25

26
/*****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
27
 * Preamble
28
 *****************************************************************************/
29 30
#include "defs.h"

31
#include <errno.h>                                                  /* errno */
32 33
#include <sys/types.h>                        /* on BSD, uio.h needs types.h */
#include <sys/uio.h>                                            /* "input.h" */
34
#include <string.h>                                            /* strerror() */
Michel Kaempf's avatar
Michel Kaempf committed
35

36 37
#include <stdlib.h>                                                /* free() */
#include <netinet/in.h>                                           /* ntohs() */
Michel Kaempf's avatar
Michel Kaempf committed
38 39

#include "config.h"
40 41
#include "common.h"
#include "threads.h"
Michel Kaempf's avatar
Michel Kaempf committed
42 43
#include "mtime.h"
#include "intf_msg.h"
44
#include "plugins.h"
Michel Kaempf's avatar
Michel Kaempf committed
45 46 47 48 49 50 51 52 53 54
#include "debug.h"

#include "input.h"
#include "input_psi.h"
#include "input_pcr.h"
#include "input_netlist.h"
#include "decoder_fifo.h"
#include "input_file.h"
#include "input_network.h"

55
#include "audio_output.h"                                   /* aout_thread_t */
56

Michel Lespinasse's avatar
 
Michel Lespinasse committed
57 58
#include "audio_decoder.h"        /* audiodec_t (for audio_decoder_thread.h) */
#include "audio_decoder_thread.h"                           /* adec_thread_t */
59

60 61 62
#include "ac3_decoder.h"              /* ac3dec_t (for ac3_decoder_thread.h) */
#include "ac3_decoder_thread.h"                           /* ac3dec_thread_t */

63 64 65 66 67 68 69 70 71 72 73
#include "video.h"                          /* picture_t (for video_output.h) */
#include "video_output.h"                                   /* vout_thread_t */

#include "vdec_idct.h"                     /* dctelem_t (for video_parser.h) */
#include "vdec_motion.h"                  /* f_motion_t (for video_parser.h) */
#include "vpar_blocks.h"                /* macroblock_t (for video_parser.h) */
#include "vpar_headers.h"                 /* sequence_t (for video_parser.h) */
#include "vpar_synchro.h"            /* video_synchro_t (for video_parser.h) */
#include "video_parser.h"                                   /* vpar_thread_t */

#include "spu_decoder.h"                                  /* spudec_thread_t */
Michel Lespinasse's avatar
Yop,  
Michel Lespinasse committed
74 75

#include "main.h"
Michel Kaempf's avatar
Michel Kaempf committed
76

77
/*****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
78
 * Local prototypes
79
 *****************************************************************************/
80 81 82 83 84 85 86 87
static void RunThread   ( input_thread_t *p_input );
static void ErrorThread ( input_thread_t *p_input );
static void EndThread   ( input_thread_t *p_input );

static __inline__ int   input_ReadPacket( input_thread_t *p_input );
static __inline__ void  input_SortPacket( input_thread_t *p_input,
                                          ts_packet_t *ts_packet );
static __inline__ void  input_DemuxTS( input_thread_t *p_input,
Michel Kaempf's avatar
Michel Kaempf committed
88
                                       ts_packet_t *ts_packet,
89 90 91 92 93
                                       es_descriptor_t *es_descriptor );
static __inline__ void  input_DemuxPES( input_thread_t *p_input,
                                        ts_packet_t *ts_packet,
                                        es_descriptor_t *p_es_descriptor,
                                        boolean_t b_unit_start, boolean_t b_packet_lost );
94 95
static __inline__ void  input_ParsePES( input_thread_t *p_input,
                                        es_descriptor_t *p_es_descriptor );
96 97 98 99
static __inline__ void  input_DemuxPSI( input_thread_t *p_input,
                                        ts_packet_t *ts_packet,
                                        es_descriptor_t *p_es_descriptor,
                                        boolean_t b_unit_start, boolean_t b_packet_lost );
Michel Kaempf's avatar
Michel Kaempf committed
100

101
/*****************************************************************************
102
 * input_CreateThread: creates a new input thread
103
 *****************************************************************************
104 105 106 107
 * This function creates a new input, and returns a pointer
 * to its description. On error, it returns NULL.
 * If pi_status is NULL, then the function will block until the thread is ready.
 * If not, it will be updated using one of the THREAD_* constants.
108
 *****************************************************************************/
109 110
input_thread_t *input_CreateThread ( int i_method, char *psz_source, int i_port, int i_vlan,
                                     p_vout_thread_t p_vout, p_aout_thread_t p_aout, int *pi_status )
Michel Kaempf's avatar
Michel Kaempf committed
111
{
112 113 114 115
    input_thread_t *    p_input;                        /* thread descriptor */
    int                 i_status;                           /* thread status */
    int                 i_index;          /* index for tables initialization */

116 117 118 119
    /* Allocate descriptor */
    intf_DbgMsg("\n");
    p_input = (input_thread_t *)malloc( sizeof(input_thread_t) );
    if( p_input == NULL )
Michel Kaempf's avatar
Michel Kaempf committed
120
    {
121
        intf_ErrMsg("error: %s\n", strerror(ENOMEM));
Michel Kaempf's avatar
Michel Kaempf committed
122 123
        return( NULL );
    }
124 125 126 127 128 129 130 131 132 133 134 135 136

    /* Initialize thread properties */
    p_input->b_die              = 0;
    p_input->b_error            = 0;
    p_input->pi_status          = (pi_status != NULL) ? pi_status : &i_status;
    *p_input->pi_status         = THREAD_CREATE;

    /* Initialize input method description */
    p_input->i_method           = i_method;
    p_input->psz_source         = psz_source;
    p_input->i_port             = i_port;
    p_input->i_vlan             = i_vlan;
    switch( i_method )
Michel Kaempf's avatar
Michel Kaempf committed
137
    {
138
    case INPUT_METHOD_TS_FILE:                               /* file methods */
139 140 141 142
        p_input->p_Open =   input_FileOpen;
        p_input->p_Read =   input_FileRead;
        p_input->p_Close =  input_FileClose;
        break;
143
    case INPUT_METHOD_TS_VLAN_BCAST:                  /* vlan network method */
144 145 146 147
        if( !p_main->b_vlans )
        {
            intf_ErrMsg("error: vlans are not activated\n");
            free( p_input );
148 149
            return( NULL );
        }
150
        /* ... pass through */
151
    case INPUT_METHOD_TS_UCAST:                           /* network methods */
152 153 154 155 156 157 158 159 160
    case INPUT_METHOD_TS_MCAST:
    case INPUT_METHOD_TS_BCAST:
        p_input->p_Open =   input_NetworkOpen;
        p_input->p_Read =   input_NetworkRead;
        p_input->p_Close =  input_NetworkClose;
        break;
    default:
        intf_ErrMsg("error: unknow input method\n");
        free( p_input );
161 162
        return( NULL );
        break;
Michel Kaempf's avatar
Michel Kaempf committed
163 164
    }

165 166
    /* Initialize stream description */
    for( i_index = 0; i_index < INPUT_MAX_ES; i_index++ )
Michel Kaempf's avatar
Michel Kaempf committed
167
    {
168
        p_input->p_es[i_index].i_id = EMPTY_PID;
169
        p_input->pp_selected_es[i_index] = NULL;
Michel Kaempf's avatar
Michel Kaempf committed
170
    }
171

172 173
    /* Initialize default settings for spawned decoders */
    p_input->p_aout                     = p_aout;
174
    p_input->p_vout                     = p_vout;
Michel Kaempf's avatar
Michel Kaempf committed
175

176 177
#ifdef STATS
    /* Initialize statistics */
178
    p_input->c_loops                    = 0;
179 180 181 182
    p_input->c_bytes                    = 0;
    p_input->c_payload_bytes            = 0;
    p_input->c_packets_read             = 0;
    p_input->c_packets_trashed          = 0;
Michel Kaempf's avatar
Michel Kaempf committed
183 184
#endif

185 186
    /* Initialize PSI and PCR decoders */
    if( input_PsiInit( p_input ) )
Michel Kaempf's avatar
Michel Kaempf committed
187 188 189 190 191
    {
        free( p_input );
        return( NULL );
    }

192
    if( input_PcrInit( p_input ) )
Michel Kaempf's avatar
Michel Kaempf committed
193
    {
194
        input_PsiEnd( p_input );
Michel Kaempf's avatar
Michel Kaempf committed
195 196 197 198
        free( p_input );
        return( NULL );
    }

199 200
    /* Initialize netlists */
    if( input_NetlistInit( p_input ) )
Michel Kaempf's avatar
Michel Kaempf committed
201
    {
202 203
        input_PsiEnd( p_input );
        input_PcrEnd( p_input );
Michel Kaempf's avatar
Michel Kaempf committed
204 205 206 207
        free( p_input );
        return( NULL );
    }

208 209
    intf_DbgMsg("configuration: method=%d, source=%s, port=%d, vlan=%d\n",
                i_method, psz_source, i_port, i_vlan );
Michel Kaempf's avatar
Michel Kaempf committed
210 211

    /* Let the appropriate method open the socket. */
212
    if( p_input->p_Open( p_input ) )
Michel Kaempf's avatar
Michel Kaempf committed
213
    {
214 215 216
        input_NetlistEnd( p_input );
        input_PsiEnd( p_input );
        input_PcrEnd( p_input );
Michel Kaempf's avatar
Michel Kaempf committed
217 218 219 220 221
        free( p_input );
        return( NULL );
    }

    /* Create thread and set locks. */
222 223 224
    vlc_mutex_init( &p_input->netlist.lock );
    vlc_mutex_init( &p_input->programs_lock );
    vlc_mutex_init( &p_input->es_lock );
225
    if( vlc_thread_create(&p_input->thread_id, "input", (void *) RunThread, (void *) p_input) )
Michel Kaempf's avatar
Michel Kaempf committed
226
    {
227 228 229 230 231
        intf_ErrMsg("error: %s\n", strerror(errno) );
        p_input->p_Close( p_input );
        input_NetlistEnd( p_input );;
        input_PsiEnd( p_input );
        input_PcrEnd( p_input );
Michel Kaempf's avatar
Michel Kaempf committed
232 233 234
        free( p_input );
        return( NULL );
    }
235

236
    intf_Msg("Input initialized\n");
237

238 239 240 241
    /* If status is NULL, wait until the thread is created */
    if( pi_status == NULL )
    {
        do
242
        {
243
            msleep( THREAD_SLEEP );
244
        }while( (i_status != THREAD_READY) && (i_status != THREAD_ERROR)
245 246 247
                && (i_status != THREAD_FATAL) );
        if( i_status != THREAD_READY )
        {
248 249
            return( NULL );
        }
250
    }
Michel Kaempf's avatar
Michel Kaempf committed
251 252 253
    return( p_input );
}

254
/*****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
255
 * input_DestroyThread: mark an input thread as zombie
256
 *****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
257
 * This function should not return until the thread is effectively cancelled.
258
 *****************************************************************************/
259
void input_DestroyThread( input_thread_t *p_input, int *pi_status )
Michel Kaempf's avatar
Michel Kaempf committed
260
{
261
    int         i_status;                                   /* thread status */
262 263 264

    /* Set status */
    p_input->pi_status = (pi_status != NULL) ? pi_status : &i_status;
265 266
    *p_input->pi_status = THREAD_DESTROY;

267 268
    /* Request thread destruction */
    p_input->b_die = 1;
Michel Kaempf's avatar
Michel Kaempf committed
269

270 271 272 273 274 275
    /* If status is NULL, wait until thread has been destroyed */
    if( pi_status == NULL )
    {
        do
        {
            msleep( THREAD_SLEEP );
276 277
        }while( (i_status != THREAD_OVER) && (i_status != THREAD_ERROR)
                && (i_status != THREAD_FATAL) );
278
    }
Michel Kaempf's avatar
Michel Kaempf committed
279 280 281
}

#if 0
282
/*****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
283
 * input_OpenAudioStream: open an audio stream
284
 *****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
285 286
 * This function spawns an audio decoder and plugs it on the audio output
 * thread.
287
 *****************************************************************************/
Michel Kaempf's avatar
Michel Kaempf committed
288 289
int input_OpenAudioStream( input_thread_t *p_input, int i_id )
{
290
    /* XXX?? */
Michel Kaempf's avatar
Michel Kaempf committed
291 292
}

293
/*****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
294
 * input_CloseAudioStream: close an audio stream
295
 *****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
296
 * This function destroys an audio decoder.
297
 *****************************************************************************/
Michel Kaempf's avatar
Michel Kaempf committed
298 299
void input_CloseAudioStream( input_thread_t *p_input, int i_id )
{
300
    /* XXX?? */
Michel Kaempf's avatar
Michel Kaempf committed
301 302
}

303
/*****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
304
 * input_OpenVideoStream: open a video stream
305
 *****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
306
 * This function spawns a video decoder and plugs it on a video output thread.
307 308
 *****************************************************************************/
int input_OpenVideoStream( input_thread_t *p_input,
Michel Kaempf's avatar
Michel Kaempf committed
309 310
                           struct vout_thread_s *p_vout, struct video_cfg_s * p_cfg )
{
311
    /* XXX?? */
Michel Kaempf's avatar
Michel Kaempf committed
312 313
}

314
/*****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
315
 * input_CloseVideoStream: close a video stream
316
 *****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
317
 * This function destroys an video decoder.
318
 *****************************************************************************/
Michel Kaempf's avatar
Michel Kaempf committed
319 320
void input_CloseVideoStream( input_thread_t *p_input, int i_id )
{
321
    /* XXX?? */
Michel Kaempf's avatar
Michel Kaempf committed
322 323 324 325 326
}
#endif

/* following functions are local */

327
/*****************************************************************************
328
 * InitThread: initialize input thread
329
 *****************************************************************************
330 331 332
 * This function is called from RunThread and performs the second step of the
 * initialization. It returns 0 on success. Note that the thread's flag are not
 * modified inside this function.
333
 *****************************************************************************/
334 335 336 337
static int InitThread( input_thread_t *p_input )
{
    /* Mark thread as running and return */
    intf_DbgMsg("\n");
338 339 340
    *p_input->pi_status =        THREAD_READY;
    intf_DbgMsg("thread ready\n");
    return( 0 );
341 342
}

343
/*****************************************************************************
344
 * RunThread: main thread loop
345
 *****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
346
 * Thread in charge of processing the network packets and demultiplexing.
347
 *****************************************************************************/
348
static void RunThread( input_thread_t *p_input )
Michel Kaempf's avatar
Michel Kaempf committed
349
{
350 351
    /*
     * Initialize thread and free configuration
352 353 354 355
     */
    p_input->b_error = InitThread( p_input );
    if( p_input->b_error )
    {
356 357
        free( p_input );                               /* destroy descriptor */
        return;
358 359 360 361 362 363
    }

    /*
     * Main loop
     */
    intf_DbgMsg("\n");
364
    while( !p_input->b_die && !p_input->b_error )
Michel Kaempf's avatar
Michel Kaempf committed
365 366 367 368
    {
        /* Scatter read the UDP packet from the network or the file. */
        if( (input_ReadPacket( p_input )) == (-1) )
        {
369
            /* FIXME??: Normally, a thread can't kill itself, but we don't have
Michel Kaempf's avatar
Michel Kaempf committed
370
             * any method in case of an error condition ... */
371
            p_input->b_error = 1;
Michel Kaempf's avatar
Michel Kaempf committed
372 373
        }

Christophe Massiot's avatar
Christophe Massiot committed
374
#ifdef STATS
Michel Kaempf's avatar
Michel Kaempf committed
375 376 377 378
        p_input->c_loops++;
#endif
    }

379 380 381
    /*
     * Error loop
     */
382 383 384 385 386
    if( p_input->b_error )
    {
        ErrorThread( p_input );
    }

387
    /* End of thread */
388
    EndThread( p_input );
389
    intf_DbgMsg("thread end\n");
Michel Kaempf's avatar
Michel Kaempf committed
390 391
}

392

393
/*****************************************************************************
394
 * ErrorThread: RunThread() error loop
395 396 397
 *****************************************************************************
 * This function is called when an error occured during thread main's loop.
 *****************************************************************************/
398 399
static void ErrorThread( input_thread_t *p_input )
{
400 401
    /* Wait until a `die' order */
    intf_DbgMsg("\n");
402 403
    while( !p_input->b_die )
    {
404 405
        /* Sleep a while */
        msleep( VOUT_IDLE_SLEEP );
406 407 408
    }
}

409
/*****************************************************************************
410
 * EndThread: end the input thread
411
 *****************************************************************************/
Michel Kaempf's avatar
Michel Kaempf committed
412
static void EndThread( input_thread_t * p_input )
413
{
414 415
    int *       pi_status;                                  /* threas status */
    int         i_es_loop;                                       /* es index */
416 417 418

    /* Store status */
    intf_DbgMsg("\n");
419 420
    pi_status = p_input->pi_status;
    *pi_status = THREAD_END;
421

422 423
    /* Close input method */
    p_input->p_Close( p_input );
424

425
    /* Destroy all decoder threads */
426 427
    for( i_es_loop = 0;
         (i_es_loop < INPUT_MAX_ES) && (p_input->pp_selected_es[i_es_loop] != NULL) ;
428
         i_es_loop++ )
429
    {
430
        switch( p_input->pp_selected_es[i_es_loop]->i_type )
431
        {
432 433
        case MPEG1_VIDEO_ES:
        case MPEG2_VIDEO_ES:
434
#ifdef OLD_DECODER
435
            vdec_DestroyThread( (vdec_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) /*, NULL */ );
436
#else
437
            vpar_DestroyThread( (vpar_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) /*, NULL */ );
438
#endif
439
            break;
440 441 442 443 444 445
        case MPEG1_AUDIO_ES:
        case MPEG2_AUDIO_ES:
            adec_DestroyThread( (adec_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) );
            break;
        case AC3_AUDIO_ES:
            ac3dec_DestroyThread( (ac3dec_thread_t *)(p_input->pp_selected_es[i_es_loop]->p_dec) );
446
            break;
447 448 449
        case DVD_SPU_ES:
            spudec_DestroyThread( (spudec_thread_t *)(p_input->pp_selected_es[i_es_loop]->p_dec) );
            break;
450 451 452
        case 0:
            /* Special streams for the PSI decoder, PID 0 and 1 */
            break;
453 454 455
#ifdef DEBUG
        default:
            intf_DbgMsg("error: unknown decoder type %d\n", p_input->pp_selected_es[i_es_loop]->i_type );
456
            break;
457
#endif
458 459 460
        }
    }

461 462 463 464
    input_NetlistEnd( p_input );                            /* clean netlist */
    input_PsiEnd( p_input );                        /* clean PSI information */
    input_PcrEnd( p_input );                        /* clean PCR information */
    free( p_input );                          /* free input_thread structure */
465

466
    /* Update status */
467
    *pi_status = THREAD_OVER;
468 469
}

470
/*****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
471
 * input_ReadPacket: reads a packet from the network or the file
472
 *****************************************************************************/
Michel Kaempf's avatar
Michel Kaempf committed
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
static __inline__ int input_ReadPacket( input_thread_t *p_input )
{
    int                 i_base_index; /* index of the first free iovec */
    int                 i_current_index;
    int                 i_packet_size;
#ifdef INPUT_LIFO_TS_NETLIST
    int                 i_meanwhile_released;
    int                 i_currently_removed;
#endif
    ts_packet_t *       p_ts_packet;

    /* In this function, we only care about the TS netlist. PES netlist
     * is for the demultiplexer. */
#ifdef INPUT_LIFO_TS_NETLIST
    i_base_index = p_input->netlist.i_ts_index;

    /* Verify that we still have packets in the TS netlist */
    if( (INPUT_MAX_TS + INPUT_TS_READ_ONCE - 1 - p_input->netlist.i_ts_index) <= INPUT_TS_READ_ONCE )
    {
        intf_ErrMsg("input error: TS netlist is empty !\n");
        return( -1 );
    }

#else /* FIFO netlist */
    i_base_index = p_input->netlist.i_ts_start;
    if( p_input->netlist.i_ts_start + INPUT_TS_READ_ONCE -1 > INPUT_MAX_TS )
    {
        /* The netlist is splitted in 2 parts. We must gather them to consolidate
           the FIFO (we make the loop easily in having the same iovec at the far
           end and in the beginning of netlist_free).
           That's why the netlist is (INPUT_MAX_TS +1) + (INPUT_TS_READ_ONCE -1)
           large. */
        memcpy( p_input->netlist.p_ts_free + INPUT_MAX_TS + 1,
                p_input->netlist.p_ts_free,
                (p_input->netlist.i_ts_start + INPUT_TS_READ_ONCE - 1 - INPUT_MAX_TS)
                  * sizeof(struct iovec) );
    }

    /* Verify that we still have packets in the TS netlist */
    if( ((p_input->netlist.i_ts_end -1 - p_input->netlist.i_ts_start) & INPUT_MAX_TS) <= INPUT_TS_READ_ONCE )
    {
        intf_ErrMsg("input error: TS netlist is empty !\n");
515
        return( -1 );
Michel Kaempf's avatar
Michel Kaempf committed
516 517 518 519
    }
#endif /* FIFO netlist */

    /* Scatter read the buffer. */
520
    i_packet_size = (*p_input->p_Read)( p_input,
Michel Kaempf's avatar
Michel Kaempf committed
521 522 523 524
                           &p_input->netlist.p_ts_free[i_base_index],
                           INPUT_TS_READ_ONCE );
    if( i_packet_size == (-1) )
    {
525 526 527 528 529 530
#if 0
        intf_DbgMsg("Read packet %d %p %d %d\n", i_base_index,
                    &p_input->netlist.p_ts_free[i_base_index],
                    p_input->netlist.i_ts_start,
                    p_input->netlist.i_ts_end);
#endif
Michel Kaempf's avatar
Michel Kaempf committed
531 532 533 534 535 536 537 538 539
        intf_ErrMsg("input error: readv() failed (%s)\n", strerror(errno));
        return( -1 );
    }

    if( i_packet_size == 0 )
    {
        /* No packet has been received, so stop here. */
        return( 0 );
    }
540

Michel Kaempf's avatar
Michel Kaempf committed
541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
    /* Demultiplex the TS packets (1..INPUT_TS_READ_ONCE) received. */
    for( i_current_index = i_base_index;
         (i_packet_size -= TS_PACKET_SIZE) >= 0;
         i_current_index++ )
    {
        /* BTW, something REALLY bad could happen if we receive packets with
           a wrong size. */
        p_ts_packet = (ts_packet_t*)(p_input->netlist.p_ts_free[i_current_index].iov_base);
        /* Don't cry :-), we are allowed to do that cast, because initially,
           our buffer was malloc'ed with sizeof(ts_packet_t) */

        /* Find out if we need this packet and demultiplex. */
        input_SortPacket( p_input /* for current PIDs and netlist */,
                          p_ts_packet);
    }

    if( i_packet_size > 0 )
    {
        intf_ErrMsg("input error: wrong size\n");
        return( -1 );
    }

    /* Remove the TS packets we have just filled from the netlist */
#ifdef INPUT_LIFO_TS_NETLIST
    /* We need to take a lock here while we're calculating index positions. */
566
    vlc_mutex_lock( &p_input->netlist.lock );
Michel Kaempf's avatar
Michel Kaempf committed
567 568 569 570 571 572 573 574

    i_meanwhile_released = i_base_index - p_input->netlist.i_ts_index;
    if( i_meanwhile_released )
    {
        /* That's where it becomes funny :-). Since we didn't take locks for
           efficiency reasons, other threads (including ourselves, with
           input_DemuxPacket) might have released packets to the netlist.
           So we have to copy these iovec where they should go.
575

Michel Kaempf's avatar
Michel Kaempf committed
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
           BTW, that explains why the TS netlist is
           (INPUT_MAX_TS +1) + (TS_READ_ONCE -1) large. */

        i_currently_removed = i_current_index - i_base_index;
        if( i_meanwhile_released < i_currently_removed )
        {
            /* Copy all iovecs in that case */
            memcpy( &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index]
                     + i_currently_removed,
                    &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index],
                    i_meanwhile_released * sizeof(struct iovec) );
        }
        else
        {
            /* We have fewer places than items, so we only move
               i_currently_removed of them. */
            memcpy( &p_input->netlist.p_ts_free[i_base_index],
                    &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index],
                    i_currently_removed * sizeof(struct iovec) );
        }

        /* Update i_netlist_index with the information gathered above. */
        p_input->netlist.i_ts_index += i_currently_removed;
    }
    else
    {
        /* Nothing happened. */
        p_input->netlist.i_ts_index = i_current_index;
    }

606
    vlc_mutex_unlock( &p_input->netlist.lock );
Michel Kaempf's avatar
Michel Kaempf committed
607 608 609 610 611 612 613

#else /* FIFO netlist */
    /* & is modulo ; that's where we make the loop. */
    p_input->netlist.i_ts_start = i_current_index & INPUT_MAX_TS;
#endif

#ifdef STATS
614
    p_input->c_packets_read += i_current_index - i_base_index;
Michel Kaempf's avatar
Michel Kaempf committed
615 616
    p_input->c_bytes += (i_current_index - i_base_index) * TS_PACKET_SIZE;
#endif
617
    return( 0 );
Michel Kaempf's avatar
Michel Kaempf committed
618 619
}

620
/*****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
621
 * input_SortPacket: find out whether we need that packet
622
 *****************************************************************************/
Michel Kaempf's avatar
Michel Kaempf committed
623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
static __inline__ void input_SortPacket( input_thread_t *p_input,
                                         ts_packet_t *p_ts_packet )
{
    int             i_current_pid;
    int             i_es_loop;

    /* Verify that sync_byte, error_indicator and scrambling_control are
       what we expected. */
    if( !(p_ts_packet->buffer[0] == 0x47) || (p_ts_packet->buffer[1] & 0x80) ||
        (p_ts_packet->buffer[3] & 0xc0) )
    {
        intf_DbgMsg("input debug: invalid TS header (%p)\n", p_ts_packet);
    }
    else
    {
        /* Get the PID of the packet. Note that ntohs is needed, for endianness
           purposes (see man page). */
        i_current_pid = U16_AT(&p_ts_packet->buffer[1]) & 0x1fff;

642 643
        //intf_DbgMsg("input debug: pid %d received (%p)\n",
        //            i_current_pid, p_ts_packet);
Michel Kaempf's avatar
Michel Kaempf committed
644 645

        /* Lock current ES state. */
646
        vlc_mutex_lock( &p_input->es_lock );
647

648
    /* Verify that we actually want this PID. */
Michel Kaempf's avatar
Michel Kaempf committed
649 650 651 652 653 654 655 656 657 658 659 660
        for( i_es_loop = 0; i_es_loop < INPUT_MAX_SELECTED_ES; i_es_loop++ )
        {
            if( p_input->pp_selected_es[i_es_loop] != NULL)
            {
                if( (*p_input->pp_selected_es[i_es_loop]).i_id
                     == i_current_pid )
                {
                    /* Don't need the lock anymore, since the value pointed
                       out by p_input->pp_selected_es[i_es_loop] can only be
                       modified from inside the input_thread (by the PSI
                       decoder): interface thread is only allowed to modify
                       the pp_selected_es table */
661
                    vlc_mutex_unlock( &p_input->es_lock );
Michel Kaempf's avatar
Michel Kaempf committed
662 663 664 665 666

                    /* We're interested. Pass it to the demultiplexer. */
                    input_DemuxTS( p_input, p_ts_packet,
                                   p_input->pp_selected_es[i_es_loop] );
                    return;
667
                }
Michel Kaempf's avatar
Michel Kaempf committed
668 669 670 671 672 673 674
            }
            else
            {
                /* pp_selected_es should not contain any hole. */
                break;
            }
        }
675
        vlc_mutex_unlock( &p_input->es_lock );
Michel Kaempf's avatar
Michel Kaempf committed
676 677 678 679
    }

    /* We weren't interested in receiving this packet. Give it back to the
       netlist. */
680 681
    //intf_DbgMsg("SortPacket: freeing unwanted TS %p (pid %d)\n", p_ts_packet,
    //                 U16_AT(&p_ts_packet->buffer[1]) & 0x1fff);
Michel Kaempf's avatar
Michel Kaempf committed
682 683
    input_NetlistFreeTS( p_input, p_ts_packet );
#ifdef STATS
684
    p_input->c_packets_trashed++;
Michel Kaempf's avatar
Michel Kaempf committed
685 686 687
#endif
}

688
/*****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
689
 * input_DemuxTS: first step of demultiplexing: the TS header
690
 *****************************************************************************
Michel Kaempf's avatar
Michel Kaempf committed
691
 * Stream must also only contain PES and PSI, so PID must have been filtered
692
 *****************************************************************************/
Michel Kaempf's avatar
Michel Kaempf committed
693 694 695 696 697
static __inline__ void input_DemuxTS( input_thread_t *p_input,
                                      ts_packet_t *p_ts_packet,
                                      es_descriptor_t *p_es_descriptor )
{
    int         i_dummy;
698 699 700 701 702
    boolean_t   b_adaption;                     /* Adaption field is present */
    boolean_t   b_payload;                         /* Packet carries payload */
    boolean_t   b_unit_start;          /* A PSI or a PES start in the packet */
    boolean_t   b_trash = 0;                 /* Must the packet be trashed ? */
    boolean_t   b_lost = 0;                     /* Was there a packet lost ? */
Michel Kaempf's avatar
Michel Kaempf committed
703 704 705 706 707 708 709

    ASSERT(p_input);
    ASSERT(p_ts_packet);
    ASSERT(p_es_descriptor);

#define p (p_ts_packet->buffer)

710 711
    //intf_DbgMsg("input debug: TS-demultiplexing packet %p, pid %d, number %d\n",
    //            p_ts_packet, U16_AT(&p[1]) & 0x1fff, p[3] & 0x0f);
Michel Kaempf's avatar
Michel Kaempf committed
712 713 714 715 716 717 718 719 720 721

#ifdef STATS
    p_es_descriptor->c_packets++;
    p_es_descriptor->c_bytes += TS_PACKET_SIZE;
#endif

    /* Extract flags values from TS common header. */
    b_unit_start = (p[1] & 0x40);
    b_adaption = (p[3] & 0x20);
    b_payload = (p[3] & 0x10);
722

Michel Kaempf's avatar
Michel Kaempf committed
723 724 725 726
    /* Extract adaption field informations if any */
    if( !b_adaption )
    {
        /* We don't have any adaptation_field, so payload start immediately
727
           after the 4 byte TS header */
Michel Kaempf's avatar
Michel Kaempf committed
728 729 730 731 732 733 734 735 736 737 738 739
        p_ts_packet->i_payload_start = 4;
    }
    else
    {
        /* p[4] is adaptation_field_length minus one */
        p_ts_packet->i_payload_start = 5 + p[4];

        /* The adaption field can be limited to the adaptation_field_length byte,
           so that there is nothing to do: skip this possibility */
        if( p[4] )
        {
            /* If the packet has both adaptation_field and payload, adaptation_field
Benoit Steiner's avatar
 
Benoit Steiner committed
740
               cannot be more than 182 bytes long; if there is only an
741
               adaptation_field, it must fill the next 183 bytes. */
Michel Kaempf's avatar
Michel Kaempf committed
742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
            if( b_payload ? (p[4] > 182) : (p[4] != 183) )
            {
                intf_DbgMsg("input debug: invalid TS adaptation field (%p)\n",
                            p_ts_packet);
#ifdef STATS
                p_es_descriptor->c_invalid_packets++;
#endif
                b_trash = 1;
            }

            /* No we are sure that the byte containing flags is present: read it */
            else
            {
                /* discontinuity_indicator */
                if( p[5] & 0x80 )
                {
                    intf_DbgMsg("discontinuity_indicator encountered by TS demux " \
                                "(position read: %d, saved: %d)\n", p[5] & 0x80,
                                p_es_descriptor->i_continuity_counter);

                    /* If the PID carries the PCR, there will be a system time-base
                       discontinuity. We let the PCR decoder handle that. */
                    p_es_descriptor->b_discontinuity = 1;
765

Benoit Steiner's avatar
 
Benoit Steiner committed
766
                    /* There also may be a continuity_counter discontinuity:
767
               resynchronise our counter with the one of the stream */
Michel Kaempf's avatar
Michel Kaempf committed
768 769 770 771 772 773
                    p_es_descriptor->i_continuity_counter = (p[3] & 0x0f) - 1;
                }

                /* random_access_indicator */
                p_es_descriptor->b_random |= p[5] & 0x40;

Benoit Steiner's avatar
 
Benoit Steiner committed
774
                /* If this is a PCR_PID, and this TS packet contains a PCR,
775
           we pass it along to the PCR decoder. */
Michel Kaempf's avatar
Michel Kaempf committed
776 777
                if( (p_es_descriptor->b_pcr) && (p[5] & 0x10) )
                {
Benoit Steiner's avatar
 
Benoit Steiner committed
778
                    /* There should be a PCR field in the packet, check if the
779
               adaption field is long enough to carry it */
Michel Kaempf's avatar
Michel Kaempf committed
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
                    if( p[4] >= 7 )
                    {
                        /* Call the PCR decoder */
                        input_PcrDecode( p_input, p_es_descriptor, &p[6] );
                    }
                }
            }
        }
    }

    /* Check the continuity of the stream. */
    i_dummy = ((p[3] & 0x0f) - p_es_descriptor->i_continuity_counter) & 0x0f;
    if( i_dummy == 1 )
    {
        /* Everything is ok, just increase our counter */
        p_es_descriptor->i_continuity_counter++;
    }
    else
    {
        if( !b_payload && i_dummy == 0 )
        {
            /* This is a packet without payload, this is allowed by the draft
802
               As there is nothing interesting in this packet (except PCR that
Michel Kaempf's avatar
Michel Kaempf committed
803 804 805 806 807 808 809 810 811 812
               have already been handled), we can trash the packet. */
            intf_DbgMsg("Packet without payload received by TS demux\n");
            b_trash = 1;
        }
        else if( i_dummy <= 0 )
        {
            /* Duplicate packet: mark it as being to be trashed. */
            intf_DbgMsg("Duplicate packet received by TS demux\n");
            b_trash = 1;
        }
Benoit Steiner's avatar
 
Benoit Steiner committed
813 814 815 816
        else if( p_es_descriptor->i_continuity_counter == 0xFF )
        {
            /* This means that the packet is the first one we receive for this
               ES since the continuity counter ranges between 0 and 0x0F
817
               excepts when it has been initialized by the input: Init the
Benoit Steiner's avatar
 
Benoit Steiner committed
818 819 820 821 822
               counter to the correct value. */
            intf_DbgMsg("First packet for PID %d received by TS demux\n",
                        p_es_descriptor->i_id);
            p_es_descriptor->i_continuity_counter = (p[3] & 0x0f);
        }
Michel Kaempf's avatar
Michel Kaempf committed
823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841
        else
        {
            /* This can indicate that we missed a packet or that the
               continuity_counter wrapped and we received a dup packet: as we
               don't know, do as if we missed a packet to be sure to recover
               from this situation */
            intf_DbgMsg("Packet lost by TS demux: current %d, packet %d\n",
                        p_es_descriptor->i_continuity_counter & 0x0f,
                        p[3] & 0x0f);
            b_lost = 1;
            p_es_descriptor->i_continuity_counter = p[3] & 0x0f;
        }
    }

    /* Trash the packet if it has no payload or if it is bad */
    if( b_trash )
    {
        input_NetlistFreeTS( p_input, p_ts_packet );
#ifdef STATS
842
        p_input->c_packets_trashed++;
Michel Kaempf's avatar
Michel Kaempf committed
843 844 845 846 847 848 849 850 851 852 853 854
#endif
    }
    else
    {
        if( p_es_descriptor->b_psi )
        {
            /* The payload contains PSI tables */
            input_DemuxPSI( p_input, p_ts_packet, p_es_descriptor,
                            b_unit_start, b_lost );
        }
        else
        {
855
            /* The payload carries a PES stream */
Michel Kaempf's avatar
Michel Kaempf committed
856 857 858 859 860 861 862 863 864 865 866
            input_DemuxPES( p_input, p_ts_packet, p_es_descriptor,
                            b_unit_start, b_lost );
        }
    }

#undef p
}




867 868 869
/*****************************************************************************
 * input_DemuxPES:
 *****************************************************************************
870
 * Gather a PES packet.
871
 *****************************************************************************/
Michel Kaempf's avatar
Michel Kaempf committed
872 873 874 875 876 877 878 879 880 881
static __inline__ void input_DemuxPES( input_thread_t *p_input,
                                       ts_packet_t *p_ts_packet,
                                       es_descriptor_t *p_es_descriptor,
                                       boolean_t b_unit_start,
                                       boolean_t b_packet_lost )
{
    int                         i_dummy;
    pes_packet_t*               p_last_pes;
    ts_packet_t *               p_ts;
    int                         i_ts_payload_size;
882

Michel Kaempf's avatar
Michel Kaempf committed
883 884 885 886 887 888 889

#define p_pes (p_es_descriptor->p_pes_packet)

    ASSERT(p_input);
    ASSERT(p_ts_packet);
    ASSERT(p_es_descriptor);

890
    //intf_DbgMsg("PES-demultiplexing %p (%p)\n", p_ts_packet, p_pes);
Michel Kaempf's avatar
Michel Kaempf committed
891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906

    /* If we lost data, discard the PES packet we are trying to reassemble
       if any and wait for the beginning of a new one in order to synchronise
       again */
    if( b_packet_lost && p_pes != NULL )
    {
        intf_DbgMsg("PES %p trashed because of packet lost\n", p_pes);
        input_NetlistFreePES( p_input, p_pes );
        p_pes = NULL;
    }

    /* If the TS packet contains the begining of a new PES packet, and if we
       were reassembling a PES packet, then the PES should be complete now,
       so parse its header and give it to the decoders */
    if( b_unit_start && p_pes != NULL )
    {
907
        /* Parse the header. The header has a variable length, but in order
Michel Kaempf's avatar
Michel Kaempf committed
908 909
           to improve the algorithm, we will read the 14 bytes we may be
           interested in */
910 911 912 913 914 915

        /* If this part of the header did not fit in the current TS packet,
           copy the part of the header we are interested in to the
           p_pes_header_save buffer. The buffer is dynamicly allocated if
           needed so it's time expensive but this situation almost never
           occurs. */
Michel Kaempf's avatar
Michel Kaempf committed
916 917 918
        p_ts = p_pes->p_first_ts;
        i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;

919
        if(i_ts_payload_size < PES_HEADER_SIZE)
Michel Kaempf's avatar
Michel Kaempf committed
920
        {
Benoit Steiner's avatar
 
Benoit Steiner committed
921
            intf_DbgMsg("Code never tested encountered, WARNING ! (benny)\n");
922 923
            if( !p_pes->p_pes_header_save )
            {
924
                p_pes->p_pes_header_save = malloc(PES_HEADER_SIZE);
925
            }
Benoit Steiner's avatar
 
Benoit Steiner committed
926

927
            i_dummy = 0;
Michel Kaempf's avatar
Michel Kaempf committed
928 929 930 931 932
            do
            {
                memcpy(p_pes->p_pes_header_save + i_dummy,
                       &p_ts->buffer[p_ts->i_payload_start], i_ts_payload_size);
                i_dummy += i_ts_payload_size;
933

Michel Kaempf's avatar
Michel Kaempf committed
934 935 936 937 938
                p_ts = p_ts->p_next_ts;
                if(!p_ts)
                {
                  /* The payload of the PES packet is shorter than the 14 bytes
                     we would read. This means that high packet lost occured
939
                     so the PES won't be useful for any decoder. Moreover,
Michel Kaempf's avatar
Michel Kaempf committed
940 941
                     this should never happen so we can trash the packet and
                     exit roughly without regrets */
942
                  intf_DbgMsg("PES packet too short: trashed\n");
Michel Kaempf's avatar
Michel Kaempf committed
943 944
                  input_NetlistFreePES( p_input, p_pes );
                  p_pes = NULL;
945
                  /* Stats XXX?? */
Michel Kaempf's avatar
Michel Kaempf committed
946 947
                  return;
                }
948

Michel Kaempf's avatar
Michel Kaempf committed
949 950 951 952 953 954 955 956 957 958 959
                i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;
            }
            while(i_ts_payload_size + i_dummy < PES_HEADER_SIZE);

            /* This last TS packet is partly header, partly payload, so just
               copy the header part */
            memcpy(p_pes->p_pes_header_save + i_dummy,
                   &p_ts->buffer[p_ts->i_payload_start],
                   PES_HEADER_SIZE - i_dummy);

            /* The header must be read in the buffer not in any TS packet */
960
            p_pes->p_pes_header = p_pes->p_pes_header_save;
961

962 963
            /* Get the PES size if defined */
            if( (i_dummy = U16_AT(p_pes->p_pes_header + 4)) )
Michel Kaempf's avatar
Michel Kaempf committed
964
            {
965
                p_pes->i_pes_real_size = i_dummy + 6;
Michel Kaempf's avatar
Michel Kaempf committed
966 967 968
            }
        }

969 970 971 972
        /* Now we have the part of the PES header we were interested in:
           p_pes_header and i_pes_real_size ; we can parse it */
        input_ParsePES( p_input, p_es_descriptor );
    }
Michel Kaempf's avatar
Michel Kaempf committed
973 974 975 976

    /* If we are at the beginning of a new PES packet, we must fetch a new
       PES buffer to begin with the reassembly of this PES packet. This is
       also here that we can synchronise with the stream if we we lost
977
       packets or if the decoder has just started */
Michel Kaempf's avatar
Michel Kaempf committed
978 979 980 981 982 983 984 985 986 987 988 989
    if( b_unit_start )
    {
        p_last_pes = p_pes;

        /* Get a new one PES from the PES netlist. */
        if( (p_pes = input_NetlistGetPES( p_input )) == (NULL) )
        {
            /* PES netlist is empty ! */
            p_input->b_error = 1;
        }
        else
        {
990
            //intf_DbgMsg("New PES packet %p (first TS: %p)\n", p_pes, p_ts_packet);
Michel Kaempf's avatar
Michel Kaempf committed
991

992 993
            /* Init the PES fields so that the first TS packet could be
             * correctly added to the PES packet (see below) */
Michel Kaempf's avatar
Michel Kaempf committed
994 995 996
            p_pes->p_first_ts = p_ts_packet;
            p_pes->p_last_ts = NULL;

997 998 999
            /* If the last pes packet was null, this means that the
             * synchronization was lost and so warn the decoder that he
             * will have to find a way to recover */
Michel Kaempf's avatar
Michel Kaempf committed
1000 1001 1002
            if( !p_last_pes )
                p_pes->b_data_loss = 1;

1003
            /* Read the b_random_access flag status and then reinit it */
Michel Kaempf's avatar
Michel Kaempf committed
1004 1005 1006
            p_pes->b_random_access = p_es_descriptor->b_random;
            p_es_descriptor->b_random = 0;
        }
1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019

        /* If the PES header fits in the first TS packet, we can
         * already set p_pes->p_pes_header, and in all cases we
	 * set p_pes->i_pes_real_size */
        if( p_ts_packet->i_payload_end - p_ts_packet->i_payload_start
                >= PES_HEADER_SIZE )
        {
            p_pes->p_pes_header = &(p_ts_packet->buffer[p_ts_packet->i_payload_start]);
            if( (i_dummy = U16_AT(p_pes->p_pes_header + 4)) )
            {
                p_pes->i_pes_real_size = i_dummy + 6;
            }
        }
Michel Kaempf's avatar
Michel Kaempf committed
1020 1021 1022
    }


1023
    /* If we are synchronized with the stream, and so if we are ready to
Michel Kaempf's avatar
Michel Kaempf committed
1024 1025 1026 1027
       receive correctly the data, add the TS packet to the current PES
       packet */
    if( p_pes != NULL )
    {
1028
        //intf_DbgMsg("Adding TS %p to PES %p\n", p_ts_packet, p_pes);
Michel Kaempf's avatar
Michel Kaempf committed
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038

        /* Size of the payload carried in the TS packet */
        i_ts_payload_size = p_ts_packet->i_payload_end -
                            p_ts_packet->i_payload_start;

        /* Update the relations between the TS packets */
        p_ts_packet->p_prev_ts = p_pes->p_last_ts;
        p_ts_packet->p_next_ts = NULL;
        if( p_pes->i_ts_packets != 0 )
        {
1039 1040 1041
            /* Regarder si il serait pas plus efficace de ne creer que
             * les liens precedent->suivant pour le moment, et les
             * liens suivant->precedent quand le paquet est termine */
Michel Kaempf's avatar
Michel Kaempf committed
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
            /* Otherwise it is the first TS packet. */
            p_pes->p_last_ts->p_next_ts = p_ts_packet;
        }
        /* Now add the TS to the PES packet */
        p_pes->p_last_ts = p_ts_packet;
        p_pes->i_ts_packets++;
        p_pes->i_pes_size += i_ts_payload_size;

        /* Stats */
#ifdef STATS
        i_dummy = p_ts_packet->i_payload_end - p_ts_packet->i_payload_start;
        p_es_descriptor->c_payload_bytes += i_dummy;
#endif
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064

        /* We can check if the packet is finished */
        if( p_pes->i_pes_size == p_pes->i_pes_real_size )
        {
            /* The packet is finished, parse it */
            input_ParsePES( p_input, p_es_descriptor );

            /* Tell the Demux we have parsed this PES, no need to redo it */
            p_pes = NULL;
        }
Michel Kaempf's avatar
Michel Kaempf committed
1065 1066 1067 1068 1069
    }
    else
    {
        /* Since we don't use the TS packet to build a PES packet, we don't
           need it anymore, so give it back to the netlist */
1070
        //intf_DbgMsg("Trashing TS %p: no PES being build\n", p_ts_packet);
1071
        input_NetlistFreeTS( p_input, p_ts_packet );
Michel Kaempf's avatar
Michel Kaempf committed
1072
    }
1073

Michel Kaempf's avatar
Michel Kaempf committed
1074 1075 1076 1077 1078
#undef p_pes
}



1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106