1 /*****************************************************************************
2 * input.c: input thread
3 * Read an MPEG2 stream, demultiplex and parse it before sending it to
5 *****************************************************************************
6 * Copyright (C) 1998, 1999, 2000 VideoLAN
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
23 *****************************************************************************/
25 /*****************************************************************************
27 *****************************************************************************/
30 #include <errno.h> /* errno */
31 #include <sys/types.h> /* on BSD, uio.h needs types.h */
32 #include <sys/uio.h> /* "input.h" */
33 #include <string.h> /* strerror() */
35 #include <stdlib.h> /* free() */
36 #include <netinet/in.h> /* ntohs() */
47 #include "input_psi.h"
48 #include "input_pcr.h"
49 #include "input_netlist.h"
50 #include "decoder_fifo.h"
51 #include "input_file.h"
52 #include "input_network.h"
54 #include "audio_output.h" /* aout_thread_t */
56 #include "audio_decoder.h" /* audiodec_t (for audio_decoder_thread.h) */
57 #include "audio_decoder_thread.h" /* adec_thread_t */
59 #include "ac3_decoder.h" /* ac3dec_t (for ac3_decoder_thread.h) */
60 #include "ac3_decoder_thread.h" /* ac3dec_thread_t */
62 #include "lpcm_decoder.h"
63 #include "lpcm_decoder_thread.h"
65 #include "video.h" /* picture_t (for video_output.h) */
66 #include "video_output.h" /* vout_thread_t */
68 #include "vdec_idct.h" /* dctelem_t (for video_parser.h) */
69 #include "vdec_motion.h" /* f_motion_t (for video_parser.h) */
70 #include "vpar_blocks.h" /* macroblock_t (for video_parser.h) */
71 #include "vpar_headers.h" /* sequence_t (for video_parser.h) */
72 #include "vpar_synchro.h" /* video_synchro_t (for video_parser.h) */
73 #include "video_parser.h" /* vpar_thread_t */
75 #include "spu_decoder.h" /* spudec_thread_t */
79 /*****************************************************************************
81 *****************************************************************************/
82 static void RunThread ( input_thread_t *p_input );
83 static void ErrorThread ( input_thread_t *p_input );
84 static void EndThread ( input_thread_t *p_input );
86 static __inline__ int input_ReadPacket( input_thread_t *p_input );
87 static __inline__ void input_SortPacket( input_thread_t *p_input,
88 ts_packet_t *ts_packet );
89 static __inline__ void input_DemuxTS( input_thread_t *p_input,
90 ts_packet_t *ts_packet,
91 es_descriptor_t *es_descriptor );
92 static __inline__ void input_DemuxPES( input_thread_t *p_input,
93 ts_packet_t *ts_packet,
94 es_descriptor_t *p_es_descriptor,
95 boolean_t b_unit_start,
96 boolean_t b_packet_lost );
97 static __inline__ void input_ParsePES( input_thread_t *p_input,
98 es_descriptor_t *p_es_descriptor );
99 static __inline__ void input_DemuxPSI( input_thread_t *p_input,
100 ts_packet_t *ts_packet,
101 es_descriptor_t *p_es_descriptor,
102 boolean_t b_unit_start,
103 boolean_t b_packet_lost );
105 /*****************************************************************************
106 * input_CreateThread: creates a new input thread
107 *****************************************************************************
108 * This function creates a new input, and returns a pointer
109 * to its description. On error, it returns NULL.
110 * If pi_status is NULL, then the function will block until the thread is ready.
111 * If not, it will be updated using one of the THREAD_* constants.
112 *****************************************************************************/
113 input_thread_t *input_CreateThread ( int i_method, void *p_source, int i_port,
114 int i_vlan, p_vout_thread_t p_vout,
115 p_aout_thread_t p_aout, int *pi_status )
117 input_thread_t * p_input; /* thread descriptor */
118 int i_status; /* thread status */
119 int i_index; /* index for tables initialization */
121 /* Allocate descriptor */
123 p_input = (input_thread_t *)malloc( sizeof(input_thread_t) );
124 if( p_input == NULL )
126 intf_ErrMsg("error: %s\n", strerror(ENOMEM));
130 /* Initialize thread properties */
132 p_input->b_error = 0;
133 p_input->pi_status = (pi_status != NULL) ? pi_status : &i_status;
134 *p_input->pi_status = THREAD_CREATE;
136 /* Initialize input method description */
137 p_input->i_method = i_method;
138 p_input->p_source = p_source;
139 p_input->i_port = i_port;
140 p_input->i_vlan = i_vlan;
143 case INPUT_METHOD_TS_FILE: /* file methods */
144 p_input->p_Open = input_FileOpen;
145 p_input->p_Read = input_FileRead;
146 p_input->p_Close = input_FileClose;
148 case INPUT_METHOD_TS_VLAN_BCAST: /* vlan network method */
149 if( !p_main->b_vlans )
151 intf_ErrMsg("error: vlans are not activated\n");
155 /* ... pass through */
156 case INPUT_METHOD_TS_UCAST: /* network methods */
157 case INPUT_METHOD_TS_MCAST:
158 case INPUT_METHOD_TS_BCAST:
159 p_input->p_Open = input_NetworkOpen;
160 p_input->p_Read = input_NetworkRead;
161 p_input->p_Close = input_NetworkClose;
164 intf_ErrMsg("error: unknow input method\n");
170 /* Initialize stream description */
171 for( i_index = 0; i_index < INPUT_MAX_ES; i_index++ )
173 p_input->p_es[i_index].i_id = EMPTY_PID;
174 p_input->pp_selected_es[i_index] = NULL;
177 /* Initialize default settings for spawned decoders */
178 p_input->p_aout = p_aout;
179 p_input->p_vout = p_vout;
182 /* Initialize statistics */
183 p_input->c_loops = 0;
184 p_input->c_bytes = 0;
185 p_input->c_payload_bytes = 0;
186 p_input->c_packets_read = 0;
187 p_input->c_packets_trashed = 0;
190 /* Initialize PSI and PCR decoders */
191 if( input_PsiInit( p_input ) )
197 if( input_PcrInit( p_input ) )
199 input_PsiEnd( p_input );
204 /* Initialize netlists */
205 if( input_NetlistInit( p_input ) )
207 input_PsiEnd( p_input );
208 input_PcrEnd( p_input );
213 intf_DbgMsg("configuration: method=%d, source=%s, port=%d, vlan=%d\n",
214 i_method, p_source, i_port, i_vlan );
216 /* Let the appropriate method open the socket. */
217 if( p_input->p_Open( p_input ) )
219 input_NetlistEnd( p_input );
220 input_PsiEnd( p_input );
221 input_PcrEnd( p_input );
226 /* Create thread and set locks. */
227 vlc_mutex_init( &p_input->netlist.lock );
228 vlc_mutex_init( &p_input->programs_lock );
229 vlc_mutex_init( &p_input->es_lock );
230 if( vlc_thread_create(&p_input->thread_id, "input", (void *) RunThread, (void *) p_input) )
232 intf_ErrMsg("error: %s\n", strerror(errno) );
233 p_input->p_Close( p_input );
234 input_NetlistEnd( p_input );;
235 input_PsiEnd( p_input );
236 input_PcrEnd( p_input );
241 intf_Msg("Input initialized\n");
243 /* If status is NULL, wait until the thread is created */
244 if( pi_status == NULL )
248 msleep( THREAD_SLEEP );
249 }while( (i_status != THREAD_READY) && (i_status != THREAD_ERROR)
250 && (i_status != THREAD_FATAL) );
251 if( i_status != THREAD_READY )
259 /*****************************************************************************
260 * input_DestroyThread: mark an input thread as zombie
261 *****************************************************************************
262 * This function should not return until the thread is effectively cancelled.
263 *****************************************************************************/
264 void input_DestroyThread( input_thread_t *p_input, int *pi_status )
266 int i_status; /* thread status */
269 p_input->pi_status = (pi_status != NULL) ? pi_status : &i_status;
270 *p_input->pi_status = THREAD_DESTROY;
272 /* Request thread destruction */
275 /* If status is NULL, wait until thread has been destroyed */
276 if( pi_status == NULL )
280 msleep( THREAD_SLEEP );
281 }while( (i_status != THREAD_OVER) && (i_status != THREAD_ERROR)
282 && (i_status != THREAD_FATAL) );
287 /*****************************************************************************
288 * input_OpenAudioStream: open an audio stream
289 *****************************************************************************
290 * This function spawns an audio decoder and plugs it on the audio output
292 *****************************************************************************/
293 int input_OpenAudioStream( input_thread_t *p_input, int i_id )
298 /*****************************************************************************
299 * input_CloseAudioStream: close an audio stream
300 *****************************************************************************
301 * This function destroys an audio decoder.
302 *****************************************************************************/
303 void input_CloseAudioStream( input_thread_t *p_input, int i_id )
308 /*****************************************************************************
309 * input_OpenVideoStream: open a video stream
310 *****************************************************************************
311 * This function spawns a video decoder and plugs it on a video output thread.
312 *****************************************************************************/
313 int input_OpenVideoStream( input_thread_t *p_input,
314 struct vout_thread_s *p_vout, struct video_cfg_s * p_cfg )
319 /*****************************************************************************
320 * input_CloseVideoStream: close a video stream
321 *****************************************************************************
322 * This function destroys an video decoder.
323 *****************************************************************************/
324 void input_CloseVideoStream( input_thread_t *p_input, int i_id )
330 /* following functions are local */
332 /*****************************************************************************
333 * InitThread: initialize input thread
334 *****************************************************************************
335 * This function is called from RunThread and performs the second step of the
336 * initialization. It returns 0 on success. Note that the thread's flag are not
337 * modified inside this function.
338 *****************************************************************************/
339 static int InitThread( input_thread_t *p_input )
341 /* Mark thread as running and return */
343 *p_input->pi_status = THREAD_READY;
344 intf_DbgMsg("thread ready\n");
348 /*****************************************************************************
350 *****************************************************************************
351 * Notice that current ES state has been locked by input_SortPacket.
352 * (No more true, changed by benny - FIXME: See if it's ok, and definitely
353 * change the code ?? )
354 *****************************************************************************/
355 static __inline__ void input_DemuxPSI( input_thread_t *p_input,
356 ts_packet_t *p_ts_packet,
357 es_descriptor_t *p_es_descriptor,
358 boolean_t b_unit_start,
359 boolean_t b_packet_lost )
361 int i_data_offset; /* Offset of the interesting data in the TS packet */
362 u16 i_data_length; /* Length of those data */
363 //boolean_t b_first_section; /* another section in the TS packet ? */
367 ASSERT(p_es_descriptor);
369 #define p_psi (p_es_descriptor->p_psi_section)
371 //intf_DbgMsg( "input debug: PSI demultiplexing %p (%p)\n", p_ts_packet, p_input);
373 //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);
376 /* Try to find the beginning of the payload in the packet to initialise
377 * the do-while loop that follows -> Compute the i_data_offset variable:
378 * by default, the value is set so that we won't enter in the while loop.
379 * It will be set to a correct value if the data are not corrupted */
380 i_data_offset = TS_PACKET_SIZE;
382 /* Has the reassembly of a section already begun in a previous packet ? */
383 if( p_psi->b_running_section )
385 /* Was data lost since the last TS packet ? */
388 /* Discard the packet and wait for the begining of a new one
390 p_psi->b_running_section = 0;
391 p_psi->i_current_position = 0;
392 intf_DbgMsg( "PSI section(s) discarded due to packet loss\n" );
396 /* The data that complete a previously began section are always at
397 * the beginning of the TS payload... */
398 i_data_offset = p_ts_packet->i_payload_start;
399 /* ...Unless there is a pointer field, that we have to bypass */
402 //intf_DbgMsg( "New part of the section received at offset %d\n", i_data_offset );
405 /* We are looking for the beginning of a new section */
410 /* Get the offset at which the data for that section can be found
411 * The offset is stored in the pointer_field since we are
412 * interested in the first section of the TS packet. Note that
413 * the +1 is to bypass the pointer field */
414 i_data_offset = p_ts_packet->i_payload_start +
415 p_ts_packet->buffer[p_ts_packet->i_payload_start] + 1;
416 //intf_DbgMsg( "New section beginning at offset %d in TS packet\n", i_data_offset );
420 /* This may either mean that the TS is bad or that the packet
421 * contains the end of a section that had been discarded in a
422 * previous loop: trash the TS packet since we cannot do
423 * anything with those data: */
424 p_psi->b_running_section = 0;
425 p_psi->i_current_position = 0;
426 intf_DbgMsg( "PSI packet discarded due to lack of synchronisation\n" );
430 /* The section we will deal with during the first iteration of the
431 * following loop is the first one contained in the TS packet */
432 // b_first_section = 1;
434 /* Reassemble the pieces of sections contained in the TS packet and
435 * decode the sections that could have been completed.
436 * Stop when we reach the end of the packet or stuffing bytes */
437 while( i_data_offset < TS_PACKET_SIZE && p_ts_packet->buffer[i_data_offset] != 0xFF )
439 /* If the current section is a new one, reinit the data fields of
440 * the p_psi struct to start its decoding */
441 if( !p_psi->b_running_section )
443 /* Read the length of the new section */
444 p_psi->i_length = (U16_AT(&p_ts_packet->buffer[i_data_offset+1]) & 0xFFF) + 3;
445 //intf_DbgMsg( "Section length %d\n", p_psi->i_length );
446 if( p_psi->i_length > PSI_SECTION_SIZE )
448 /* The TS packet is corrupted, stop here to avoid possible
450 intf_DbgMsg( "PSI Section size is too big, aborting its reception\n" );
454 /* Init the reassembly of that section */
455 p_psi->b_running_section = 1;
456 p_psi->i_current_position = 0;
459 /* Compute the length of data related to the section in this TS packet */
460 if( p_psi->i_length - p_psi->i_current_position > TS_PACKET_SIZE - i_data_offset)
461 i_data_length = TS_PACKET_SIZE - i_data_offset;
463 i_data_length = p_psi->i_length - p_psi->i_current_position;
465 /* Copy those data in the section buffer */
466 memcpy( &p_psi->buffer[p_psi->i_current_position], &p_ts_packet->buffer[i_data_offset],
469 /* Interesting data are now after the ones we copied, since no gap is
470 * allowed between 2 sections in a TS packets */
471 i_data_offset += i_data_length;
473 /* Decode the packet if it is now complete */
474 if (p_psi->i_length == p_psi->i_current_position + i_data_length)
476 /* Packet is complete, decode it */
477 //intf_DbgMsg( "SECTION COMPLETE: starting decoding of its data\n" );
478 input_PsiDecode( p_input, p_psi );
480 /* Prepare the buffer to receive a new section */
481 p_psi->i_current_position = 0;
482 p_psi->b_running_section = 0;
484 /* The new section won't be the first anymore */
485 //b_first_section = 0;
489 /* Prepare the buffer to receive the next part of the section */
490 p_psi->i_current_position += i_data_length;
491 //intf_DbgMsg( "Section not complete, waiting for the end\n" );
494 //intf_DbgMsg( "Must loop ? Next data offset: %d, stuffing: %d\n",
495 // i_data_offset, p_ts_packet->buffer[i_data_offset] );
498 /* Relase the TS packet, we don't need it anymore */
499 input_NetlistFreeTS( p_input, p_ts_packet );
504 /*****************************************************************************
506 *****************************************************************************
507 * Parse a finished PES packet and analyze its header.
508 *****************************************************************************/
509 static __inline__ void input_ParsePES( input_thread_t *p_input,
510 es_descriptor_t *p_es_descriptor )
512 decoder_fifo_t * p_fifo;
513 u8 i_pes_header_size;
515 int i_ts_payload_size;
518 #define p_pes (p_es_descriptor->p_pes_packet)
520 //intf_DbgMsg("End of PES packet %p\n", p_pes);
522 /* First read the 6 header bytes common to all PES packets:
523 use them to test the PES validity */
524 if( (p_pes->p_pes_header[0] || p_pes->p_pes_header[1] ||
525 (p_pes->p_pes_header[2] != 1)) ||
526 /* packet_start_code_prefix != 0x000001 */
527 ((p_pes->i_pes_real_size) &&
528 (p_pes->i_pes_real_size != p_pes->i_pes_size)) )
529 /* PES_packet_length is set and != total received payload */
531 /* Trash the packet and set p_pes to NULL to be sure the next PES
532 packet will have its b_data_lost flag set */
533 intf_DbgMsg("Corrupted PES packet (size doesn't match) : trashed\n");
534 input_NetlistFreePES( p_input, p_pes );
540 /* The PES packet is valid. Check its type to test if it may
541 carry additional informations in a header extension */
542 p_pes->i_stream_id = p_pes->p_pes_header[3];
544 switch( p_pes->i_stream_id )
546 case 0xBE: /* Padding */
547 case 0xBC: /* Program stream map */
548 case 0xBF: /* Private stream 2 */
551 case 0xFF: /* Program stream directory */
552 case 0xF2: /* DSMCC stream */
553 case 0xF8: /* ITU-T H.222.1 type E stream */
554 /* The payload begins immediatly after the 6 bytes header, so
555 we have finished with the parsing */
556 i_pes_header_size = 6;
560 switch( p_pes->p_pes_header[8] & 0xc0 )
562 case 0x80: /* MPEG2: 10xx xxxx */
563 case 0x00: /* FIXME: This shouldn't be allowed !! */
564 /* The PES header contains at least 3 more bytes: parse them */
565 p_pes->b_data_alignment = p_pes->p_pes_header[6] & 0x04;
566 p_pes->b_has_pts = p_pes->p_pes_header[7] & 0x80;
567 i_pes_header_size = p_pes->p_pes_header[8] + 9;
569 /* Now parse the optional header extensions (in the limit of
571 if( p_pes->b_has_pts )
573 pcr_descriptor_t * p_pcr;
575 p_pcr = p_input->p_pcr;
578 ( ((mtime_t)(p_pes->p_pes_header[9] & 0x0E) << 29) |
579 (((mtime_t)U16_AT(p_pes->p_pes_header + 10) << 14) - (1 << 14)) |
580 ((mtime_t)U16_AT(p_pes->p_pes_header + 12) >> 1) ) * 300;
583 if( p_pcr->i_synchro_state )
585 switch( p_pcr->i_synchro_state )
587 case SYNCHRO_NOT_STARTED:
588 p_pes->b_has_pts = 0;
592 p_pes->i_pts += p_pcr->delta_pcr;
593 p_pcr->delta_absolute = mdate() - p_pes->i_pts + INPUT_PTS_DELAY;
594 p_pes->i_pts += p_pcr->delta_absolute;
595 p_pcr->i_synchro_state = 0;
598 case SYNCHRO_REINIT: /* We skip a PES */
599 p_pes->b_has_pts = 0;
600 p_pcr->i_synchro_state = SYNCHRO_START;
606 p_pes->i_pts += p_pcr->delta_pcr + p_pcr->delta_absolute;
611 default: /* MPEG1 or some strange thing */
612 /* since this isn't supported yet, we certainly gonna crash */
613 intf_ErrMsg( "FIXME: unknown PES type %.2x\n",
614 p_pes->p_pes_header[8] );
615 i_pes_header_size = 6;
622 /* Now we've parsed the header, we just have to indicate in some
623 * specific TS packets where the PES payload begins (renumber
624 * i_payload_start), so that the decoders can find the beginning
625 * of their data right out of the box. */
626 p_ts = p_pes->p_first_ts;
627 i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;
628 while( i_pes_header_size > i_ts_payload_size )
630 /* These packets are entirely filled by the PES header. */
631 i_pes_header_size -= i_ts_payload_size;
632 p_ts->i_payload_start = p_ts->i_payload_end;
633 /* Go to the next TS packet: here we won't have to test it is
634 * not NULL because we trash the PES packets when packet lost
636 p_ts = p_ts->p_next_ts;
637 i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;
639 /* This last packet is partly header, partly payload. */
640 p_ts->i_payload_start += i_pes_header_size;
643 /* Now we can eventually put the PES packet in the decoder's
645 switch( p_es_descriptor->i_type )
649 p_fifo = &(((vpar_thread_t*)(p_es_descriptor->p_dec))->fifo);
654 p_fifo = &(((adec_thread_t*)(p_es_descriptor->p_dec))->fifo);
658 p_fifo = &(((ac3dec_thread_t *)(p_es_descriptor->p_dec))->fifo);
662 p_fifo = &(((lpcmdec_thread_t *)(p_es_descriptor->p_dec))->fifo);
666 /* we skip the first byte at the beginning of the
667 * subpicture payload, it only contains the SPU ID. */
668 p_ts->i_payload_start++;
669 p_fifo = &(((spudec_thread_t *)(p_es_descriptor->p_dec))->fifo);
673 /* This should never happen */
674 intf_DbgMsg("Unknown stream type (%d, %d): PES trashed\n",
675 p_es_descriptor->i_id, p_es_descriptor->i_type);
682 vlc_mutex_lock( &p_fifo->data_lock );
683 if( DECODER_FIFO_ISFULL( *p_fifo ) )
685 /* The FIFO is full !!! This should not happen. */
687 p_input->c_packets_trashed += p_pes->i_ts_packets;
688 p_es_descriptor->c_invalid_packets += p_pes->i_ts_packets;
690 input_NetlistFreePES( p_input, p_pes );
691 intf_DbgMsg("PES trashed - fifo full ! (%d, %d)\n",
692 p_es_descriptor->i_id, p_es_descriptor->i_type);
696 //intf_DbgMsg("Putting %p into fifo %p/%d\n",
697 // p_pes, p_fifo, p_fifo->i_end);
698 p_fifo->buffer[p_fifo->i_end] = p_pes;
699 DECODER_FIFO_INCEND( *p_fifo );
701 /* Warn the decoder that it's got work to do. */
702 vlc_cond_signal( &p_fifo->data_wait );
704 vlc_mutex_unlock( &p_fifo->data_lock );
708 intf_DbgMsg("No fifo to receive PES %p: trash\n", p_pes);
710 p_input->c_packets_trashed += p_pes->i_ts_packets;
711 p_es_descriptor->c_invalid_packets += p_pes->i_ts_packets;
713 input_NetlistFreePES( p_input, p_pes );
719 /*****************************************************************************
721 *****************************************************************************
722 * Gather a PES packet.
723 *****************************************************************************/
724 static __inline__ void input_DemuxPES( input_thread_t *p_input,
725 ts_packet_t *p_ts_packet,
726 es_descriptor_t *p_es_descriptor,
727 boolean_t b_unit_start,
728 boolean_t b_packet_lost )
731 pes_packet_t* p_last_pes;
733 int i_ts_payload_size;
736 #define p_pes (p_es_descriptor->p_pes_packet)
740 ASSERT(p_es_descriptor);
742 //intf_DbgMsg("PES-demultiplexing %p (%p)\n", p_ts_packet, p_pes);
744 /* If we lost data, discard the PES packet we are trying to reassemble
745 if any and wait for the beginning of a new one in order to synchronise
747 if( b_packet_lost && p_pes != NULL )
749 intf_DbgMsg("PES %p trashed because of packet lost\n", p_pes);
750 input_NetlistFreePES( p_input, p_pes );
754 /* If the TS packet contains the begining of a new PES packet, and if we
755 were reassembling a PES packet, then the PES should be complete now,
756 so parse its header and give it to the decoders */
757 if( b_unit_start && p_pes != NULL )
759 /* Parse the header. The header has a variable length, but in order
760 to improve the algorithm, we will read the 14 bytes we may be
763 /* If this part of the header did not fit in the current TS packet,
764 copy the part of the header we are interested in to the
765 p_pes_header_save buffer. The buffer is dynamicly allocated if
766 needed so it's time expensive but this situation almost never
768 p_ts = p_pes->p_first_ts;
769 i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;
771 if(i_ts_payload_size < PES_HEADER_SIZE)
773 intf_DbgMsg("Code never tested encountered, WARNING ! (benny)\n");
774 if( !p_pes->p_pes_header_save )
776 p_pes->p_pes_header_save = malloc(PES_HEADER_SIZE);
782 memcpy( p_pes->p_pes_header_save + i_dummy,
783 &p_ts->buffer[p_ts->i_payload_start],
785 i_dummy += i_ts_payload_size;
787 p_ts = p_ts->p_next_ts;
790 /* The payload of the PES packet is shorter than the 14 bytes
791 we would read. This means that high packet lost occured
792 so the PES won't be useful for any decoder. Moreover,
793 this should never happen so we can trash the packet and
794 exit roughly without regrets */
795 intf_DbgMsg("PES packet too short: trashed\n");
796 input_NetlistFreePES( p_input, p_pes );
802 i_ts_payload_size = p_ts->i_payload_end - p_ts->i_payload_start;
804 while(i_ts_payload_size + i_dummy < PES_HEADER_SIZE);
806 /* This last TS packet is partly header, partly payload, so just
807 copy the header part */
808 memcpy(p_pes->p_pes_header_save + i_dummy,
809 &p_ts->buffer[p_ts->i_payload_start],
810 PES_HEADER_SIZE - i_dummy);
812 /* The header must be read in the buffer not in any TS packet */
813 p_pes->p_pes_header = p_pes->p_pes_header_save;
815 /* Get the PES size if defined */
816 if( (i_dummy = U16_AT(p_pes->p_pes_header + 4)) )
818 p_pes->i_pes_real_size = i_dummy + 6;
822 /* Now we have the part of the PES header we were interested in:
823 p_pes_header and i_pes_real_size ; we can parse it */
824 input_ParsePES( p_input, p_es_descriptor );
827 /* If we are at the beginning of a new PES packet, we must fetch a new
828 PES buffer to begin with the reassembly of this PES packet. This is
829 also here that we can synchronise with the stream if we we lost
830 packets or if the decoder has just started */
835 /* Get a new one PES from the PES netlist. */
836 if( (p_pes = input_NetlistGetPES( p_input )) == (NULL) )
838 /* PES netlist is empty ! */
839 p_input->b_error = 1;
843 //intf_DbgMsg("New PES packet %p (first TS: %p)\n", p_pes, p_ts_packet);
845 /* Init the PES fields so that the first TS packet could be
846 * correctly added to the PES packet (see below) */
847 p_pes->p_first_ts = p_ts_packet;
848 p_pes->p_last_ts = NULL;
850 /* If the last pes packet was null, this means that the
851 * synchronization was lost and so warn the decoder that he
852 * will have to find a way to recover */
854 p_pes->b_data_loss = 1;
856 /* Read the b_random_access flag status and then reinit it */
857 p_pes->b_random_access = p_es_descriptor->b_random;
858 p_es_descriptor->b_random = 0;
861 /* If the PES header fits in the first TS packet, we can
862 * already set p_pes->p_pes_header, and in all cases we
863 * set p_pes->i_pes_real_size */
864 if( p_ts_packet->i_payload_end - p_ts_packet->i_payload_start
867 p_pes->p_pes_header = &(p_ts_packet->buffer[p_ts_packet->i_payload_start]);
868 if( (i_dummy = U16_AT(p_pes->p_pes_header + 4)) )
870 p_pes->i_pes_real_size = i_dummy + 6;
876 /* If we are synchronized with the stream, and so if we are ready to
877 receive correctly the data, add the TS packet to the current PES
881 //intf_DbgMsg("Adding TS %p to PES %p\n", p_ts_packet, p_pes);
883 /* Size of the payload carried in the TS packet */
884 i_ts_payload_size = p_ts_packet->i_payload_end -
885 p_ts_packet->i_payload_start;
887 /* Update the relations between the TS packets */
888 p_ts_packet->p_prev_ts = p_pes->p_last_ts;
889 p_ts_packet->p_next_ts = NULL;
890 if( p_pes->i_ts_packets != 0 )
892 /* Regarder si il serait pas plus efficace de ne creer que
893 * les liens precedent->suivant pour le moment, et les
894 * liens suivant->precedent quand le paquet est termine */
895 /* Otherwise it is the first TS packet. */
896 p_pes->p_last_ts->p_next_ts = p_ts_packet;
898 /* Now add the TS to the PES packet */
899 p_pes->p_last_ts = p_ts_packet;
900 p_pes->i_ts_packets++;
901 p_pes->i_pes_size += i_ts_payload_size;
905 i_dummy = p_ts_packet->i_payload_end - p_ts_packet->i_payload_start;
906 p_es_descriptor->c_payload_bytes += i_dummy;
909 /* We can check if the packet is finished */
910 if( p_pes->i_pes_size == p_pes->i_pes_real_size )
912 /* The packet is finished, parse it */
913 input_ParsePES( p_input, p_es_descriptor );
915 /* Tell the Demux we have parsed this PES, no need to redo it */
921 /* Since we don't use the TS packet to build a PES packet, we don't
922 need it anymore, so give it back to the netlist */
923 //intf_DbgMsg("Trashing TS %p: no PES being build\n", p_ts_packet);
924 input_NetlistFreeTS( p_input, p_ts_packet );
930 /*****************************************************************************
931 * input_DemuxTS: first step of demultiplexing: the TS header
932 *****************************************************************************
933 * Stream must also only contain PES and PSI, so PID must have been filtered
934 *****************************************************************************/
935 static __inline__ void input_DemuxTS( input_thread_t *p_input,
936 ts_packet_t *p_ts_packet,
937 es_descriptor_t *p_es_descriptor )
940 boolean_t b_adaption; /* Adaption field is present */
941 boolean_t b_payload; /* Packet carries payload */
942 boolean_t b_unit_start; /* A PSI or a PES start in the packet */
943 boolean_t b_trash = 0; /* Must the packet be trashed ? */
944 boolean_t b_lost = 0; /* Was there a packet lost ? */
948 ASSERT(p_es_descriptor);
950 #define p (p_ts_packet->buffer)
952 //intf_DbgMsg("input debug: TS-demultiplexing packet %p, pid %d, number %d\n",
953 // p_ts_packet, U16_AT(&p[1]) & 0x1fff, p[3] & 0x0f);
956 p_es_descriptor->c_packets++;
957 p_es_descriptor->c_bytes += TS_PACKET_SIZE;
960 /* Extract flags values from TS common header. */
961 b_unit_start = (p[1] & 0x40);
962 b_adaption = (p[3] & 0x20);
963 b_payload = (p[3] & 0x10);
965 /* Extract adaption field informations if any */
968 /* We don't have any adaptation_field, so payload start immediately
969 after the 4 byte TS header */
970 p_ts_packet->i_payload_start = 4;
974 /* p[4] is adaptation_field_length minus one */
975 p_ts_packet->i_payload_start = 5 + p[4];
977 /* The adaption field can be limited to the adaptation_field_length byte,
978 so that there is nothing to do: skip this possibility */
981 /* If the packet has both adaptation_field and payload, adaptation_field
982 cannot be more than 182 bytes long; if there is only an
983 adaptation_field, it must fill the next 183 bytes. */
984 if( b_payload ? (p[4] > 182) : (p[4] != 183) )
986 intf_DbgMsg("input debug: invalid TS adaptation field (%p)\n",
989 p_es_descriptor->c_invalid_packets++;
994 /* No we are sure that the byte containing flags is present: read it */
997 /* discontinuity_indicator */
1000 intf_DbgMsg("discontinuity_indicator encountered by TS demux " \
1001 "(position read: %d, saved: %d)\n", p[5] & 0x80,
1002 p_es_descriptor->i_continuity_counter);
1004 /* If the PID carries the PCR, there will be a system time-base
1005 discontinuity. We let the PCR decoder handle that. */
1006 p_es_descriptor->b_discontinuity = 1;
1008 /* There also may be a continuity_counter discontinuity:
1009 resynchronise our counter with the one of the stream */
1010 p_es_descriptor->i_continuity_counter = (p[3] & 0x0f) - 1;
1013 /* random_access_indicator */
1014 p_es_descriptor->b_random |= p[5] & 0x40;
1016 /* If this is a PCR_PID, and this TS packet contains a PCR,
1017 we pass it along to the PCR decoder. */
1018 if( (p_es_descriptor->b_pcr) && (p[5] & 0x10) )
1020 /* There should be a PCR field in the packet, check if the
1021 adaption field is long enough to carry it */
1024 /* Call the PCR decoder */
1025 input_PcrDecode( p_input, p_es_descriptor, &p[6] );
1032 /* Check the continuity of the stream. */
1033 i_dummy = ((p[3] & 0x0f) - p_es_descriptor->i_continuity_counter) & 0x0f;
1036 /* Everything is ok, just increase our counter */
1037 p_es_descriptor->i_continuity_counter++;
1041 if( !b_payload && i_dummy == 0 )
1043 /* This is a packet without payload, this is allowed by the draft
1044 As there is nothing interesting in this packet (except PCR that
1045 have already been handled), we can trash the packet. */
1046 intf_DbgMsg("Packet without payload received by TS demux\n");
1049 else if( i_dummy <= 0 )
1051 /* Duplicate packet: mark it as being to be trashed. */
1052 intf_DbgMsg("Duplicate packet received by TS demux\n");
1055 else if( p_es_descriptor->i_continuity_counter == 0xFF )
1057 /* This means that the packet is the first one we receive for this
1058 ES since the continuity counter ranges between 0 and 0x0F
1059 excepts when it has been initialized by the input: Init the
1060 counter to the correct value. */
1061 intf_DbgMsg("First packet for PID %d received by TS demux\n",
1062 p_es_descriptor->i_id);
1063 p_es_descriptor->i_continuity_counter = (p[3] & 0x0f);
1067 /* This can indicate that we missed a packet or that the
1068 continuity_counter wrapped and we received a dup packet: as we
1069 don't know, do as if we missed a packet to be sure to recover
1070 from this situation */
1071 intf_DbgMsg("Packet lost by TS demux: current %d, packet %d\n",
1072 p_es_descriptor->i_continuity_counter & 0x0f,
1075 p_es_descriptor->i_continuity_counter = p[3] & 0x0f;
1079 /* Trash the packet if it has no payload or if it is bad */
1082 input_NetlistFreeTS( p_input, p_ts_packet );
1084 p_input->c_packets_trashed++;
1089 if( p_es_descriptor->b_psi )
1091 /* The payload contains PSI tables */
1092 input_DemuxPSI( p_input, p_ts_packet, p_es_descriptor,
1093 b_unit_start, b_lost );
1097 /* The payload carries a PES stream */
1098 input_DemuxPES( p_input, p_ts_packet, p_es_descriptor,
1099 b_unit_start, b_lost );
1106 /*****************************************************************************
1107 * input_SortPacket: find out whether we need that packet
1108 *****************************************************************************/
1109 static __inline__ void input_SortPacket( input_thread_t *p_input,
1110 ts_packet_t *p_ts_packet )
1115 /* Verify that sync_byte, error_indicator and scrambling_control are
1116 what we expected. */
1117 if( !(p_ts_packet->buffer[0] == 0x47) || (p_ts_packet->buffer[1] & 0x80) ||
1118 (p_ts_packet->buffer[3] & 0xc0) )
1120 intf_DbgMsg("input debug: invalid TS header (%p)\n", p_ts_packet);
1124 /* Get the PID of the packet. Note that ntohs is needed, for endianness
1125 purposes (see man page). */
1126 i_current_pid = U16_AT(&p_ts_packet->buffer[1]) & 0x1fff;
1128 //intf_DbgMsg("input debug: pid %d received (%p)\n",
1129 // i_current_pid, p_ts_packet);
1131 /* Lock current ES state. */
1132 vlc_mutex_lock( &p_input->es_lock );
1134 /* Verify that we actually want this PID. */
1135 for( i_es_loop = 0; i_es_loop < INPUT_MAX_SELECTED_ES; i_es_loop++ )
1137 if( p_input->pp_selected_es[i_es_loop] != NULL)
1139 if( (*p_input->pp_selected_es[i_es_loop]).i_id
1142 /* Don't need the lock anymore, since the value pointed
1143 out by p_input->pp_selected_es[i_es_loop] can only be
1144 modified from inside the input_thread (by the PSI
1145 decoder): interface thread is only allowed to modify
1146 the pp_selected_es table */
1147 vlc_mutex_unlock( &p_input->es_lock );
1149 /* We're interested. Pass it to the demultiplexer. */
1150 input_DemuxTS( p_input, p_ts_packet,
1151 p_input->pp_selected_es[i_es_loop] );
1157 /* pp_selected_es should not contain any hole. */
1161 vlc_mutex_unlock( &p_input->es_lock );
1164 /* We weren't interested in receiving this packet. Give it back to the
1166 //intf_DbgMsg("SortPacket: freeing unwanted TS %p (pid %d)\n", p_ts_packet,
1167 // U16_AT(&p_ts_packet->buffer[1]) & 0x1fff);
1168 input_NetlistFreeTS( p_input, p_ts_packet );
1170 p_input->c_packets_trashed++;
1174 /*****************************************************************************
1175 * input_ReadPacket: reads a packet from the network or the file
1176 *****************************************************************************/
1177 static __inline__ int input_ReadPacket( input_thread_t *p_input )
1179 int i_base_index; /* index of the first free iovec */
1180 int i_current_index;
1182 #ifdef INPUT_LIFO_TS_NETLIST
1183 int i_meanwhile_released;
1184 int i_currently_removed;
1186 ts_packet_t * p_ts_packet;
1188 /* In this function, we only care about the TS netlist. PES netlist
1189 * is for the demultiplexer. */
1190 #ifdef INPUT_LIFO_TS_NETLIST
1191 i_base_index = p_input->netlist.i_ts_index;
1193 /* Verify that we still have packets in the TS netlist */
1194 if( (INPUT_MAX_TS + INPUT_TS_READ_ONCE - 1 - p_input->netlist.i_ts_index) <= INPUT_TS_READ_ONCE )
1196 intf_ErrMsg("input error: TS netlist is empty !\n");
1200 #else /* FIFO netlist */
1201 i_base_index = p_input->netlist.i_ts_start;
1202 if( p_input->netlist.i_ts_start + INPUT_TS_READ_ONCE -1 > INPUT_MAX_TS )
1204 /* The netlist is splitted in 2 parts. We must gather them to consolidate
1205 the FIFO (we make the loop easily in having the same iovec at the far
1206 end and in the beginning of netlist_free).
1207 That's why the netlist is (INPUT_MAX_TS +1) + (INPUT_TS_READ_ONCE -1)
1209 memcpy( p_input->netlist.p_ts_free + INPUT_MAX_TS + 1,
1210 p_input->netlist.p_ts_free,
1211 (p_input->netlist.i_ts_start + INPUT_TS_READ_ONCE - 1 - INPUT_MAX_TS)
1212 * sizeof(struct iovec) );
1215 /* Verify that we still have packets in the TS netlist */
1216 if( ((p_input->netlist.i_ts_end -1 - p_input->netlist.i_ts_start) & INPUT_MAX_TS) <= INPUT_TS_READ_ONCE )
1218 intf_ErrMsg("input error: TS netlist is empty !\n");
1221 #endif /* FIFO netlist */
1223 /* Scatter read the buffer. */
1224 i_packet_size = (*p_input->p_Read)( p_input,
1225 &p_input->netlist.p_ts_free[i_base_index],
1226 INPUT_TS_READ_ONCE );
1227 if( i_packet_size == (-1) )
1230 intf_DbgMsg("Read packet %d %p %d %d\n", i_base_index,
1231 &p_input->netlist.p_ts_free[i_base_index],
1232 p_input->netlist.i_ts_start,
1233 p_input->netlist.i_ts_end);
1235 intf_ErrMsg("input error: readv() failed (%s)\n", strerror(errno));
1239 if( i_packet_size == 0 )
1241 /* No packet has been received, so stop here. */
1245 /* Demultiplex the TS packets (1..INPUT_TS_READ_ONCE) received. */
1246 for( i_current_index = i_base_index;
1247 (i_packet_size -= TS_PACKET_SIZE) >= 0;
1250 /* BTW, something REALLY bad could happen if we receive packets with
1252 p_ts_packet = (ts_packet_t*)(p_input->netlist.p_ts_free[i_current_index].iov_base);
1253 /* Don't cry :-), we are allowed to do that cast, because initially,
1254 our buffer was malloc'ed with sizeof(ts_packet_t) */
1256 /* Find out if we need this packet and demultiplex. */
1257 input_SortPacket( p_input /* for current PIDs and netlist */,
1261 if( i_packet_size > 0 )
1263 intf_ErrMsg("input error: wrong size\n");
1267 /* Remove the TS packets we have just filled from the netlist */
1268 #ifdef INPUT_LIFO_TS_NETLIST
1269 /* We need to take a lock here while we're calculating index positions. */
1270 vlc_mutex_lock( &p_input->netlist.lock );
1272 i_meanwhile_released = i_base_index - p_input->netlist.i_ts_index;
1273 if( i_meanwhile_released )
1275 /* That's where it becomes funny :-). Since we didn't take locks for
1276 efficiency reasons, other threads (including ourselves, with
1277 input_DemuxPacket) might have released packets to the netlist.
1278 So we have to copy these iovec where they should go.
1280 BTW, that explains why the TS netlist is
1281 (INPUT_MAX_TS +1) + (TS_READ_ONCE -1) large. */
1283 i_currently_removed = i_current_index - i_base_index;
1284 if( i_meanwhile_released < i_currently_removed )
1286 /* Copy all iovecs in that case */
1287 memcpy( &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index]
1288 + i_currently_removed,
1289 &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index],
1290 i_meanwhile_released * sizeof(struct iovec) );
1294 /* We have fewer places than items, so we only move
1295 i_currently_removed of them. */
1296 memcpy( &p_input->netlist.p_ts_free[i_base_index],
1297 &p_input->netlist.p_ts_free[p_input->netlist.i_ts_index],
1298 i_currently_removed * sizeof(struct iovec) );
1301 /* Update i_netlist_index with the information gathered above. */
1302 p_input->netlist.i_ts_index += i_currently_removed;
1306 /* Nothing happened. */
1307 p_input->netlist.i_ts_index = i_current_index;
1310 vlc_mutex_unlock( &p_input->netlist.lock );
1312 #else /* FIFO netlist */
1313 /* & is modulo ; that's where we make the loop. */
1314 p_input->netlist.i_ts_start = i_current_index & INPUT_MAX_TS;
1318 p_input->c_packets_read += i_current_index - i_base_index;
1319 p_input->c_bytes += (i_current_index - i_base_index) * TS_PACKET_SIZE;
1324 /*****************************************************************************
1325 * RunThread: main thread loop
1326 *****************************************************************************
1327 * Thread in charge of processing the network packets and demultiplexing.
1328 *****************************************************************************/
1329 static void RunThread( input_thread_t *p_input )
1332 * Initialize thread and free configuration
1334 p_input->b_error = InitThread( p_input );
1335 if( p_input->b_error )
1337 free( p_input ); /* destroy descriptor */
1345 while( !p_input->b_die && !p_input->b_error )
1347 /* Scatter read the UDP packet from the network or the file. */
1348 if( (input_ReadPacket( p_input )) == (-1) )
1350 /* FIXME??: Normally, a thread can't kill itself, but we don't have
1351 * any method in case of an error condition ... */
1352 p_input->b_error = 1;
1363 if( p_input->b_error )
1365 ErrorThread( p_input );
1369 EndThread( p_input );
1370 intf_DbgMsg("thread end\n");
1374 /*****************************************************************************
1375 * ErrorThread: RunThread() error loop
1376 *****************************************************************************
1377 * This function is called when an error occured during thread main's loop.
1378 *****************************************************************************/
1379 static void ErrorThread( input_thread_t *p_input )
1381 /* Wait until a `die' order */
1383 while( !p_input->b_die )
1386 msleep( VOUT_IDLE_SLEEP );
1390 /*****************************************************************************
1391 * EndThread: end the input thread
1392 *****************************************************************************/
1393 static void EndThread( input_thread_t * p_input )
1395 int * pi_status; /* threas status */
1396 int i_es_loop; /* es index */
1400 pi_status = p_input->pi_status;
1401 *pi_status = THREAD_END;
1403 /* Close input method */
1404 p_input->p_Close( p_input );
1406 /* Destroy all decoder threads */
1408 (i_es_loop < INPUT_MAX_ES) && (p_input->pp_selected_es[i_es_loop] != NULL) ;
1411 switch( p_input->pp_selected_es[i_es_loop]->i_type )
1413 case MPEG1_VIDEO_ES:
1414 case MPEG2_VIDEO_ES:
1415 vpar_DestroyThread( (vpar_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) /*, NULL */ );
1417 case MPEG1_AUDIO_ES:
1418 case MPEG2_AUDIO_ES:
1419 adec_DestroyThread( (adec_thread_t*)(p_input->pp_selected_es[i_es_loop]->p_dec) );
1422 ac3dec_DestroyThread( (ac3dec_thread_t *)(p_input->pp_selected_es[i_es_loop]->p_dec) );
1425 lpcmdec_DestroyThread((lpcmdec_thread_t *)(p_input->pp_selected_es[i_es_loop]->p_dec) );
1428 spudec_DestroyThread( (spudec_thread_t *)(p_input->pp_selected_es[i_es_loop]->p_dec) );
1431 /* Special streams for the PSI decoder, PID 0 and 1 */
1435 intf_DbgMsg("error: unknown decoder type %d\n", p_input->pp_selected_es[i_es_loop]->i_type );
1441 input_NetlistEnd( p_input ); /* clean netlist */
1442 input_PsiEnd( p_input ); /* clean PSI information */
1443 input_PcrEnd( p_input ); /* clean PCR information */
1444 free( p_input ); /* free input_thread structure */
1447 *pi_status = THREAD_OVER;