* modules/codec/mad/*: don't let mad drop corrupted mpeg frames without telling us...
[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->bit_stream.p_pes->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->bit_stream.p_pes->i_pts;
93         }
94
95         /* Fill-in the buffer. If an error occurs print a message and leave
96          * the decoding loop. If the end of stream is reached we also leave
97          * the loop but the return status is left untouched. */
98         if( i_wanted > (size_t)(p_dec->bit_stream.p_data->p_payload_end
99                                  - p_dec->bit_stream.p_data->p_payload_start) )
100         {
101             i_wanted = p_dec->bit_stream.p_data->p_payload_end
102                         - p_dec->bit_stream.p_data->p_payload_start;
103             memcpy( p_dec->buffer + i_left,
104                     p_dec->bit_stream.p_data->p_payload_start, i_wanted );
105             NextDataPacket( p_dec->p_fifo, &p_dec->bit_stream );
106             /* No need to check that p_dec->bit_stream->p_data is valid
107              * since we check later on for b_die and b_error */
108         }
109         else
110         {
111             memcpy( p_dec->buffer + i_left,
112                     p_dec->bit_stream.p_data->p_payload_start, i_wanted );
113             p_dec->bit_stream.p_data->p_payload_start += i_wanted;
114         }
115
116         if ( p_dec->p_fifo->b_die )
117         {
118             msg_Dbg( p_dec->p_fifo, "stopping libmad decoder" );
119             return MAD_FLOW_STOP;
120         }
121
122         if ( p_dec->p_fifo->b_error )
123         {
124             msg_Warn( p_dec->p_fifo, "ignoring current audio frame" );    
125             return MAD_FLOW_IGNORE;
126         }
127
128         /* Pipe the new buffer content to libmad's stream decoder facility.
129          * Libmad never copies the buffer, but just references it. So keep
130          * it in mad_adec_thread_t structure. */
131         mad_stream_buffer( p_stream, (unsigned char*) &p_dec->buffer,
132                            i_left + i_wanted );
133         p_stream->error = 0;
134     }
135
136     return MAD_FLOW_CONTINUE;
137 }
138
139 /*****************************************************************************
140  * libmad_output: this function is called just after the frame is decoded
141  *****************************************************************************/
142 enum mad_flow libmad_output( void *p_data, struct mad_header const *p_header,
143                              struct mad_pcm *p_pcm )
144 {
145     mad_adec_thread_t * p_dec = (mad_adec_thread_t *) p_data;
146     aout_buffer_t *     p_buffer;
147     mad_fixed_t const * p_left = p_pcm->samples[0];
148     mad_fixed_t const * p_right = p_pcm->samples[1];
149     unsigned int        i_samples = p_pcm->length;
150     mad_fixed_t *       p_samples;
151     unsigned int        i_channels = (p_pcm->channels == 2) ?
152                                      AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT :
153                                      AOUT_CHAN_CENTER;
154
155     /* Creating the audio output fifo. Assume the samplerate and nr of channels
156      * from the first decoded frame is right for the entire audio track. */
157     if( (p_dec->p_aout_input != NULL) &&
158         (p_dec->output_format.i_rate != p_pcm->samplerate
159            || p_dec->output_format.i_physical_channels != i_channels) )
160     {
161         /* Parameters changed - this should not happen. */
162         aout_DecDelete( p_dec->p_aout, p_dec->p_aout_input );
163         p_dec->p_aout_input = NULL;
164     }
165
166     /* Creating the audio input if not created yet. */
167     if( p_dec->p_aout_input == NULL )
168     {
169         p_dec->output_format.i_rate = p_pcm->samplerate;
170         p_dec->output_format.i_physical_channels = i_channels;
171         p_dec->output_format.i_original_channels = i_channels;
172         aout_DateInit( &p_dec->end_date, p_pcm->samplerate );
173         p_dec->p_aout_input = aout_DecNew( p_dec->p_fifo,
174                                            &p_dec->p_aout,
175                                            &p_dec->output_format );
176
177         if ( p_dec->p_aout_input == NULL )
178         {
179             p_dec->p_fifo->b_error = VLC_TRUE;
180             return MAD_FLOW_BREAK;
181         }
182     }
183
184     if( p_dec->i_current_pts )
185     {
186         /* Set the Presentation Time Stamp */
187         if( p_dec->i_current_pts != aout_DateGet( &p_dec->end_date ) )
188         {
189             aout_DateSet( &p_dec->end_date, p_dec->i_current_pts );
190         }
191
192         p_dec->i_current_pts = 0;
193     }
194     else if( p_dec->i_next_pts )
195     {
196         /* No PTS this time, but it'll be for next frame */
197         p_dec->i_current_pts = p_dec->i_next_pts;
198         p_dec->i_next_pts = 0;
199     }
200
201     if( !aout_DateGet( &p_dec->end_date ) )
202     {
203         /* No date available yet, wait for the first PTS. */
204         return MAD_FLOW_CONTINUE;
205     }
206
207     p_buffer = aout_DecNewBuffer( p_dec->p_aout, p_dec->p_aout_input, i_samples );
208
209     if ( p_buffer == NULL )
210     {
211         msg_Err( p_dec->p_fifo, "allocating new buffer failed" );
212         return MAD_FLOW_BREAK;
213     }
214
215     p_buffer->start_date = aout_DateGet( &p_dec->end_date );
216     p_buffer->end_date = aout_DateIncrement( &p_dec->end_date, i_samples );
217
218     /* Interleave and keep buffers in mad_fixed_t format */
219     p_samples = (mad_fixed_t *)p_buffer->p_buffer;
220
221     switch( p_pcm->channels )
222     {
223     case 2:
224         while( i_samples-- )
225         {
226             *p_samples++ = *p_left++;
227             *p_samples++ = *p_right++;
228         }
229         break;
230
231     case 1:
232         p_dec->p_fifo->p_vlc->pf_memcpy( p_samples, p_left,
233                                          i_samples * sizeof(mad_fixed_t) );
234         break;
235
236     default:
237         msg_Err( p_dec->p_fifo, "cannot interleave %i channels",
238                                 p_pcm->channels );
239     }
240
241     aout_DecPlay( p_dec->p_aout, p_dec->p_aout_input, p_buffer );
242
243     return MAD_FLOW_CONTINUE;
244 }
245
246 /*****************************************************************************
247  * libmad_error: this function is called when an error occurs during decoding
248  *****************************************************************************/
249 enum mad_flow libmad_error( void *p_data, struct mad_stream *p_libmad_stream,
250                             struct mad_frame *p_libmad_frame )
251 {
252     mad_adec_thread_t *p_dec = (mad_adec_thread_t *) p_data;
253     enum mad_flow result;
254     struct mad_pcm *p_pcm;
255
256     switch (p_libmad_stream->error)
257     {             
258
259     case MAD_ERROR_BADDATAPTR:        /* bad main_data_begin pointer */
260         msg_Warn( p_dec->p_fifo, "lost synchronization" );
261
262         if( p_dec->output_format.i_rate &&
263             p_dec->output_format.i_physical_channels )
264         {
265             p_pcm = malloc( sizeof(struct mad_pcm) );
266             memset( p_pcm, 0, sizeof(struct mad_pcm) );
267             p_pcm->length = 32 * MAD_NSBSAMPLES( &p_libmad_frame->header );
268             p_pcm->channels = ( p_dec->output_format.i_physical_channels ==
269                                 AOUT_CHAN_CENTER ) ? 1 : 2;
270             p_pcm->samplerate = p_dec->output_format.i_rate;
271             libmad_output( p_data, NULL, p_pcm );
272             free( p_pcm );
273         }
274         result = MAD_FLOW_CONTINUE;
275         break;
276
277     default:
278         result = MAD_FLOW_CONTINUE;
279         break;
280
281 #if 0
282     case MAD_ERROR_BUFLEN:                /* input buffer too small (or EOF) */
283         msg_Err( p_dec->p_fifo, "input buffer too small (or EOF)" );
284         result = MAD_FLOW_CONTINUE;
285         break;
286     case MAD_ERROR_BUFPTR:                /* invalid (null) buffer pointer */
287         msg_Err( p_dec->p_fifo, "invalid (null) buffer pointer" );
288         result = MAD_FLOW_STOP;
289         break;
290     case MAD_ERROR_NOMEM:                 /* not enough memory */
291         msg_Err( p_dec->p_fifo, "invalid (null) buffer pointer" );
292         result = MAD_FLOW_STOP;
293         break;
294     case MAD_ERROR_LOSTSYNC:            /* lost synchronization */
295         msg_Err( p_dec->p_fifo, "lost synchronization" );
296         result = MAD_FLOW_CONTINUE;
297         break;
298     case MAD_ERROR_BADLAYER:            /* reserved header layer value */
299         msg_Err( p_dec->p_fifo, "reserved header layer value" );
300         result = MAD_FLOW_CONTINUE;
301         break;
302     case MAD_ERROR_BADBITRATE:        /* forbidden bitrate value */
303         msg_Err( p_dec->p_fifo, "forbidden bitrate value" );
304         result = MAD_FLOW_CONTINUE;
305         break;
306     case MAD_ERROR_BADSAMPLERATE: /* reserved sample frequency value */
307         msg_Err( p_dec->p_fifo, "reserved sample frequency value" );
308         result = MAD_FLOW_CONTINUE;
309         break;
310     case MAD_ERROR_BADEMPHASIS:     /* reserved emphasis value */
311         msg_Err( p_dec->p_fifo, "reserverd emphasis value" );
312         result = MAD_FLOW_CONTINUE;
313         break;
314     case MAD_ERROR_BADCRC:                /* CRC check failed */
315         msg_Err( p_dec->p_fifo, "CRC check failed" );
316         result = MAD_FLOW_CONTINUE;
317         break;
318     case MAD_ERROR_BADBITALLOC:     /* forbidden bit allocation value */
319         msg_Err( p_dec->p_fifo, "forbidden bit allocation value" );
320         result = MAD_FLOW_IGNORE;
321         break;
322     case MAD_ERROR_BADSCALEFACTOR:/* bad scalefactor index */
323         msg_Err( p_dec->p_fifo, "bad scalefactor index" );
324         result = MAD_FLOW_CONTINUE;
325         break;
326     case MAD_ERROR_BADFRAMELEN:     /* bad frame length */
327         msg_Err( p_dec->p_fifo, "bad frame length" );
328         result = MAD_FLOW_CONTINUE;
329         break;
330     case MAD_ERROR_BADBIGVALUES:    /* bad big_values count */
331         msg_Err( p_dec->p_fifo, "bad big values count" );
332         result = MAD_FLOW_IGNORE;
333         break;
334     case MAD_ERROR_BADBLOCKTYPE:    /* reserved block_type */
335         msg_Err( p_dec->p_fifo, "reserverd block_type" );
336         result = MAD_FLOW_IGNORE;
337         break;
338     case MAD_ERROR_BADSCFSI:            /* bad scalefactor selection info */
339         msg_Err( p_dec->p_fifo, "bad scalefactor selection info" );
340         result = MAD_FLOW_CONTINUE;
341         break;
342     case MAD_ERROR_BADDATAPTR:        /* bad main_data_begin pointer */
343         msg_Err( p_dec->p_fifo, "bad main_data_begin pointer" );
344         result = MAD_FLOW_CONTINUE;
345         break;
346     case MAD_ERROR_BADPART3LEN:     /* bad audio data length */
347         msg_Err( p_dec->p_fifo, "bad audio data length" );
348         result = MAD_FLOW_IGNORE;
349         break;
350     case MAD_ERROR_BADHUFFTABLE:    /* bad Huffman table select */
351         msg_Err( p_dec->p_fifo, "bad Huffman table select" );
352         result = MAD_FLOW_IGNORE;
353         break;
354     case MAD_ERROR_BADHUFFDATA:     /* Huffman data overrun */
355         msg_Err( p_dec->p_fifo, "Huffman data overrun" );
356         result = MAD_FLOW_IGNORE;
357         break;
358     case MAD_ERROR_BADSTEREO:         /* incompatible block_type for JS */
359         msg_Err( p_dec->p_fifo, "incompatible block_type for JS" );
360         result = MAD_FLOW_IGNORE;
361         break;
362     default:
363         msg_Err( p_dec->p_fifo, "unknown error occured stopping decoder" );
364         result = MAD_FLOW_STOP;
365         break;
366 #endif
367     }
368     
369     return (MAD_RECOVERABLE(p_libmad_stream->error)? result: MAD_FLOW_STOP);
370 }
371
372 /*****************************************************************************
373  * libmad_message: this function is called to send a message
374  *****************************************************************************/
375 /* enum mad_flow libmad_message(void *, void*, unsigned int*)
376  * {
377  *     return MAD_FLOW_CONTINUE;
378  * }
379  */
380
381
382
383 /****************************************************************************
384  * Print human readable informations about an audio MPEG frame.
385  ****************************************************************************/
386 static void PrintFrameInfo(struct mad_header *Header)
387 {
388         const char      *Layer,
389                         *Mode,
390                         *Emphasis;
391
392         /* Convert the layer number to its printed representation. */
393         switch(Header->layer)
394         {
395                 case MAD_LAYER_I:
396                         Layer="I";
397                         break;
398                 case MAD_LAYER_II:
399                         Layer="II";
400                         break;
401                 case MAD_LAYER_III:
402                         Layer="III";
403                         break;
404                 default:
405                         Layer="(unexpected layer value)";
406                         break;
407         }
408
409         /* Convert the audio mode to its printed representation. */
410         switch(Header->mode)
411         {
412                 case MAD_MODE_SINGLE_CHANNEL:
413                         Mode="single channel";
414                         break;
415                 case MAD_MODE_DUAL_CHANNEL:
416                         Mode="dual channel";
417                         break;
418                 case MAD_MODE_JOINT_STEREO:
419                         Mode="joint (MS/intensity) stereo";
420                         break;
421                 case MAD_MODE_STEREO:
422                         Mode="normal LR stereo";
423                         break;
424                 default:
425                         Mode="(unexpected mode value)";
426                         break;
427         }
428
429         /* Convert the emphasis to its printed representation. */
430         switch(Header->emphasis)
431         {
432                 case MAD_EMPHASIS_NONE:
433                         Emphasis="no";
434                         break;
435                 case MAD_EMPHASIS_50_15_US:
436                         Emphasis="50/15 us";
437                         break;
438                 case MAD_EMPHASIS_CCITT_J_17:
439                         Emphasis="CCITT J.17";
440                         break;
441                 default:
442                         Emphasis="(unexpected emphasis value)";
443                         break;
444         }
445
446 //X     msg_Err("statistics: %lu kb/s audio mpeg layer %s stream %s crc, "
447 //X                     "%s with %s emphasis at %d Hz sample rate\n",
448 //X                     Header->bitrate,Layer,
449 //X                     Header->flags&MAD_FLAG_PROTECTION?"with":"without",
450 //X                     Mode,Emphasis,Header->samplerate);
451 }