Removed aout_CreateFifo from mad_adec.c InitThread() and added it to mad_libmad.c...
[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     /* Creating the audio output fifo */
228     if (p_mad_adec->p_aout_fifo==NULL) {
229         p_mad_adec->p_aout_fifo = aout_CreateFifo(  
230                 AOUT_ADEC_STEREO_FIFO,          /* fifo type */
231                 p_libmad_pcm->channels,         /* nr. of channels */
232                 p_libmad_pcm->samplerate,       /* frame rate in Hz ?*/
233                 0,                              /* units */
234                 ADEC_FRAME_SIZE/2,              /* frame size */
235                 NULL  );                        /* buffer */
236
237         if ( p_mad_adec->p_aout_fifo == NULL )
238         {
239                 return( -1 );
240         }
241
242         intf_ErrMsg("mad_adec debug: in libmad_output aout fifo created");
243     }
244
245     /* Set timestamp to synchronize audio and video decoder fifo's */
246     vlc_mutex_lock (&p_mad_adec->p_aout_fifo->data_lock);
247     p_mad_adec->p_aout_fifo->l_rate = p_libmad_header->samplerate;
248     p_mad_adec->p_aout_fifo->date[p_mad_adec->p_aout_fifo->l_end_frame] = p_mad_adec->i_pts_save;
249
250     buffer = ((byte_t *)p_mad_adec->p_aout_fifo->buffer) + (p_mad_adec->p_aout_fifo->l_end_frame * ADEC_FRAME_SIZE);
251
252     while (nsamples--)
253     {
254 #ifdef MPG321_ROUTINES
255         sample = audio_linear_dither(16, *left_ch++, &dither);
256 #else
257         sample = s24_to_s16_pcm(*left_ch++);
258 #endif
259
260 #ifndef WORDS_BIGENDIAN
261         *buffer++ = (byte_t) (sample) & 0xFF;
262         *buffer++ = (byte_t) (sample >> 8) & 0xFF;
263 #else
264         *buffer++ = (byte_t) (sample >> 8);
265         *buffer++ = (byte_t) (sample);
266 #endif
267         if (p_libmad_pcm->channels == 2) {
268
269             /* right audio channel */
270 #ifdef MPG321_ROUTINES
271             sample = audio_linear_dither(16, *right_ch++, &dither);
272 #else
273             sample = s24_to_s16_pcm(*right_ch++);
274 #endif
275
276 #ifndef WORDS_BIGENDIAN
277             *buffer++ = (byte_t) (sample) & 0xFF;
278             *buffer++ = (byte_t) (sample >> 8) & 0xFF;
279 #else
280             *buffer++ = (byte_t) (sample >> 8);
281             *buffer++ = (byte_t) (sample);
282 #endif                                          
283         }
284     }
285
286 //    vlc_mutex_lock (&p_mad_adec->p_aout_fifo->data_lock);
287     p_mad_adec->p_aout_fifo->l_end_frame = (p_mad_adec->p_aout_fifo->l_end_frame + 1) & AOUT_FIFO_SIZE;
288     vlc_cond_signal (&p_mad_adec->p_aout_fifo->data_wait);
289     vlc_mutex_unlock (&p_mad_adec->p_aout_fifo->data_lock);
290
291     return MAD_FLOW_CONTINUE;
292 }
293
294 /*****************************************************************************
295  * libmad_error: this function is called when an error occurs during decoding
296  *****************************************************************************/
297 enum mad_flow libmad_error(void *data, struct mad_stream *p_libmad_stream, struct mad_frame *p_libmad_frame)
298 {
299     enum mad_flow result = MAD_FLOW_CONTINUE;
300
301     switch (p_libmad_stream->error)
302     {             
303     case MAD_ERROR_BUFLEN:                /* input buffer too small (or EOF) */
304         intf_ErrMsg("libmad error: input buffer too small (or EOF)");
305         result = MAD_FLOW_CONTINUE;
306         break;
307     case MAD_ERROR_BUFPTR:                /* invalid (null) buffer pointer */
308         intf_ErrMsg("libmad error: invalid (null) buffer pointer");
309         result = MAD_FLOW_STOP;
310         break;
311     case MAD_ERROR_NOMEM:                 /* not enough memory */
312         intf_ErrMsg("libmad error: invalid (null) buffer pointer");
313         result = MAD_FLOW_STOP;
314         break;
315     case MAD_ERROR_LOSTSYNC:            /* lost synchronization */
316         intf_ErrMsg("libmad error: lost synchronization");
317         mad_stream_sync(p_libmad_stream);
318         result = MAD_FLOW_CONTINUE;
319         break;
320     case MAD_ERROR_BADLAYER:            /* reserved header layer value */
321         intf_ErrMsg("libmad error: reserved header layer value");
322         result = MAD_FLOW_CONTINUE;
323         break;
324     case MAD_ERROR_BADBITRATE:        /* forbidden bitrate value */
325         intf_ErrMsg("libmad error: forbidden bitrate value");
326         result = MAD_FLOW_CONTINUE;
327         break;
328     case MAD_ERROR_BADSAMPLERATE: /* reserved sample frequency value */
329             intf_ErrMsg("libmad error: reserved sample frequency value");
330         result = MAD_FLOW_CONTINUE;
331         break;
332     case MAD_ERROR_BADEMPHASIS:     /* reserved emphasis value */
333         intf_ErrMsg("libmad error: reserverd emphasis value");
334         result = MAD_FLOW_CONTINUE;
335         break;
336     case MAD_ERROR_BADCRC:                /* CRC check failed */
337         intf_ErrMsg("libmad error: CRC check failed");
338         result = MAD_FLOW_CONTINUE;
339         break;
340     case MAD_ERROR_BADBITALLOC:     /* forbidden bit allocation value */
341         intf_ErrMsg("libmad error: forbidden bit allocation value");
342         result = MAD_FLOW_IGNORE;
343         break;
344     case MAD_ERROR_BADSCALEFACTOR:/* bad scalefactor index */
345         intf_ErrMsg("libmad error: bad scalefactor index");
346         result = MAD_FLOW_CONTINUE;
347         break;
348     case MAD_ERROR_BADFRAMELEN:     /* bad frame length */
349         intf_ErrMsg("libmad error: bad frame length");
350         result = MAD_FLOW_CONTINUE;
351         break;
352     case MAD_ERROR_BADBIGVALUES:    /* bad big_values count */
353         intf_ErrMsg("libmad error: bad big values count");
354         result = MAD_FLOW_IGNORE;
355         break;
356     case MAD_ERROR_BADBLOCKTYPE:    /* reserved block_type */
357         intf_ErrMsg("libmad error: reserverd block_type");
358         result = MAD_FLOW_IGNORE;
359         break;
360     case MAD_ERROR_BADSCFSI:            /* bad scalefactor selection info */
361         intf_ErrMsg("libmad error: bad scalefactor selection info");
362         result = MAD_FLOW_CONTINUE;
363         break;
364     case MAD_ERROR_BADDATAPTR:        /* bad main_data_begin pointer */
365         intf_ErrMsg("libmad error: bad main_data_begin pointer");
366         result = MAD_FLOW_STOP;
367         break;
368     case MAD_ERROR_BADPART3LEN:     /* bad audio data length */
369         intf_ErrMsg("libmad error: bad audio data length");
370         result = MAD_FLOW_IGNORE;
371         break;
372     case MAD_ERROR_BADHUFFTABLE:    /* bad Huffman table select */
373         intf_ErrMsg("libmad error: bad Huffman table select");
374         result = MAD_FLOW_IGNORE;
375         break;
376     case MAD_ERROR_BADHUFFDATA:     /* Huffman data overrun */
377         intf_ErrMsg("libmad error: Huffman data overrun");
378         result = MAD_FLOW_IGNORE;
379         break;
380     case MAD_ERROR_BADSTEREO:         /* incompatible block_type for JS */
381         intf_ErrMsg("libmad error: incompatible block_type for JS");
382         result = MAD_FLOW_IGNORE;
383         break;
384     default:
385         intf_ErrMsg("libmad error: unknown error occured stopping decoder");
386         result = MAD_FLOW_STOP;
387         break;
388     }
389     
390     //return (MAD_RECOVERABLE(p_libmad_stream->error)? result: MAD_FLOW_STOP);
391     return (MAD_FLOW_CONTINUE);
392 }
393
394 /*****************************************************************************
395  * libmad_message: this function is called to send a message
396  *****************************************************************************/
397 /* enum mad_flow libmad_message(void *, void*, unsigned int*)
398  * {
399  *     return MAD_FLOW_CONTINUE;
400  * }
401  */
402
403