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