* configure.ac.in Makefile.am: enable asf demuxer plugin
[vlc.git] / modules / demux / asf / asf.c
1 /*****************************************************************************
2  * asf.c : ASFv01 file input module for vlc
3  *****************************************************************************
4  * Copyright (C) 2001 VideoLAN
5  * $Id: asf.c,v 1.2 2002/10/21 09:18:37 fenrir Exp $
6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7  * 
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  * 
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
21  *****************************************************************************/
22
23 /*****************************************************************************
24  * Preamble
25  *****************************************************************************/
26 #include <stdlib.h>                                      /* malloc(), free() */
27 #include <string.h>                                              /* strdup() */
28 #include <errno.h>
29 #include <sys/types.h>
30
31 #include <vlc/vlc.h>
32 #include <vlc/input.h>
33
34 #include "libasf.h"
35 #include "asf.h"
36
37 /*****************************************************************************
38  * Local prototypes
39  *****************************************************************************/
40 static int    Activate   ( vlc_object_t * );
41 static void   Deactivate ( vlc_object_t * );
42 static int    Demux      ( input_thread_t * );
43
44 /*****************************************************************************
45  * Module descriptor
46  *****************************************************************************/
47 vlc_module_begin();
48     set_description( "ASF v1.0 demuxer (file only)" );
49     set_capability( "demux", 200 );
50     set_callbacks( Activate, Deactivate );
51     add_shortcut( "asf" );
52 vlc_module_end();
53
54 static u16 GetWLE( u8 *p_buff )
55 {
56     return( (p_buff[0]) + ( p_buff[1] <<8 ) );
57 }
58 static u32 GetDWLE( u8 *p_buff )
59 {   
60     return( p_buff[0] + ( p_buff[1] <<8 ) +
61             ( p_buff[2] <<16 ) + ( p_buff[3] <<24 ) );
62 }
63
64 /*****************************************************************************
65  * Activate: check file and initializes ASF structures
66  *****************************************************************************/
67 static int Activate( vlc_object_t * p_this )
68 {   
69     input_thread_t *p_input = (input_thread_t *)p_this;
70     u8  *p_peek;
71     guid_t guid;
72     
73     demux_sys_t *p_demux;
74     int i_stream;
75     
76     /* Initialize access plug-in structures. */
77     if( p_input->i_mtu == 0 )
78     {
79         /* Improve speed. */
80         p_input->i_bufsize = INPUT_DEFAULT_BUFSIZE ;
81     }
82
83     p_input->pf_demux = Demux;
84
85     /* a little test to see if it could be a asf stream */
86     if( input_Peek( p_input, &p_peek, 16 ) < 16 )
87     {
88         msg_Warn( p_input, "ASF v1.0 plugin discarded (cannot peek)" );
89         return( -1 );
90     }
91     GetGUID( &guid, p_peek );
92     if( !CmpGUID( &guid, &asf_object_header_guid ) )
93     {
94         msg_Warn( p_input, "ASF v1.0 plugin discarded (not a valid file)" );
95         return( -1 );
96     }
97
98     /* create our structure that will contains all data */
99     if( !( p_input->p_demux_data = 
100                 p_demux = malloc( sizeof( demux_sys_t ) ) ) )
101     {
102         msg_Err( p_input, "out of memory" );
103         return( -1 );
104     }
105     memset( p_demux, 0, sizeof( demux_sys_t ) );
106
107     /* Now load all object ( except raw data ) */
108     if( !ASF_ReadObjectRoot( p_input, &p_demux->root, p_input->stream.b_seekable ) )
109     {
110         msg_Warn( p_input, "ASF v1.0 plugin discarded (not a valid file)" );
111         free( p_demux );
112         return( -1 );
113     }
114     /* Check if we have found all mandatory asf object */
115     if( !p_demux->root.p_hdr || !p_demux->root.p_data )
116     {
117         ASF_FreeObjectRoot( p_input, &p_demux->root );
118         free( p_demux );
119         msg_Warn( p_input, "ASF v1.0 plugin discarded (not a valid file)" );
120         return( -1 );
121     }
122    
123     if( !( p_demux->p_fp = ASF_FindObject( p_demux->root.p_hdr,
124                                     &asf_object_file_properties_guid, 0 ) ) )
125     {
126         ASF_FreeObjectRoot( p_input, &p_demux->root );
127         free( p_demux );
128         msg_Warn( p_input, "ASF v1.0 plugin discarded (missing file_properties object)" );
129         return( -1 );
130     }
131     
132     if( p_demux->p_fp->i_min_data_packet_size != p_demux->p_fp->i_max_data_packet_size )
133     {
134         ASF_FreeObjectRoot( p_input, &p_demux->root );
135         free( p_demux );
136         msg_Warn( p_input, "ASF v1.0 plugin discarded (invalid file_properties object)" );
137         return( -1 );
138     }
139     
140     p_demux->i_streams = ASF_CountObject( p_demux->root.p_hdr, 
141                                           &asf_object_stream_properties_guid );
142     if( !p_demux->i_streams )
143     {
144         ASF_FreeObjectRoot( p_input, &p_demux->root );
145         free( p_demux );
146         msg_Warn( p_input, "ASF plugin discarded (cannot find any stream!)" );
147         return( -1 );
148     }
149     else
150     {
151         msg_Dbg( p_input, "found %d streams", p_demux->i_streams );
152     }
153
154     /*  create one program */
155     vlc_mutex_lock( &p_input->stream.stream_lock );
156     if( input_InitStream( p_input, 0 ) == -1)
157     {
158         vlc_mutex_unlock( &p_input->stream.stream_lock );
159         msg_Err( p_input, "cannot init stream" );
160         return( -1 );
161     }
162     if( input_AddProgram( p_input, 0, 0) == NULL )
163     {
164         vlc_mutex_unlock( &p_input->stream.stream_lock );
165         msg_Err( p_input, "cannot add program" );
166         return( -1 );
167     }
168     p_input->stream.p_selected_program = p_input->stream.pp_programs[0];
169     p_input->stream.i_mux_rate = 0 ; /* FIXME */
170     vlc_mutex_unlock( &p_input->stream.stream_lock );
171
172     for( i_stream = 0; i_stream < p_demux->i_streams; i_stream ++ )
173     {
174         asf_stream_t    *p_stream;
175         asf_object_stream_properties_t *p_sp;
176         
177         p_sp = ASF_FindObject( p_demux->root.p_hdr,
178                                &asf_object_stream_properties_guid,
179                                i_stream );
180
181         p_stream = 
182             p_demux->stream[p_sp->i_stream_number] = 
183                 malloc( sizeof( asf_stream_t ) );
184         memset( p_stream, 0, sizeof( asf_stream_t ) );
185         p_stream->p_sp = p_sp;
186
187         vlc_mutex_lock( &p_input->stream.stream_lock );
188         p_stream->p_es = 
189             input_AddES( p_input,
190                          p_input->stream.p_selected_program,
191                          p_sp->i_stream_number,
192                          p_sp->i_type_specific_data_length );
193         if( p_sp->i_type_specific_data_length > 11 )
194         {
195             memcpy( p_stream->p_es->p_demux_data,
196                     p_sp->p_type_specific_data + 11,
197                     p_sp->i_type_specific_data_length - 11 );
198         }
199
200         vlc_mutex_unlock( &p_input->stream.stream_lock );
201         if( CmpGUID( &p_sp->i_stream_type, &asf_object_stream_type_audio ) )
202         {
203             int i_codec;
204             if( p_sp->p_type_specific_data )
205             {
206                 i_codec = GetWLE( p_sp->p_type_specific_data );
207             }
208             else
209             {
210                 i_codec = -1;
211             }
212
213             p_stream->i_cat = AUDIO_ES;
214             msg_Dbg( p_input,
215                     "adding new audio stream(codec:0x%x,ID:%d)", 
216                     i_codec,
217                     p_sp->i_stream_number );
218             switch( i_codec )
219             {
220                 case( 0x01 ):
221                     p_stream->p_es->i_fourcc = 
222                         VLC_FOURCC( 'a', 'r', 'a', 'w' );
223                     break;
224                 case( 0x50 ):
225                 case( 0x55 ):
226                     p_stream->p_es->i_fourcc = 
227                         VLC_FOURCC( 'm','p','g','a' );
228                     break;
229                 case( 0x2000 ):
230                     p_stream->p_es->i_fourcc = 
231                         VLC_FOURCC( 'a','5','2',' ' );
232                     break;
233                 case( 0x160 ):
234                 case( 0x161 ):
235                     p_stream->p_es->i_fourcc = 
236                         VLC_FOURCC( 'w','m','a',' ' );
237                     break;
238                 default:
239                     p_stream->p_es->i_fourcc = 
240                         VLC_FOURCC( 'u','n','d','f' );
241             }
242             
243         }
244         else
245         if( CmpGUID( &p_sp->i_stream_type, &asf_object_stream_type_video ) )
246         {
247             p_stream->i_cat = VIDEO_ES;
248             msg_Dbg( p_input,
249                     "adding new video stream(ID:%d)", 
250                     p_sp->i_stream_number );
251             if( p_sp->p_type_specific_data )
252             {
253                 p_stream->p_es->i_fourcc =
254                     GetDWLE( p_sp->p_type_specific_data + 27 );
255             }
256             else
257             {
258                 p_stream->p_es->i_fourcc = 
259                     VLC_FOURCC( 'u','n','d','f' );
260             }
261
262         }
263         else
264         {
265             p_stream->i_cat = UNKNOWN_ES;
266             msg_Dbg( p_input, 
267                     "ignoring unknown stream(ID:%d)", 
268                     p_sp->i_stream_number );
269             p_stream->p_es->i_fourcc = VLC_FOURCC( 'u','n','d','f' );
270         }
271         p_stream->p_es->i_cat = p_stream->i_cat;
272
273         vlc_mutex_lock( &p_input->stream.stream_lock );
274         input_SelectES( p_input, p_stream->p_es );
275         vlc_mutex_unlock( &p_input->stream.stream_lock );
276     }
277     
278     vlc_mutex_lock( &p_input->stream.stream_lock );
279     p_input->stream.p_selected_program->b_is_ok = 1;
280     vlc_mutex_unlock( &p_input->stream.stream_lock );
281
282     p_demux->i_data_begin = p_demux->root.p_data->i_object_pos + 50;
283     if( p_demux->root.p_data->i_object_size != 0 )
284     { // local file
285         p_demux->i_data_end = p_demux->root.p_data->i_object_pos +
286                                     p_demux->root.p_data->i_object_size;
287     }
288     else
289     { // live/broacast
290         p_demux->i_data_end = -1;
291     }
292
293
294     // go to first packet
295     ASF_SeekAbsolute( p_input, p_demux->i_data_begin );
296     return( 0 );
297 }
298
299 /*****************************************************************************
300  * Demux: read packet and send them to decoders 
301  *****************************************************************************/
302 #define GETVALUE2b( bits, var, def ) \
303     switch( (bits)&0x03 ) \
304     { \
305         case 1: var = p_peek[i_skip]; i_skip++; break; \
306         case 2: var = GetWLE( p_peek + i_skip );  i_skip+= 2; break; \
307         case 3: var = GetDWLE( p_peek + i_skip ); i_skip+= 4; break; \
308         case 0: \
309         default: var = def; break;\
310     }
311
312 static int Demux( input_thread_t *p_input )
313 {
314     demux_sys_t *p_demux = p_input->p_demux_data;
315     int i;
316
317     /* catch seek from user */
318     if( p_input->stream.p_selected_program->i_synchro_state == SYNCHRO_REINIT )
319     {
320         off_t i_offset;
321         
322         i_offset = ASF_TellAbsolute( p_input ) - p_demux->i_data_begin;
323         
324         if( i_offset  < 0 )
325         {
326             i_offset = 0;
327         }
328         /* XXX work only when i_min_data_packet_size == i_max_data_packet_size */
329         i_offset -= i_offset % p_demux->p_fp->i_min_data_packet_size;
330         ASF_SeekAbsolute( p_input, p_demux->i_data_begin + i_offset );
331
332         p_demux->i_time = 0;
333         for( i = 0; i < 128 ; i++ )
334         {
335 #define p_stream p_demux->stream[i]
336             if( p_stream )
337             {
338                 p_stream->i_time = 0;
339             }
340 #undef p_stream
341         }
342
343     }
344     /* first wait for the good time to read a packet */
345
346     input_ClockManageRef( p_input,
347                           p_input->stream.p_selected_program,
348                           p_demux->i_pcr );
349
350     /* update pcr XXX in mpeg scale so in 90000 unit/s */
351     p_demux->i_pcr = p_demux->i_time * 9 / 100;
352
353     for( i = 0; i < 10; i++ ) // parse 10 packets
354     {
355         int i_data_packet_min = p_demux->p_fp->i_min_data_packet_size;
356         u8  *p_peek;
357         int i_skip;
358         
359         int i_packet_size_left;
360         int i_packet_flags;
361         int i_packet_property;
362
363         int b_packet_multiple_payload;
364         int i_packet_length;
365         int i_packet_sequence;
366         int i_packet_padding_length;
367         
368         u32 i_packet_send_time;
369         u16 i_packet_duration;
370         int i_payload;
371         int i_payload_count;
372         int i_payload_length_type;
373
374         
375         if( input_Peek( p_input, &p_peek, i_data_packet_min ) < i_data_packet_min )
376         {
377             // EOF ?
378             msg_Err( p_input, "cannot peek while getting new packet, EOF ?" );
379             return( 0 );
380         }
381         i_skip = 0;
382         
383         /* *** parse error correction if present *** */
384         if( p_peek[0]&0x80 )
385         {
386             int i_error_correction_length_type;
387             int i_error_correction_data_length;
388             int i_opaque_data_present;
389
390             i_error_correction_data_length = p_peek[0] & 0x0f;  // 4bits
391             i_opaque_data_present = ( p_peek[0] >> 4 )& 0x01;    // 1bit
392             i_error_correction_length_type = ( p_peek[0] >> 5 ) & 0x03; // 2bits
393             i_skip += 1; // skip error correction flags
394         
395             if( i_error_correction_length_type != 0x00 ||
396                 i_opaque_data_present != 0 ||
397                 i_error_correction_data_length != 0x02 )
398             {
399                 goto loop_error_recovery;
400             }
401
402             i_skip += i_error_correction_data_length;
403         }
404         else
405         {
406             msg_Warn( p_input, "p_peek[0]&0x80 != 0x80" );
407         }
408
409         i_packet_flags = p_peek[i_skip]; i_skip++;
410         i_packet_property = p_peek[i_skip]; i_skip++;
411         
412         b_packet_multiple_payload = i_packet_flags&0x01;
413
414         /* read some value */
415         GETVALUE2b( i_packet_flags >> 5, i_packet_length, i_data_packet_min );
416         GETVALUE2b( i_packet_flags >> 1, i_packet_sequence, 0 );
417         GETVALUE2b( i_packet_flags >> 3, i_packet_padding_length, 0 );
418
419         i_packet_send_time = GetDWLE( p_peek + i_skip ); i_skip += 4;
420         i_packet_duration  = GetWLE( p_peek + i_skip ); i_skip += 2;
421     
422         i_packet_size_left = i_packet_length;   // XXX donnĂ©es reellement lu
423
424         if( b_packet_multiple_payload )
425         {
426             i_payload_count = p_peek[i_skip] & 0x3f;
427             i_payload_length_type = ( p_peek[i_skip] >> 6 )&0x03;
428             i_skip++;
429         }
430         else
431         {
432             i_payload_count = 1;
433             i_payload_length_type = 0x02; // unused
434         }
435
436         for( i_payload = 0; i_payload < i_payload_count ; i_payload++ )
437         {
438             asf_stream_t   *p_stream;
439
440             int i_stream_number;
441             int i_media_object_number;
442             int i_media_object_offset;
443             int i_replicated_data_length;
444             int i_payload_data_length;
445             int i_payload_data_pos;
446             int i_sub_payload_data_length;
447             int i_tmp;
448
449             mtime_t i_pts;
450             mtime_t i_pts_delta;
451
452             i_stream_number = p_peek[i_skip] & 0x7f; 
453             i_skip++;
454             
455             GETVALUE2b( i_packet_property >> 4, i_media_object_number, 0 );
456             GETVALUE2b( i_packet_property >> 2, i_tmp, 0 );
457             GETVALUE2b( i_packet_property, i_replicated_data_length, 0 );
458             
459             if( i_replicated_data_length > 1 ) // should be at least 8 bytes
460             {
461                 i_pts = (mtime_t)GetDWLE( p_peek + i_skip + 4 ) * 1000;
462                 i_skip += i_replicated_data_length;
463                 i_pts_delta = 0;
464
465                 i_media_object_offset = i_tmp;
466             }
467             else if( i_replicated_data_length == 1 )
468             {
469
470                 msg_Warn( p_input, "found compressed payload" );
471
472                 i_pts = (mtime_t)i_tmp * 1000;
473                 i_pts_delta = (mtime_t)p_peek[i_skip] * 1000; i_skip++;
474
475                 i_media_object_offset = 0;
476             }
477             else
478             {
479                 i_pts = (mtime_t)i_packet_send_time * 1000;
480                 i_pts_delta = 0;
481
482                 i_media_object_offset = i_tmp;
483             }
484
485
486             if( b_packet_multiple_payload )
487             {
488                 GETVALUE2b( i_payload_length_type, i_payload_data_length, 0 );
489             }
490             else
491             {
492                 msg_Warn( p_input, "single payload" );
493                 i_payload_data_length = i_packet_length - i_packet_padding_length - i_skip;
494             }
495             
496 #if 0
497              msg_Dbg( p_input, 
498                       "payload(%d/%d) stream_number:%d media_object_number:%d media_object_offset:%d replicated_data_length:%d payload_data_length %d",
499                       i_payload + 1, 
500                       i_payload_count,
501                       i_stream_number,
502                       i_media_object_number, 
503                       i_media_object_offset, 
504                       i_replicated_data_length, 
505                       i_payload_data_length );
506 #endif
507
508             if( !( p_stream = p_demux->stream[i_stream_number] ) )
509             {
510                 msg_Warn( p_input, "undeclared stream[Id 0x%x]", i_stream_number );
511                 i_skip += i_payload_data_length;
512                 continue;   // over payload
513             }
514
515             if( !p_stream->p_es || !p_stream->p_es->p_decoder_fifo )
516             {
517                 i_skip += i_payload_data_length;
518                 continue;
519             }
520
521
522             for( i_payload_data_pos = 0; 
523                  i_payload_data_pos < i_payload_data_length && 
524                         i_packet_size_left > 0; 
525                  i_payload_data_pos += i_sub_payload_data_length )
526             {
527                 data_packet_t  *p_data;
528                 int i_read;
529                 // read sub payload length
530                 if( i_replicated_data_length == 1 )
531                 {
532                     i_sub_payload_data_length = p_peek[i_skip]; i_skip++;
533                     i_payload_data_pos++;
534                 }
535                 else
536                 {
537                     i_sub_payload_data_length = i_payload_data_length;
538                 }
539
540                 /* FIXME I don't use i_media_object_number, sould I ? */
541                 if( p_stream->p_pes && i_media_object_offset == 0 )                 {
542                     /* send complete packet to decoder */
543                     if( p_stream->p_pes->i_pes_size > 0 )
544                     {
545                         input_DecodePES( p_stream->p_es->p_decoder_fifo, p_stream->p_pes );
546                         p_stream->p_pes = NULL;
547                     }
548                 }
549
550                 if( !p_stream->p_pes )  // add a new PES
551                 {
552                     p_stream->i_time = ( (mtime_t)i_pts + i_payload * (mtime_t)i_pts_delta );
553                     
554                     p_stream->p_pes = input_NewPES( p_input->p_method_data );
555                     p_stream->p_pes->i_dts = 
556                         p_stream->p_pes->i_pts = 
557                             input_ClockGetTS( p_input, 
558                                               p_input->stream.p_selected_program,
559                                               p_stream->i_time * 9 / 100 );
560
561                     p_stream->p_pes->p_next = NULL;
562                     p_stream->p_pes->i_nb_data = 0;
563                     p_stream->p_pes->i_pes_size = 0;
564                 }
565
566                 i_read = i_sub_payload_data_length + i_skip;
567                 if( input_SplitBuffer( p_input, &p_data, i_read ) < i_read )
568                 {
569                     msg_Err( p_input, "cannot read data" );
570                     return( 0 );
571                 }
572                 p_data->p_payload_start += i_skip;
573                 i_packet_size_left -= i_read;
574
575                 
576                 if( !p_stream->p_pes->p_first )
577                 {
578                     p_stream->p_pes->p_first = p_stream->p_pes->p_last = p_data;
579                 }
580                 else
581                 {
582                     p_stream->p_pes->p_last->p_next = p_data;
583                     p_stream->p_pes->p_last = p_data;
584                 }
585                 p_stream->p_pes->i_pes_size += i_sub_payload_data_length;
586                 p_stream->p_pes->i_nb_data++;
587
588                 i_skip = 0;
589                 if( i_packet_size_left > 0 )
590                 {
591                     if( input_Peek( p_input, &p_peek, i_packet_size_left ) < i_packet_size_left )
592                     {
593                         // EOF ?
594                         msg_Warn( p_input, "cannot peek, EOF ?" );
595                         return( 0 );
596                     }
597                 }
598             }
599         }
600         
601         if( i_packet_size_left > 0 )
602         {
603             if( !ASF_SkipBytes( p_input, i_packet_size_left ) )
604             {
605                 msg_Warn( p_input, "cannot skip data, EOF ?" );
606                 return( 0 );
607             }
608         }
609
610         continue;
611
612 loop_error_recovery:
613         msg_Warn( p_input, "unsupported packet header" );
614         if( p_demux->p_fp->i_min_data_packet_size != p_demux->p_fp->i_max_data_packet_size )
615         {
616             msg_Err( p_input, "unsupported packet header, fatal error" );
617             return( -1 );
618         }
619         ASF_SkipBytes( p_input, i_data_packet_min );
620
621     }   // loop over packet
622     
623     p_demux->i_time = 0;
624     for( i = 0; i < 128 ; i++ )
625     {
626 #define p_stream p_demux->stream[i]
627         if( p_stream && p_stream->p_es && p_stream->p_es->p_decoder_fifo )
628         {
629             p_demux->i_time = __MAX( p_demux->i_time, p_stream->i_time );
630         }
631 #undef p_stream
632     }
633
634     return( 1 );
635 }
636
637 /*****************************************************************************
638  * MP4End: frees unused data
639  *****************************************************************************/
640 static void Deactivate( vlc_object_t * p_this )
641 {   
642 #define FREE( p ) \
643     if( p ) { free( p ); } 
644    
645     input_thread_t *  p_input = (input_thread_t *)p_this;
646     demux_sys_t *p_demux = p_input->p_demux_data;
647     int i_stream;
648     
649     msg_Dbg( p_input, "Freeing all memory" );
650     ASF_FreeObjectRoot( p_input, &p_demux->root );
651     for( i_stream = 0; i_stream < 128; i_stream++ )
652     {
653 #define p_stream p_demux->stream[i_stream]
654         if( p_stream )
655         {
656             if( p_stream->p_pes )
657             {
658                 input_DeletePES( p_input->p_method_data, p_stream->p_pes );
659             }
660             free( p_stream );
661         }
662 #undef p_stream
663     }
664     
665 #undef FREE
666 }
667