* Modules.am : added aac.c and wav.c
[vlc.git] / modules / demux / aac / demux.c
1 /*****************************************************************************
2  * demux.c : Raw aac Stream input module for vlc
3  *****************************************************************************
4  * Copyright (C) 2001 VideoLAN
5  * $Id: demux.c,v 1.10 2003/05/14 21:29:42 fenrir Exp $
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
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 <stdlib.h>                                      /* malloc(), free() */
28 #include <string.h>
29
30 #include <vlc/vlc.h>
31 #include <vlc/input.h>
32
33 #include <sys/types.h>
34
35 /*****************************************************************************
36  * Local prototypes
37  *****************************************************************************/
38 static int  Activate    ( vlc_object_t * );
39 static int  Demux       ( input_thread_t * );
40 static void Deactivate  ( vlc_object_t * );
41
42 /*****************************************************************************
43  * Module descriptor
44  *****************************************************************************/
45 vlc_module_begin();
46     set_description( _("AAC stream demuxer" ) );
47     set_capability( "demux", 10 );
48     set_callbacks( Activate, NULL );
49     add_shortcut( "aac" );
50 vlc_module_end();
51
52 /*****************************************************************************
53  * Definitions of structures  and functions used by this plugins
54  *****************************************************************************/
55 #define FREE( p ) if( p ) { free( p );  (p) = NULL; }
56 /* XXX set this to 0 to avoid problem with PS XXX */
57 /* but with some file or web radio will failed to detect */
58 /* it's you to choose */
59 #define AAC_MAXTESTPOS    0
60
61 static int i_aac_samplerate[16] =
62 {
63     96000, 88200, 64000, 48000, 44100, 32000, 
64     24000, 22050, 16000, 12000, 11025, 8000,
65     7350,  0,     0,     0
66 };
67
68 typedef struct adts_header_s
69 {
70     int i_id;
71     int i_framelength;
72     int i_layer;
73     int i_protection_absent;
74     int i_profile;
75     int i_samplerate_index;
76     int i_private_bit;
77     int i_channel_configuration;
78     int i_original;
79     int i_home;
80     int i_emphasis;
81     int i_copyright_identification_bit;
82     int i_copyright_identification_start;
83     int i_aac_frame_length;
84     int i_adts_buffer_fullness;
85     int i_no_raw_data_blocks_in_frame;
86     int i_crc_check;
87
88 } adts_header_t;
89
90 /* Not yet used */
91 typedef struct adif_header_s
92 {
93     int     b_copyright_id_present;
94     uint8_t i_copyright_id[10];
95
96     int     b_original_copy;
97
98     int     i_home;
99     int     i_bitstream_type;
100     int     i_bitrate;
101     int     i_num_program_config_elements;
102     int     adif_buffer_fullness;
103
104 //    program_config_element
105
106
107 } adif_header_t;
108
109 struct demux_sys_t
110 {
111     mtime_t i_pts;
112
113     es_descriptor_t         *p_es;
114
115     int                     b_adif_header;
116     adif_header_t           adif_header;
117
118     int                     b_adts_header;
119     adts_header_t           adts_header;
120
121     /* extracted information */
122     int i_samplerate_index;
123     int i_object_type;
124     int i_samplerate;
125     int i_channels;
126     int i_framelength;
127     int i_aac_frame_length;
128 };
129
130 /****************************************************************************
131  * bit_* : function to get a bitstream from a memory buffer
132  ****************************************************************************
133  *
134  ****************************************************************************/
135 typedef struct bit_s
136 {
137     uint8_t *p_buffer;
138     int i_buffer;
139     int i_mask;
140 } bit_t;
141
142 static void bit_init( bit_t *p_bit,
143                       uint8_t    *p_buffer,
144                       int   i_buffer )
145 {
146     p_bit->p_buffer = p_buffer;
147     p_bit->i_buffer = i_buffer;
148     p_bit->i_mask = 0x80;
149 }
150
151 static uint32_t bit_get( bit_t *p_bit )
152 {
153     uint32_t i_bit;
154     if( p_bit->i_buffer <= 0 )
155     {
156         return( 0 );
157     }
158     i_bit = ( p_bit->p_buffer[0]&p_bit->i_mask ) ? 1 : 0;
159
160     p_bit->i_mask >>= 1;
161     if( !p_bit->i_mask )
162     {
163         p_bit->p_buffer++;
164         p_bit->i_buffer--;
165         p_bit->i_mask = 0x80;
166     }
167     return( i_bit );
168 }
169
170 static uint32_t bit_gets( bit_t *p_bit, int i_count )
171 {
172     uint32_t i_bits;
173     i_bits = 0;
174     for( ; i_count > 0; i_count-- )
175     {
176         i_bits = ( i_bits << 1 )|bit_get( p_bit );
177     }
178     return( i_bits );
179 }
180
181 /*****************************************************************************
182  * Function to manipulate stream easily
183  *****************************************************************************
184  *
185  * SkipBytes : skip bytes :) not yet uoptimised ( read bytes to be skipped )
186  *
187  * ReadPes : read data and make a PES
188  *
189  *****************************************************************************/
190 static int SkipBytes( input_thread_t *p_input, int i_size )
191 {
192     data_packet_t *p_data;
193     int i_read;
194
195     while( i_size > 0 )
196     {
197         i_read = input_SplitBuffer(p_input, &p_data, __MIN( i_size, 1024 ) );
198         if( i_read <= 0 )
199         {
200             return( 0 );
201         }
202         input_DeletePacket( p_input->p_method_data, p_data );
203         i_size -= i_read;
204     }
205     return( 1 );
206 }
207
208 static int ReadPES( input_thread_t *p_input,
209                     pes_packet_t **pp_pes,
210                     int i_size )
211 {
212     pes_packet_t *p_pes;
213
214     *pp_pes = NULL;
215
216     if( !(p_pes = input_NewPES( p_input->p_method_data )) )
217     {
218         msg_Err( p_input, "cannot allocate new PES" );
219         return( 0 );
220     }
221
222     while( i_size > 0 )
223     {
224         data_packet_t   *p_data;
225         int i_read;
226
227         if( (i_read = input_SplitBuffer( p_input,
228                                          &p_data,
229                                          __MIN( i_size, 1024 ) ) ) <= 0 )
230         {
231             input_DeletePES( p_input->p_method_data, p_pes );
232             return( 0 );
233         }
234         if( !p_pes->p_first )
235         {
236             p_pes->p_first = p_data;
237             p_pes->i_nb_data = 1;
238             p_pes->i_pes_size = i_read;
239         }
240         else
241         {
242             p_pes->p_last->p_next  = p_data;
243             p_pes->i_nb_data++;
244             p_pes->i_pes_size += i_read;
245         }
246         p_pes->p_last  = p_data;
247         i_size -= i_read;
248     }
249     *pp_pes = p_pes;
250     return( 1 );
251 }
252
253 /*****************************************************************************
254  * GetADIF: find and load adif header if present
255  *****************************************************************************/
256 static int GetADIF( input_thread_t *p_input,
257                     adif_header_t  *p_adif )
258 {
259     uint8_t  *p_peek;
260     int i_size;
261
262     if( ( i_size = input_Peek( p_input, &p_peek, 60 ) ) < 60  )
263     {
264         /* it's false, min size is 11 byte but easier ;) */
265         return( 0 );
266     }
267     if( ( p_peek[0] != 'A' )||( p_peek[1] != 'D' )||
268         ( p_peek[2] != 'I' )||( p_peek[3] != 'F' ) )
269     {
270         return( 0 );
271     }
272
273     /* we now that we have an adif header */
274
275 //    return( 1 );
276     return( 0 ); /* need some work */
277 }
278
279 /*****************************************************************************
280  * GetADTS: find and load adts header 
281  *****************************************************************************/
282 #define ADTS_HEADERSIZE 10 /* 8+2 for crc */
283 static int GetADTS( input_thread_t  *p_input,
284                     adts_header_t   *p_adts,
285                     int             i_max_pos,
286                     int             *pi_skip )
287 {
288     uint8_t  *p_peek;
289     int i_size;
290     bit_t bit;
291
292     if( ( i_size = input_Peek( p_input, &p_peek, i_max_pos + ADTS_HEADERSIZE ) )
293             < ADTS_HEADERSIZE )
294     {
295         return( 0 );
296     }
297     *pi_skip = 0;
298     for( ; ; )
299     {
300         if( i_size < ADTS_HEADERSIZE )
301         {
302             return( 0 );
303         }
304         if( ( p_peek[0] != 0xff )||
305             ( ( p_peek[1]&0xf6 ) != 0xf0 ) ) /* Layer == 0 */
306         {
307             p_peek++;
308             i_size--;
309             *pi_skip += 1;
310             continue;
311         }
312         /* we have find an adts header, load it */
313         break;
314     }
315
316     bit_init( &bit, p_peek, i_size );
317     bit_gets( &bit, 12 ); /* synchro bits */
318
319     p_adts->i_id        = bit_get( &bit );
320     p_adts->i_layer     = bit_gets( &bit, 2);
321     p_adts->i_protection_absent = bit_get( &bit );
322     p_adts->i_profile           = bit_gets( &bit, 2 );
323     p_adts->i_samplerate_index  = bit_gets( &bit, 4);
324     p_adts->i_private_bit       = bit_get( &bit );
325     p_adts->i_channel_configuration = bit_gets( &bit, 3);
326     p_adts->i_original  = bit_get( &bit );
327     p_adts->i_home      = bit_get( &bit );
328     if( p_adts->i_id == 0 )
329     {
330         p_adts->i_emphasis = bit_gets( &bit, 2);
331     }
332
333     p_adts->i_copyright_identification_bit   = bit_get( &bit );
334     p_adts->i_copyright_identification_start = bit_get( &bit );
335     p_adts->i_aac_frame_length               = bit_gets( &bit, 13 );
336     p_adts->i_adts_buffer_fullness           = bit_gets( &bit, 11 );
337     p_adts->i_no_raw_data_blocks_in_frame    = bit_gets( &bit, 2 );
338
339     if( p_adts->i_protection_absent == 0 )
340     {
341         p_adts->i_crc_check = bit_gets( &bit, 16 );
342     }
343     return( 1 );
344 }
345
346 static void ExtractConfiguration( demux_sys_t *p_aac )
347 {
348     if( p_aac->b_adif_header )
349     {
350
351     }
352     if( p_aac->b_adts_header )
353     {
354         p_aac->i_samplerate_index = p_aac->adts_header.i_samplerate_index;
355         p_aac->i_object_type = p_aac->adts_header.i_profile;
356         p_aac->i_samplerate  = i_aac_samplerate[p_aac->i_samplerate_index];
357         p_aac->i_channels    = p_aac->adts_header.i_channel_configuration;
358         if( p_aac->i_channels > 6 )
359         {
360             /* I'm not sure of that, got from faad */
361             p_aac->i_channels = 2;
362         }
363         p_aac->i_aac_frame_length = p_aac->adts_header.i_aac_frame_length;
364         p_aac->i_framelength = 1024;
365     }
366     /* FIXME FIXME for LD, but LD = ?
367     if( p_aac->i_object_type == LD )
368     {
369         p_aac->i_framelength /= 2;
370     }
371     */
372 }
373
374 #if 0
375 /****************************************************************************
376  * CheckPS : check if this stream could be some ps, 
377  *           yes it's ugly ...  but another idea ?
378  *           XXX it seems that aac stream always match ...
379  ****************************************************************************/
380 static int CheckPS( input_thread_t *p_input )
381 {
382     uint8_t *p_peek;
383     int i_size = input_Peek( p_input, &p_peek, 8196 );
384
385     while( i_size >  4 )
386     {
387         if( ( p_peek[0] == 0 ) && ( p_peek[1] == 0 )&&
388             ( p_peek[2] == 1 ) && ( p_peek[3] >= 0xb9 ) )
389         {
390             return( 1 ); /* Perhaps some ps stream */
391         }
392         p_peek++;
393        i_size--;
394     }
395     return( 0 );
396 }
397 #endif
398
399 /*****************************************************************************
400  * Activate: initializes AAC demux structures
401  *****************************************************************************/
402 static int Activate( vlc_object_t * p_this )
403 {
404     input_thread_t * p_input = (input_thread_t *)p_this;
405     demux_sys_t * p_aac;
406     input_info_category_t * p_category;
407     module_t * p_id3;
408
409     int i_skip;
410     int b_forced = VLC_FALSE;
411
412     if( p_input->psz_demux && !strncmp( p_input->psz_demux, "aac", 3 ) )
413     {
414         b_forced = VLC_TRUE;
415     }
416     else if( p_input->psz_name )
417     {
418         int  i_len = strlen( p_input->psz_name );
419
420         if( i_len > 4 && !strcasecmp( &p_input->psz_name[i_len - 4], ".aac" ) )
421         {
422             b_forced = VLC_TRUE;
423         }
424     }
425
426     if( !b_forced )
427     {
428         return -1;
429     }
430
431     /* Set the demux function */
432     p_input->pf_demux = Demux;
433
434     /* Initialize access plug-in structures. */
435     if( p_input->i_mtu == 0 )
436     {
437     /* Improve speed. */
438         p_input->i_bufsize = INPUT_DEFAULT_BUFSIZE;
439     }
440
441     /* skip possible id3 header */
442     p_id3 = module_Need( p_input, "id3", NULL );
443     if ( p_id3 ) {
444         module_Unneed( p_input, p_id3 );
445     }
446
447     /* allocate p_aac */
448     if( !( p_aac = malloc( sizeof( demux_sys_t ) ) ) )
449     {
450         msg_Err( p_input, "out of memory" );
451         return( -1 );
452     }
453     memset( p_aac, 0, sizeof( demux_sys_t ) );
454
455     /* Now check for adif/adts header */
456     i_skip = 0;
457     if( GetADIF( p_input, &p_aac->adif_header ) )
458     {
459         p_aac->b_adif_header = 1;
460         msg_Err( p_input,
461                  "found ADIF header (unsupported)" );
462         free( p_aac );
463         return( -1 );
464     }
465     else
466     if( GetADTS( p_input,
467                  &p_aac->adts_header,
468                  b_forced ? 8000 : 0,
469                  &i_skip  ) )
470     {
471         p_aac->b_adts_header = 1;
472         msg_Info( p_input,
473                   "found ADTS header" );
474     }
475     else
476     {
477         msg_Warn( p_input,
478                   "AAC module discarded (no header found)" );
479         free( p_aac );
480         return( -1 );
481     }
482     ExtractConfiguration( p_aac );
483
484     vlc_mutex_lock( &p_input->stream.stream_lock );
485     if( input_InitStream( p_input, 0 ) == -1)
486     {
487         vlc_mutex_unlock( &p_input->stream.stream_lock );
488         msg_Err( p_input, "cannot init stream" );
489         return( -1 );
490     }
491     if( input_AddProgram( p_input, 0, 0) == NULL )
492     {
493         vlc_mutex_unlock( &p_input->stream.stream_lock );
494         msg_Err( p_input, "cannot add program" );
495         return( -1 );
496     }
497     p_input->stream.pp_programs[0]->b_is_ok = 0;
498     p_input->stream.p_selected_program = p_input->stream.pp_programs[0];
499
500     /* create our ES */
501     p_aac->p_es = input_AddES( p_input, p_input->stream.p_selected_program, 
502                                1 /* id */, AUDIO_ES, NULL, 0 );
503     if( !p_aac->p_es )
504     {
505         vlc_mutex_unlock( &p_input->stream.stream_lock );
506         msg_Err( p_input, "out of memory" );
507         return( -1 );
508     }
509
510     p_aac->p_es->i_stream_id = 1;
511     p_aac->p_es->i_fourcc = VLC_FOURCC( 'm', 'p', '4', 'a' );
512     input_SelectES( p_input, p_aac->p_es );
513
514     p_input->stream.p_selected_program->b_is_ok = 1;
515     vlc_mutex_unlock( &p_input->stream.stream_lock );
516
517
518
519     vlc_mutex_lock( &p_input->stream.stream_lock );
520     if( p_aac->b_adif_header )
521     {
522         p_input->stream.i_mux_rate = 0 / 50;
523     }
524     if( p_aac->b_adts_header )
525     {
526         p_input->stream.i_mux_rate = 0 / 50;
527     }
528     vlc_mutex_unlock( &p_input->stream.stream_lock );
529 #if 0
530     /* FIXME FIXME FIXME FIXME FIXME FIXME FIXME */
531     /* if i don't do that, it don't work correctly but why ??? */
532     if( p_input->stream.b_seekable )
533     {
534         p_input->pf_seek( p_input, 0 );
535         input_AccessReinit( p_input );
536     }
537     /* FIXME FIXME FIXME FIXME FIXME FIXME FIXME */
538 #endif
539
540     /* all is ok :)) */
541     if( p_aac->b_adif_header )
542     {
543     }
544
545     if( p_aac->b_adts_header )
546     {
547         msg_Dbg( p_input,
548                  "audio AAC MPEG-%d layer-%d  %d channels %dHz",
549                  p_aac->adts_header.i_id == 1 ? 2 : 4,
550                  4 - p_aac->adts_header.i_layer, /* it's always 4 in fact */
551                  p_aac->i_channels,
552                  p_aac->i_samplerate );
553
554         vlc_mutex_lock( &p_input->stream.stream_lock );
555         p_category = input_InfoCategory( p_input, _("Aac") );
556
557         input_AddInfo( p_category, _("Input Type"), "MPEG-%d AAC",
558                        p_aac->adts_header.i_id == 1 ? 2 : 4 );
559
560         input_AddInfo( p_category, _("Layer"), "%d", 
561                        4 - p_aac->adts_header.i_layer );
562         input_AddInfo( p_category, _("Channels"), "%d", 
563                        p_aac->i_channels );
564         input_AddInfo( p_category, _("Sample Rate"), "%dHz", 
565                        p_aac->i_samplerate );
566
567         vlc_mutex_unlock( &p_input->stream.stream_lock );
568     }
569
570     p_input->p_demux_data = p_aac;
571
572
573     return( 0 );
574 }
575
576 /*****************************************************************************
577  * Demux: reads and demuxes data packets
578  *****************************************************************************
579  * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
580  *****************************************************************************/
581 static int Demux( input_thread_t * p_input )
582 {
583     int i_skip;
584     int i_found;
585
586     pes_packet_t    *p_pes;
587     demux_sys_t *p_aac = p_input->p_demux_data;
588
589     /* Get a frame */
590     if( p_aac->b_adif_header )
591     {
592         i_skip = 0;
593         return( -1 ); /* FIXME */
594     }
595     else
596     if( p_aac->b_adts_header )
597     {
598         i_found = GetADTS( p_input,
599                            &p_aac->adts_header,
600                            8000,
601                            &i_skip );
602     }
603     else
604     {
605         return( -1 );
606     }
607     ExtractConfiguration( p_aac );
608
609     /* skip garbage bytes */
610     if( i_skip > 0 )
611     {
612         msg_Dbg( p_input,
613                  "skipping %d bytes",
614                  i_skip );
615         SkipBytes( p_input, i_skip );
616     }
617
618     if( !i_found )
619     {
620         msg_Info( p_input, "can't find next frame" );
621         return( 0 );
622     }
623
624     input_ClockManageRef( p_input,
625                           p_input->stream.p_selected_program,
626                           p_aac->i_pts );
627
628     if( !ReadPES( p_input, &p_pes, p_aac->i_aac_frame_length ) )
629     {
630         msg_Warn( p_input,
631                  "cannot read data" );
632         return( -1 );
633     }
634     p_pes->i_dts =
635         p_pes->i_pts = input_ClockGetTS( p_input,
636                                          p_input->stream.p_selected_program,
637                                          p_aac->i_pts );
638
639     if( !p_aac->p_es->p_decoder_fifo )
640     {
641         msg_Err( p_input, "no audio decoder" );
642         input_DeletePES( p_input->p_method_data, p_pes );
643         return( -1 ); /* perhaps not, it's my choice */
644     }
645     else
646     {
647         input_DecodePES( p_aac->p_es->p_decoder_fifo, p_pes );
648     }
649
650     /* Update date information */
651     p_aac->i_pts += (mtime_t)90000 *
652                     (mtime_t)p_aac->i_framelength /
653                     (mtime_t)p_aac->i_samplerate;
654
655     return( 1 );
656 }
657
658 static void Deactivate( vlc_object_t * p_this )
659 {
660     input_thread_t *p_input = (input_thread_t*)p_this;
661 //    demux_sys_t    *p_aac = p_input->p_demux_data;
662
663     FREE( p_input->p_demux_data );
664 }
665