* More precise way to retrieve a PTS from the bit stream.
[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     size_t ReadSize, Remaining;
51     unsigned char      *ReadStart;
52
53     if ( p_mad_adec->p_fifo->b_die == 1 ) {
54         intf_ErrMsg( "mad_adec error: libmad_input stopping libmad decoder" );
55         return MAD_FLOW_STOP;
56     }
57
58     if ( p_mad_adec->p_fifo->b_error == 1 ) {
59         intf_ErrMsg( "mad_adec error: libmad_input ignoring current audio frame" );     
60         return MAD_FLOW_IGNORE;
61     }
62
63     /* libmad_stream_buffer does not consume the total buffer, it consumes only data
64      * for one frame only. So all data left in the buffer should be put back in front.
65      */
66     if ((p_libmad_stream->buffer==NULL) || (p_libmad_stream->error==MAD_ERROR_BUFLEN))
67     {
68         /* libmad does not consume all the buffer it's given. Some
69          * datas, part of a truncated frame, is left unused at the
70          * end of the buffer. Those datas must be put back at the
71          * beginning of the buffer and taken in account for
72          * refilling the buffer. This means that the input buffer
73          * must be large enough to hold a complete frame at the
74          * highest observable bit-rate (currently 448 kb/s). XXX=XXX
75          * Is 2016 bytes the size of the largest frame?
76          * (448000*(1152/32000))/8
77          */
78         if(p_libmad_stream->next_frame!=NULL)
79         {
80             Remaining=p_libmad_stream->bufend-p_libmad_stream->next_frame;
81             memmove(p_mad_adec->buffer,p_libmad_stream->next_frame,Remaining);
82             ReadStart=p_mad_adec->buffer+Remaining;
83             ReadSize=(MAD_BUFFER_SIZE)-Remaining;
84
85             /* Store time stamp of next frame */
86             p_mad_adec->i_current_pts = p_mad_adec->i_next_pts;
87             CurrentPTS( &p_mad_adec->bit_stream, &p_mad_adec->i_next_pts, NULL );
88         }
89         else
90         {
91             ReadSize=(MAD_BUFFER_SIZE);
92             ReadStart=p_mad_adec->buffer;
93             Remaining=0;
94             p_mad_adec->i_next_pts = 0;
95             CurrentPTS( &p_mad_adec->bit_stream, &p_mad_adec->i_current_pts, NULL );
96         }
97
98         /* Fill-in the buffer. If an error occurs print a message
99          * and leave the decoding loop. If the end of stream is
100          * reached we also leave the loop but the return status is
101          * left untouched.
102          */
103 #if 0
104         /* This is currently buggy --Meuuh */
105         if( ReadSize > p_mad_adec->bit_stream.p_end
106                         - p_mad_adec->bit_stream.p_byte )
107         {
108             FAST_MEMCPY( ReadStart, p_mad_adec->bit_stream.p_byte,
109                p_mad_adec->bit_stream.p_end - p_mad_adec->bit_stream.p_byte );
110             p_mad_adec->bit_stream.pf_next_data_packet( &p_mad_adec->bit_stream );
111         }
112         else
113         {
114             FAST_MEMCPY( ReadStart, p_mad_adec->bit_stream.p_byte,
115                          ReadSize );
116             p_mad_adec->bit_stream.p_byte += ReadSize;
117         }
118 #else
119         /* This is PTS-inaccurate --Meuuh */
120         GetChunk( &p_mad_adec->bit_stream, ReadStart, ReadSize );
121 #endif
122
123         if ( p_mad_adec->p_fifo->b_die == 1 )
124         {
125             intf_ErrMsg( "mad_adec error: libmad_input stopping libmad decoder" );
126             return MAD_FLOW_STOP;
127         }
128
129         if ( p_mad_adec->p_fifo->b_error == 1 )
130         {
131             intf_ErrMsg( "mad_adec error: libmad_input ignoring current audio frame" );    
132             return MAD_FLOW_IGNORE;
133         }
134
135         /* Pipe the new buffer content to libmad's stream decoder facility.
136          * Libmad never copies the buffer, but just references it. So keep it in
137          * mad_adec_thread_t structure.
138          */
139         mad_stream_buffer(p_libmad_stream,(unsigned char*) &p_mad_adec->buffer,
140                           MAD_BUFFER_SIZE);
141         p_libmad_stream->error=0;
142     }
143
144     return MAD_FLOW_CONTINUE;
145 }
146
147 /*****************************************************************************
148  * libmad_header: this function is called just after the header of a frame is
149  * decoded
150  *****************************************************************************/
151 /*
152  *enum mad_flow libmad_header(void *data, struct mad_header const *p_libmad_header)
153  *{
154  *   mad_adec_thread_t *p_mad_adec = (mad_adec_thread_t *) data;
155  *
156  *   intf_ErrMsg( "mad_adec: libmad_header samplerate %d", p_libmad_header->samplerate);
157  *   intf_DbgMsg( "mad_adec: libmad_header bitrate %d", p_libmad_header->bitrate);      
158  *
159  *   p_mad_adec->p_aout_fifo->l_rate = p_libmad_header->samplerate;
160  *   mad_timer_add(&p_mad_adec->libmad_timer,p_libmad_header->duration); 
161  *
162  *   return MAD_FLOW_CONTINUE;
163  *}
164  */
165
166 /*****************************************************************************
167  * lib_mad_filter: this function is called to filter data of a frame
168  *****************************************************************************/
169 /* enum mad_flow libmad_filter(void *data, struct mad_stream const *p_libmad_stream, struct mad_frame *p_libmad_frame)
170  * {
171  *      return MAD_FLOW_CONTINUE;
172  * }
173  */
174
175 //#define MPG321_ROUTINES     1
176 #ifdef MPG321_ROUTINES
177 /*****************************************************************************
178  * support routines borrowed from mpg321 (file: mad.c), which is distributed
179  * under GPL license
180  *
181  * mpg321 was written by Joe Drew <drew@debian.org>, and based upon 'plaympeg'
182  * from the smpeg sources, which was written by various people from Loki Software
183  * (http://www.lokigames.com).
184  *
185  * It also incorporates some source from mad, written by Robert Leslie
186  *****************************************************************************/
187
188 /* The following two routines and data structure are from the ever-brilliant
189      Rob Leslie.
190 */
191
192 struct audio_dither {
193     mad_fixed_t error[3];
194     mad_fixed_t random;
195 };
196
197 /*
198 * NAME:                prng()
199 * DESCRIPTION: 32-bit pseudo-random number generator
200 */
201 static __inline__ unsigned long prng(unsigned long state)
202 {
203     return (state * 0x0019660dL + 0x3c6ef35fL) & 0xffffffffL;
204 }
205
206 /*
207 * NAME:                audio_linear_dither()
208 * DESCRIPTION: generic linear sample quantize and dither routine
209 */
210 static __inline__ signed int audio_linear_dither(unsigned int bits, mad_fixed_t sample,
211                                     struct audio_dither *dither)
212 {
213     unsigned int scalebits;
214     mad_fixed_t output, mask, random;
215
216     enum {
217         MIN = -MAD_F_ONE,
218         MAX = MAD_F_ONE - 1
219     };
220
221     /* noise shape */
222     sample += dither->error[0] - dither->error[1] + dither->error[2];
223
224     dither->error[2] = dither->error[1];
225     dither->error[1] = dither->error[0] / 2;
226
227     /* bias */
228     output = sample + (1L << (MAD_F_FRACBITS + 1 - bits - 1));
229
230     scalebits = MAD_F_FRACBITS + 1 - bits;
231     mask = (1L << scalebits) - 1;
232
233     /* dither */
234     random    = prng(dither->random);
235     output += (random & mask) - (dither->random & mask);
236
237     dither->random = random;
238
239     /* clip */
240     if (output > MAX) {
241         output = MAX;
242
243         if (sample > MAX)
244             sample = MAX;
245     }
246     else if (output < MIN) {
247         output = MIN;
248
249         if (sample < MIN)
250             sample = MIN;
251     }
252
253     /* quantize */
254     output &= ~mask;
255
256     /* error feedback */
257     dither->error[0] = sample - output;
258
259     /* scale */
260     return output >> scalebits;
261 }
262 #endif
263
264 /*****************************************************************************
265  * s24_to_s16_pcm: Scale a 24 bit pcm sample to a 16 bit pcm sample.
266  *****************************************************************************/
267 static __inline__ mad_fixed_t s24_to_s16_pcm(mad_fixed_t sample)
268 {
269   /* round */
270   sample += (1L << (MAD_F_FRACBITS - 16));
271
272   /* clip */
273   if (sample >= MAD_F_ONE)
274     sample = MAD_F_ONE - 1;
275   else if (sample < -MAD_F_ONE)
276     sample = -MAD_F_ONE;
277
278   /* quantize */
279   return sample >> (MAD_F_FRACBITS + 1 - 16);
280 }
281
282 /*****************************************************************************
283  * libmad_ouput: this function is called just after the frame is decoded
284  *****************************************************************************/
285 enum mad_flow libmad_output(void *data, struct mad_header const *p_libmad_header, struct mad_pcm *p_libmad_pcm)
286 {
287     mad_adec_thread_t *p_mad_adec= (mad_adec_thread_t *) data;
288     byte_t *buffer=NULL;
289
290     mad_fixed_t const *left_ch = p_libmad_pcm->samples[0], *right_ch = p_libmad_pcm->samples[1];
291     register int nsamples = p_libmad_pcm->length;
292     mad_fixed_t sample;
293 #ifdef MPG321_ROUTINES
294     static struct audio_dither dither;
295 #endif
296
297     /* Creating the audio output fifo */
298     if (p_mad_adec->p_aout_fifo==NULL)
299     {
300         p_mad_adec->p_aout_fifo = aout_CreateFifo(  
301                 AOUT_ADEC_STEREO_FIFO,          /* fifo type */
302                 p_libmad_pcm->channels,         /* nr. of channels */
303                 p_libmad_pcm->samplerate,       /* frame rate in Hz ?*/
304                 0,                              /* units */
305                 ADEC_FRAME_SIZE,                /* frame size */
306                 NULL  );                        /* buffer */
307
308         if ( p_mad_adec->p_aout_fifo == NULL )
309         {
310                 return( -1 );
311         }
312
313         intf_ErrMsg("mad_adec debug: in libmad_output aout fifo created");
314     }
315     else
316     {
317         p_mad_adec->p_aout_fifo->l_rate = p_libmad_pcm->samplerate;
318     }
319
320 /* Some frames are nog quite right. Why ??? I do not know. Probably syncing and CRC errors ??
321  * Leaving those frames out futher removes the jitter in the sound and makes it more fluent.
322  * Still I am missing something, because it is not completely fluent.
323  */
324     if ((p_mad_adec->libmad_decoder->sync->stream.error==MAD_ERROR_BADCRC) ||
325         (p_mad_adec->libmad_decoder->sync->stream.error==MAD_ERROR_BADBITRATE) ||
326         (p_mad_adec->libmad_decoder->sync->stream.error==MAD_ERROR_BADSCALEFACTOR)
327        ) {
328 //      intf_ErrMsg( "LIBMAD_OUTPUT: nr of channels [%d], samplerate in Hz [%d,%d], sample size [%d], error_code [%0x]",
329 //               p_libmad_pcm->channels, p_libmad_pcm->samplerate, p_libmad_header->samplerate,
330 //               p_libmad_pcm->length, p_mad_adec->libmad_decoder->sync->stream.error);
331 //      PrintFrameInfo(&p_libmad_header);
332         return MAD_FLOW_IGNORE;
333     }
334
335     /* Set timestamp to synchronize audio and video decoder fifo's */
336     p_mad_adec->p_aout_fifo->l_rate = p_libmad_header->samplerate;
337     if( p_mad_adec->i_current_pts )
338     {
339         p_mad_adec->p_aout_fifo->date[p_mad_adec->p_aout_fifo->l_end_frame]
340                 = p_mad_adec->i_current_pts;
341     }
342     else
343     {
344         p_mad_adec->p_aout_fifo->date[p_mad_adec->p_aout_fifo->l_end_frame]
345                 = LAST_MDATE;
346     }
347     mad_timer_add(&p_mad_adec->libmad_timer,p_libmad_header->duration);
348
349     buffer = ((byte_t *)p_mad_adec->p_aout_fifo->buffer) + (p_mad_adec->p_aout_fifo->l_end_frame * MAD_OUTPUT_SIZE);
350
351     while (nsamples--)
352     {
353 #ifdef MPG321_ROUTINES
354         sample = audio_linear_dither(16, *left_ch++, &dither);
355 #else
356         sample = s24_to_s16_pcm(*left_ch++);
357 #endif
358
359 #ifndef WORDS_BIGENDIAN
360         *buffer++ = (byte_t) (sample >> 0);
361         *buffer++ = (byte_t) (sample >> 8);
362 #else
363         *buffer++ = (byte_t) (sample >> 8);
364         *buffer++ = (byte_t) (sample >> 0);
365 #endif
366         if (p_libmad_pcm->channels == 2) {
367
368             /* right audio channel */
369 #ifdef MPG321_ROUTINES
370             sample = audio_linear_dither(16, *right_ch++, &dither);
371 #else
372             sample = s24_to_s16_pcm(*right_ch++);
373 #endif
374
375 #ifndef WORDS_BIGENDIAN
376             *buffer++ = (byte_t) (sample >> 0);
377             *buffer++ = (byte_t) (sample >> 8);
378 #else
379             *buffer++ = (byte_t) (sample >> 8);
380             *buffer++ = (byte_t) (sample >> 0);
381 #endif                                          
382         }
383         else {
384             /* Somethimes a single channel frame is found, while the rest of the movie are
385              * stereo channel frames. How to deal with this ??
386              * One solution is to silence the second channel.
387              */
388             *buffer++ = (byte_t) (0);
389             *buffer++ = (byte_t) (0);
390         }
391     }
392     /* DEBUG */
393     if (p_libmad_pcm->channels == 1) {
394        intf_ErrMsg( "mad debug: libmad_output channels [%d]", p_libmad_pcm->channels);
395     }
396
397     vlc_mutex_lock (&p_mad_adec->p_aout_fifo->data_lock);
398     p_mad_adec->p_aout_fifo->l_end_frame = (p_mad_adec->p_aout_fifo->l_end_frame + 1) & AOUT_FIFO_SIZE;
399     vlc_cond_signal (&p_mad_adec->p_aout_fifo->data_wait);
400     vlc_mutex_unlock (&p_mad_adec->p_aout_fifo->data_lock);
401
402     return MAD_FLOW_CONTINUE;
403 }
404
405 /*****************************************************************************
406  * libmad_error: this function is called when an error occurs during decoding
407  *****************************************************************************/
408 enum mad_flow libmad_error(void *data, struct mad_stream *p_libmad_stream, struct mad_frame *p_libmad_frame)
409 {
410     enum mad_flow result = MAD_FLOW_CONTINUE;
411
412     switch (p_libmad_stream->error)
413     {             
414     case MAD_ERROR_BUFLEN:                /* input buffer too small (or EOF) */
415         intf_ErrMsg("libmad error: input buffer too small (or EOF)");
416         result = MAD_FLOW_CONTINUE;
417         break;
418     case MAD_ERROR_BUFPTR:                /* invalid (null) buffer pointer */
419         intf_ErrMsg("libmad error: invalid (null) buffer pointer");
420         result = MAD_FLOW_STOP;
421         break;
422     case MAD_ERROR_NOMEM:                 /* not enough memory */
423         intf_ErrMsg("libmad error: invalid (null) buffer pointer");
424         result = MAD_FLOW_STOP;
425         break;
426     case MAD_ERROR_LOSTSYNC:            /* lost synchronization */
427         intf_ErrMsg("libmad error: lost synchronization");
428         mad_stream_sync(p_libmad_stream);
429         result = MAD_FLOW_CONTINUE;
430         break;
431     case MAD_ERROR_BADLAYER:            /* reserved header layer value */
432         intf_ErrMsg("libmad error: reserved header layer value");
433         result = MAD_FLOW_CONTINUE;
434         break;
435     case MAD_ERROR_BADBITRATE:        /* forbidden bitrate value */
436         intf_ErrMsg("libmad error: forbidden bitrate value");
437         result = MAD_FLOW_CONTINUE;
438         break;
439     case MAD_ERROR_BADSAMPLERATE: /* reserved sample frequency value */
440             intf_ErrMsg("libmad error: reserved sample frequency value");
441         result = MAD_FLOW_CONTINUE;
442         break;
443     case MAD_ERROR_BADEMPHASIS:     /* reserved emphasis value */
444         intf_ErrMsg("libmad error: reserverd emphasis value");
445         result = MAD_FLOW_CONTINUE;
446         break;
447     case MAD_ERROR_BADCRC:                /* CRC check failed */
448         intf_ErrMsg("libmad error: CRC check failed");
449         result = MAD_FLOW_CONTINUE;
450         break;
451     case MAD_ERROR_BADBITALLOC:     /* forbidden bit allocation value */
452         intf_ErrMsg("libmad error: forbidden bit allocation value");
453         result = MAD_FLOW_IGNORE;
454         break;
455     case MAD_ERROR_BADSCALEFACTOR:/* bad scalefactor index */
456         intf_ErrMsg("libmad error: bad scalefactor index");
457         result = MAD_FLOW_CONTINUE;
458         break;
459     case MAD_ERROR_BADFRAMELEN:     /* bad frame length */
460         intf_ErrMsg("libmad error: bad frame length");
461         result = MAD_FLOW_CONTINUE;
462         break;
463     case MAD_ERROR_BADBIGVALUES:    /* bad big_values count */
464         intf_ErrMsg("libmad error: bad big values count");
465         result = MAD_FLOW_IGNORE;
466         break;
467     case MAD_ERROR_BADBLOCKTYPE:    /* reserved block_type */
468         intf_ErrMsg("libmad error: reserverd block_type");
469         result = MAD_FLOW_IGNORE;
470         break;
471     case MAD_ERROR_BADSCFSI:            /* bad scalefactor selection info */
472         intf_ErrMsg("libmad error: bad scalefactor selection info");
473         result = MAD_FLOW_CONTINUE;
474         break;
475     case MAD_ERROR_BADDATAPTR:        /* bad main_data_begin pointer */
476         intf_ErrMsg("libmad error: bad main_data_begin pointer");
477         result = MAD_FLOW_STOP;
478         break;
479     case MAD_ERROR_BADPART3LEN:     /* bad audio data length */
480         intf_ErrMsg("libmad error: bad audio data length");
481         result = MAD_FLOW_IGNORE;
482         break;
483     case MAD_ERROR_BADHUFFTABLE:    /* bad Huffman table select */
484         intf_ErrMsg("libmad error: bad Huffman table select");
485         result = MAD_FLOW_IGNORE;
486         break;
487     case MAD_ERROR_BADHUFFDATA:     /* Huffman data overrun */
488         intf_ErrMsg("libmad error: Huffman data overrun");
489         result = MAD_FLOW_IGNORE;
490         break;
491     case MAD_ERROR_BADSTEREO:         /* incompatible block_type for JS */
492         intf_ErrMsg("libmad error: incompatible block_type for JS");
493         result = MAD_FLOW_IGNORE;
494         break;
495     default:
496         intf_ErrMsg("libmad error: unknown error occured stopping decoder");
497         result = MAD_FLOW_STOP;
498         break;
499     }
500     
501     //return (MAD_RECOVERABLE(p_libmad_stream->error)? result: MAD_FLOW_STOP);
502     return (MAD_FLOW_CONTINUE);
503 }
504
505 /*****************************************************************************
506  * libmad_message: this function is called to send a message
507  *****************************************************************************/
508 /* enum mad_flow libmad_message(void *, void*, unsigned int*)
509  * {
510  *     return MAD_FLOW_CONTINUE;
511  * }
512  */
513
514