Optimized libmad_output() for smoother sound. It is still not optimal.
[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 #include "debug.h"
35
36 /*****************************************************************************
37  * Libmad includes files
38  *****************************************************************************/
39 #include <mad.h>
40 #include "mad_adec.h"
41 #include "mad_libmad.h"
42
43 /*****************************************************************************
44  * libmad_input: this function is called by libmad when the input buffer needs
45  * to be filled.
46  *****************************************************************************/
47 enum mad_flow libmad_input(void *data, struct mad_stream *p_libmad_stream)
48 {
49     mad_adec_thread_t *p_mad_adec = (mad_adec_thread_t *) data;
50     byte_t buffer[ADEC_FRAME_SIZE];
51
52     /* Store time stamp of current frame */
53     if ( p_mad_adec->p_fifo->p_first->i_pts ) {
54          p_mad_adec->i_pts_save = p_mad_adec->p_fifo->p_first->i_pts;
55          p_mad_adec->p_fifo->p_first->i_pts = 0;
56     }
57     else {
58          p_mad_adec->i_pts_save = LAST_MDATE;
59     }
60
61     GetChunk( &p_mad_adec->bit_stream, buffer, ADEC_FRAME_SIZE );
62
63     if ( p_mad_adec->p_fifo->b_die == 1 ) {
64         intf_ErrMsg( "mad_adec error: libmad_input stopping libmad decoder" );
65         return MAD_FLOW_STOP;
66     }
67
68     if ( p_mad_adec->p_fifo->b_error == 1 ) {
69         intf_ErrMsg( "mad_adec error: libmad_input ignoring current audio frame" );     
70         return MAD_FLOW_IGNORE;
71     }
72
73     /* the length meant to be in bytes */
74     mad_stream_buffer(p_libmad_stream, (unsigned char*) &buffer, ADEC_FRAME_SIZE );
75
76     return MAD_FLOW_CONTINUE;
77 }
78
79 /*****************************************************************************
80  * libmad_header: this function is called just after the header of a frame is
81  * decoded
82  *****************************************************************************/
83 /* enum mad_flow libmad_header(void *data, struct mad_header const *p_libmad_header)
84  * {
85  *   mad_adec_thread_t *p_mad_adec = (mad_adec_thread_t *) data;
86  *
87  *   intf_ErrMsg( "mad_adec: libmad_header samplerate %d", p_libmad_header->samplerate);
88  *   intf_DbgMsg( "mad_adec: libmad_header bitrate %d", p_libmad_header->bitrate);      
89  *
90  *   p_mad_adec->p_aout_fifo->l_rate = p_libmad_header->samplerate;
91  *
92  *   return MAD_FLOW_CONTINUE;
93  * }
94  */
95
96 /*****************************************************************************
97  * lib_mad_filter: this function is called to filter data of a frame
98  *****************************************************************************/
99 /* enum mad_flow libmad_filter(void *data, struct mad_stream const *p_libmad_stream, struct mad_frame *p_libmad_frame)
100  * {
101  *      return MAD_FLOW_CONTINUE;
102  * }
103  */
104
105 //#define MPG321_ROUTINES     1
106 #ifdef MPG321_ROUTINES
107 /*****************************************************************************
108  * support routines borrowed from mpg321 (file: mad.c), which is distributed
109  * under GPL license
110  *
111  * mpg321 was written by Joe Drew <drew@debian.org>, and based upon 'plaympeg'
112  * from the smpeg sources, which was written by various people from Loki Software
113  * (http://www.lokigames.com).
114  *
115  * It also incorporates some source from mad, written by Robert Leslie
116  *****************************************************************************/
117
118 /* The following two routines and data structure are from the ever-brilliant
119      Rob Leslie.
120 */
121
122 struct audio_dither {
123     mad_fixed_t error[3];
124     mad_fixed_t random;
125 };
126
127 /*
128 * NAME:                prng()
129 * DESCRIPTION: 32-bit pseudo-random number generator
130 */
131 static __inline__ unsigned long prng(unsigned long state)
132 {
133     return (state * 0x0019660dL + 0x3c6ef35fL) & 0xffffffffL;
134 }
135
136 /*
137 * NAME:                audio_linear_dither()
138 * DESCRIPTION: generic linear sample quantize and dither routine
139 */
140 static __inline__ signed long audio_linear_dither(unsigned int bits, mad_fixed_t sample,
141                                     struct audio_dither *dither)
142 {
143     unsigned int scalebits;
144     mad_fixed_t output, mask, random;
145
146     enum {
147         MIN = -MAD_F_ONE,
148         MAX =    MAD_F_ONE - 1
149     };
150
151     /* noise shape */
152     sample += dither->error[0] - dither->error[1] + dither->error[2];
153
154     dither->error[2] = dither->error[1];
155     dither->error[1] = dither->error[0] / 2;
156
157     /* bias */
158     output = sample + (1L << (MAD_F_FRACBITS + 1 - bits - 1));
159
160     scalebits = MAD_F_FRACBITS + 1 - bits;
161     mask = (1L << scalebits) - 1;
162
163     /* dither */
164     random    = prng(dither->random);
165     output += (random & mask) - (dither->random & mask);
166
167     dither->random = random;
168
169     /* clip */
170     if (output > MAX) {
171         output = MAX;
172
173         if (sample > MAX)
174             sample = MAX;
175     }
176     else if (output < MIN) {
177         output = MIN;
178
179         if (sample < MIN)
180             sample = MIN;
181     }
182
183     /* quantize */
184     output &= ~mask;
185
186     /* error feedback */
187     dither->error[0] = sample - output;
188
189     /* scale */
190     return output >> scalebits;
191 }
192 #endif
193
194 /*****************************************************************************
195  * s24_to_s16_pcm: Scale a 24 bit pcm sample to a 16 bit pcm sample.
196  *****************************************************************************/
197 static __inline__ mad_fixed_t s24_to_s16_pcm(mad_fixed_t sample)
198 {
199   /* round */
200   sample += (1L << (MAD_F_FRACBITS - 16));
201
202   /* clip */
203   if (sample >= MAD_F_ONE)
204     sample = MAD_F_ONE - 1;
205   else if (sample < -MAD_F_ONE)
206     sample = -MAD_F_ONE;
207
208   /* quantize */
209   return sample >> (MAD_F_FRACBITS + 1 - 16);
210 }
211
212 /*****************************************************************************
213  * libmad_ouput: this function is called just after the frame is decoded
214  *****************************************************************************/
215 enum mad_flow libmad_output(void *data, struct mad_header const *p_libmad_header, struct mad_pcm *p_libmad_pcm)
216 {
217     mad_adec_thread_t *p_mad_adec= (mad_adec_thread_t *) data;
218     byte_t *buffer=NULL;
219
220     mad_fixed_t const *left_ch = p_libmad_pcm->samples[0], *right_ch = p_libmad_pcm->samples[1];
221     register int nsamples = p_libmad_pcm->length;
222     mad_fixed_t sample;
223 #ifdef MPG321_ROUTINES
224     static struct audio_dither dither;
225 #endif
226
227     /* Set timestamp to synchronize audio and video decoder fifo's */
228     vlc_mutex_lock (&p_mad_adec->p_aout_fifo->data_lock);
229     p_mad_adec->p_aout_fifo->l_rate = p_libmad_header->samplerate;
230     p_mad_adec->p_aout_fifo->date[p_mad_adec->p_aout_fifo->l_end_frame] = p_mad_adec->i_pts_save;
231
232     buffer = ((byte_t *)p_mad_adec->p_aout_fifo->buffer) + (p_mad_adec->p_aout_fifo->l_end_frame * ADEC_FRAME_SIZE);
233
234     if (p_libmad_pcm->channels == 2)
235     {
236         while (nsamples--)
237         {
238 #ifdef MPG321_ROUTINES
239             sample = audio_linear_dither(16, *left_ch++, &dither);
240 #else
241             sample = s24_to_s16_pcm(*left_ch++);
242 #endif
243
244 #ifndef WORDS_BIGENDIAN
245             *buffer++ = (byte_t) (sample) & 0xFF;
246             *buffer++ = (byte_t) (sample >> 8) & 0xFF;
247 #else
248             *buffer++ = (byte_t) (sample >> 8);
249             *buffer++ = (byte_t) (sample);
250 #endif
251             /* right audio channel */
252 #ifdef MPG321_ROUTINES
253             sample = audio_linear_dither(16, *right_ch++, &dither);
254 #else
255             sample = s24_to_s16_pcm(*right_ch++);
256 #endif
257
258 #ifndef WORDS_BIGENDIAN
259             *buffer++ = (byte_t) (sample);
260             *buffer++ = (byte_t) (sample >> 8);
261 #else
262             *buffer++ = (byte_t) (sample >> 8);
263             *buffer++ = (byte_t) (sample);
264 #endif                                          
265         }
266   }
267   else
268   {
269         while (nsamples--)
270         {
271 #ifdef MPG321_ROUTINES
272             sample = audio_linear_dither(16, *left_ch++, &dither);
273 #else
274             sample = s24_to_s16_pcm(*left_ch++);
275 #endif
276
277 #ifndef WORDS_BIGENDIAN
278             *buffer++ = (byte_t) (sample);
279             *buffer++ = (byte_t) (sample >> 8);
280 #else
281             *buffer++ = (byte_t) (sample >> 8);
282             *buffer++ = (byte_t) (sample);
283 #endif                                  
284         }
285     }
286
287 //    vlc_mutex_lock (&p_mad_adec->p_aout_fifo->data_lock);
288     p_mad_adec->p_aout_fifo->l_end_frame = (p_mad_adec->p_aout_fifo->l_end_frame + 1) & AOUT_FIFO_SIZE;
289     vlc_cond_signal (&p_mad_adec->p_aout_fifo->data_wait);
290     vlc_mutex_unlock (&p_mad_adec->p_aout_fifo->data_lock);
291
292     return MAD_FLOW_CONTINUE;
293 }
294
295 /*****************************************************************************
296  * libmad_error: this function is called when an error occurs during decoding
297  *****************************************************************************/
298 enum mad_flow libmad_error(void *data, struct mad_stream *p_libmad_stream, struct mad_frame *p_libmad_frame)
299 {
300     enum mad_flow result = MAD_FLOW_CONTINUE;
301
302     switch (p_libmad_stream->error)
303     {             
304     case MAD_ERROR_BUFLEN:                /* input buffer too small (or EOF) */
305         intf_ErrMsg("libmad error: input buffer too small (or EOF)");
306         result = MAD_FLOW_CONTINUE;
307         break;
308     case MAD_ERROR_BUFPTR:                /* invalid (null) buffer pointer */
309         intf_ErrMsg("libmad error: invalid (null) buffer pointer");
310         result = MAD_FLOW_STOP;
311         break;
312     case MAD_ERROR_NOMEM:                 /* not enough memory */
313         intf_ErrMsg("libmad error: invalid (null) buffer pointer");
314         result = MAD_FLOW_STOP;
315         break;
316     case MAD_ERROR_LOSTSYNC:            /* lost synchronization */
317         intf_ErrMsg("libmad error: lost synchronization");
318         mad_stream_sync(p_libmad_stream);
319         result = MAD_FLOW_CONTINUE;
320         break;
321     case MAD_ERROR_BADLAYER:            /* reserved header layer value */
322         intf_ErrMsg("libmad error: reserved header layer value");
323         result = MAD_FLOW_CONTINUE;
324         break;
325     case MAD_ERROR_BADBITRATE:        /* forbidden bitrate value */
326         intf_ErrMsg("libmad error: forbidden bitrate value");
327         result = MAD_FLOW_CONTINUE;
328         break;
329     case MAD_ERROR_BADSAMPLERATE: /* reserved sample frequency value */
330             intf_ErrMsg("libmad error: reserved sample frequency value");
331         result = MAD_FLOW_CONTINUE;
332         break;
333     case MAD_ERROR_BADEMPHASIS:     /* reserved emphasis value */
334         intf_ErrMsg("libmad error: reserverd emphasis value");
335         result = MAD_FLOW_CONTINUE;
336         break;
337     case MAD_ERROR_BADCRC:                /* CRC check failed */
338         intf_ErrMsg("libmad error: CRC check failed");
339         result = MAD_FLOW_CONTINUE;
340         break;
341     case MAD_ERROR_BADBITALLOC:     /* forbidden bit allocation value */
342         intf_ErrMsg("libmad error: forbidden bit allocation value");
343         result = MAD_FLOW_IGNORE;
344         break;
345     case MAD_ERROR_BADSCALEFACTOR:/* bad scalefactor index */
346         intf_ErrMsg("libmad error: bad scalefactor index");
347         result = MAD_FLOW_CONTINUE;
348         break;
349     case MAD_ERROR_BADFRAMELEN:     /* bad frame length */
350         intf_ErrMsg("libmad error: bad frame length");
351         result = MAD_FLOW_CONTINUE;
352         break;
353     case MAD_ERROR_BADBIGVALUES:    /* bad big_values count */
354         intf_ErrMsg("libmad error: bad big values count");
355         result = MAD_FLOW_IGNORE;
356         break;
357     case MAD_ERROR_BADBLOCKTYPE:    /* reserved block_type */
358         intf_ErrMsg("libmad error: reserverd block_type");
359         result = MAD_FLOW_IGNORE;
360         break;
361     case MAD_ERROR_BADSCFSI:            /* bad scalefactor selection info */
362         intf_ErrMsg("libmad error: bad scalefactor selection info");
363         result = MAD_FLOW_CONTINUE;
364         break;
365     case MAD_ERROR_BADDATAPTR:        /* bad main_data_begin pointer */
366         intf_ErrMsg("libmad error: bad main_data_begin pointer");
367         result = MAD_FLOW_STOP;
368         break;
369     case MAD_ERROR_BADPART3LEN:     /* bad audio data length */
370         intf_ErrMsg("libmad error: bad audio data length");
371         result = MAD_FLOW_IGNORE;
372         break;
373     case MAD_ERROR_BADHUFFTABLE:    /* bad Huffman table select */
374         intf_ErrMsg("libmad error: bad Huffman table select");
375         result = MAD_FLOW_IGNORE;
376         break;
377     case MAD_ERROR_BADHUFFDATA:     /* Huffman data overrun */
378         intf_ErrMsg("libmad error: Huffman data overrun");
379         result = MAD_FLOW_IGNORE;
380         break;
381     case MAD_ERROR_BADSTEREO:         /* incompatible block_type for JS */
382         intf_ErrMsg("libmad error: incompatible block_type for JS");
383         result = MAD_FLOW_IGNORE;
384         break;
385     default:
386         intf_ErrMsg("libmad error: unknown error occured stopping decoder");
387         result = MAD_FLOW_STOP;
388         break;
389     }
390     
391     //return (MAD_RECOVERABLE(p_libmad_stream->error)? result: MAD_FLOW_STOP);
392     return (MAD_FLOW_CONTINUE);
393 }
394
395 /*****************************************************************************
396  * libmad_message: this function is called to send a message
397  *****************************************************************************/
398 /* enum mad_flow libmad_message(void *, void*, unsigned int*)
399  * {
400  *     return MAD_FLOW_CONTINUE;
401  * }
402  */
403
404