4add301b907d965c68067e4c0e14d66f9d9c7684
[vlc.git] / modules / codec / faad / decoder.c
1 /*****************************************************************************
2  * decoder.c: AAC decoder using libfaad2
3  *****************************************************************************
4  * Copyright (C) 2001, 2002 VideoLAN
5  * $Id: decoder.c,v 1.2 2002/08/23 14:05:22 sam 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 <vlc/vlc.h>
28 #include <vlc/aout.h>
29 #include <vlc/decoder.h>
30 #include <vlc/input.h>
31
32 #include <stdlib.h>                                      /* malloc(), free() */
33 #include <string.h>                                              /* strdup() */
34
35 #include <faad.h>
36
37 #include "decoder.h"
38
39
40 /*****************************************************************************
41  * Local prototypes
42  *****************************************************************************/
43 static int  OpenDecoder    ( vlc_object_t * );
44
45 static int  RunDecoder     ( decoder_fifo_t * );
46 static int  InitThread     ( adec_thread_t * );
47 static void DecodeThread   ( adec_thread_t * );
48 static void EndThread      ( adec_thread_t * );
49
50 /*****************************************************************************
51  * Module descriptor
52  *****************************************************************************/
53
54 vlc_module_begin();
55     set_description( _("AAC decoder module (libfaad2)") );
56     set_capability( "decoder", 60 );
57     set_callbacks( OpenDecoder, NULL );
58 vlc_module_end();
59
60 /*****************************************************************************
61  * OpenDecoder: probe the decoder and return score
62  *****************************************************************************
63  * Tries to launch a decoder and return score so that the interface is able
64  * to choose.
65  *****************************************************************************/
66 static int OpenDecoder( vlc_object_t *p_this )
67 {
68     decoder_fifo_t *p_fifo = (decoder_fifo_t*) p_this;
69     
70     if( p_fifo->i_fourcc != VLC_FOURCC('m','p','4','a') )
71     {   
72         return VLC_EGENERIC;
73     }
74
75     p_fifo->pf_run = RunDecoder;
76     return VLC_SUCCESS;
77 }
78
79 /*****************************************************************************
80  * RunDecoder: this function is called just after the thread is created
81  *****************************************************************************/
82 static int RunDecoder( decoder_fifo_t *p_fifo )
83 {
84     adec_thread_t *p_adec;
85     int b_error;
86
87     if( !( p_adec = malloc( sizeof( adec_thread_t ) ) ) )
88     {
89         msg_Err( p_fifo, "out of memory" );
90         DecoderError( p_fifo );
91         return( -1 );
92     }
93     memset( p_adec, 0, sizeof( adec_thread_t ) );
94     
95     p_adec->p_fifo = p_fifo;
96
97     if( InitThread( p_adec ) != 0 )
98     {
99         DecoderError( p_fifo );
100         return( -1 );
101     }
102
103     while( ( !p_adec->p_fifo->b_die )&&( !p_adec->p_fifo->b_error ) )
104     {
105         DecodeThread( p_adec );
106     }
107
108
109     if( ( b_error = p_adec->p_fifo->b_error ) )
110     {
111         DecoderError( p_adec->p_fifo );
112     }
113
114     EndThread( p_adec );
115     if( b_error )
116     {
117         return( -1 );
118     }
119
120     return( 0 );
121 }
122
123
124 #define FREE( p ) if( p ) free( p ); p = NULL
125 #define GetWLE( p ) \
126     ( *(u8*)(p) + ( *((u8*)(p)+1) << 8 ) )
127
128 #define GetDWLE( p ) \
129     (  *(u8*)(p) + ( *((u8*)(p)+1) << 8 ) + \
130         ( *((u8*)(p)+2) << 16 ) + ( *((u8*)(p)+3) << 24 ) )
131     
132 static void faac_GetWaveFormatEx( waveformatex_t *p_wh,
133                                           u8 *p_data )
134 {
135
136     p_wh->i_formattag     = GetWLE( p_data );
137     p_wh->i_channels      = GetWLE( p_data + 2 );
138     p_wh->i_samplespersec = GetDWLE( p_data + 4 );
139     p_wh->i_avgbytespersec= GetDWLE( p_data + 8 );
140     p_wh->i_blockalign    = GetWLE( p_data + 12 );
141     p_wh->i_bitspersample = GetWLE( p_data + 14 );
142     p_wh->i_size          = GetWLE( p_data + 16 );
143
144     if( p_wh->i_size )
145     {
146         p_wh->p_data = malloc( p_wh->i_size );
147         memcpy( p_wh->p_data, p_data + 18, p_wh->i_size );
148     }
149 }
150
151 /* get the first pes from fifo */
152 static pes_packet_t *__PES_GET( decoder_fifo_t *p_fifo )
153 {
154     pes_packet_t *p_pes;
155
156     vlc_mutex_lock( &p_fifo->data_lock );
157
158     /* if fifo is emty wait */
159     while( !p_fifo->p_first )
160     {
161         if( p_fifo->b_die )
162         {
163             vlc_mutex_unlock( &p_fifo->data_lock );
164             return( NULL );
165         }
166         vlc_cond_wait( &p_fifo->data_wait, &p_fifo->data_lock );
167     }
168     p_pes = p_fifo->p_first;
169
170     vlc_mutex_unlock( &p_fifo->data_lock );
171
172     return( p_pes );
173 }
174
175 /* free the first pes and go to next */
176 static void __PES_NEXT( decoder_fifo_t *p_fifo )
177 {
178     pes_packet_t *p_next;
179
180     vlc_mutex_lock( &p_fifo->data_lock );
181     
182     p_next = p_fifo->p_first->p_next;
183     p_fifo->p_first->p_next = NULL;
184     input_DeletePES( p_fifo->p_packets_mgt, p_fifo->p_first );
185     p_fifo->p_first = p_next;
186     p_fifo->i_depth--;
187
188     if( !p_fifo->p_first )
189     {
190         /* No PES in the fifo */
191         /* pp_last no longer valid */
192         p_fifo->pp_last = &p_fifo->p_first;
193         while( !p_fifo->p_first )
194         {
195             vlc_cond_signal( &p_fifo->data_wait );
196             vlc_cond_wait( &p_fifo->data_wait, &p_fifo->data_lock );
197         }
198     }
199     vlc_mutex_unlock( &p_fifo->data_lock );
200 }
201
202 static inline void __GetFrame( adec_thread_t *p_adec )
203 {
204     pes_packet_t  *p_pes;
205     data_packet_t *p_data;
206     byte_t        *p_buffer;
207
208     p_pes = __PES_GET( p_adec->p_fifo );
209     if( p_pes->i_pts )
210     {
211         p_adec->pts = p_pes->i_pts;
212     }
213
214     while( ( !p_pes->i_nb_data )||( !p_pes->i_pes_size ) )
215     {
216         __PES_NEXT( p_adec->p_fifo );
217         p_pes = __PES_GET( p_adec->p_fifo );
218     }
219     p_adec->i_framesize = p_pes->i_pes_size;
220     if( p_pes->i_nb_data == 1 )
221     {
222         p_adec->p_framedata = p_pes->p_first->p_payload_start;
223         return;    
224     }
225     /* get a buffer and gather all data packet */
226     if( p_adec->i_buffer_size < p_pes->i_pes_size )
227     {
228         p_adec->i_buffer_size = 3 * p_pes->i_pes_size / 2;
229         if( p_adec->p_buffer )
230         {
231             p_adec->p_buffer = realloc( p_adec->p_buffer,
232                                         p_adec->i_buffer_size );
233         }
234         else
235         {
236             p_adec->p_buffer = malloc( p_adec->i_buffer_size );
237         }
238     }
239     
240     p_buffer = p_adec->p_framedata = p_adec->p_buffer;
241     p_data = p_pes->p_first;
242     do
243     {
244         p_adec->p_fifo->p_vlc->pf_memcpy( p_buffer, p_data->p_payload_start, 
245                      p_data->p_payload_end - p_data->p_payload_start );
246         p_buffer += p_data->p_payload_end - p_data->p_payload_start;
247         p_data = p_data->p_next;
248     } while( p_data );
249 }
250
251 static inline void __NextFrame( adec_thread_t *p_adec )
252 {
253     __PES_NEXT( p_adec->p_fifo );
254 }
255
256
257 /*****************************************************************************
258  * InitThread: initialize data before entering main loop
259  *****************************************************************************/
260 static int InitThread( adec_thread_t * p_adec )
261 {
262     int i_status;
263     unsigned long i_rate;
264     unsigned char i_channels;
265             
266     faacDecConfiguration *p_faad_config;
267
268     if( !p_adec->p_fifo->p_demux_data )
269     {
270         msg_Warn( p_adec->p_fifo,
271                   "cannot load stream informations" );
272     }
273     else
274     {
275         faac_GetWaveFormatEx( &p_adec->format,
276                               (u8*)p_adec->p_fifo->p_demux_data );
277     }
278
279     if( !( p_adec->p_handle = faacDecOpen() ) )
280     {
281         msg_Err( p_adec->p_fifo,
282                  "cannot initialize faad" );
283         FREE( p_adec->format.p_data );
284         return( -1 );
285     }
286     
287     if( !p_adec->format.p_data )
288     {
289
290         msg_Warn( p_adec->p_fifo,
291                  "DecoderSpecificInfo missing, trying with first frame" );
292         __GetFrame( p_adec );
293
294         i_status = faacDecInit( p_adec->p_handle,
295                                 p_adec->p_framedata,
296                                 &i_rate,
297                                 &i_channels );
298 //        __NextFrame( p_adec );
299     }
300     else
301     {
302         i_status = faacDecInit2( p_adec->p_handle,
303                                  p_adec->format.p_data,
304                                  p_adec->format.i_size,
305                                  &i_rate,
306                                  &i_channels );
307     }
308
309     if( i_status < 0 )
310     {
311         msg_Err( p_adec->p_fifo,
312                  "failed to initialize faad" );
313         faacDecClose( p_adec->p_handle );
314         return( -1 );
315     }
316     msg_Dbg( p_adec->p_fifo,
317              "faad intitialized, samplerate:%dHz channels:%d",
318              i_rate, 
319              i_channels );
320
321
322     /* set default configuration */
323     p_faad_config = faacDecGetCurrentConfiguration( p_adec->p_handle );
324     p_faad_config->outputFormat = FAAD_FMT_FLOAT;
325     faacDecSetConfiguration( p_adec->p_handle, p_faad_config );
326         
327
328     /* Initialize the thread properties */
329     p_adec->output_format.i_format = AOUT_FMT_FLOAT32;
330     p_adec->output_format.i_rate = i_rate;
331     p_adec->output_format.i_channels = i_channels;
332   
333 #if 0
334     if( !p_adec->format.p_data )
335     {
336         /* Init the BitStream */
337         InitBitstream( &p_adec->bit_stream, p_adec->p_fifo,
338                        NULL, NULL );
339         p_adec->p_framedata = malloc( AAC_MAXCHANNELS * FAAD_MIN_STREAMSIZE );
340         p_adec->i_framesize = 0;
341     }
342 #endif
343
344     return( 0 );
345 }
346
347 /*****************************************************************************
348  * DecodeThread: decodes a frame
349  *****************************************************************************
350  * XXX it will work only for frame based streams like from mp4 file
351  *     but it's the only way to use libfaad2 without having segfault
352  *     after 1 or 2 frames
353  *****************************************************************************/
354 static void DecodeThread( adec_thread_t *p_adec )
355 {
356     aout_buffer_t    *p_aout_buffer;
357
358     void             *p_faad_buffer;
359     faacDecFrameInfo faad_frame;
360
361     /* **** Get a new frames from streams **** */
362     __GetFrame( p_adec );
363     
364     /* **** decode this frame **** */
365     p_faad_buffer = faacDecDecode( p_adec->p_handle,
366                                    &faad_frame,
367                                    p_adec->p_framedata );
368     /* **** switch to the next frame **** */
369     __NextFrame( p_adec );
370
371 #if 0
372     /* 
373      * XXX don't work ! XXX 
374      *
375      * first even without format.p_data stream can be frame based
376      * and it make libfaad segfault
377      *
378      */
379     if( p_adec->format.p_data )
380     {
381         __GetFrame( p_adec );
382         /* Now decode data */
383         p_faad_buffer = faacDecDecode( p_adec->p_handle,
384                                        &faad_frame,
385                                        p_adec->p_framedata );
386         __NextFrame( p_adec );
387
388     }
389     else
390     {
391         int i_count;
392         /* fill buffer */
393         i_count = __MAX( 1, p_adec->output_format.i_channels ) * FAAD_MIN_STREAMSIZE -
394                         p_adec->i_framesize;
395         
396         GetChunk( &p_adec->bit_stream,
397                   p_adec->p_framedata + p_adec->i_framesize,
398                   i_count );
399         p_adec->i_framesize += i_count;
400         p_faad_buffer = faacDecDecode( p_adec->p_handle,
401                                        &faad_frame,
402                                        p_adec->p_framedata );
403         /* update data buffer pos */
404         i_count = __MIN( p_adec->i_framesize,
405                          __MAX( 1, faad_frame.bytesconsumed ) );
406         memcpy( p_adec->p_framedata,
407                 p_adec->p_framedata + i_count,
408                 p_adec->i_framesize - i_count );
409         p_adec->i_framesize -= i_count;
410     }
411 #endif
412
413     /* **** some sanity checks to see if we have samples to out **** */
414     if( faad_frame.error > 0 )
415     {
416         msg_Warn( p_adec->p_fifo, "%s", 
417                   faacDecGetErrorMessage(faad_frame.error) );
418         return;
419     }
420     if( ( faad_frame.channels <= 0 )||
421         ( faad_frame.channels > AAC_MAXCHANNELS) )
422     {
423         msg_Warn( p_adec->p_fifo,
424                   "invalid channels count(%d)", faad_frame.channels );
425         return;
426     }
427     if( faad_frame.samples <= 0 )
428     {
429         msg_Warn( p_adec->p_fifo, "decoded zero sample !" );
430         return;
431     }
432
433 #if 0
434     msg_Dbg( p_adec->p_fifo,
435              "decoded frame samples:%d, channels:%d, consumed:%d",
436              faad_frame.samples,
437              faad_frame.channels,
438              faad_frame.bytesconsumed );
439 #endif
440
441     /* **** Now we can output these samples **** */
442     
443     /* **** First check if we have a valid output **** */
444     if( ( !p_adec->p_aout_input )||
445         ( p_adec->output_format.i_channels != faad_frame.channels ) )
446     {
447         if( p_adec->p_aout_input )
448         {
449             /* **** Delete the old **** */
450             aout_InputDelete( p_adec->p_aout, p_adec->p_aout_input );
451         }
452
453         /* **** Create a new audio output **** */
454         p_adec->output_format.i_channels = faad_frame.channels;
455         aout_DateInit( &p_adec->date, p_adec->output_format.i_rate );
456         p_adec->p_aout_input = aout_InputNew( p_adec->p_fifo,
457                                               &p_adec->p_aout,
458                                               &p_adec->output_format );
459     }
460
461     if( !p_adec->p_aout_input )
462     {
463         msg_Err( p_adec->p_fifo, "cannot create aout" );
464         return;
465     }
466     
467     if( p_adec->pts != 0 && p_adec->pts != aout_DateGet( &p_adec->date ) )
468     {
469         aout_DateSet( &p_adec->date, p_adec->pts );
470     }
471     else if( !aout_DateGet( &p_adec->date ) )
472     {
473         return;
474     }
475
476     p_aout_buffer = aout_BufferNew( p_adec->p_aout, 
477                                     p_adec->p_aout_input,
478                                     faad_frame.samples / faad_frame.channels );
479     if( !p_aout_buffer )
480     {
481         msg_Err( p_adec->p_fifo, "cannot get aout buffer" );
482         p_adec->p_fifo->b_error = 1;
483         return;
484     }
485     p_aout_buffer->start_date = aout_DateGet( &p_adec->date );
486     p_aout_buffer->end_date = aout_DateIncrement( &p_adec->date,
487                                                   faad_frame.samples /
488                                                       faad_frame.channels );
489     memcpy( p_aout_buffer->p_buffer,
490             p_faad_buffer,
491             p_aout_buffer->i_nb_bytes );
492
493     aout_BufferPlay( p_adec->p_aout, p_adec->p_aout_input, p_aout_buffer );
494 }
495
496
497 /*****************************************************************************
498  * EndThread : faad decoder thread destruction
499  *****************************************************************************/
500 static void EndThread (adec_thread_t *p_adec)
501 {
502     if( p_adec->p_aout_input )
503     {
504         aout_InputDelete( p_adec->p_aout, p_adec->p_aout_input );
505     }
506
507     if( p_adec->p_handle )
508     {
509         faacDecClose( p_adec->p_handle );
510     }
511
512     FREE( p_adec->format.p_data );
513     FREE( p_adec->p_buffer );
514
515     msg_Dbg( p_adec->p_fifo, "faad decoder closed" );
516         
517     free( p_adec );
518 }
519