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