]> git.sesse.net Git - vlc/blob - src/input/input.c
Commit bis des modifications concernant l'initialisation du continuity
[vlc] / src / input / input.c
1 /*******************************************************************************
2  * input.c: input thread 
3  * (c)1998 VideoLAN
4  *******************************************************************************
5  * Read an MPEG2 stream, demultiplex and parse it before sending it to
6  * decoders.
7  ******************************************************************************/
8
9 /*******************************************************************************
10  * Preamble
11  ******************************************************************************/
12 #include <errno.h>
13 #include <sys/uio.h>                                                 /* iovec */
14 #include <string.h>
15
16 #include <X11/Xlib.h>
17 #include <X11/extensions/XShm.h>
18 #include <sys/soundcard.h>
19
20 #include <stdlib.h>                               /* atoi(), malloc(), free() */
21 #include <stdio.h>
22 #include <sys/ioctl.h>                                             /* ioctl() */
23 #include <net/if.h>                                                  /* ifreq */
24 #include <netinet/in.h>
25
26 #include "common.h"
27 #include "config.h"
28 #include "mtime.h"
29 #include "vlc_thread.h"
30 #include "intf_msg.h"
31 #include "debug.h"
32
33 #include "input.h"
34 #include "input_psi.h"
35 #include "input_pcr.h"
36 #include "input_netlist.h"
37 #include "decoder_fifo.h"
38 #include "input_file.h"
39 #include "input_network.h"
40
41 #include "audio_output.h"
42 #include "audio_decoder.h"
43
44 #include "video.h"
45 #include "video_output.h"
46 #include "video_decoder.h"
47
48 /******************************************************************************
49  * Local prototypes
50  ******************************************************************************/
51 static void input_Thread( input_thread_t *p_input );
52 static void ErrorThread( input_thread_t *p_input );
53 static void EndThread( input_thread_t *p_input );
54 static __inline__ int input_ReadPacket( input_thread_t *p_input );
55 static __inline__ void input_SortPacket( input_thread_t *p_input,
56                                          ts_packet_t *ts_packet );
57 static __inline__ void input_DemuxTS( input_thread_t *p_input,
58                                       ts_packet_t *ts_packet,
59                                       es_descriptor_t *es_descriptor );
60 static __inline__ void input_DemuxPES( input_thread_t *p_input,
61                                        ts_packet_t *ts_packet,
62                                        es_descriptor_t *p_es_descriptor,
63                                        boolean_t b_unit_start, boolean_t b_packet_lost );
64 static __inline__ void input_DemuxPSI( input_thread_t *p_input,
65                                        ts_packet_t *ts_packet,
66                                        es_descriptor_t *p_es_descriptor,
67                                        boolean_t b_unit_start, boolean_t b_packet_lost );
68
69 /*******************************************************************************
70  * input_CreateThread: initialize and spawn an input thread
71  *******************************************************************************
72  * This function initializes and spawns an input thread. It returns NULL on
73  * failure. If you want a better understanding of the input thread, don't start
74  * by reading this function :-).
75  *******************************************************************************/
76 input_thread_t *input_CreateThread( input_cfg_t *p_cfg )
77 {
78     input_thread_t *    p_input;
79     int i_index;
80     
81     intf_DbgMsg("input debug 1-1: creating thread (cfg : %p)\n", p_cfg );
82
83     /* Allocate input_thread_t structure. */
84     if( !( p_input = (input_thread_t *)malloc(sizeof(input_thread_t)) ) )
85     {
86         intf_ErrMsg("input error: can't allocate input thread structure (%s)\n",
87                     strerror(errno));
88         return( NULL );
89     }
90     /* Init it */
91     bzero( p_input, sizeof(input_thread_t));
92     for( i_index = 0; i_index < INPUT_MAX_ES; i_index++ )
93     {
94         p_input->p_es[i_index].i_id = EMPTY_PID;
95     }
96
97     /* Find out which method we are gonna use and retrieve pointers. */
98     if( !((p_cfg->i_properties) & INPUT_CFG_METHOD) )
99     {
100         /* i_method is not set. */
101         intf_DbgMsg("input debug: using default method (%d)\n",
102                     INPUT_DEFAULT_METHOD);
103         p_cfg->i_method = INPUT_DEFAULT_METHOD;
104         p_cfg->i_properties |= INPUT_CFG_METHOD;
105     }
106     p_input->i_method = p_cfg->i_method;
107     switch( p_cfg->i_method )
108     {
109         /* File methods */
110         case INPUT_METHOD_TS_FILE:
111             p_input->p_open = &input_FileCreateMethod;
112             p_input->p_read = &input_FileRead;
113             p_input->p_clean = &input_FileDestroyMethod;
114             break;
115
116         /* Network methods */
117         case INPUT_METHOD_TS_UCAST:
118         case INPUT_METHOD_TS_MCAST:
119         case INPUT_METHOD_TS_BCAST:
120         case INPUT_METHOD_TS_VLAN_BCAST:
121             p_input->p_open = &input_NetworkCreateMethod;
122             p_input->p_read = &input_NetworkRead;
123             p_input->p_clean = &input_NetworkDestroyMethod;
124             break;
125
126         case INPUT_METHOD_NONE:
127         default:
128 #ifdef DEBUG
129             /* Internal error, which should never happen */
130             intf_DbgMsg("input debug: unknow method type %d\n",
131                             p_cfg->i_method);
132             return( NULL );
133 #endif
134             break;
135     }
136
137     /* Initialize PSI decoder. */
138     intf_DbgMsg("Initializing PSI decoder\n");
139     if( input_PsiInit( p_input ) == -1 )
140     {
141         free( p_input );
142         return( NULL );
143     }
144
145     /* Initialize PCR decoder. */
146     intf_DbgMsg("Initializing PCR decoder\n");
147     if( input_PcrInit( p_input ) == -1 )
148     {
149         input_PsiClean( p_input );
150         free( p_input );
151         return( NULL );
152     }
153
154     /* Initialize netlists. */
155     if( input_NetlistOpen( p_input ) )
156     {
157         input_PsiClean( p_input );
158         input_PcrClean( p_input );
159         free( p_input );
160         return( NULL );
161     }
162
163 #ifdef STATS
164     /* Initialize counters. */
165     p_input->c_bytes = 0;
166     p_input->c_payload_bytes = 0;
167     p_input->c_ts_packets_read = 0;
168     p_input->c_ts_packets_trashed = 0;
169 #ifdef DEBUG
170     p_input->c_loops = 0;
171 #endif
172 #endif
173
174     /* Let the appropriate method open the socket. */
175     if( (*(p_input->p_open))( p_input, p_cfg ) == -1 )
176     {
177         input_NetlistClean( p_input );
178         input_PsiClean( p_input );
179         input_PcrClean( p_input );
180         free( p_input );
181         return( NULL );
182     }
183
184     intf_DbgMsg("input debug: method %d properly initialized the socket\n",
185                 p_input->i_method);
186
187     /* Create thread and set locks. */
188     p_input->b_die = 0;
189     vlc_mutex_init( &p_input->netlist.lock );
190     vlc_mutex_init( &p_input->programs_lock );
191     vlc_mutex_init( &p_input->es_lock );
192 #ifdef NO_THREAD
193     input_Thread( p_input );
194 #else
195     if( vlc_thread_create(&p_input->thread_id, "input", (vlc_thread_func)input_Thread, 
196                        (void *) p_input) )
197     {
198         intf_ErrMsg("input error: can't spawn input thread (%s)\n", 
199                     strerror(errno) );
200         (*p_input->p_clean)( p_input );
201         input_NetlistClean( p_input );;
202         input_PsiClean( p_input );
203         input_PcrClean( p_input );
204         free( p_input );
205         return( NULL );
206     }
207 #endif
208
209     /* Default setting for new decoders */
210     p_input->p_aout = p_cfg->p_aout;
211
212     return( p_input );
213 }
214
215 /******************************************************************************
216  * input_DestroyThread: mark an input thread as zombie
217  ******************************************************************************
218  * This function should not return until the thread is effectively cancelled.
219  ******************************************************************************/
220 void input_DestroyThread( input_thread_t *p_input )
221 {
222     intf_DbgMsg("input debug: requesting termination of input thread\n");
223     p_input->b_die = 1;                          /* ask thread to kill itself */
224
225     /* Remove this as soon as the "status" flag is implemented */
226     vlc_thread_join( p_input->thread_id );            /* wait until it's done */
227 }
228
229 #if 0
230 /*******************************************************************************
231  * input_OpenAudioStream: open an audio stream
232  *******************************************************************************
233  * This function spawns an audio decoder and plugs it on the audio output
234  * thread.
235  *******************************************************************************/
236 int input_OpenAudioStream( input_thread_t *p_input, int i_id )
237 {
238     /* ?? */
239 }
240
241 /*******************************************************************************
242  * input_CloseAudioStream: close an audio stream
243  *******************************************************************************
244  * This function destroys an audio decoder.
245  *******************************************************************************/
246 void input_CloseAudioStream( input_thread_t *p_input, int i_id )
247 {
248     /* ?? */
249 }
250
251 /*******************************************************************************
252  * input_OpenVideoStream: open a video stream
253  *******************************************************************************
254  * This function spawns a video decoder and plugs it on a video output thread.
255  *******************************************************************************/
256 int input_OpenVideoStream( input_thread_t *p_input, 
257                            struct vout_thread_s *p_vout, struct video_cfg_s * p_cfg )
258 {
259     /* ?? */
260 }
261
262 /*******************************************************************************
263  * input_CloseVideoStream: close a video stream
264  *******************************************************************************
265  * This function destroys an video decoder.
266  *******************************************************************************/
267 void input_CloseVideoStream( input_thread_t *p_input, int i_id )
268 {
269     /* ?? */
270 }
271 #endif
272
273 /* following functions are local */
274
275 /*******************************************************************************
276  * input_Thread: input thread
277  *******************************************************************************
278  * Thread in charge of processing the network packets and demultiplexing.
279  *******************************************************************************/
280 static void input_Thread( input_thread_t *p_input )
281 {
282     intf_DbgMsg("input debug 11-1: thread %p is active\n", p_input);
283     while( !p_input->b_die && !p_input->b_error )
284     {
285         /* Scatter read the UDP packet from the network or the file. */
286         if( (input_ReadPacket( p_input )) == (-1) )
287         {
288             /* ??? Normally, a thread can't kill itself, but we don't have
289              * any method in case of an error condition ... */
290             p_input->b_error = 1;
291         }
292
293 #ifdef STATS
294         p_input->c_loops++;
295 #endif
296     }
297
298     if( p_input->b_error )
299     {
300         ErrorThread( p_input );
301     }
302
303     /* Ohoh, we have to die as soon as possible. */
304     EndThread( p_input );
305
306     intf_DbgMsg("input debug: thread %p destroyed\n", p_input);
307     vlc_thread_exit( 0 );
308 }
309
310
311 /******************************************************************************
312  * ErrorThread: RunThread() error loop
313  ******************************************************************************/
314 static void ErrorThread( input_thread_t *p_input )
315 {
316     while( !p_input->b_die )
317     {
318         msleep( INPUT_IDLE_SLEEP );
319     }
320 }
321
322 /*******************************************************************************
323  * EndThread: end the input thread
324  *******************************************************************************/
325 static void EndThread( input_thread_t * p_input )
326 {
327     int i_es_loop;
328
329     (*p_input->p_clean)( p_input );           /* close input method */
330
331     /* Destroy all decoder threads. */
332     for( i_es_loop = 0; i_es_loop < INPUT_MAX_ES; i_es_loop++ )
333     {
334         if( p_input->pp_selected_es[i_es_loop] )
335         {
336             switch( p_input->pp_selected_es[i_es_loop]->i_type )
337             {
338                 case MPEG1_VIDEO_ES:
339                 case MPEG2_VIDEO_ES:
340                     vdec_DestroyThread( (vdec_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) /*, NULL */ );
341                     break;
342
343                 case MPEG1_AUDIO_ES:
344                 case MPEG2_AUDIO_ES:
345                     adec_DestroyThread( (adec_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) );
346                     break;
347
348                 default:
349                     break;
350             }
351         }
352         else
353         {
354             /* pp_selected_es should not contain any hole. */
355             break;
356         }
357     }
358
359     input_NetlistClean( p_input );                           /* clean netlist */
360     input_PsiClean( p_input );                       /* clean PSI information */
361     input_PcrClean( p_input );                       /* clean PCR information */
362     free( p_input );                           /* free input_thread structure */
363
364     intf_DbgMsg("input debug: EndThread(%p)\n", p_input);
365 }
366
367 /*******************************************************************************
368  * input_ReadPacket: reads a packet from the network or the file
369  *******************************************************************************/
370 static __inline__ int input_ReadPacket( input_thread_t *p_input )
371 {
372     int                 i_base_index; /* index of the first free iovec */
373     int                 i_current_index;
374     int                 i_packet_size;
375 #ifdef INPUT_LIFO_TS_NETLIST
376     int                 i_meanwhile_released;
377     int                 i_currently_removed;
378 #endif
379     ts_packet_t *       p_ts_packet;
380
381     /* In this function, we only care about the TS netlist. PES netlist
382      * is for the demultiplexer. */
383 #ifdef INPUT_LIFO_TS_NETLIST
384     i_base_index = p_input->netlist.i_ts_index;
385
386     /* Verify that we still have packets in the TS netlist */
387     if( (INPUT_MAX_TS + INPUT_TS_READ_ONCE - 1 - p_input->netlist.i_ts_index) <= INPUT_TS_READ_ONCE )
388     {
389         intf_ErrMsg("input error: TS netlist is empty !\n");
390         return( -1 );
391     }
392
393 #else /* FIFO netlist */
394     i_base_index = p_input->netlist.i_ts_start;
395     if( p_input->netlist.i_ts_start + INPUT_TS_READ_ONCE -1 > INPUT_MAX_TS )
396     {
397         /* The netlist is splitted in 2 parts. We must gather them to consolidate
398            the FIFO (we make the loop easily in having the same iovec at the far
399            end and in the beginning of netlist_free).
400            That's why the netlist is (INPUT_MAX_TS +1) + (INPUT_TS_READ_ONCE -1)
401            large. */
402         memcpy( p_input->netlist.p_ts_free + INPUT_MAX_TS + 1,
403                 p_input->netlist.p_ts_free,
404                 (p_input->netlist.i_ts_start + INPUT_TS_READ_ONCE - 1 - INPUT_MAX_TS)
405                   * sizeof(struct iovec) );
406     }
407
408     /* Verify that we still have packets in the TS netlist */
409     if( ((p_input->netlist.i_ts_end -1 - p_input->netlist.i_ts_start) & INPUT_MAX_TS) <= INPUT_TS_READ_ONCE )
410     {
411         intf_ErrMsg("input error: TS netlist is empty !\n");
412         return( -1 );
413     }
414 #endif /* FIFO netlist */
415
416     /* Scatter read the buffer. */
417     i_packet_size = (*p_input->p_read)( p_input,
418                            &p_input->netlist.p_ts_free[i_base_index],
419                            INPUT_TS_READ_ONCE );
420     if( i_packet_size == (-1) )
421     {
422 //      intf_DbgMsg("Read packet %d %p %d %d\n", i_base_index,
423 //                      &p_input->netlist.p_ts_free[i_base_index],
424 //                      p_input->netlist.i_ts_start,
425 //                      p_input->netlist.i_ts_end);
426         intf_ErrMsg("input error: readv() failed (%s)\n", strerror(errno));
427         return( -1 );
428     }
429
430     if( i_packet_size == 0 )
431     {
432         /* No packet has been received, so stop here. */
433         return( 0 );
434     }
435      
436     /* Demultiplex the TS packets (1..INPUT_TS_READ_ONCE) received. */
437     for( i_current_index = i_base_index;
438          (i_packet_size -= TS_PACKET_SIZE) >= 0;
439          i_current_index++ )
440     {
441         /* BTW, something REALLY bad could happen if we receive packets with
442            a wrong size. */
443         p_ts_packet = (ts_packet_t*)(p_input->netlist.p_ts_free[i_current_index].iov_base);
444         /* Don't cry :-), we are allowed to do that cast, because initially,
445            our buffer was malloc'ed with sizeof(ts_packet_t) */
446
447         /* Find out if we need this packet and demultiplex. */
448         input_SortPacket( p_input /* for current PIDs and netlist */,
449                           p_ts_packet);
450     }
451
452     if( i_packet_size > 0 )
453     {
454         intf_ErrMsg("input error: wrong size\n");
455         return( -1 );
456     }
457
458     /* Remove the TS packets we have just filled from the netlist */
459 #ifdef INPUT_LIFO_TS_NETLIST
460     /* We need to take a lock here while we're calculating index positions. */
461     vlc_mutex_lock( &p_input->netlist.lock );
462
463     i_meanwhile_released = i_base_index - p_input->netlist.i_ts_index;
464     if( i_meanwhile_released )
465     {
466         /* That's where it becomes funny :-). Since we didn't take locks for
467            efficiency reasons, other threads (including ourselves, with
468            input_DemuxPacket) might have released packets to the netlist.
469            So we have to copy these iovec where they should go.
470            
471            BTW, that explains why the TS netlist is
472            (INPUT_MAX_TS +1) + (TS_READ_ONCE -1) large. */
473
474         i_currently_removed = i_current_index - i_base_index;
475         if( i_meanwhile_released < i_currently_removed )
476         {
477             /* Copy all iovecs in that case */
478             memcpy( &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index]
479                      + i_currently_removed,
480                     &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index],
481                     i_meanwhile_released * sizeof(struct iovec) );
482         }
483         else
484         {
485             /* We have fewer places than items, so we only move
486                i_currently_removed of them. */
487             memcpy( &p_input->netlist.p_ts_free[i_base_index],
488                     &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index],
489                     i_currently_removed * sizeof(struct iovec) );
490         }
491
492         /* Update i_netlist_index with the information gathered above. */
493         p_input->netlist.i_ts_index += i_currently_removed;
494     }
495     else
496     {
497         /* Nothing happened. */
498         p_input->netlist.i_ts_index = i_current_index;
499     }
500
501     vlc_mutex_unlock( &p_input->netlist.lock );
502
503 #else /* FIFO netlist */
504     /* & is modulo ; that's where we make the loop. */
505     p_input->netlist.i_ts_start = i_current_index & INPUT_MAX_TS;
506 #endif
507
508 #ifdef STATS
509     p_input->c_ts_packets_read += i_current_index - i_base_index;
510     p_input->c_bytes += (i_current_index - i_base_index) * TS_PACKET_SIZE;
511 #endif
512         return( 0 );
513 }
514
515 /*******************************************************************************
516  * input_SortPacket: find out whether we need that packet
517  *******************************************************************************/
518 static __inline__ void input_SortPacket( input_thread_t *p_input,
519                                          ts_packet_t *p_ts_packet )
520 {
521     int             i_current_pid;
522     int             i_es_loop;
523
524     /* Verify that sync_byte, error_indicator and scrambling_control are
525        what we expected. */
526     if( !(p_ts_packet->buffer[0] == 0x47) || (p_ts_packet->buffer[1] & 0x80) ||
527         (p_ts_packet->buffer[3] & 0xc0) )
528     {
529         intf_DbgMsg("input debug: invalid TS header (%p)\n", p_ts_packet);
530     }
531     else
532     {
533         /* Get the PID of the packet. Note that ntohs is needed, for endianness
534            purposes (see man page). */
535         i_current_pid = U16_AT(&p_ts_packet->buffer[1]) & 0x1fff;
536
537 //      intf_DbgMsg("input debug: pid %d received (%p)\n",
538 //                    i_current_pid, p_ts_packet);
539
540         /* Lock current ES state. */
541         vlc_mutex_lock( &p_input->es_lock );
542         
543         /* Verify that we actually want this PID. */
544         for( i_es_loop = 0; i_es_loop < INPUT_MAX_SELECTED_ES; i_es_loop++ )
545         {
546             if( p_input->pp_selected_es[i_es_loop] != NULL)
547             {
548                 if( (*p_input->pp_selected_es[i_es_loop]).i_id
549                      == i_current_pid )
550                 {
551                     /* Don't need the lock anymore, since the value pointed
552                        out by p_input->pp_selected_es[i_es_loop] can only be
553                        modified from inside the input_thread (by the PSI
554                        decoder): interface thread is only allowed to modify
555                        the pp_selected_es table */
556                     vlc_mutex_unlock( &p_input->es_lock );
557
558                     /* We're interested. Pass it to the demultiplexer. */
559                     input_DemuxTS( p_input, p_ts_packet,
560                                    p_input->pp_selected_es[i_es_loop] );
561                     return;
562                 }
563             }
564             else
565             {
566                 /* pp_selected_es should not contain any hole. */
567                 break;
568             }
569         }
570         vlc_mutex_unlock( &p_input->es_lock );
571     }
572
573     /* We weren't interested in receiving this packet. Give it back to the
574        netlist. */
575 //    intf_DbgMsg("SortPacket: freeing unwanted TS %p (pid %d)\n", p_ts_packet,
576 //                     U16_AT(&p_ts_packet->buffer[1]) & 0x1fff);
577     input_NetlistFreeTS( p_input, p_ts_packet );
578 #ifdef STATS
579     p_input->c_ts_packets_trashed++;
580 #endif
581 }
582
583 /*******************************************************************************
584  * input_DemuxTS: first step of demultiplexing: the TS header
585  *******************************************************************************
586  * Stream must also only contain PES and PSI, so PID must have been filtered
587  *******************************************************************************/
588 static __inline__ void input_DemuxTS( input_thread_t *p_input,
589                                       ts_packet_t *p_ts_packet,
590                                       es_descriptor_t *p_es_descriptor )
591 {
592     int         i_dummy;
593     boolean_t   b_adaption;                       /* Adaption field is present */
594     boolean_t   b_payload;                           /* Packet carries payload */
595     boolean_t   b_unit_start;            /* A PSI or a PES start in the packet */
596     boolean_t   b_trash = 0;                   /* Must the packet be trashed ? */
597     boolean_t   b_lost = 0;                      /* Was there a packet lost ? */
598
599     ASSERT(p_input);
600     ASSERT(p_ts_packet);
601     ASSERT(p_es_descriptor);
602
603 #define p (p_ts_packet->buffer)
604
605 //    intf_DbgMsg("input debug: TS-demultiplexing packet %p, pid %d, number %d\n",
606 //                p_ts_packet, U16_AT(&p[1]) & 0x1fff, p[3] & 0x0f);
607
608 #ifdef STATS
609     p_es_descriptor->c_packets++;
610     p_es_descriptor->c_bytes += TS_PACKET_SIZE;
611 #endif
612
613     /* Extract flags values from TS common header. */
614     b_unit_start = (p[1] & 0x40);
615     b_adaption = (p[3] & 0x20);
616     b_payload = (p[3] & 0x10);
617     
618     /* Extract adaption field informations if any */
619     if( !b_adaption )
620     {
621         /* We don't have any adaptation_field, so payload start immediately
622          after the 4 byte TS header */
623         p_ts_packet->i_payload_start = 4;
624     }
625     else
626     {
627         /* p[4] is adaptation_field_length minus one */
628         p_ts_packet->i_payload_start = 5 + p[4];
629
630         /* The adaption field can be limited to the adaptation_field_length byte,
631            so that there is nothing to do: skip this possibility */
632         if( p[4] )
633         {
634             /* If the packet has both adaptation_field and payload, adaptation_field
635                cannot be more than 182 bytes long; if there is only an
636                adaptation_field, it must fill the next 183 bytes. */
637             if( b_payload ? (p[4] > 182) : (p[4] != 183) )
638             {
639                 intf_DbgMsg("input debug: invalid TS adaptation field (%p)\n",
640                             p_ts_packet);
641 #ifdef STATS
642                 p_es_descriptor->c_invalid_packets++;
643 #endif
644                 b_trash = 1;
645             }
646
647             /* No we are sure that the byte containing flags is present: read it */
648             else
649             {
650                 /* discontinuity_indicator */
651                 if( p[5] & 0x80 )
652                 {
653                     intf_DbgMsg("discontinuity_indicator encountered by TS demux " \
654                                 "(position read: %d, saved: %d)\n", p[5] & 0x80,
655                                 p_es_descriptor->i_continuity_counter);
656
657                     /* If the PID carries the PCR, there will be a system time-base
658                        discontinuity. We let the PCR decoder handle that. */
659                     p_es_descriptor->b_discontinuity = 1;
660                     
661                     /* There also may be a continuity_counter discontinuity:
662                        resynchronise our counter with the one of the stream */
663                     p_es_descriptor->i_continuity_counter = (p[3] & 0x0f) - 1;
664                 }
665
666                 /* random_access_indicator */
667                 p_es_descriptor->b_random |= p[5] & 0x40;
668
669                 /* If this is a PCR_PID, and this TS packet contains a PCR,
670                    we pass it along to the PCR decoder. */
671                 if( (p_es_descriptor->b_pcr) && (p[5] & 0x10) )
672                 {
673                     /* There should be a PCR field in the packet, check if the
674                        adaption field is long enough to carry it */
675                     if( p[4] >= 7 )
676                     {
677                         /* Call the PCR decoder */
678                         input_PcrDecode( p_input, p_es_descriptor, &p[6] );
679                     }
680                 }
681             }
682         }
683     }
684
685     /* Check the continuity of the stream. */
686     i_dummy = ((p[3] & 0x0f) - p_es_descriptor->i_continuity_counter) & 0x0f;
687     if( i_dummy == 1 )
688     {
689         /* Everything is ok, just increase our counter */
690         p_es_descriptor->i_continuity_counter++;
691     }
692     else
693     {
694         if( !b_payload && i_dummy == 0 )
695         {
696             /* This is a packet without payload, this is allowed by the draft
697                As there is nothing interessant in this packet (except PCR that
698                have already been handled), we can trash the packet. */
699             intf_DbgMsg("Packet without payload received by TS demux\n");
700             b_trash = 1;
701         }
702         else if( i_dummy <= 0 )
703         {
704             /* Duplicate packet: mark it as being to be trashed. */
705             intf_DbgMsg("Duplicate packet received by TS demux\n");
706             b_trash = 1;
707         }
708         else if( p_es_descriptor->i_continuity_counter == 0xFF )
709         {
710             /* This means that the packet is the first one we receive for this
711                ES since the continuity counter ranges between 0 and 0x0F
712                excepts when it has been initialized by the input: Init the 
713                counter to the correct value. */
714             intf_DbgMsg("First packet for PID %d received by TS demux\n",
715                         p_es_descriptor->i_id);
716             p_es_descriptor->i_continuity_counter = (p[3] & 0x0f);
717         }
718         else
719         {
720             /* This can indicate that we missed a packet or that the
721                continuity_counter wrapped and we received a dup packet: as we
722                don't know, do as if we missed a packet to be sure to recover
723                from this situation */
724             intf_DbgMsg("Packet lost by TS demux: current %d, packet %d\n",
725                         p_es_descriptor->i_continuity_counter & 0x0f,
726                         p[3] & 0x0f);
727             b_lost = 1;
728             p_es_descriptor->i_continuity_counter = p[3] & 0x0f;
729         }
730     }
731
732     /* Trash the packet if it has no payload or if it is bad */
733     if( b_trash )
734     {
735         input_NetlistFreeTS( p_input, p_ts_packet );
736 #ifdef STATS
737         p_input->c_ts_packets_trashed++;
738 #endif
739     }
740     else
741     {
742         if( p_es_descriptor->b_psi )
743         {
744             /* The payload contains PSI tables */
745             input_DemuxPSI( p_input, p_ts_packet, p_es_descriptor,
746                             b_unit_start, b_lost );
747         }
748         else
749         {
750             /* The payload carries a PES stream */ 
751             input_DemuxPES( p_input, p_ts_packet, p_es_descriptor,
752                             b_unit_start, b_lost );
753         }
754     }
755
756 #undef p
757 }
758
759
760
761
762 /*******************************************************************************
763  * input_DemuxPES: 
764  *******************************************************************************
765  * Gather a PES packet and analyzes its header.
766  *******************************************************************************/
767 static __inline__ void input_DemuxPES( input_thread_t *p_input,
768                                        ts_packet_t *p_ts_packet,
769                                        es_descriptor_t *p_es_descriptor,
770                                        boolean_t b_unit_start,
771                                        boolean_t b_packet_lost )
772 {
773     decoder_fifo_t *            p_fifo;
774     u8                          i_pes_header_size;
775     int                         i_dummy;
776     pes_packet_t*               p_last_pes;
777     ts_packet_t *               p_ts;
778     int                         i_ts_payload_size;
779     
780
781 #define p_pes (p_es_descriptor->p_pes_packet)
782
783     ASSERT(p_input);
784     ASSERT(p_ts_packet);
785     ASSERT(p_es_descriptor);
786
787 //    intf_DbgMsg("PES-demultiplexing %p (%p)\n", p_ts_packet, p_pes);
788
789     /* If we lost data, discard the PES packet we are trying to reassemble
790        if any and wait for the beginning of a new one in order to synchronise
791        again */
792     if( b_packet_lost && p_pes != NULL )
793     {
794         intf_DbgMsg("PES %p trashed because of packet lost\n", p_pes);
795         input_NetlistFreePES( p_input, p_pes );
796         p_pes = NULL;
797     }
798
799     /* If the TS packet contains the begining of a new PES packet, and if we
800        were reassembling a PES packet, then the PES should be complete now,
801        so parse its header and give it to the decoders */
802     if( b_unit_start && p_pes != NULL )
803     {
804 //        intf_DbgMsg("End of PES packet %p\n", p_pes);
805
806         /* Parse the header. The header has a variable length, but in order 
807            to improve the algorithm, we will read the 14 bytes we may be
808            interested in */
809         p_ts = p_pes->p_first_ts;
810         i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;
811         i_dummy = 0;
812
813         if(i_ts_payload_size >= PES_HEADER_SIZE)
814         {
815             /* This part of the header entirely fits in the payload of   
816                the first TS packet */
817             p_pes->p_pes_header = &(p_ts->buffer[p_ts->i_payload_start]);
818         }
819         else
820         {
821             /* This part of the header does not fit in the current TS packet:
822                copy the part of the header we are interested in to the
823                p_pes_header_save buffer. The buffer is dynamicly allocated if
824                needed so it's time expensive but this situation almost never
825                occur. */
826             intf_DbgMsg("Code never tested encountered, WARNING ! (benny)\n");
827             if( !p_pes->p_pes_header_save )
828                 p_pes->p_pes_header_save = malloc(PES_HEADER_SIZE); 
829
830             do
831             {
832                 memcpy(p_pes->p_pes_header_save + i_dummy,
833                        &p_ts->buffer[p_ts->i_payload_start], i_ts_payload_size);
834                 i_dummy += i_ts_payload_size;
835             
836                 p_ts = p_ts->p_next_ts;
837                 if(!p_ts)
838                 {
839                   /* The payload of the PES packet is shorter than the 14 bytes
840                      we would read. This means that high packet lost occured
841                      so the PES won't be usefull for any decoder. Moreover,
842                      this should never happen so we can trash the packet and
843                      exit roughly without regrets */
844                   intf_DbgMsg("PES packet too short: trashed\n");
845                   input_NetlistFreePES( p_input, p_pes );
846                   p_pes = NULL;
847                   /* Stats ?? */
848                   return;
849                 }
850                 
851                 i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;
852             }
853             while(i_ts_payload_size + i_dummy < PES_HEADER_SIZE);
854
855             /* This last TS packet is partly header, partly payload, so just
856                copy the header part */
857             memcpy(p_pes->p_pes_header_save + i_dummy,
858                    &p_ts->buffer[p_ts->i_payload_start],
859                    PES_HEADER_SIZE - i_dummy);
860
861             /* The header must be read in the buffer not in any TS packet */
862            p_pes->p_pes_header = p_pes->p_pes_header_save;
863         }
864         
865         /* Now we have the part of the PES header we were interested in:
866            parse it */
867
868         /* First read the 6 header bytes common to all PES packets:
869            use them to test the PES validity */
870         if( (p_pes->p_pes_header[0] || p_pes->p_pes_header[1] ||
871             (p_pes->p_pes_header[2] != 1)) ||
872                                      /* packet_start_code_prefix != 0x000001 */
873             ((i_dummy = U16_AT(p_pes->p_pes_header + 4)) &&
874              (i_dummy + 6 != p_pes->i_pes_size)) )
875                    /* PES_packet_length is set and != total received payload */
876         {
877           /* Trash the packet and set p_pes to NULL to be sure the next PES
878              packet will have its b_data_lost flag set */
879           intf_DbgMsg("Corrupted PES packet received: trashed\n");
880           input_NetlistFreePES( p_input, p_pes );
881           p_pes = NULL;
882           /* Stats ?? */
883         }
884         else
885         {
886             /* The PES packet is valid. Check its type to test if it may
887                carry additional informations in a header extension */
888             p_pes->i_stream_id =  p_pes->p_pes_header[3];
889
890             switch( p_pes->i_stream_id )
891             {
892             case 0xBE:  /* Padding */
893             case 0xBC:  /* Program stream map */
894             case 0xBF:  /* Private stream 2 */
895             case 0xB0:  /* ECM */
896             case 0xB1:  /* EMM */
897             case 0xFF:  /* Program stream directory */
898             case 0xF2:  /* DSMCC stream */
899             case 0xF8:  /* ITU-T H.222.1 type E stream */
900                 /* The payload begins immediatly after the 6 bytes header, so
901                    we have finished with the parsing */
902                 i_pes_header_size = 6;
903                 break;
904
905             default:
906                 /* The PES header contains at least 3 more bytes: parse them */
907                 p_pes->b_data_alignment = p_pes->p_pes_header[6] & 0x04;
908                 p_pes->b_has_pts = p_pes->p_pes_header[7] & 0x80;
909                 i_pes_header_size = 9 + p_pes->p_pes_header[8];
910
911                 /* Now parse the optional header extensions (in the limit of
912                    the 14 bytes */
913                 if( p_pes->b_has_pts )
914                 {
915                     pcr_descriptor_t * p_pcr;
916
917                     p_pcr = p_input->p_pcr;
918                     vlc_mutex_lock( &p_pcr->lock );
919                     if( p_pcr->delta_clock == 0 )
920                     {
921                         p_pes->b_has_pts = 0;
922                     }
923                     else
924                     {
925                         p_pes->i_pts = ( ((mtime_t)(p_pes->p_pes_header[9] & 0x0E) << 29) |
926                                          (((mtime_t)U16_AT(p_pes->p_pes_header + 10) << 14) - (1 << 14)) |
927                                          ((mtime_t)U16_AT(p_pes->p_pes_header + 12) >> 1) );
928                         p_pes->i_pts *= 300;
929                         p_pes->i_pts /= 27;
930                         p_pes->i_pts += p_pcr->delta_clock;
931                         if( p_pcr->c_pts == 0 )
932                         {
933                             p_pcr->delta_decode = mdate() - p_pes->i_pts + 500000;
934                         }
935                         p_pes->i_pts += p_pcr->delta_decode;
936                         p_pcr->c_pts += 1;
937                     }
938                     vlc_mutex_unlock( &p_pcr->lock );
939                 }
940                 break;
941             }
942
943             /* Now we've parsed the header, we just have to indicate in some
944                specific TS packets where the PES payload begins (renumber
945                i_payload_start), so that the decoders can find the beginning
946                of their data right out of the box. */
947             p_ts = p_pes->p_first_ts;
948             i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;
949             while( i_pes_header_size > i_ts_payload_size )
950             {
951                 /* These packets are entirely filled by the PES header. */
952                 i_pes_header_size -= i_ts_payload_size;
953                 p_ts->i_payload_start = p_ts->i_payload_end;
954                 /* Go to the next TS packet: here we won't have to test it is
955                    not NULL because we trash the PES packets when packet lost
956                    occurs */
957                 p_ts = p_ts->p_next_ts;
958                 i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;
959             }
960             /* This last packet is partly header, partly payload. */
961             p_ts->i_payload_start += i_pes_header_size;
962
963             /* Now we can eventually put the PES packet in the decoder's
964                PES fifo */
965             switch( p_es_descriptor->i_type )
966             {
967             case MPEG1_VIDEO_ES:
968             case MPEG2_VIDEO_ES:
969                 p_fifo = &(((vdec_thread_t*)(p_es_descriptor->p_dec))->fifo);
970                 break;
971             case MPEG1_AUDIO_ES:
972             case MPEG2_AUDIO_ES:
973                 p_fifo = &(((adec_thread_t*)(p_es_descriptor->p_dec))->fifo);
974                 break;
975             default:
976                 /* This should never happen. */
977                 intf_DbgMsg("Unknown stream type (%d, %d): PES trashed\n",
978                             p_es_descriptor->i_id, p_es_descriptor->i_type);
979                 p_fifo = NULL;
980                 break;
981             }
982
983             if( p_fifo != NULL )
984             {
985                 vlc_mutex_lock( &p_fifo->data_lock );
986                 if( DECODER_FIFO_ISFULL( *p_fifo ) )
987                 {
988                     /* The FIFO is full !!! This should not happen. */
989 #ifdef STATS
990                     p_input->c_ts_packets_trashed += p_pes->i_ts_packets;
991                     p_es_descriptor->c_invalid_packets += p_pes->i_ts_packets;
992 #endif
993                     input_NetlistFreePES( p_input, p_pes );
994                     intf_DbgMsg("PES trashed - fifo full ! (%d, %d)\n",
995                                p_es_descriptor->i_id, p_es_descriptor->i_type);
996                 }
997                 else
998                 {
999 //                    intf_DbgMsg("Putting %p into fifo %p/%d\n",
1000 //                                p_pes, p_fifo, p_fifo->i_end);
1001                     p_fifo->buffer[p_fifo->i_end] = p_pes;
1002                     DECODER_FIFO_INCEND( *p_fifo );
1003
1004                     /* Warn the decoder that it's got work to do. */
1005                     vlc_cond_signal( &p_fifo->data_wait );
1006                 }
1007                 vlc_mutex_unlock( &p_fifo->data_lock );
1008             }
1009             else
1010             {
1011                 intf_DbgMsg("No fifo to receive PES %p: trash\n", p_pes);
1012 #ifdef STATS
1013                 p_input->c_ts_packets_trashed += p_pes->i_ts_packets;
1014                 p_es_descriptor->c_invalid_packets += p_pes->i_ts_packets;
1015 #endif
1016                 input_NetlistFreePES( p_input, p_pes );
1017             }
1018         }
1019     }
1020
1021
1022     /* If we are at the beginning of a new PES packet, we must fetch a new
1023        PES buffer to begin with the reassembly of this PES packet. This is
1024        also here that we can synchronise with the stream if we we lost
1025        packets or if the decoder has just started */ 
1026     if( b_unit_start )
1027     {
1028         p_last_pes = p_pes;
1029
1030         /* Get a new one PES from the PES netlist. */
1031         if( (p_pes = input_NetlistGetPES( p_input )) == (NULL) )
1032         {
1033             /* PES netlist is empty ! */
1034             p_input->b_error = 1;
1035         }
1036         else
1037         {
1038 //           intf_DbgMsg("New PES packet %p (first TS: %p)\n", p_pes, p_ts_packet);
1039
1040             /* Init the PES fields so that the first TS packet could be correctly
1041                added to the PES packet (see below) */
1042             p_pes->p_first_ts = p_ts_packet;
1043             p_pes->p_last_ts = NULL;
1044
1045             /* If the last pes packet was null, this means that the synchronisation
1046                was lost and so warn the decoder that he will have to find a way to
1047                recover */
1048             if( !p_last_pes )
1049                 p_pes->b_data_loss = 1;
1050
1051             /* Read the b_random_access flag status and then reinit it */     
1052             p_pes->b_random_access = p_es_descriptor->b_random;
1053             p_es_descriptor->b_random = 0;
1054         }
1055     }
1056
1057
1058     /* If we are synchronised with the stream, and so if we are ready to
1059        receive correctly the data, add the TS packet to the current PES
1060        packet */
1061     if( p_pes != NULL )
1062     {
1063 //      intf_DbgMsg("Adding TS %p to PES %p\n", p_ts_packet, p_pes);
1064
1065         /* Size of the payload carried in the TS packet */
1066         i_ts_payload_size = p_ts_packet->i_payload_end -
1067                             p_ts_packet->i_payload_start;
1068
1069         /* Update the relations between the TS packets */
1070         p_ts_packet->p_prev_ts = p_pes->p_last_ts;
1071         p_ts_packet->p_next_ts = NULL;
1072         if( p_pes->i_ts_packets != 0 )
1073         {
1074             /* Regarder si il serait pas plus efficace de ne creer que les liens
1075                precedent->suivant pour le moment, et les liens suivant->precedent
1076                quand le paquet est termine */
1077             /* Otherwise it is the first TS packet. */
1078             p_pes->p_last_ts->p_next_ts = p_ts_packet;
1079         }
1080         /* Now add the TS to the PES packet */
1081         p_pes->p_last_ts = p_ts_packet;
1082         p_pes->i_ts_packets++;
1083         p_pes->i_pes_size += i_ts_payload_size;
1084
1085         /* Stats */
1086 #ifdef STATS
1087         i_dummy = p_ts_packet->i_payload_end - p_ts_packet->i_payload_start;
1088         p_es_descriptor->c_payload_bytes += i_dummy;
1089 #endif
1090     }
1091     else
1092     {
1093         /* Since we don't use the TS packet to build a PES packet, we don't
1094            need it anymore, so give it back to the netlist */
1095 //        intf_DbgMsg("Trashing TS %p: no PES being build\n", p_ts_packet);
1096         input_NetlistFreeTS( p_input, p_ts_packet );     
1097     }
1098     
1099 #undef p_pes
1100 }
1101
1102
1103
1104
1105 /*******************************************************************************
1106  * input_DemuxPSI:
1107  *******************************************************************************
1108  * Notice that current ES state has been locked by input_SortPacket. (No more true,
1109  * changed by benny - See if it's ok, and definitely change the code ???????? )
1110  *******************************************************************************/
1111 static __inline__ void input_DemuxPSI( input_thread_t *p_input,
1112                                        ts_packet_t *p_ts_packet,
1113                                        es_descriptor_t *p_es_descriptor,
1114                                        boolean_t b_unit_start, boolean_t b_packet_lost )
1115 {
1116     int i_data_offset;      /* Offset of the interesting data in the TS packet */
1117     u16 i_data_length;                                 /* Length of those data */
1118     //boolean_t b_first_section; /* Was there another section in the TS packet ? */
1119     
1120     ASSERT(p_input);
1121     ASSERT(p_ts_packet);
1122     ASSERT(p_es_descriptor);
1123
1124 #define p_psi (p_es_descriptor->p_psi_section)
1125
1126 //    intf_DbgMsg( "input debug: PSI demultiplexing %p (%p)\n", p_ts_packet, p_input);
1127
1128 //    intf_DbgMsg( "Packet: %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x (unit start: %d)\n", p_ts_packet->buffer[p_ts_packet->i_payload_start], p_ts_packet->buffer[p_ts_packet->i_payload_start+1], p_ts_packet->buffer[p_ts_packet->i_payload_start+2], p_ts_packet->buffer[p_ts_packet->i_payload_start+3], p_ts_packet->buffer[p_ts_packet->i_payload_start+4], p_ts_packet->buffer[p_ts_packet->i_payload_start+5], p_ts_packet->buffer[p_ts_packet->i_payload_start+6], p_ts_packet->buffer[p_ts_packet->i_payload_start+7], p_ts_packet->buffer[p_ts_packet->i_payload_start+8], p_ts_packet->buffer[p_ts_packet->i_payload_start+9], p_ts_packet->buffer[p_ts_packet->i_payload_start+10], p_ts_packet->buffer[p_ts_packet->i_payload_start+11], p_ts_packet->buffer[p_ts_packet->i_payload_start+12], p_ts_packet->buffer[p_ts_packet->i_payload_start+13], p_ts_packet->buffer[p_ts_packet->i_payload_start+14], p_ts_packet->buffer[p_ts_packet->i_payload_start+15], p_ts_packet->buffer[p_ts_packet->i_payload_start+16], p_ts_packet->buffer[p_ts_packet->i_payload_start+17], p_ts_packet->buffer[p_ts_packet->i_payload_start+18], p_ts_packet->buffer[p_ts_packet->i_payload_start+19], p_ts_packet->buffer[p_ts_packet->i_payload_start+20], b_unit_start);
1129
1130
1131     /* Try to find the beginning of the payload in the packet to initialise
1132        the do-while loop that follows -> Compute the i_data_offset variable:
1133        by default, the value is set so that we won't enter in the while loop.
1134        It will be set to a correct value if the data are not corrupted */
1135     i_data_offset = TS_PACKET_SIZE;
1136
1137     /* Has the reassembly of a section already began in a previous packet ? */
1138     if( p_psi->b_running_section )
1139     {
1140         /* Was data lost since the last TS packet ? */
1141         if( b_packet_lost )
1142         {
1143             /* Discard the packet and wait for the begining of a new one to resynch */
1144             p_psi->b_running_section = 0;
1145             p_psi->i_current_position = 0;
1146             intf_DbgMsg( "PSI section(s) discarded due to packet loss\n" );
1147         }
1148         else
1149         {
1150             /* The data that complete a previously began section are always at
1151                the beginning of the TS payload... */
1152             i_data_offset = p_ts_packet->i_payload_start;
1153             /* ...Unless there is a pointer field, that we have to bypass */
1154             if( b_unit_start )
1155                 i_data_offset++;
1156 //            intf_DbgMsg( "New part of the section received at offset %d\n", i_data_offset );
1157         }
1158     }
1159     /* We are looking for the beginning of a new section */
1160     else
1161     {
1162         if( b_unit_start )
1163         {
1164             /* Get the offset at which the data for that section can be found
1165                The offset is stored in the pointer_field since we are interested in
1166                the first section of the TS packet. Note that the +1 is to bypass
1167                the pointer field */
1168             i_data_offset = p_ts_packet->i_payload_start +
1169                             p_ts_packet->buffer[p_ts_packet->i_payload_start] + 1;
1170 //            intf_DbgMsg( "New section beginning at offset %d in TS packet\n", i_data_offset );
1171         }
1172         else
1173         {
1174             /* This may either mean that the TS is bad or that the packet contains
1175                the end of a section that had been discarded in a previous loop: 
1176                trash the TS packet since we cannot do anything with those data: */
1177             p_psi->b_running_section = 0;
1178             p_psi->i_current_position = 0;
1179             intf_DbgMsg( "PSI packet discarded due to lack of synchronisation\n" );
1180         }
1181     }
1182
1183     /* The section we will deal with during the first iteration of the following
1184        loop is the first one contained in the TS packet */
1185     //    b_first_section = 1;
1186
1187     /* Reassemble the pieces of sections contained in the TS packet and decode
1188        the sections that could have been completed.
1189        Stop when we reach the end of the packet or stuffing bytes */
1190     while( i_data_offset < TS_PACKET_SIZE && p_ts_packet->buffer[i_data_offset] != 0xFF )
1191     {
1192         /* If the current section is a new one, reinit the data fields of the p_psi
1193            struct to start its decoding */
1194         if( !p_psi->b_running_section )
1195         {
1196             /* Read the length of the new section */
1197             p_psi->i_length = (U16_AT(&p_ts_packet->buffer[i_data_offset+1]) & 0xFFF) + 3;
1198 //            intf_DbgMsg( "Section length %d\n", p_psi->i_length );
1199             if( p_psi->i_length > PSI_SECTION_SIZE )
1200             {
1201                 /* The TS packet is corrupted, stop here to avoid possible a seg fault */
1202                 intf_DbgMsg( "PSI Section size is too big, aborting its reception\n" );
1203                 break;
1204             }
1205
1206             /* Init the reassembly of that section */
1207             p_psi->b_running_section = 1;
1208             p_psi->i_current_position = 0;
1209         }
1210         
1211         /* Compute the length of data related to the section in this TS packet */
1212         if( p_psi->i_length - p_psi->i_current_position > TS_PACKET_SIZE - i_data_offset)
1213             i_data_length = TS_PACKET_SIZE - i_data_offset;
1214         else
1215           i_data_length = p_psi->i_length - p_psi->i_current_position;
1216
1217         /* Copy those data in the section buffer */
1218         memcpy( &p_psi->buffer[p_psi->i_current_position], &p_ts_packet->buffer[i_data_offset],
1219                 i_data_length );
1220
1221         /* Interesting data are now after the ones we copied, since no gap is
1222            allowed between 2 sections in a TS packets */
1223         i_data_offset += i_data_length;
1224
1225         /* Decode the packet if it is now complete */
1226         if (p_psi->i_length == p_psi->i_current_position + i_data_length)
1227         {
1228             /* Packet is complete, decode it */
1229 //            intf_DbgMsg( "SECTION COMPLETE: starting decoding of its data\n" );
1230             input_PsiDecode( p_input, p_psi );
1231
1232             /* Prepare the buffer to receive a new section */
1233             p_psi->i_current_position = 0;
1234             p_psi->b_running_section = 0;
1235         
1236             /* The new section won't be the first anymore */
1237             //b_first_section = 0;
1238         }
1239         else
1240         {
1241             /* Prepare the buffer to receive the next part of the section */
1242           p_psi->i_current_position += i_data_length;
1243 //          intf_DbgMsg( "Section not complete, waiting for the end\n" );
1244         }
1245     
1246 //        intf_DbgMsg( "Must loop ? Next data offset: %d, stuffing: %d\n",
1247 //                     i_data_offset, p_ts_packet->buffer[i_data_offset] );
1248     }
1249
1250     /* Relase the TS packet, we don't need it anymore */
1251     input_NetlistFreeTS( p_input, p_ts_packet );
1252
1253 #undef p_psi  
1254 }