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