1 /***************************************************************************
2 mad_libmad.c - description
4 Functions that are called by libmad to communicate with vlc decoder
8 copyright : (C) 2001 by Jean-Paul Saman
10 ***************************************************************************/
12 /***************************************************************************
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. *
19 ***************************************************************************/
21 /*****************************************************************************
23 *****************************************************************************/
24 #include <stdlib.h> /* malloc(), free() */
25 #include <string.h> /* strdup() */
27 #include <videolan/vlc.h>
29 #include "audio_output.h"
31 #include "stream_control.h"
32 #include "input_ext-dec.h"
36 /*****************************************************************************
37 * Libmad includes files
38 *****************************************************************************/
41 #include "mad_libmad.h"
43 /*****************************************************************************
44 * libmad_input: this function is called by libmad when the input buffer needs
46 *****************************************************************************/
47 enum mad_flow libmad_input(void *data, struct mad_stream *p_libmad_stream)
49 mad_adec_thread_t *p_mad_adec = (mad_adec_thread_t *) data;
50 byte_t buffer[ADEC_FRAME_SIZE];
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;
58 p_mad_adec->i_pts_save = LAST_MDATE;
61 GetChunk( &p_mad_adec->bit_stream, buffer, ADEC_FRAME_SIZE );
63 if ( p_mad_adec->p_fifo->b_die == 1 ) {
64 intf_ErrMsg( "mad_adec error: libmad_input stopping libmad decoder" );
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;
73 /* the length meant to be in bytes */
74 mad_stream_buffer(p_libmad_stream, (unsigned char*) &buffer, ADEC_FRAME_SIZE );
76 return MAD_FLOW_CONTINUE;
79 /*****************************************************************************
80 * libmad_header: this function is called just after the header of a frame is
82 *****************************************************************************/
83 /* enum mad_flow libmad_header(void *data, struct mad_header const *p_libmad_header)
85 * mad_adec_thread_t *p_mad_adec = (mad_adec_thread_t *) data;
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);
90 * p_mad_adec->p_aout_fifo->l_rate = p_libmad_header->samplerate;
92 * return MAD_FLOW_CONTINUE;
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)
101 * return MAD_FLOW_CONTINUE;
105 //#define MPG321_ROUTINES 1
106 #ifdef MPG321_ROUTINES
107 /*****************************************************************************
108 * support routines borrowed from mpg321 (file: mad.c), which is distributed
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).
115 * It also incorporates some source from mad, written by Robert Leslie
116 *****************************************************************************/
118 /* The following two routines and data structure are from the ever-brilliant
122 struct audio_dither {
123 mad_fixed_t error[3];
129 * DESCRIPTION: 32-bit pseudo-random number generator
131 static __inline__ unsigned long prng(unsigned long state)
133 return (state * 0x0019660dL + 0x3c6ef35fL) & 0xffffffffL;
137 * NAME: audio_linear_dither()
138 * DESCRIPTION: generic linear sample quantize and dither routine
140 static __inline__ signed long audio_linear_dither(unsigned int bits, mad_fixed_t sample,
141 struct audio_dither *dither)
143 unsigned int scalebits;
144 mad_fixed_t output, mask, random;
152 sample += dither->error[0] - dither->error[1] + dither->error[2];
154 dither->error[2] = dither->error[1];
155 dither->error[1] = dither->error[0] / 2;
158 output = sample + (1L << (MAD_F_FRACBITS + 1 - bits - 1));
160 scalebits = MAD_F_FRACBITS + 1 - bits;
161 mask = (1L << scalebits) - 1;
164 random = prng(dither->random);
165 output += (random & mask) - (dither->random & mask);
167 dither->random = random;
176 else if (output < MIN) {
187 dither->error[0] = sample - output;
190 return output >> scalebits;
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)
200 sample += (1L << (MAD_F_FRACBITS - 16));
203 if (sample >= MAD_F_ONE)
204 sample = MAD_F_ONE - 1;
205 else if (sample < -MAD_F_ONE)
209 return sample >> (MAD_F_FRACBITS + 1 - 16);
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)
217 mad_adec_thread_t *p_mad_adec= (mad_adec_thread_t *) data;
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;
223 #ifdef MPG321_ROUTINES
224 static struct audio_dither dither;
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 ?*/
234 ADEC_FRAME_SIZE/2, /* frame size */
237 if ( p_mad_adec->p_aout_fifo == NULL )
242 intf_ErrMsg("mad_adec debug: in libmad_output aout fifo created");
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;
250 buffer = ((byte_t *)p_mad_adec->p_aout_fifo->buffer) + (p_mad_adec->p_aout_fifo->l_end_frame * ADEC_FRAME_SIZE);
254 #ifdef MPG321_ROUTINES
255 sample = audio_linear_dither(16, *left_ch++, &dither);
257 sample = s24_to_s16_pcm(*left_ch++);
260 #ifndef WORDS_BIGENDIAN
261 *buffer++ = (byte_t) (sample) & 0xFF;
262 *buffer++ = (byte_t) (sample >> 8) & 0xFF;
264 *buffer++ = (byte_t) (sample >> 8);
265 *buffer++ = (byte_t) (sample);
267 if (p_libmad_pcm->channels == 2) {
269 /* right audio channel */
270 #ifdef MPG321_ROUTINES
271 sample = audio_linear_dither(16, *right_ch++, &dither);
273 sample = s24_to_s16_pcm(*right_ch++);
276 #ifndef WORDS_BIGENDIAN
277 *buffer++ = (byte_t) (sample) & 0xFF;
278 *buffer++ = (byte_t) (sample >> 8) & 0xFF;
280 *buffer++ = (byte_t) (sample >> 8);
281 *buffer++ = (byte_t) (sample);
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);
291 return MAD_FLOW_CONTINUE;
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)
299 enum mad_flow result = MAD_FLOW_CONTINUE;
301 switch (p_libmad_stream->error)
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;
307 case MAD_ERROR_BUFPTR: /* invalid (null) buffer pointer */
308 intf_ErrMsg("libmad error: invalid (null) buffer pointer");
309 result = MAD_FLOW_STOP;
311 case MAD_ERROR_NOMEM: /* not enough memory */
312 intf_ErrMsg("libmad error: invalid (null) buffer pointer");
313 result = MAD_FLOW_STOP;
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;
320 case MAD_ERROR_BADLAYER: /* reserved header layer value */
321 intf_ErrMsg("libmad error: reserved header layer value");
322 result = MAD_FLOW_CONTINUE;
324 case MAD_ERROR_BADBITRATE: /* forbidden bitrate value */
325 intf_ErrMsg("libmad error: forbidden bitrate value");
326 result = MAD_FLOW_CONTINUE;
328 case MAD_ERROR_BADSAMPLERATE: /* reserved sample frequency value */
329 intf_ErrMsg("libmad error: reserved sample frequency value");
330 result = MAD_FLOW_CONTINUE;
332 case MAD_ERROR_BADEMPHASIS: /* reserved emphasis value */
333 intf_ErrMsg("libmad error: reserverd emphasis value");
334 result = MAD_FLOW_CONTINUE;
336 case MAD_ERROR_BADCRC: /* CRC check failed */
337 intf_ErrMsg("libmad error: CRC check failed");
338 result = MAD_FLOW_CONTINUE;
340 case MAD_ERROR_BADBITALLOC: /* forbidden bit allocation value */
341 intf_ErrMsg("libmad error: forbidden bit allocation value");
342 result = MAD_FLOW_IGNORE;
344 case MAD_ERROR_BADSCALEFACTOR:/* bad scalefactor index */
345 intf_ErrMsg("libmad error: bad scalefactor index");
346 result = MAD_FLOW_CONTINUE;
348 case MAD_ERROR_BADFRAMELEN: /* bad frame length */
349 intf_ErrMsg("libmad error: bad frame length");
350 result = MAD_FLOW_CONTINUE;
352 case MAD_ERROR_BADBIGVALUES: /* bad big_values count */
353 intf_ErrMsg("libmad error: bad big values count");
354 result = MAD_FLOW_IGNORE;
356 case MAD_ERROR_BADBLOCKTYPE: /* reserved block_type */
357 intf_ErrMsg("libmad error: reserverd block_type");
358 result = MAD_FLOW_IGNORE;
360 case MAD_ERROR_BADSCFSI: /* bad scalefactor selection info */
361 intf_ErrMsg("libmad error: bad scalefactor selection info");
362 result = MAD_FLOW_CONTINUE;
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;
368 case MAD_ERROR_BADPART3LEN: /* bad audio data length */
369 intf_ErrMsg("libmad error: bad audio data length");
370 result = MAD_FLOW_IGNORE;
372 case MAD_ERROR_BADHUFFTABLE: /* bad Huffman table select */
373 intf_ErrMsg("libmad error: bad Huffman table select");
374 result = MAD_FLOW_IGNORE;
376 case MAD_ERROR_BADHUFFDATA: /* Huffman data overrun */
377 intf_ErrMsg("libmad error: Huffman data overrun");
378 result = MAD_FLOW_IGNORE;
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;
385 intf_ErrMsg("libmad error: unknown error occured stopping decoder");
386 result = MAD_FLOW_STOP;
390 //return (MAD_RECOVERABLE(p_libmad_stream->error)? result: MAD_FLOW_STOP);
391 return (MAD_FLOW_CONTINUE);
394 /*****************************************************************************
395 * libmad_message: this function is called to send a message
396 *****************************************************************************/
397 /* enum mad_flow libmad_message(void *, void*, unsigned int*)
399 * return MAD_FLOW_CONTINUE;