* ./modules/*: moved plugins to the new tree. Yet untested builds include
[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 *data, struct mad_stream *p_libmad_stream)
45 {
46     mad_adec_thread_t *p_mad_adec = (mad_adec_thread_t *) data;
47     size_t             ReadSize, Remaining;
48     unsigned char     *ReadStart;
49
50     if ( p_mad_adec->p_fifo->b_die == 1 ) {
51         msg_Dbg( p_mad_adec->p_fifo, "libmad_input stopping libmad decoder" );
52         return MAD_FLOW_STOP;
53     }
54
55     if ( p_mad_adec->p_fifo->b_error == 1 ) {
56         msg_Warn( p_mad_adec->p_fifo, "libmad_input ignoring current audio frame" );
57         return MAD_FLOW_IGNORE;
58     }
59
60     /* libmad_stream_buffer does not consume the total buffer, it consumes only data
61      * for one frame only. So all data left in the buffer should be put back in front.
62      */
63     if ((p_libmad_stream->buffer==NULL) || (p_libmad_stream->error==MAD_ERROR_BUFLEN))
64     {
65         /* libmad does not consume all the buffer it's given. Some
66          * datas, part of a truncated frame, is left unused at the
67          * end of the buffer. Those datas must be put back at the
68          * beginning of the buffer and taken in account for
69          * refilling the buffer. This means that the input buffer
70          * must be large enough to hold a complete frame at the
71          * highest observable bit-rate (currently 448 kb/s). XXX=XXX
72          * Is 2016 bytes the size of the largest frame?
73          * (448000*(1152/32000))/8
74          */
75         if(p_libmad_stream->next_frame!=NULL)
76         {
77             Remaining=p_libmad_stream->bufend-p_libmad_stream->next_frame;
78             if( p_mad_adec->buffer != p_libmad_stream->next_frame )
79             {
80                 memcpy( p_mad_adec->buffer,
81                         p_libmad_stream->next_frame, Remaining );
82             }
83             ReadStart=p_mad_adec->buffer+Remaining;
84             ReadSize=(MAD_BUFFER_MDLEN)-Remaining;
85
86             /* Store time stamp of next frame */
87             p_mad_adec->i_current_pts = p_mad_adec->i_next_pts;
88             p_mad_adec->i_next_pts = p_mad_adec->p_fifo->p_first->i_pts;
89         }
90         else
91         {
92             ReadSize=(MAD_BUFFER_MDLEN);
93             ReadStart=p_mad_adec->buffer;
94             Remaining=0;
95             p_mad_adec->i_next_pts = 0;
96             p_mad_adec->i_current_pts = p_mad_adec->p_fifo->p_first->i_pts;
97         }
98
99         /* Fill-in the buffer. If an error occurs print a message
100          * and leave the decoding loop. If the end of stream is
101          * reached we also leave the loop but the return status is
102          * left untouched.
103          */
104         if( ReadSize > p_mad_adec->p_data->p_payload_end
105                         - p_mad_adec->p_data->p_payload_start )
106         {
107             ReadSize = p_mad_adec->p_data->p_payload_end
108                         - p_mad_adec->p_data->p_payload_start;
109             memcpy( ReadStart, p_mad_adec->p_data->p_payload_start, ReadSize );
110             NextDataPacket( p_mad_adec->p_fifo, &p_mad_adec->p_data );
111         }
112         else
113         {
114             memcpy( ReadStart, p_mad_adec->p_data->p_payload_start, ReadSize );
115             p_mad_adec->p_data->p_payload_start += ReadSize;
116         }
117
118         if ( p_mad_adec->p_fifo->b_die == 1 )
119         {
120             msg_Dbg( p_mad_adec->p_fifo, "libmad_input stopping libmad decoder" );
121             return MAD_FLOW_STOP;
122         }
123
124         if ( p_mad_adec->p_fifo->b_error == 1 )
125         {
126             msg_Warn( p_mad_adec->p_fifo, "libmad_input ignoring current audio frame" );    
127             return MAD_FLOW_IGNORE;
128         }
129
130         /* Pipe the new buffer content to libmad's stream decoder facility.
131          * Libmad never copies the buffer, but just references it. So keep it in
132          * mad_adec_thread_t structure.
133          */
134         mad_stream_buffer(p_libmad_stream,(unsigned char*) &p_mad_adec->buffer,
135                           Remaining + ReadSize);
136         p_libmad_stream->error=0;
137     }
138
139     return MAD_FLOW_CONTINUE;
140 }
141
142 /*****************************************************************************
143  * libmad_header: this function is called just after the header of a frame is
144  * decoded
145  *****************************************************************************/
146 /*
147  *enum mad_flow libmad_header(void *data, struct mad_header const *p_libmad_header)
148  *{
149  *   mad_adec_thread_t *p_mad_adec = (mad_adec_thread_t *) data;
150  *
151  *   msg_Err( p_mad_adec->p_fifo, "libmad_header samplerate %d", p_libmad_header->samplerate);
152  *
153  *   PrintFrameInfo(p_limad_mad_header)
154  *   return MAD_FLOW_CONTINUE;
155  *}
156  */
157
158 /*****************************************************************************
159  * lib_mad_filter: this function is called to filter data of a frame
160  *****************************************************************************/
161 /* enum mad_flow libmad_filter(void *data, struct mad_stream const *p_libmad_stream, struct mad_frame *p_libmad_frame)
162  * {
163  *      return MAD_FLOW_CONTINUE;
164  * }
165  */
166
167 /*****************************************************************************
168  * support routines borrowed from mpg321 (file: mad.c), which is distributed
169  * under GPL license
170  *
171  * mpg321 was written by Joe Drew <drew@debian.org>, and based upon 'plaympeg'
172  * from the smpeg sources, which was written by various people from Loki Software
173  * (http://www.lokigames.com).
174  *
175  * It also incorporates some source from mad, written by Robert Leslie
176  *****************************************************************************/
177
178 /* The following two routines and data structure are from the ever-brilliant
179      Rob Leslie.
180 */
181
182 struct audio_dither {
183     mad_fixed_t error[3];
184     mad_fixed_t random;
185 };
186
187 /*
188 * NAME:                prng()
189 * DESCRIPTION: 32-bit pseudo-random number generator
190 */
191 static inline unsigned long prng(unsigned long state)
192 {
193     return (state * 0x0019660dL + 0x3c6ef35fL) & 0xffffffffL;
194 }
195
196 /*
197 * NAME:        mpg321_s24_to_s16_pcm()
198 * DESCRIPTION: generic linear sample quantize and dither routine
199 */
200 static inline signed int mpg321_s24_to_s16_pcm(unsigned int bits, mad_fixed_t sample,
201                                     struct audio_dither *dither)
202 {
203     unsigned int scalebits;
204     mad_fixed_t output, mask, random;
205
206     enum {
207         MIN = -MAD_F_ONE,
208         MAX = MAD_F_ONE - 1
209     };
210
211     /* noise shape */
212     sample += dither->error[0] - dither->error[1] + dither->error[2];
213
214     dither->error[2] = dither->error[1];
215     dither->error[1] = dither->error[0] / 2;
216
217     /* bias */
218     output = sample + (1L << (MAD_F_FRACBITS + 1 - bits - 1));
219
220     scalebits = MAD_F_FRACBITS + 1 - bits;
221     mask = (1L << scalebits) - 1;
222
223     /* dither */
224     random    = prng(dither->random);
225     output += (random & mask) - (dither->random & mask);
226
227     dither->random = random;
228
229     /* clip */
230     if (output > MAX) {
231         output = MAX;
232
233         if (sample > MAX)
234             sample = MAX;
235     }
236     else if (output < MIN) {
237         output = MIN;
238
239         if (sample < MIN)
240             sample = MIN;
241     }
242
243     /* quantize */
244     output &= ~mask;
245
246     /* error feedback */
247     dither->error[0] = sample - output;
248
249     /* scale */
250     return output >> scalebits;
251 }
252
253 /*****************************************************************************
254  * s24_to_s16_pcm: Scale a 24 bit pcm sample to a 16 bit pcm sample.
255  *****************************************************************************/
256 static inline mad_fixed_t s24_to_s16_pcm(mad_fixed_t sample)
257 {
258   /* round */
259   sample += (1L << (MAD_F_FRACBITS - 16));
260
261   /* clip */
262   if (sample >= MAD_F_ONE)
263     sample = MAD_F_ONE - 1;
264   else if (sample < -MAD_F_ONE)
265     sample = -MAD_F_ONE;
266
267   /* quantize */
268   return sample >> (MAD_F_FRACBITS + 1 - 16);
269 }
270
271 /*****************************************************************************
272  * libmad_ouput: this function is called just after the frame is decoded
273  *****************************************************************************/
274 enum mad_flow libmad_output(void *data, struct mad_header const *p_libmad_header, struct mad_pcm *p_libmad_pcm)
275 {
276     mad_adec_thread_t *p_mad_adec= (mad_adec_thread_t *) data;
277     byte_t *buffer=NULL;
278     mad_fixed_t const *left_ch = p_libmad_pcm->samples[0], *right_ch = p_libmad_pcm->samples[1];
279     register int nsamples = p_libmad_pcm->length;
280     mad_fixed_t sample;
281     static struct audio_dither dither;
282
283     /* Creating the audio output fifo.
284      * Assume the samplerate and nr of channels from the first decoded frame is right for the entire audio track.
285      */
286     if (p_mad_adec->p_aout_fifo==NULL)
287     {
288         p_mad_adec->p_aout_fifo = aout_CreateFifo(
289                 p_mad_adec->p_fifo,
290                 AOUT_FIFO_PCM,              /* fifo type */
291                 2, /*p_libmad_pcm->channels,*/     /* nr. of channels */
292                 p_libmad_pcm->samplerate,   /* frame rate in Hz ?*/
293                 p_libmad_pcm->length*2,     /* length of output buffer *2 channels*/
294                 NULL  );                    /* buffer */
295
296         if ( p_mad_adec->p_aout_fifo == NULL )
297         {
298                 return MAD_FLOW_BREAK;
299         }
300
301         msg_Dbg( p_mad_adec->p_fifo, "aout fifo created");
302     }
303
304     if (p_mad_adec->p_aout_fifo->i_rate != p_libmad_pcm->samplerate)
305     {
306         msg_Warn( p_mad_adec->p_fifo, "samplerate is changing from [%d] Hz "
307                   "to [%d] Hz, sample size [%d], error_code [%0x]",
308                   p_mad_adec->p_aout_fifo->i_rate, p_libmad_pcm->samplerate,
309                   p_libmad_pcm->length,
310                   p_mad_adec->libmad_decoder->sync->stream.error );
311         p_mad_adec->p_aout_fifo->i_rate = p_libmad_pcm->samplerate;
312     }
313
314     if( p_mad_adec->i_current_pts )
315     {
316         p_mad_adec->p_aout_fifo->date[p_mad_adec->p_aout_fifo->i_end_frame]
317                 = p_mad_adec->i_current_pts;
318     }
319     else
320     {
321         p_mad_adec->p_aout_fifo->date[p_mad_adec->p_aout_fifo->i_end_frame]
322                 = LAST_MDATE;
323     }
324 //    mad_timer_add(&p_mad_adec->libmad_timer,p_libmad_header->duration);
325
326     buffer = ((byte_t *)p_mad_adec->p_aout_fifo->buffer) + (p_mad_adec->p_aout_fifo->i_end_frame * (p_libmad_pcm->length*4));
327
328     while (nsamples--)
329     {
330         switch (p_mad_adec->audio_scaling)
331         {
332           case MPG321_SCALING:
333                sample = mpg321_s24_to_s16_pcm(16, *left_ch++, &dither);
334           break;
335           case FAST_SCALING: /* intended fall through */
336           default:
337                sample = s24_to_s16_pcm(*left_ch++);
338           break;
339                           }
340
341         /* left audio channel */
342 #ifndef WORDS_BIGENDIAN
343         *buffer++ = (byte_t) (sample >> 0);
344         *buffer++ = (byte_t) (sample >> 8);
345 #else
346           *buffer++ = (byte_t) (sample >> 8);
347           *buffer++ = (byte_t) (sample >> 0);
348 #endif
349         if (p_libmad_pcm->channels == 2)
350         {
351             /* right audio channel */
352             switch (p_mad_adec->audio_scaling)
353             {
354               case MPG321_SCALING:
355                    sample = mpg321_s24_to_s16_pcm(16, *right_ch++, &dither);
356               break;
357               case FAST_SCALING: /* intended fall through */
358               default:
359                    sample = s24_to_s16_pcm(*right_ch++);
360               break;
361                           }
362         }
363         /* else reuse left_ch */
364 #ifndef WORDS_BIGENDIAN
365         *buffer++ = (byte_t) (sample >> 0);
366         *buffer++ = (byte_t) (sample >> 8);
367 #else
368         *buffer++ = (byte_t) (sample >> 8);
369         *buffer++ = (byte_t) (sample >> 0);
370 #endif                                          
371     }
372
373     /* DEBUG */
374     /*
375     if (p_libmad_pcm->channels == 1) {
376        msg_Dbg( p_mad_adec->p_fifo, "libmad_output channels [%d]", p_libmad_pcm->channels);
377     }
378     */
379
380     vlc_mutex_lock (&p_mad_adec->p_aout_fifo->data_lock);
381     p_mad_adec->p_aout_fifo->i_end_frame = (p_mad_adec->p_aout_fifo->i_end_frame + 1) & AOUT_FIFO_SIZE;
382     vlc_cond_signal (&p_mad_adec->p_aout_fifo->data_wait);
383     vlc_mutex_unlock (&p_mad_adec->p_aout_fifo->data_lock);
384
385     return MAD_FLOW_CONTINUE;
386 }
387
388 /*****************************************************************************
389  * libmad_error: this function is called when an error occurs during decoding
390  *****************************************************************************/
391 enum mad_flow libmad_error(void *data, struct mad_stream *p_libmad_stream, struct mad_frame *p_libmad_frame)
392 {
393     enum mad_flow result = MAD_FLOW_CONTINUE;
394
395     switch (p_libmad_stream->error)
396     {             
397     case MAD_ERROR_BUFLEN:                /* input buffer too small (or EOF) */
398 //X        intf_ErrMsg("libmad error: input buffer too small (or EOF)");
399         result = MAD_FLOW_CONTINUE;
400         break;
401     case MAD_ERROR_BUFPTR:                /* invalid (null) buffer pointer */
402 //X        intf_ErrMsg("libmad error: invalid (null) buffer pointer");
403         result = MAD_FLOW_STOP;
404         break;
405     case MAD_ERROR_NOMEM:                 /* not enough memory */
406 //X        intf_ErrMsg("libmad error: invalid (null) buffer pointer");
407         result = MAD_FLOW_STOP;
408         break;
409     case MAD_ERROR_LOSTSYNC:            /* lost synchronization */
410 //X        intf_ErrMsg("libmad error: lost synchronization");
411         mad_stream_sync(p_libmad_stream);
412         result = MAD_FLOW_CONTINUE;
413         break;
414     case MAD_ERROR_BADLAYER:            /* reserved header layer value */
415 //X        intf_ErrMsg("libmad error: reserved header layer value");
416         result = MAD_FLOW_CONTINUE;
417         break;
418     case MAD_ERROR_BADBITRATE:        /* forbidden bitrate value */
419 //X        intf_ErrMsg("libmad error: forbidden bitrate value");
420         result = MAD_FLOW_CONTINUE;
421         break;
422     case MAD_ERROR_BADSAMPLERATE: /* reserved sample frequency value */
423 //X        intf_ErrMsg("libmad error: reserved sample frequency value");
424         result = MAD_FLOW_CONTINUE;
425         break;
426     case MAD_ERROR_BADEMPHASIS:     /* reserved emphasis value */
427 //X        intf_ErrMsg("libmad error: reserverd emphasis value");
428         result = MAD_FLOW_CONTINUE;
429         break;
430     case MAD_ERROR_BADCRC:                /* CRC check failed */
431 //X        intf_ErrMsg("libmad error: CRC check failed");
432         result = MAD_FLOW_CONTINUE;
433         break;
434     case MAD_ERROR_BADBITALLOC:     /* forbidden bit allocation value */
435 //X        intf_ErrMsg("libmad error: forbidden bit allocation value");
436         result = MAD_FLOW_IGNORE;
437         break;
438     case MAD_ERROR_BADSCALEFACTOR:/* bad scalefactor index */
439 //X        intf_ErrMsg("libmad error: bad scalefactor index");
440         result = MAD_FLOW_CONTINUE;
441         break;
442     case MAD_ERROR_BADFRAMELEN:     /* bad frame length */
443 //X        intf_ErrMsg("libmad error: bad frame length");
444         result = MAD_FLOW_CONTINUE;
445         break;
446     case MAD_ERROR_BADBIGVALUES:    /* bad big_values count */
447 //X        intf_ErrMsg("libmad error: bad big values count");
448         result = MAD_FLOW_IGNORE;
449         break;
450     case MAD_ERROR_BADBLOCKTYPE:    /* reserved block_type */
451 //X        intf_ErrMsg("libmad error: reserverd block_type");
452         result = MAD_FLOW_IGNORE;
453         break;
454     case MAD_ERROR_BADSCFSI:            /* bad scalefactor selection info */
455 //X        intf_ErrMsg("libmad error: bad scalefactor selection info");
456         result = MAD_FLOW_CONTINUE;
457         break;
458     case MAD_ERROR_BADDATAPTR:        /* bad main_data_begin pointer */
459 //X        intf_ErrMsg("libmad error: bad main_data_begin pointer");
460         result = MAD_FLOW_STOP;
461         break;
462     case MAD_ERROR_BADPART3LEN:     /* bad audio data length */
463 //X        intf_ErrMsg("libmad error: bad audio data length");
464         result = MAD_FLOW_IGNORE;
465         break;
466     case MAD_ERROR_BADHUFFTABLE:    /* bad Huffman table select */
467 //X        intf_ErrMsg("libmad error: bad Huffman table select");
468         result = MAD_FLOW_IGNORE;
469         break;
470     case MAD_ERROR_BADHUFFDATA:     /* Huffman data overrun */
471 //X        intf_ErrMsg("libmad error: Huffman data overrun");
472         result = MAD_FLOW_IGNORE;
473         break;
474     case MAD_ERROR_BADSTEREO:         /* incompatible block_type for JS */
475 //X        intf_ErrMsg("libmad error: incompatible block_type for JS");
476         result = MAD_FLOW_IGNORE;
477         break;
478     default:
479 //X        intf_ErrMsg("libmad error: unknown error occured stopping decoder");
480         result = MAD_FLOW_STOP;
481         break;
482     }
483     
484     return (MAD_RECOVERABLE(p_libmad_stream->error)? result: MAD_FLOW_STOP);
485     //return (MAD_FLOW_CONTINUE);
486 }
487
488 /*****************************************************************************
489  * libmad_message: this function is called to send a message
490  *****************************************************************************/
491 /* enum mad_flow libmad_message(void *, void*, unsigned int*)
492  * {
493  *     return MAD_FLOW_CONTINUE;
494  * }
495  */
496
497
498
499 /****************************************************************************
500  * Print human readable informations about an audio MPEG frame.                         *
501  ****************************************************************************/
502 static void PrintFrameInfo(struct mad_header *Header)
503 {
504         const char      *Layer,
505                         *Mode,
506                         *Emphasis;
507
508         /* Convert the layer number to it's printed representation. */
509         switch(Header->layer)
510         {
511                 case MAD_LAYER_I:
512                         Layer="I";
513                         break;
514                 case MAD_LAYER_II:
515                         Layer="II";
516                         break;
517                 case MAD_LAYER_III:
518                         Layer="III";
519                         break;
520                 default:
521                         Layer="(unexpected layer value)";
522                         break;
523         }
524
525         /* Convert the audio mode to it's printed representation. */
526         switch(Header->mode)
527         {
528                 case MAD_MODE_SINGLE_CHANNEL:
529                         Mode="single channel";
530                         break;
531                 case MAD_MODE_DUAL_CHANNEL:
532                         Mode="dual channel";
533                         break;
534                 case MAD_MODE_JOINT_STEREO:
535                         Mode="joint (MS/intensity) stereo";
536                         break;
537                 case MAD_MODE_STEREO:
538                         Mode="normal LR stereo";
539                         break;
540                 default:
541                         Mode="(unexpected mode value)";
542                         break;
543         }
544
545         /* Convert the emphasis to it's printed representation. */
546         switch(Header->emphasis)
547         {
548                 case MAD_EMPHASIS_NONE:
549                         Emphasis="no";
550                         break;
551                 case MAD_EMPHASIS_50_15_US:
552                         Emphasis="50/15 us";
553                         break;
554                 case MAD_EMPHASIS_CCITT_J_17:
555                         Emphasis="CCITT J.17";
556                         break;
557                 default:
558                         Emphasis="(unexpected emphasis value)";
559                         break;
560         }
561
562 //X     intf_ErrMsg("statistics: %lu kb/s audio mpeg layer %s stream %s crc, "
563 //X                     "%s with %s emphasis at %d Hz sample rate\n",
564 //X                     Header->bitrate,Layer,
565 //X                     Header->flags&MAD_FLAG_PROTECTION?"with":"without",
566 //X                     Mode,Emphasis,Header->samplerate);
567 }