]> git.sesse.net Git - vlc/blob - plugins/mpeg/input_ps.c
. moved the playlist handling from input/input.c to interface/interface.c
[vlc] / plugins / mpeg / input_ps.c
1 /*****************************************************************************
2  * input_ps.c: PS demux and packet management
3  *****************************************************************************
4  * Copyright (C) 1998, 1999, 2000 VideoLAN
5  * $Id: input_ps.c,v 1.2 2001/02/08 07:24:25 sam Exp $
6  *
7  * Authors: 
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  * 
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include "defs.h"
28
29 #include <stdlib.h>
30 #include <string.h>
31 #include <errno.h>
32
33 #include "config.h"
34 #include "common.h"
35 #include "threads.h"
36 #include "mtime.h"
37 #include "tests.h"
38
39 #include "intf_msg.h"
40
41 #include "main.h"
42
43 #include "stream_control.h"
44 #include "input_ext-intf.h"
45 #include "input_ext-dec.h"
46
47 #include "input.h"
48
49 #include "input_ps.h"
50 #include "mpeg_system.h"
51
52 #include "debug.h"
53
54 #include "modules.h"
55
56 /*****************************************************************************
57  * Local prototypes
58  *****************************************************************************/
59 static int  PSProbe     ( probedata_t * );
60 static int  PSRead      ( struct input_thread_s *,
61                           data_packet_t * p_packets[INPUT_READ_ONCE] );
62 static void PSInit      ( struct input_thread_s * );
63 static void PSEnd       ( struct input_thread_s * );
64 static struct pes_packet_s *  NewPES    ( void * p_garbage );
65 static struct data_packet_s * NewPacket ( void *, size_t );
66 static void DeletePacket( void *, struct data_packet_s * );
67 static void DeletePES   ( void *, struct pes_packet_s * );
68
69 /*****************************************************************************
70  * Functions exported as capabilities. They are declared as static so that
71  * we don't pollute the namespace too much.
72  *****************************************************************************/
73 void input_getfunctions( function_list_t * p_function_list )
74 {
75 #define input p_function_list->functions.input
76     p_function_list->pf_probe = PSProbe;
77     input.pf_init             = PSInit;
78     input.pf_open             = input_FileOpen;
79     input.pf_close            = input_FileClose;
80     input.pf_end              = PSEnd;
81     input.pf_read             = PSRead;
82     input.pf_demux            = input_DemuxPS;
83     input.pf_new_packet       = NewPacket;
84     input.pf_new_pes          = NewPES;
85     input.pf_delete_packet    = DeletePacket;
86     input.pf_delete_pes       = DeletePES;
87     input.pf_rewind           = NULL;
88     input.pf_seek             = NULL;
89 #undef input
90 }
91
92 /*
93  * Data reading functions
94  */
95
96 /*****************************************************************************
97  * PSProbe: verifies that the stream is a PS stream
98  *****************************************************************************/
99 static int PSProbe( probedata_t *p_data )
100 {
101     if( TestMethod( INPUT_METHOD_VAR, "ps" ) )
102     {
103         return( 999 );
104     }
105
106     return 10;
107 }
108
109 /*****************************************************************************
110  * PSInit: initializes PS structures
111  *****************************************************************************/
112 static void PSInit( input_thread_t * p_input )
113 {
114     thread_ps_data_t *  p_method;
115
116     if( (p_method =
117          (thread_ps_data_t *)malloc( sizeof(thread_ps_data_t) )) == NULL )
118     {
119         intf_ErrMsg( "Out of memory" );
120         p_input->b_error = 1;
121         return;
122     }
123
124     p_input->p_plugin_data = (void *)p_method;
125     p_input->p_method_data = NULL;
126
127     /* Re-open the socket as a buffered FILE stream */
128     if( (p_method->stream = fdopen( p_input->i_handle, "r" )) == NULL )
129     {
130         intf_ErrMsg( "Cannot open file (%s)", strerror(errno) );
131         p_input->b_error = 1;
132         return;
133     }
134     fseek( p_method->stream, 0, SEEK_SET );
135
136     /* FIXME : detect if InitStream failed */
137     input_InitStream( p_input, sizeof( stream_ps_data_t ) );
138     input_AddProgram( p_input, 0, sizeof( stream_ps_data_t ) );
139
140     if( p_input->stream.b_seekable )
141     {
142         stream_ps_data_t * p_demux_data =
143              (stream_ps_data_t *)p_input->stream.pp_programs[0]->p_demux_data;
144
145         /* Pre-parse the stream to gather stream_descriptor_t. */
146         p_input->stream.pp_programs[0]->b_is_ok = 0;
147         p_demux_data->i_PSM_version = EMPTY_PSM_VERSION;
148
149         while( !p_input->b_die && !p_input->b_error
150                 && !p_demux_data->b_has_PSM )
151         {
152             int                 i_result, i;
153             data_packet_t *     pp_packets[INPUT_READ_ONCE];
154
155             i_result = PSRead( p_input, pp_packets );
156             if( i_result == 1 )
157             {
158                 /* EOF */
159                 vlc_mutex_lock( &p_input->stream.stream_lock );
160                 p_input->stream.pp_programs[0]->b_is_ok = 1;
161                 vlc_mutex_unlock( &p_input->stream.stream_lock );
162                 break;
163             }
164             if( i_result == -1 )
165             {
166                 p_input->b_error = 1;
167                 break;
168             }
169
170             for( i = 0; i < INPUT_READ_ONCE && pp_packets[i] != NULL; i++ )
171             {
172                 /* FIXME: use i_p_config_t */
173                 input_ParsePS( p_input, pp_packets[i] );
174                 DeletePacket( p_input->p_method_data, pp_packets[i] );
175             }
176
177             /* File too big. */
178             if( p_input->stream.i_tell > INPUT_PREPARSE_LENGTH )
179             {
180                 break;
181             }
182         }
183         fseek( p_method->stream, 0, SEEK_SET );
184         vlc_mutex_lock( &p_input->stream.stream_lock );
185         p_input->stream.i_tell = 0;
186         if( p_demux_data->b_has_PSM )
187         {
188             /* (The PSM decoder will care about spawning the decoders) */
189             p_input->stream.pp_programs[0]->b_is_ok = 1;
190         }
191 #ifdef AUTO_SPAWN
192         else
193         {
194             /* (We have to do it ourselves) */
195             int                 i_es;
196
197             /* FIXME: we should do multiple passes in case an audio type
198              * is not present */
199             for( i_es = 0;
200                  i_es < p_input->stream.pp_programs[0]->i_es_number;
201                  i_es++ )
202             {
203 #define p_es p_input->stream.pp_programs[0]->pp_es[i_es]
204                 switch( p_es->i_type )
205                 {
206                     case MPEG1_VIDEO_ES:
207                     case MPEG2_VIDEO_ES:
208                         input_SelectES( p_input, p_es );
209                         break;
210
211                     case MPEG1_AUDIO_ES:
212                     case MPEG2_AUDIO_ES:
213                         if( main_GetIntVariable( INPUT_DVD_CHANNEL_VAR, 0 )
214                                 == (p_es->i_id & 0x1F) )
215                         switch( main_GetIntVariable( INPUT_DVD_AUDIO_VAR, 0 ) )
216                         {
217                         case 0:
218                             main_PutIntVariable( INPUT_DVD_CHANNEL_VAR,
219                                                  REQUESTED_MPEG );
220                         case REQUESTED_MPEG:
221                             input_SelectES( p_input, p_es );
222                         }
223                         break;
224
225                     case AC3_AUDIO_ES:
226                         if( main_GetIntVariable( INPUT_DVD_CHANNEL_VAR, 0 )
227                                 == ((p_es->i_id & 0xF00) >> 8) )
228                         switch( main_GetIntVariable( INPUT_DVD_AUDIO_VAR, 0 ) )
229                         {
230                         case 0:
231                             main_PutIntVariable( INPUT_DVD_CHANNEL_VAR,
232                                                  REQUESTED_AC3 );
233                         case REQUESTED_AC3:
234                             input_SelectES( p_input, p_es );
235                         }
236                         break;
237
238                     case DVD_SPU_ES:
239                         if( main_GetIntVariable( INPUT_DVD_SUBTITLE_VAR, -1 )
240                                 == ((p_es->i_id & 0x1F00) >> 8) )
241                         {
242                             input_SelectES( p_input, p_es );
243                         }
244                         break;
245
246                     case LPCM_AUDIO_ES:
247                         /* FIXME ! */
248                         break;
249                 }
250             }
251                     
252         }
253 #endif
254 #ifdef STATS
255         input_DumpStream( p_input );
256 #endif
257         vlc_mutex_unlock( &p_input->stream.stream_lock );
258     }
259     else
260     {
261         /* The programs will be added when we read them. */
262         vlc_mutex_lock( &p_input->stream.stream_lock );
263         p_input->stream.pp_programs[0]->b_is_ok = 0;
264         vlc_mutex_unlock( &p_input->stream.stream_lock );
265     }
266 }
267
268 /*****************************************************************************
269  * PSEnd: frees unused data
270  *****************************************************************************/
271 static void PSEnd( input_thread_t * p_input )
272 {
273     free( p_input->stream.p_demux_data );
274     free( p_input->p_plugin_data );
275 }
276
277 /*****************************************************************************
278  * SafeRead: reads a chunk of stream and correctly detects errors
279  *****************************************************************************/
280 static __inline__ int SafeRead( input_thread_t * p_input, byte_t * p_buffer,
281                                 size_t i_len )
282 {
283     thread_ps_data_t *  p_method;
284     int                 i_error;
285
286     p_method = (thread_ps_data_t *)p_input->p_plugin_data;
287     while( fread( p_buffer, i_len, 1, p_method->stream ) != 1 )
288     {
289         if( feof( p_method->stream ) )
290         {
291             return( 1 );
292         }
293
294         if( (i_error = ferror( p_method->stream )) )
295         {
296             intf_ErrMsg( "Read failed (%s)", strerror(i_error) );
297             return( -1 );
298         }
299     }
300     vlc_mutex_lock( &p_input->stream.stream_lock );
301     p_input->stream.i_tell += i_len;
302     vlc_mutex_unlock( &p_input->stream.stream_lock );
303     return( 0 );
304 }
305
306 /*****************************************************************************
307  * PSRead: reads data packets
308  *****************************************************************************
309  * Returns -1 in case of error, 0 if everything went well, and 1 in case of
310  * EOF.
311  *****************************************************************************/
312 static int PSRead( input_thread_t * p_input,
313                    data_packet_t * pp_packets[INPUT_READ_ONCE] )
314 {
315     byte_t              p_header[6];
316     data_packet_t *     p_data;
317     size_t              i_packet_size;
318     int                 i_packet, i_error;
319     thread_ps_data_t *  p_method;
320
321     p_method = (thread_ps_data_t *)p_input->p_plugin_data;
322
323     memset( pp_packets, 0, INPUT_READ_ONCE * sizeof(data_packet_t *) );
324     for( i_packet = 0; i_packet < INPUT_READ_ONCE; i_packet++ )
325     {
326         /* Read what we believe to be a packet header. */
327         if( (i_error = SafeRead( p_input, p_header, 6 )) )
328         {
329             return( i_error );
330         }
331
332         if( (U32_AT(p_header) & 0xFFFFFF00) != 0x100L )
333         {
334             /* This is not the startcode of a packet. Read the stream
335              * until we find one. */
336             u32         i_startcode = U32_AT(p_header);
337             int         i_dummy;
338
339             if( i_startcode )
340             {
341                 /* It is common for MPEG-1 streams to pad with zeros
342                  * (although it is forbidden by the recommendation), so
343                  * don't bother everybody in this case. */
344                 intf_WarnMsg( 1, "Garbage at input (%x)", i_startcode );
345             }
346
347             while( (i_startcode & 0xFFFFFF00) != 0x100L )
348             {
349                 i_startcode <<= 8;
350                 if( (i_dummy = getc( p_method->stream )) != EOF )
351                 {
352                     i_startcode |= i_dummy;
353                 }
354                 else
355                 {
356                     return( 1 );
357                 }
358             }
359             /* Packet found. */
360             *(u32 *)p_header = U32_AT(&i_startcode);
361             if( (i_error = SafeRead( p_input, p_header + 4, 2 )) )
362             {
363                 return( i_error );
364             }
365         }
366
367         if( U32_AT(p_header) != 0x1BA )
368         {
369             /* That's the case for all packets, except pack header. */
370             i_packet_size = U16_AT(&p_header[4]);
371         }
372         else
373         {
374             /* Pack header. */
375             if( (p_header[4] & 0xC0) == 0x40 )
376             {
377                 /* MPEG-2 */
378                 i_packet_size = 8;
379             }
380             else if( (p_header[4] & 0xF0) == 0x20 )
381             {
382                 /* MPEG-1 */
383                 i_packet_size = 6;
384             }
385             else
386             {
387                 intf_ErrMsg( "Unable to determine stream type" );
388                 return( -1 );
389             }
390         }
391
392         /* Fetch a packet of the appropriate size. */
393         if( (p_data = NewPacket( p_input, i_packet_size + 6 )) == NULL )
394         {
395             intf_ErrMsg( "Out of memory" );
396             return( -1 );
397         }
398
399         /* Copy the header we already read. */
400         memcpy( p_data->p_buffer, p_header, 6 );
401
402         /* Read the remaining of the packet. */
403         if( i_packet_size && (i_error =
404                 SafeRead( p_input, p_data->p_buffer + 6, i_packet_size )) )
405         {
406             return( i_error );
407         }
408
409         /* In MPEG-2 pack headers we still have to read stuffing bytes. */
410         if( U32_AT(p_header) == 0x1BA )
411         {
412             if( i_packet_size == 8 && (p_data->p_buffer[13] & 0x7) != 0 )
413             {
414                 /* MPEG-2 stuffing bytes */
415                 byte_t      p_garbage[8];
416                 if( (i_error = SafeRead( p_input, p_garbage,
417                                          p_data->p_buffer[13] & 0x7)) )
418                 {
419                     return( i_error );
420                 }
421             }
422         }
423
424         /* Give the packet to the other input stages. */
425         pp_packets[i_packet] = p_data;
426     }
427
428     return( 0 );
429 }
430
431
432 /*
433  * Packet management utilities
434  */
435
436 /*****************************************************************************
437  * NewPacket: allocates a data packet
438  *****************************************************************************/
439 static struct data_packet_s * NewPacket( void * p_garbage,
440                                          size_t i_size )
441 {
442     data_packet_t * p_data;
443
444     /* Safety check */
445     if( i_size > INPUT_MAX_PACKET_SIZE )
446     {
447         intf_ErrMsg( "Packet too big (%d)", i_size );
448         return NULL;
449     }
450
451     if( (p_data = (data_packet_t *)malloc( sizeof(data_packet_t) )) == NULL )
452     {
453         intf_DbgMsg( "Out of memory" );
454         return NULL;
455     }
456
457     if( (p_data->p_buffer = (byte_t *)malloc( i_size )) == NULL )
458     {
459         intf_DbgMsg( "Out of memory" );
460         free( p_data );
461         return NULL;
462     }
463
464     /* Initialize data */
465     p_data->p_next = NULL;
466     p_data->b_discard_payload = 0;
467
468     p_data->p_payload_start = p_data->p_buffer;
469     p_data->p_payload_end = p_data->p_buffer + i_size;
470
471     return( p_data );
472 }
473
474 /*****************************************************************************
475  * NewPES: allocates a pes packet
476  *****************************************************************************/
477 static pes_packet_t * NewPES( void * p_garbage )
478 {
479     pes_packet_t * p_pes;
480
481     if( (p_pes = (pes_packet_t *)malloc( sizeof(pes_packet_t) )) == NULL )
482     {
483         intf_DbgMsg( "Out of memory" );
484         return NULL;
485     }
486
487     p_pes->b_messed_up = p_pes->b_data_alignment = p_pes->b_discontinuity =
488         p_pes->i_pts = p_pes->i_dts = 0;
489     p_pes->i_pes_size = 0;
490     p_pes->p_first = NULL;
491
492     return( p_pes );
493 }
494
495 /*****************************************************************************
496  * DeletePacket: deletes a data packet
497  *****************************************************************************/
498 static void DeletePacket( void * p_garbage,
499                           data_packet_t * p_data )
500 {
501     ASSERT(p_data);
502     ASSERT(p_data->p_buffer);
503     free( p_data->p_buffer );
504     free( p_data );
505 }
506
507 /*****************************************************************************
508  * DeletePES: deletes a PES packet and associated data packets
509  *****************************************************************************/
510 static void DeletePES( void * p_garbage, pes_packet_t * p_pes )
511 {
512     data_packet_t *     p_data;
513     data_packet_t *     p_next;
514
515     p_data = p_pes->p_first;
516
517     while( p_data != NULL )
518     {
519         p_next = p_data->p_next;
520         free( p_data->p_buffer );
521         free( p_data );
522         p_data = p_next;
523     }
524
525     free( p_pes );
526 }
527
528