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