]> 4ch.mooo.com Git - 16.git/blob - src/lib/dl/ext/libmad/frame.c
meh did some cleanings and i will work on mapread to mm thingy sometime soon! oops...
[16.git] / src / lib / dl / ext / libmad / frame.c
1 /*
2  * libmad - MPEG audio decoder library
3  * Copyright (C) 2000-2004 Underbit Technologies, Inc.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  *
19  * $Id: frame.c,v 1.29 2004/02/04 22:59:19 rob Exp $
20  */
21
22 # ifdef HAVE_CONFIG_H
23 #  include "config.h"
24 # endif
25
26 # include "global.h"
27
28 # include <stdlib.h>
29 # include <stdio.h>
30
31 # include "bit.h"
32 # include "stream.h"
33 # include "frame.h"
34 # include "timer.h"
35 # include "layer12.h"
36 # include "layer3.h"
37
38 static
39 unsigned long const bitrate_table[5][15] = {
40   /* MPEG-1 */
41   { 0,  32000,  64000,  96000, 128000, 160000, 192000, 224000,  /* Layer I   */
42        256000, 288000, 320000, 352000, 384000, 416000, 448000 },
43   { 0,  32000,  48000,  56000,  64000,  80000,  96000, 112000,  /* Layer II  */
44        128000, 160000, 192000, 224000, 256000, 320000, 384000 },
45   { 0,  32000,  40000,  48000,  56000,  64000,  80000,  96000,  /* Layer III */
46        112000, 128000, 160000, 192000, 224000, 256000, 320000 },
47
48   /* MPEG-2 LSF */
49   { 0,  32000,  48000,  56000,  64000,  80000,  96000, 112000,  /* Layer I   */
50        128000, 144000, 160000, 176000, 192000, 224000, 256000 },
51   { 0,   8000,  16000,  24000,  32000,  40000,  48000,  56000,  /* Layers    */
52         64000,  80000,  96000, 112000, 128000, 144000, 160000 } /* II & III  */
53 };
54
55 static
56 unsigned int const samplerate_table[3] = { 44100, 48000, 32000 };
57
58 static
59 int (*const decoder_table[3])(struct mad_stream *, struct mad_frame *) = {
60   mad_layer_I,
61   mad_layer_II,
62   mad_layer_III
63 };
64
65 /*
66  * NAME:        header->init()
67  * DESCRIPTION: initialize header struct
68  */
69 void mad_header_init(struct mad_header *header)
70 {
71   header->layer          = 0;
72   header->mode           = 0;
73   header->mode_extension = 0;
74   header->emphasis       = 0;
75
76   header->bitrate        = 0;
77   header->samplerate     = 0;
78
79   header->crc_check      = 0;
80   header->crc_target     = 0;
81
82   header->flags          = 0;
83   header->private_bits   = 0;
84
85   header->duration       = mad_timer_zero;
86 }
87
88 /*
89  * NAME:        frame->init()
90  * DESCRIPTION: initialize frame struct
91  */
92 void mad_frame_init(struct mad_frame *frame)
93 {
94   mad_header_init(&frame->header);
95
96   frame->options = 0;
97
98   frame->overlap = 0;
99   mad_frame_mute(frame);
100 }
101
102 /*
103  * NAME:        frame->finish()
104  * DESCRIPTION: deallocate any dynamic memory associated with frame
105  */
106 void mad_frame_finish(struct mad_frame *frame)
107 {
108   mad_header_finish(&frame->header);
109
110   if (frame->overlap) {
111     free(frame->overlap);
112     frame->overlap = 0;
113   }
114 }
115
116 /*
117  * NAME:        decode_header()
118  * DESCRIPTION: read header data and following CRC word
119  */
120 static
121 int decode_header(struct mad_header *header, struct mad_stream *stream)
122 {
123   unsigned int index;
124
125   header->flags        = 0;
126   header->private_bits = 0;
127
128   /* header() */
129
130   /* syncword */
131   mad_bit_skip(&stream->ptr, 11);
132
133   /* MPEG 2.5 indicator (really part of syncword) */
134   if (mad_bit_read(&stream->ptr, 1) == 0)
135     header->flags |= MAD_FLAG_MPEG_2_5_EXT;
136
137   /* ID */
138   if (mad_bit_read(&stream->ptr, 1) == 0)
139     header->flags |= MAD_FLAG_LSF_EXT;
140   else if (header->flags & MAD_FLAG_MPEG_2_5_EXT) {
141     stream->error = MAD_ERROR_LOSTSYNC;
142     return -1;
143   }
144
145   /* layer */
146   header->layer = 4 - mad_bit_read(&stream->ptr, 2);
147
148   if (header->layer == 4) {
149     stream->error = MAD_ERROR_BADLAYER;
150     return -1;
151   }
152
153   /* protection_bit */
154   if (mad_bit_read(&stream->ptr, 1) == 0) {
155     header->flags    |= MAD_FLAG_PROTECTION;
156     header->crc_check = mad_bit_crc(stream->ptr, 16, 0xffff);
157   }
158
159   /* bitrate_index */
160   index = mad_bit_read(&stream->ptr, 4);
161
162   if (index == 15) {
163     stream->error = MAD_ERROR_BADBITRATE;
164     return -1;
165   }
166
167   if (header->flags & MAD_FLAG_LSF_EXT)
168     header->bitrate = bitrate_table[3 + (header->layer >> 1)][index];
169   else
170     header->bitrate = bitrate_table[header->layer - 1][index];
171
172   /* sampling_frequency */
173   index = mad_bit_read(&stream->ptr, 2);
174
175   if (index == 3) {
176     stream->error = MAD_ERROR_BADSAMPLERATE;
177     return -1;
178   }
179
180   header->samplerate = samplerate_table[index];
181
182   if (header->flags & MAD_FLAG_LSF_EXT) {
183     header->samplerate /= 2;
184
185     if (header->flags & MAD_FLAG_MPEG_2_5_EXT)
186       header->samplerate /= 2;
187   }
188
189   /* padding_bit */
190   if (mad_bit_read(&stream->ptr, 1))
191     header->flags |= MAD_FLAG_PADDING;
192
193   /* private_bit */
194   if (mad_bit_read(&stream->ptr, 1))
195     header->private_bits |= MAD_PRIVATE_HEADER;
196
197   /* mode */
198   header->mode = 3 - mad_bit_read(&stream->ptr, 2);
199
200   /* mode_extension */
201   header->mode_extension = mad_bit_read(&stream->ptr, 2);
202
203   /* copyright */
204   if (mad_bit_read(&stream->ptr, 1))
205     header->flags |= MAD_FLAG_COPYRIGHT;
206
207   /* original/copy */
208   if (mad_bit_read(&stream->ptr, 1))
209     header->flags |= MAD_FLAG_ORIGINAL;
210
211   /* emphasis */
212   header->emphasis = mad_bit_read(&stream->ptr, 2);
213
214 # if defined(OPT_STRICT)
215   /*
216    * ISO/IEC 11172-3 says this is a reserved emphasis value, but
217    * streams exist which use it anyway. Since the value is not important
218    * to the decoder proper, we allow it unless OPT_STRICT is defined.
219    */
220   if (header->emphasis == MAD_EMPHASIS_RESERVED) {
221     stream->error = MAD_ERROR_BADEMPHASIS;
222     return -1;
223   }
224 # endif
225
226   /* error_check() */
227
228   /* crc_check */
229   if (header->flags & MAD_FLAG_PROTECTION)
230     header->crc_target = mad_bit_read(&stream->ptr, 16);
231
232   return 0;
233 }
234
235 /*
236  * NAME:        free_bitrate()
237  * DESCRIPTION: attempt to discover the bitstream's free bitrate
238  */
239 static
240 int free_bitrate(struct mad_stream *stream, struct mad_header const *header)
241 {
242   struct mad_bitptr keep_ptr;
243   unsigned long rate = 0;
244   unsigned int pad_slot, slots_per_frame;
245   unsigned char const *ptr = 0;
246
247   keep_ptr = stream->ptr;
248
249   pad_slot = (header->flags & MAD_FLAG_PADDING) ? 1 : 0;
250   slots_per_frame = (header->layer == MAD_LAYER_III &&
251                      (header->flags & MAD_FLAG_LSF_EXT)) ? 72 : 144;
252
253   while (mad_stream_sync(stream) == 0) {
254     struct mad_stream peek_stream;
255     struct mad_header peek_header;
256
257     peek_stream = *stream;
258     peek_header = *header;
259
260     if (decode_header(&peek_header, &peek_stream) == 0 &&
261         peek_header.layer == header->layer &&
262         peek_header.samplerate == header->samplerate) {
263       unsigned int N;
264
265       ptr = mad_bit_nextbyte(&stream->ptr);
266
267       N = ptr - stream->this_frame;
268
269       if (header->layer == MAD_LAYER_I) {
270         rate = (unsigned long) header->samplerate *
271           (N - 4 * pad_slot + 4) / 48 / 1000;
272       }
273       else {
274         rate = (unsigned long) header->samplerate *
275           (N - pad_slot + 1) / slots_per_frame / 1000;
276       }
277
278       if (rate >= 8)
279         break;
280     }
281
282     mad_bit_skip(&stream->ptr, 8);
283   }
284
285   stream->ptr = keep_ptr;
286
287   if (rate < 8 || (header->layer == MAD_LAYER_III && rate > 640)) {
288     stream->error = MAD_ERROR_LOSTSYNC;
289     return -1;
290   }
291
292   stream->freerate = rate * 1000;
293
294   return 0;
295 }
296
297 /*
298  * NAME:        header->decode()
299  * DESCRIPTION: read the next frame header from the stream
300  */
301 int mad_header_decode(struct mad_header *header, struct mad_stream *stream)
302 {
303   register unsigned char const *ptr, *end;
304   unsigned int pad_slot, N;
305
306   ptr = stream->next_frame;
307   end = stream->bufend;
308
309   if (ptr == 0) {
310     stream->error = MAD_ERROR_BUFPTR;
311     goto fail;
312   }
313
314   /* stream skip */
315   if (stream->skiplen) {
316     if (!stream->sync)
317       ptr = stream->this_frame;
318
319     if (end - ptr < stream->skiplen) {
320       stream->skiplen   -= end - ptr;
321       stream->next_frame = end;
322
323       stream->error = MAD_ERROR_BUFLEN;
324       goto fail;
325     }
326
327     ptr += stream->skiplen;
328     stream->skiplen = 0;
329
330     stream->sync = 1;
331   }
332
333  sync:
334   /* synchronize */
335   if (stream->sync) {
336     if (end - ptr < MAD_BUFFER_GUARD) {
337       stream->next_frame = ptr;
338
339       stream->error = MAD_ERROR_BUFLEN;
340       goto fail;
341     }
342     else if (!(ptr[0] == 0xff && (ptr[1] & 0xe0) == 0xe0)) {
343       /* mark point where frame sync word was expected */
344       stream->this_frame = ptr;
345       stream->next_frame = ptr + 1;
346
347       stream->error = MAD_ERROR_LOSTSYNC;
348       goto fail;
349     }
350   }
351   else {
352     mad_bit_init(&stream->ptr, ptr);
353
354     if (mad_stream_sync(stream) == -1) {
355       if (end - stream->next_frame >= MAD_BUFFER_GUARD)
356         stream->next_frame = end - MAD_BUFFER_GUARD;
357
358       stream->error = MAD_ERROR_BUFLEN;
359       goto fail;
360     }
361
362     ptr = mad_bit_nextbyte(&stream->ptr);
363   }
364
365   /* begin processing */
366   stream->this_frame = ptr;
367   stream->next_frame = ptr + 1;  /* possibly bogus sync word */
368
369   mad_bit_init(&stream->ptr, stream->this_frame);
370
371   if (decode_header(header, stream) == -1)
372     goto fail;
373
374   /* calculate frame duration */
375   mad_timer_set(&header->duration, 0,
376                 32 * MAD_NSBSAMPLES(header), header->samplerate);
377
378   /* calculate free bit rate */
379   if (header->bitrate == 0) {
380     if ((stream->freerate == 0 || !stream->sync ||
381          (header->layer == MAD_LAYER_III && stream->freerate > 640000)) &&
382         free_bitrate(stream, header) == -1)
383       goto fail;
384
385     header->bitrate = stream->freerate;
386     header->flags  |= MAD_FLAG_FREEFORMAT;
387   }
388
389   /* calculate beginning of next frame */
390   pad_slot = (header->flags & MAD_FLAG_PADDING) ? 1 : 0;
391
392   if (header->layer == MAD_LAYER_I)
393     N = ((12 * header->bitrate / header->samplerate) + pad_slot) * 4;
394   else {
395     unsigned int slots_per_frame;
396
397     slots_per_frame = (header->layer == MAD_LAYER_III &&
398                        (header->flags & MAD_FLAG_LSF_EXT)) ? 72 : 144;
399
400     N = (slots_per_frame * header->bitrate / header->samplerate) + pad_slot;
401   }
402
403   /* verify there is enough data left in buffer to decode this frame */
404   if (N + MAD_BUFFER_GUARD > end - stream->this_frame) {
405     stream->next_frame = stream->this_frame;
406
407     stream->error = MAD_ERROR_BUFLEN;
408     goto fail;
409   }
410
411   stream->next_frame = stream->this_frame + N;
412
413   if (!stream->sync) {
414     /* check that a valid frame header follows this frame */
415
416     ptr = stream->next_frame;
417     if (!(ptr[0] == 0xff && (ptr[1] & 0xe0) == 0xe0)) {
418       ptr = stream->next_frame = stream->this_frame + 1;
419       goto sync;
420     }
421
422     stream->sync = 1;
423   }
424
425   header->flags |= MAD_FLAG_INCOMPLETE;
426
427   return 0;
428
429  fail:
430   stream->sync = 0;
431
432   return -1;
433 }
434
435 /*
436  * NAME:        frame->decode()
437  * DESCRIPTION: decode a single frame from a bitstream
438  */
439 int mad_frame_decode(struct mad_frame *frame, struct mad_stream *stream)
440 {
441   frame->options = stream->options;
442
443   /* header() */
444   /* error_check() */
445
446   if (!(frame->header.flags & MAD_FLAG_INCOMPLETE) &&
447       mad_header_decode(&frame->header, stream) == -1)
448     goto fail;
449
450   /* audio_data() */
451
452   frame->header.flags &= ~MAD_FLAG_INCOMPLETE;
453
454   if (decoder_table[frame->header.layer - 1](stream, frame) == -1) {
455     if (!MAD_RECOVERABLE(stream->error))
456       stream->next_frame = stream->this_frame;
457
458     goto fail;
459   }
460
461   /* ancillary_data() */
462
463   if (frame->header.layer != MAD_LAYER_III) {
464     struct mad_bitptr next_frame;
465
466     mad_bit_init(&next_frame, stream->next_frame);
467
468     stream->anc_ptr    = stream->ptr;
469     stream->anc_bitlen = mad_bit_length(&stream->ptr, &next_frame);
470
471     mad_bit_finish(&next_frame);
472   }
473
474   return 0;
475
476  fail:
477   stream->anc_bitlen = 0;
478   return -1;
479 }
480
481 /*
482  * NAME:        frame->mute()
483  * DESCRIPTION: zero all subband values so the frame becomes silent
484  */
485 void mad_frame_mute(struct mad_frame *frame)
486 {
487   unsigned int s, sb;
488
489   for (s = 0; s < 36; ++s) {
490     for (sb = 0; sb < 32; ++sb) {
491       frame->sbsample[0][s][sb] =
492       frame->sbsample[1][s][sb] = 0;
493     }
494   }
495
496   if (frame->overlap) {
497     for (s = 0; s < 18; ++s) {
498       for (sb = 0; sb < 32; ++sb) {
499         (*frame->overlap)[0][sb][s] =
500         (*frame->overlap)[1][sb][s] = 0;
501       }
502     }
503   }
504 }