ad4b48ef2ba3b41535bfa1157ed1fb922f8d4a61
[vlc.git] / modules / codec / mad / libmad.c
1 /***************************************************************************
2              libmad.c  -  description
3                -------------------
4     Functions that are called by libmad to communicate with vlc decoder
5     infrastructure.
6
7     begin                : Mon Nov 5 2001
8     copyright            : (C) 2001 by Jean-Paul Saman
9     email                : jpsaman@wxs.nl
10  ***************************************************************************/
11
12 /***************************************************************************
13  *                                                                         *
14  *   This program is free software; you can redistribute it and/or modify  *
15  *   it under the terms of the GNU General Public License as published by  *
16  *   the Free Software Foundation; either version 2 of the License, or     *
17  *   (at your option) any later version.                                   *
18  *                                                                         *
19  ***************************************************************************/
20
21 /*****************************************************************************
22  * Preamble
23  *****************************************************************************/
24 #include <stdlib.h>                                      /* malloc(), free() */
25 #include <string.h>                                              /* strdup() */
26
27 #include <vlc/vlc.h>
28 #include <vlc/aout.h>
29 #include <vlc/decoder.h>
30
31 /*****************************************************************************
32  * Libmad includes files
33  *****************************************************************************/
34 #include <mad.h>
35 #include "decoder.h"
36 #include "libmad.h"
37
38 static void PrintFrameInfo(struct mad_header *Header);
39
40 /*****************************************************************************
41  * libmad_input: this function is called by libmad when the input buffer needs
42  * to be filled.
43  *****************************************************************************/
44 enum mad_flow libmad_input( void *p_data, struct mad_stream *p_stream )
45 {
46     mad_adec_thread_t * p_dec = (mad_adec_thread_t *) p_data;
47     size_t   i_wanted, i_left;
48
49     if ( p_dec->p_fifo->b_die )
50     {
51         msg_Dbg( p_dec->p_fifo, "stopping libmad decoder" );
52         return MAD_FLOW_STOP;
53     }
54
55     if ( p_dec->p_fifo->b_error )
56     {
57         msg_Warn( p_dec->p_fifo, "ignoring current audio frame" );
58         return MAD_FLOW_IGNORE;
59     }
60
61     /* libmad_stream_buffer does not consume the total buffer, it consumes
62      * only data for one frame only. So all data left in the buffer should
63      * be put back in front. */
64     if ( !p_stream->buffer || p_stream->error == MAD_ERROR_BUFLEN )
65     {
66        /* libmad does not consume all the buffer it's given. Some data,
67         * part of a truncated frame, is left unused at the end of the
68         * buffer. Those datas must be put back at the beginning of the
69         * buffer and taken in account for refilling the buffer. This
70         * means that the input buffer must be large enough to hold a
71         * complete frame at the highest observable bit-rate (currently
72         * 448 kb/s). XXX=XXX Is 2016 bytes the size of the largest frame?
73         * (448000*(1152/32000))/8 */
74         if( p_stream->next_frame )
75         {
76             i_left = p_stream->bufend - p_stream->next_frame;
77             if( p_dec->buffer != p_stream->next_frame )
78             {
79                 memcpy( p_dec->buffer, p_stream->next_frame, i_left );
80             }
81             i_wanted = MAD_BUFFER_MDLEN - i_left;
82
83             /* Store timestamp for next frame */
84             p_dec->i_next_pts = p_dec->p_fifo->p_first->i_pts;
85         }
86         else
87         {
88             i_wanted = MAD_BUFFER_MDLEN;
89             i_left = 0;
90
91             /* Store timestamp for this frame */
92             p_dec->i_current_pts = p_dec->p_fifo->p_first->i_pts;
93         }
94         p_dec->p_fifo->p_first->i_pts = 0;
95
96         /* Fill-in the buffer. If an error occurs print a message and leave
97          * the decoding loop. If the end of stream is reached we also leave
98          * the loop but the return status is left untouched. */
99         if( i_wanted > p_dec->p_data->p_payload_end
100                         - p_dec->p_data->p_payload_start )
101         {
102             i_wanted = p_dec->p_data->p_payload_end
103                         - p_dec->p_data->p_payload_start;
104             memcpy( p_dec->buffer + i_left,
105                     p_dec->p_data->p_payload_start, i_wanted );
106             NextDataPacket( p_dec->p_fifo, &p_dec->p_data );
107         }
108         else
109         {
110             memcpy( p_dec->buffer + i_left,
111                     p_dec->p_data->p_payload_start, i_wanted );
112             p_dec->p_data->p_payload_start += i_wanted;
113         }
114
115         if ( p_dec->p_fifo->b_die )
116         {
117             msg_Dbg( p_dec->p_fifo, "stopping libmad decoder" );
118             return MAD_FLOW_STOP;
119         }
120
121         if ( p_dec->p_fifo->b_error )
122         {
123             msg_Warn( p_dec->p_fifo, "ignoring current audio frame" );    
124             return MAD_FLOW_IGNORE;
125         }
126
127         /* Pipe the new buffer content to libmad's stream decoder facility.
128          * Libmad never copies the buffer, but just references it. So keep
129          * it in mad_adec_thread_t structure. */
130         mad_stream_buffer( p_stream, (unsigned char*) &p_dec->buffer,
131                            i_left + i_wanted );
132         p_stream->error = 0;
133     }
134
135     return MAD_FLOW_CONTINUE;
136 }
137
138 /*****************************************************************************
139  * libmad_output: this function is called just after the frame is decoded
140  *****************************************************************************/
141 enum mad_flow libmad_output( void *p_data, struct mad_header const *p_header,
142                              struct mad_pcm *p_pcm )
143 {
144     mad_adec_thread_t * p_dec = (mad_adec_thread_t *) p_data;
145     aout_buffer_t *     p_buffer;
146     mad_fixed_t const * p_left = p_pcm->samples[0];
147     mad_fixed_t const * p_right = p_pcm->samples[1];
148     int                 i_samples = p_pcm->length;
149     mad_fixed_t *       p_samples;
150
151     /* Creating the audio output fifo. Assume the samplerate and nr of channels
152      * from the first decoded frame is right for the entire audio track. */
153     if( (p_dec->p_aout_input != NULL) &&
154         (p_dec->output_format.i_rate != p_pcm->samplerate
155            || p_dec->output_format.i_channels != p_pcm->channels) )
156     {
157         /* Parameters changed - this should not happen. */
158         aout_InputDelete( p_dec->p_aout, p_dec->p_aout_input );
159         p_dec->p_aout_input = NULL;
160     }
161
162     /* Creating the audio input if not created yet. */
163     if( p_dec->p_aout_input == NULL )
164     {
165         p_dec->output_format.i_rate = p_pcm->samplerate;
166         p_dec->output_format.i_channels = p_pcm->channels;
167         aout_DateInit( &p_dec->end_date, p_pcm->samplerate );
168         p_dec->p_aout_input = aout_InputNew( p_dec->p_fifo,
169                                              &p_dec->p_aout,
170                                              &p_dec->output_format );
171
172         if ( p_dec->p_aout_input == NULL )
173         {
174             p_dec->p_fifo->b_error = VLC_TRUE;
175             return MAD_FLOW_BREAK;
176         }
177     }
178
179     if( p_dec->i_current_pts )
180     {
181         /* Set the Presentation Time Stamp */
182         if( p_dec->i_current_pts != aout_DateGet( &p_dec->end_date ) )
183         {
184             aout_DateSet( &p_dec->end_date, p_dec->i_current_pts );
185         }
186
187         p_dec->i_current_pts = 0;
188     }
189     else if( p_dec->i_next_pts )
190     {
191         /* No PTS this time, but it'll be for next frame */
192         p_dec->i_current_pts = p_dec->i_next_pts;
193         p_dec->i_next_pts = 0;
194     }
195
196     if( !aout_DateGet( &p_dec->end_date ) )
197     {
198         /* No date available yet, wait for the first PTS. */
199         return MAD_FLOW_CONTINUE;
200     }
201
202     p_buffer = aout_BufferNew( p_dec->p_aout, p_dec->p_aout_input, i_samples );
203
204     if ( p_buffer == NULL )
205     {
206         msg_Err( p_dec->p_fifo, "allocating new buffer failed" );
207         return MAD_FLOW_BREAK;
208     }
209
210     p_buffer->start_date = aout_DateGet( &p_dec->end_date );
211     p_buffer->end_date = aout_DateIncrement( &p_dec->end_date, i_samples );
212
213     /* Interleave and keep buffers in mad_fixed_t format */
214     p_samples = (mad_fixed_t *)p_buffer->p_buffer;
215
216     switch( p_pcm->channels )
217     {
218     case 2:
219         while( i_samples-- )
220         {
221             *p_samples++ = *p_left++;
222             *p_samples++ = *p_right++;
223         }
224         break;
225
226     case 1:
227         p_dec->p_fifo->p_vlc->pf_memcpy( p_samples, p_left,
228                                          i_samples * sizeof(mad_fixed_t) );
229         break;
230
231     default:
232         msg_Err( p_dec->p_fifo, "cannot interleave %i channels",
233                                 p_pcm->channels );
234     }
235
236     aout_BufferPlay( p_dec->p_aout, p_dec->p_aout_input, p_buffer );
237
238     return MAD_FLOW_CONTINUE;
239 }
240
241 /*****************************************************************************
242  * libmad_error: this function is called when an error occurs during decoding
243  *****************************************************************************/
244 enum mad_flow libmad_error( void *data, struct mad_stream *p_libmad_stream,
245                             struct mad_frame *p_libmad_frame )
246 {
247     mad_adec_thread_t *p_dec = (mad_adec_thread_t *) data;
248     enum mad_flow result = MAD_FLOW_CONTINUE;
249
250     switch (p_libmad_stream->error)
251     {             
252     case MAD_ERROR_BUFLEN:                /* input buffer too small (or EOF) */
253         msg_Err( p_dec->p_fifo, "input buffer too small (or EOF)" );
254         result = MAD_FLOW_CONTINUE;
255         break;
256     case MAD_ERROR_BUFPTR:                /* invalid (null) buffer pointer */
257         msg_Err( p_dec->p_fifo, "invalid (null) buffer pointer" );
258         result = MAD_FLOW_STOP;
259         break;
260     case MAD_ERROR_NOMEM:                 /* not enough memory */
261         msg_Err( p_dec->p_fifo, "invalid (null) buffer pointer" );
262         result = MAD_FLOW_STOP;
263         break;
264     case MAD_ERROR_LOSTSYNC:            /* lost synchronization */
265         msg_Err( p_dec->p_fifo, "lost synchronization" );
266         mad_stream_sync(p_libmad_stream);
267         result = MAD_FLOW_CONTINUE;
268         break;
269     case MAD_ERROR_BADLAYER:            /* reserved header layer value */
270         msg_Err( p_dec->p_fifo, "reserved header layer value" );
271         result = MAD_FLOW_CONTINUE;
272         break;
273     case MAD_ERROR_BADBITRATE:        /* forbidden bitrate value */
274         msg_Err( p_dec->p_fifo, "forbidden bitrate value" );
275         result = MAD_FLOW_CONTINUE;
276         break;
277     case MAD_ERROR_BADSAMPLERATE: /* reserved sample frequency value */
278         msg_Err( p_dec->p_fifo, "reserved sample frequency value" );
279         result = MAD_FLOW_CONTINUE;
280         break;
281     case MAD_ERROR_BADEMPHASIS:     /* reserved emphasis value */
282         msg_Err( p_dec->p_fifo, "reserverd emphasis value" );
283         result = MAD_FLOW_CONTINUE;
284         break;
285     case MAD_ERROR_BADCRC:                /* CRC check failed */
286         msg_Err( p_dec->p_fifo, "CRC check failed" );
287         result = MAD_FLOW_CONTINUE;
288         break;
289     case MAD_ERROR_BADBITALLOC:     /* forbidden bit allocation value */
290         msg_Err( p_dec->p_fifo, "forbidden bit allocation value" );
291         result = MAD_FLOW_IGNORE;
292         break;
293     case MAD_ERROR_BADSCALEFACTOR:/* bad scalefactor index */
294         msg_Err( p_dec->p_fifo, "bad scalefactor index" );
295         result = MAD_FLOW_CONTINUE;
296         break;
297     case MAD_ERROR_BADFRAMELEN:     /* bad frame length */
298         msg_Err( p_dec->p_fifo, "bad frame length" );
299         result = MAD_FLOW_CONTINUE;
300         break;
301     case MAD_ERROR_BADBIGVALUES:    /* bad big_values count */
302         msg_Err( p_dec->p_fifo, "bad big values count" );
303         result = MAD_FLOW_IGNORE;
304         break;
305     case MAD_ERROR_BADBLOCKTYPE:    /* reserved block_type */
306         msg_Err( p_dec->p_fifo, "reserverd block_type" );
307         result = MAD_FLOW_IGNORE;
308         break;
309     case MAD_ERROR_BADSCFSI:            /* bad scalefactor selection info */
310         msg_Err( p_dec->p_fifo, "bad scalefactor selection info" );
311         result = MAD_FLOW_CONTINUE;
312         break;
313     case MAD_ERROR_BADDATAPTR:        /* bad main_data_begin pointer */
314         msg_Err( p_dec->p_fifo, "bad main_data_begin pointer" );
315         result = MAD_FLOW_STOP;
316         break;
317     case MAD_ERROR_BADPART3LEN:     /* bad audio data length */
318         msg_Err( p_dec->p_fifo, "bad audio data length" );
319         result = MAD_FLOW_IGNORE;
320         break;
321     case MAD_ERROR_BADHUFFTABLE:    /* bad Huffman table select */
322         msg_Err( p_dec->p_fifo, "bad Huffman table select" );
323         result = MAD_FLOW_IGNORE;
324         break;
325     case MAD_ERROR_BADHUFFDATA:     /* Huffman data overrun */
326         msg_Err( p_dec->p_fifo, "Huffman data overrun" );
327         result = MAD_FLOW_IGNORE;
328         break;
329     case MAD_ERROR_BADSTEREO:         /* incompatible block_type for JS */
330         msg_Err( p_dec->p_fifo, "incompatible block_type for JS" );
331         result = MAD_FLOW_IGNORE;
332         break;
333     default:
334         msg_Err( p_dec->p_fifo, "unknown error occured stopping decoder" );
335         result = MAD_FLOW_STOP;
336         break;
337     }
338     
339     return (MAD_RECOVERABLE(p_libmad_stream->error)? result: MAD_FLOW_STOP);
340     //return (MAD_FLOW_CONTINUE);
341 }
342
343 /*****************************************************************************
344  * libmad_message: this function is called to send a message
345  *****************************************************************************/
346 /* enum mad_flow libmad_message(void *, void*, unsigned int*)
347  * {
348  *     return MAD_FLOW_CONTINUE;
349  * }
350  */
351
352
353
354 /****************************************************************************
355  * Print human readable informations about an audio MPEG frame.                         *
356  ****************************************************************************/
357 static void PrintFrameInfo(struct mad_header *Header)
358 {
359         const char      *Layer,
360                         *Mode,
361                         *Emphasis;
362
363         /* Convert the layer number to its printed representation. */
364         switch(Header->layer)
365         {
366                 case MAD_LAYER_I:
367                         Layer="I";
368                         break;
369                 case MAD_LAYER_II:
370                         Layer="II";
371                         break;
372                 case MAD_LAYER_III:
373                         Layer="III";
374                         break;
375                 default:
376                         Layer="(unexpected layer value)";
377                         break;
378         }
379
380         /* Convert the audio mode to its printed representation. */
381         switch(Header->mode)
382         {
383                 case MAD_MODE_SINGLE_CHANNEL:
384                         Mode="single channel";
385                         break;
386                 case MAD_MODE_DUAL_CHANNEL:
387                         Mode="dual channel";
388                         break;
389                 case MAD_MODE_JOINT_STEREO:
390                         Mode="joint (MS/intensity) stereo";
391                         break;
392                 case MAD_MODE_STEREO:
393                         Mode="normal LR stereo";
394                         break;
395                 default:
396                         Mode="(unexpected mode value)";
397                         break;
398         }
399
400         /* Convert the emphasis to its printed representation. */
401         switch(Header->emphasis)
402         {
403                 case MAD_EMPHASIS_NONE:
404                         Emphasis="no";
405                         break;
406                 case MAD_EMPHASIS_50_15_US:
407                         Emphasis="50/15 us";
408                         break;
409                 case MAD_EMPHASIS_CCITT_J_17:
410                         Emphasis="CCITT J.17";
411                         break;
412                 default:
413                         Emphasis="(unexpected emphasis value)";
414                         break;
415         }
416
417 //X     msg_Err("statistics: %lu kb/s audio mpeg layer %s stream %s crc, "
418 //X                     "%s with %s emphasis at %d Hz sample rate\n",
419 //X                     Header->bitrate,Layer,
420 //X                     Header->flags&MAD_FLAG_PROTECTION?"with":"without",
421 //X                     Mode,Emphasis,Header->samplerate);
422 }