* all: I have added two new variables in es_descriptor_t and
[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.17 2003/01/07 21:49:01 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 <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 #include "codecs.h"
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 static int pi_channels_maps[6] =
124 {
125     0,
126     AOUT_CHAN_CENTER,   AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
127     AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
128     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT,
129     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
130      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
131 };
132
133 #define FREE( p ) if( p != NULL ) free( p ); p = NULL
134 #define GetWLE( p ) \
135     ( *(u8*)(p) + ( *((u8*)(p)+1) << 8 ) )
136
137 #define GetDWLE( p ) \
138     (  *(u8*)(p) + ( *((u8*)(p)+1) << 8 ) + \
139         ( *((u8*)(p)+2) << 16 ) + ( *((u8*)(p)+3) << 24 ) )
140     
141 static void faac_GetWaveFormatEx( waveformatex_t *p_wh,
142                                           u8 *p_data )
143 {
144     WAVEFORMATEX *p_wfdata = (WAVEFORMATEX*)p_data;
145     
146     p_wh->i_formattag     = p_wfdata->wFormatTag;
147     p_wh->i_nb_channels   = p_wfdata->nChannels;
148     p_wh->i_samplespersec = p_wfdata->nSamplesPerSec;
149     p_wh->i_avgbytespersec= p_wfdata->nAvgBytesPerSec;
150     p_wh->i_blockalign    = p_wfdata->nBlockAlign;
151     p_wh->i_bitspersample = p_wfdata->wBitsPerSample;
152     p_wh->i_size          = p_wfdata->cbSize;
153
154     if( p_wh->i_size )
155     {
156         p_wh->p_data = malloc( p_wh->i_size );
157         memcpy( p_wh->p_data, 
158                 p_data + sizeof(WAVEFORMATEX) , 
159                 p_wh->i_size );
160     }
161 }
162
163 static void GetPESData( u8 *p_buf, int i_max, pes_packet_t *p_pes )
164 {   
165     int i_copy; 
166     int i_count;
167
168     data_packet_t   *p_data;
169
170     i_count = 0;
171     p_data = p_pes->p_first;
172     while( p_data != NULL && i_count < i_max )
173     {
174
175         i_copy = __MIN( p_data->p_payload_end - p_data->p_payload_start, 
176                         i_max - i_count );
177
178         if( i_copy > 0 )
179         {
180             memcpy( p_buf,
181                     p_data->p_payload_start,
182                     i_copy );
183         }
184
185         p_data = p_data->p_next;
186         i_count += i_copy;
187         p_buf   += i_copy;
188     }
189
190     if( i_count < i_max )
191     {
192         memset( p_buf, 0, i_max - i_count );
193     }
194 }
195
196 /*****************************************************************************
197  * InitThread: initialize data before entering main loop
198  *****************************************************************************/
199 static int InitThread( adec_thread_t * p_adec )
200 {
201     WAVEFORMATEX    *p_wf;
202     int i_status;
203     unsigned long   i_rate;
204     unsigned char   i_nb_channels;
205
206     faacDecConfiguration *p_faad_config;
207
208     if( ( p_wf = (WAVEFORMATEX*)p_adec->p_fifo->p_waveformatex ) == NULL )
209     {
210         msg_Warn( p_adec->p_fifo,
211                   "cannot load stream informations" );
212     }
213     else
214     {
215         faac_GetWaveFormatEx( &p_adec->format,
216                               (uint8_t*)p_wf );
217     }
218
219     p_adec->p_buffer = NULL;
220     p_adec->i_buffer = 0;
221
222
223     if( !( p_adec->p_handle = faacDecOpen() ) )
224     {
225         msg_Err( p_adec->p_fifo,
226                  "cannot initialize faad" );
227         FREE( p_adec->format.p_data );
228         return( -1 );
229     }
230
231     if( p_adec->format.p_data == NULL )
232     {
233         int i_frame_size;
234         pes_packet_t *p_pes;
235
236         msg_Warn( p_adec->p_fifo,
237                  "DecoderSpecificInfo missing, trying with first frame" );
238         // gather first frame
239         do
240         {
241             input_ExtractPES( p_adec->p_fifo, &p_pes );
242             if( !p_pes )
243             {
244                 return( -1 );
245             }
246             i_frame_size = p_pes->i_pes_size;
247
248             if( i_frame_size > 0 )
249             {
250                 if( p_adec->i_buffer < i_frame_size + 16 )
251                 {
252                     FREE( p_adec->p_buffer );
253                     p_adec->p_buffer = malloc( i_frame_size + 16 );
254                     p_adec->i_buffer = i_frame_size + 16;
255                 }
256                 
257                 GetPESData( p_adec->p_buffer, p_adec->i_buffer, p_pes );
258             }
259             else
260             {
261                 input_DeletePES( p_adec->p_fifo->p_packets_mgt, p_pes );
262             }
263         } while( i_frame_size <= 0 );
264
265
266         i_status = faacDecInit( p_adec->p_handle,
267                                 p_adec->p_buffer,
268                                 i_frame_size,
269                                 &i_rate,
270                                 &i_nb_channels );
271     }
272     else
273     {
274         i_status = faacDecInit2( p_adec->p_handle,
275                                  p_adec->format.p_data,
276                                  p_adec->format.i_size,
277                                  &i_rate,
278                                  &i_nb_channels );
279     }
280
281     if( i_status < 0 )
282     {
283         msg_Err( p_adec->p_fifo,
284                  "failed to initialize faad" );
285         faacDecClose( p_adec->p_handle );
286         return( -1 );
287     }
288     msg_Dbg( p_adec->p_fifo,
289              "faad intitialized, samplerate:%dHz channels:%d",
290              i_rate, 
291              i_nb_channels );
292
293
294     /* set default configuration */
295     p_faad_config = faacDecGetCurrentConfiguration( p_adec->p_handle );
296     p_faad_config->outputFormat = FAAD_FMT_FLOAT;
297     faacDecSetConfiguration( p_adec->p_handle, p_faad_config );
298         
299
300     /* Initialize the thread properties */
301     p_adec->output_format.i_format = VLC_FOURCC('f','l','3','2');
302     p_adec->output_format.i_rate = i_rate;
303     p_adec->output_format.i_physical_channels =
304         p_adec->output_format.i_original_channels =
305             pi_channels_maps[i_nb_channels];
306     p_adec->p_aout = NULL;
307     p_adec->p_aout_input = NULL;
308
309     p_adec->pts = 0;
310   
311     return( 0 );
312 }
313
314 /*****************************************************************************
315  * DecodeThread: decodes a frame
316  *****************************************************************************
317  * XXX it will work only for frame based streams like from mp4 file
318  *     but it's the only way to use libfaad2 without having segfault
319  *     after 1 or 2 frames
320  *****************************************************************************/
321 static void DecodeThread( adec_thread_t *p_adec )
322 {
323     aout_buffer_t    *p_aout_buffer;
324
325     void             *p_faad_buffer;
326     faacDecFrameInfo faad_frame;
327     int  i_frame_size;
328     pes_packet_t *p_pes;
329
330     /* **** Get a new frames from streams **** */
331     do
332     {
333         input_ExtractPES( p_adec->p_fifo, &p_pes );
334         if( !p_pes )
335         {
336             p_adec->p_fifo->b_error = 1;
337             return;
338         }
339         if( p_pes->i_pts != 0 )
340         {
341             p_adec->pts = p_pes->i_pts;
342         }
343         i_frame_size = p_pes->i_pes_size;
344
345         if( i_frame_size > 0 )
346         {
347             if( p_adec->i_buffer < i_frame_size + 16 )
348             {
349                 FREE( p_adec->p_buffer );
350                 p_adec->p_buffer = malloc( i_frame_size + 16 );
351                 p_adec->i_buffer = i_frame_size + 16;
352             }
353             
354             GetPESData( p_adec->p_buffer, p_adec->i_buffer, p_pes );
355         }
356         input_DeletePES( p_adec->p_fifo->p_packets_mgt, p_pes );
357     } while( i_frame_size <= 0 );
358     
359     /* **** decode this frame **** */
360     p_faad_buffer = faacDecDecode( p_adec->p_handle,
361                                    &faad_frame,
362                                    p_adec->p_buffer,
363                                    i_frame_size );
364
365     /* **** some sanity checks to see if we have samples to out **** */
366     if( faad_frame.error > 0 )
367     {
368         msg_Warn( p_adec->p_fifo, "%s", 
369                   faacDecGetErrorMessage(faad_frame.error) );
370         return;
371     }
372     if( ( faad_frame.channels <= 0 )||
373         ( faad_frame.channels > AAC_MAXCHANNELS) ||
374         ( faad_frame.channels > 5 ) )
375     {
376         msg_Warn( p_adec->p_fifo,
377                   "invalid channels count(%d)", faad_frame.channels );
378         return;
379     }
380     if( faad_frame.samples <= 0 )
381     {
382         msg_Warn( p_adec->p_fifo, "decoded zero sample !" );
383         return;
384     }
385
386 #if 0
387     msg_Dbg( p_adec->p_fifo,
388              "decoded frame samples:%d, channels:%d, consumed:%d",
389              faad_frame.samples,
390              faad_frame.channels,
391              faad_frame.bytesconsumed );
392 #endif
393
394     /* **** Now we can output these samples **** */
395     
396     /* **** First check if we have a valid output **** */
397     if( ( !p_adec->p_aout_input )||
398         ( p_adec->output_format.i_original_channels !=
399              pi_channels_maps[faad_frame.channels] ) )
400     {
401         if( p_adec->p_aout_input )
402         {
403             /* **** Delete the old **** */
404             aout_DecDelete( p_adec->p_aout, p_adec->p_aout_input );
405         }
406
407         /* **** Create a new audio output **** */
408         p_adec->output_format.i_physical_channels =
409             p_adec->output_format.i_original_channels =
410                 pi_channels_maps[faad_frame.channels];
411
412         aout_DateInit( &p_adec->date, p_adec->output_format.i_rate );
413         p_adec->p_aout_input = aout_DecNew( p_adec->p_fifo,
414                                             &p_adec->p_aout,
415                                             &p_adec->output_format );
416     }
417
418     if( !p_adec->p_aout_input )
419     {
420         msg_Err( p_adec->p_fifo, "cannot create aout" );
421         return;
422     }
423     
424     if( p_adec->pts != 0 && p_adec->pts != aout_DateGet( &p_adec->date ) )
425     {
426         aout_DateSet( &p_adec->date, p_adec->pts );
427     }
428     else if( !aout_DateGet( &p_adec->date ) )
429     {
430         return;
431     }
432
433     p_aout_buffer = aout_DecNewBuffer( p_adec->p_aout, 
434                                        p_adec->p_aout_input,
435                                        faad_frame.samples / faad_frame.channels );
436     if( !p_aout_buffer )
437     {
438         msg_Err( p_adec->p_fifo, "cannot get aout buffer" );
439         p_adec->p_fifo->b_error = 1;
440         return;
441     }
442     p_aout_buffer->start_date = aout_DateGet( &p_adec->date );
443     p_aout_buffer->end_date = aout_DateIncrement( &p_adec->date,
444                                                   faad_frame.samples /
445                                                       faad_frame.channels );
446     memcpy( p_aout_buffer->p_buffer,
447             p_faad_buffer,
448             p_aout_buffer->i_nb_bytes );
449
450     aout_DecPlay( p_adec->p_aout, p_adec->p_aout_input, p_aout_buffer );
451 }
452
453
454 /*****************************************************************************
455  * EndThread : faad decoder thread destruction
456  *****************************************************************************/
457 static void EndThread (adec_thread_t *p_adec)
458 {
459     if( p_adec->p_aout_input )
460     {
461         aout_DecDelete( p_adec->p_aout, p_adec->p_aout_input );
462     }
463
464     if( p_adec->p_handle )
465     {
466         faacDecClose( p_adec->p_handle );
467     }
468
469     FREE( p_adec->format.p_data );
470     FREE( p_adec->p_buffer );
471
472     msg_Dbg( p_adec->p_fifo, "faad decoder closed" );
473         
474     free( p_adec );
475 }
476