streo mp3 player see: http://mbed.org/users/okini3939/notebook/I2S_AUDIO
Dependencies: FatFileSystemCpp I2SSlave TLV320 mbed
Fork of madplayer by
frame.cpp
00001 /* 00002 * libmad - MPEG audio decoder library 00003 * Copyright (C) 2000-2004 Underbit Technologies, Inc. 00004 * 00005 * This program is free software; you can redistribute it and/or modify 00006 * it under the terms of the GNU General Public License as published by 00007 * the Free Software Foundation; either version 2 of the License, or 00008 * (at your option) any later version. 00009 * 00010 * This program is distributed in the hope that it will be useful, 00011 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00012 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00013 * GNU General Public License for more details. 00014 * 00015 * You should have received a copy of the GNU General Public License 00016 * along with this program; if not, write to the Free Software 00017 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 00018 * 00019 * $Id: frame.c,v 1.1 2010/11/23 20:12:57 andy Exp $ 00020 */ 00021 00022 # include "config.h" 00023 00024 # include "global.h" 00025 00026 # include <stdlib.h> 00027 00028 # include "bit.h" 00029 # include "stream.h" 00030 # include "frame.h" 00031 # include "timer.h" 00032 # include "layer12.h" 00033 # include "layer3.h" 00034 00035 static 00036 unsigned long const bitrate_table[5][15] = { 00037 /* MPEG-1 */ 00038 { 0, 32000, 64000, 96000, 128000, 160000, 192000, 224000, /* Layer I */ 00039 256000, 288000, 320000, 352000, 384000, 416000, 448000 }, 00040 { 0, 32000, 48000, 56000, 64000, 80000, 96000, 112000, /* Layer II */ 00041 128000, 160000, 192000, 224000, 256000, 320000, 384000 }, 00042 { 0, 32000, 40000, 48000, 56000, 64000, 80000, 96000, /* Layer III */ 00043 112000, 128000, 160000, 192000, 224000, 256000, 320000 }, 00044 00045 /* MPEG-2 LSF */ 00046 { 0, 32000, 48000, 56000, 64000, 80000, 96000, 112000, /* Layer I */ 00047 128000, 144000, 160000, 176000, 192000, 224000, 256000 }, 00048 { 0, 8000, 16000, 24000, 32000, 40000, 48000, 56000, /* Layers */ 00049 64000, 80000, 96000, 112000, 128000, 144000, 160000 } /* II & III */ 00050 }; 00051 00052 static 00053 unsigned int const samplerate_table[3] = { 44100, 48000, 32000 }; 00054 00055 static 00056 int (*const decoder_table[3])(struct mad_stream *, struct mad_frame *) = { 00057 mad_layer_I, 00058 mad_layer_II, 00059 mad_layer_III 00060 }; 00061 00062 /* 00063 * NAME: header->init() 00064 * DESCRIPTION: initialize header struct 00065 */ 00066 void mad_header_init(struct mad_header *header) 00067 { 00068 header->layer = (enum mad_layer)0; 00069 header->mode = (enum mad_mode)0; 00070 header->mode_extension = 0; 00071 header->emphasis = (enum mad_emphasis)0; 00072 00073 header->bitrate = 0; 00074 header->samplerate = 0; 00075 00076 header->crc_check = 0; 00077 header->crc_target = 0; 00078 00079 header->flags = 0; 00080 header->private_bits = 0; 00081 00082 header->duration = mad_timer_zero; 00083 } 00084 00085 /* 00086 * NAME: frame->init() 00087 * DESCRIPTION: initialize frame struct 00088 */ 00089 void mad_frame_init(struct mad_frame *frame) 00090 { 00091 mad_header_init(&frame->header); 00092 00093 frame->options = 0; 00094 00095 //### frame->overlap = 0; 00096 mad_frame_mute(frame); 00097 } 00098 00099 /* 00100 * NAME: frame->finish() 00101 * DESCRIPTION: deallocate any dynamic memory associated with frame 00102 */ 00103 void mad_frame_finish(struct mad_frame *frame) 00104 { 00105 mad_header_finish(&frame->header); 00106 /* ### 00107 if (frame->overlap) { 00108 free(frame->overlap); 00109 frame->overlap = 0; 00110 } 00111 */ 00112 } 00113 00114 /* 00115 * NAME: decode_header() 00116 * DESCRIPTION: read header data and following CRC word 00117 */ 00118 static 00119 int decode_header(struct mad_header *header, struct mad_stream *stream) 00120 { 00121 unsigned int index; 00122 00123 header->flags = 0; 00124 header->private_bits = 0; 00125 00126 /* header() */ 00127 00128 /* syncword */ 00129 mad_bit_skip(&stream->ptr, 11); 00130 00131 /* MPEG 2.5 indicator (really part of syncword) */ 00132 if (mad_bit_read(&stream->ptr, 1) == 0) 00133 header->flags |= MAD_FLAG_MPEG_2_5_EXT; 00134 00135 /* ID */ 00136 if (mad_bit_read(&stream->ptr, 1) == 0) 00137 header->flags |= MAD_FLAG_LSF_EXT; 00138 else if (header->flags & MAD_FLAG_MPEG_2_5_EXT) { 00139 stream->error = MAD_ERROR_LOSTSYNC; 00140 return -1; 00141 } 00142 00143 /* layer */ 00144 header->layer = (enum mad_layer)(4 - mad_bit_read(&stream->ptr, 2)); 00145 00146 if (header->layer == 4) { 00147 stream->error = MAD_ERROR_BADLAYER; 00148 return -1; 00149 } 00150 00151 /* protection_bit */ 00152 if (mad_bit_read(&stream->ptr, 1) == 0) { 00153 header->flags |= MAD_FLAG_PROTECTION; 00154 header->crc_check = mad_bit_crc(stream->ptr, 16, 0xffff); 00155 } 00156 00157 /* bitrate_index */ 00158 index = mad_bit_read(&stream->ptr, 4); 00159 00160 if (index == 15) { 00161 stream->error = MAD_ERROR_BADBITRATE; 00162 return -1; 00163 } 00164 00165 if (header->flags & MAD_FLAG_LSF_EXT) 00166 header->bitrate = bitrate_table[3 + (header->layer >> 1)][index]; 00167 else 00168 header->bitrate = bitrate_table[header->layer - 1][index]; 00169 00170 /* sampling_frequency */ 00171 index = mad_bit_read(&stream->ptr, 2); 00172 00173 if (index == 3) { 00174 stream->error = MAD_ERROR_BADSAMPLERATE; 00175 return -1; 00176 } 00177 00178 header->samplerate = samplerate_table[index]; 00179 00180 if (header->flags & MAD_FLAG_LSF_EXT) { 00181 header->samplerate /= 2; 00182 00183 if (header->flags & MAD_FLAG_MPEG_2_5_EXT) 00184 header->samplerate /= 2; 00185 } 00186 00187 /* padding_bit */ 00188 if (mad_bit_read(&stream->ptr, 1)) 00189 header->flags |= MAD_FLAG_PADDING; 00190 00191 /* private_bit */ 00192 if (mad_bit_read(&stream->ptr, 1)) 00193 header->private_bits |= MAD_PRIVATE_HEADER; 00194 00195 /* mode */ 00196 header->mode = (enum mad_mode)(3 - mad_bit_read(&stream->ptr, 2)); 00197 00198 /* mode_extension */ 00199 header->mode_extension = mad_bit_read(&stream->ptr, 2); 00200 00201 /* copyright */ 00202 if (mad_bit_read(&stream->ptr, 1)) 00203 header->flags |= MAD_FLAG_COPYRIGHT; 00204 00205 /* original/copy */ 00206 if (mad_bit_read(&stream->ptr, 1)) 00207 header->flags |= MAD_FLAG_ORIGINAL; 00208 00209 /* emphasis */ 00210 header->emphasis = (enum mad_emphasis)mad_bit_read(&stream->ptr, 2); 00211 00212 # if defined(OPT_STRICT) 00213 /* 00214 * ISO/IEC 11172-3 says this is a reserved emphasis value, but 00215 * streams exist which use it anyway. Since the value is not important 00216 * to the decoder proper, we allow it unless OPT_STRICT is defined. 00217 */ 00218 if (header->emphasis == MAD_EMPHASIS_RESERVED) { 00219 stream->error = MAD_ERROR_BADEMPHASIS; 00220 return -1; 00221 } 00222 # endif 00223 00224 /* error_check() */ 00225 00226 /* crc_check */ 00227 if (header->flags & MAD_FLAG_PROTECTION) 00228 header->crc_target = mad_bit_read(&stream->ptr, 16); 00229 00230 return 0; 00231 } 00232 00233 /* 00234 * NAME: free_bitrate() 00235 * DESCRIPTION: attempt to discover the bitstream's free bitrate 00236 */ 00237 static 00238 int free_bitrate(struct mad_stream *stream, struct mad_header const *header) 00239 { 00240 struct mad_bitptr keep_ptr; 00241 unsigned long rate = 0; 00242 unsigned int pad_slot, slots_per_frame; 00243 unsigned char const *ptr = 0; 00244 00245 keep_ptr = stream->ptr; 00246 00247 pad_slot = (header->flags & MAD_FLAG_PADDING) ? 1 : 0; 00248 slots_per_frame = (header->layer == MAD_LAYER_III && 00249 (header->flags & MAD_FLAG_LSF_EXT)) ? 72 : 144; 00250 00251 while (mad_stream_sync(stream) == 0) { 00252 struct mad_stream peek_stream; 00253 struct mad_header peek_header; 00254 00255 peek_stream = *stream; 00256 peek_header = *header; 00257 00258 if (decode_header(&peek_header, &peek_stream) == 0 && 00259 peek_header.layer == header->layer && 00260 peek_header.samplerate == header->samplerate) { 00261 unsigned int N; 00262 00263 ptr = mad_bit_nextbyte(&stream->ptr); 00264 00265 N = ptr - stream->this_frame; 00266 00267 if (header->layer == MAD_LAYER_I) { 00268 rate = (unsigned long) header->samplerate * 00269 (N - 4 * pad_slot + 4) / 48 / 1000; 00270 } 00271 else { 00272 rate = (unsigned long) header->samplerate * 00273 (N - pad_slot + 1) / slots_per_frame / 1000; 00274 } 00275 00276 if (rate >= 8) 00277 break; 00278 } 00279 00280 mad_bit_skip(&stream->ptr, 8); 00281 } 00282 00283 stream->ptr = keep_ptr; 00284 00285 if (rate < 8 || (header->layer == MAD_LAYER_III && rate > 640)) { 00286 stream->error = MAD_ERROR_LOSTSYNC; 00287 return -1; 00288 } 00289 00290 stream->freerate = rate * 1000; 00291 00292 return 0; 00293 } 00294 00295 /* 00296 * NAME: header->decode() 00297 * DESCRIPTION: read the next frame header from the stream 00298 */ 00299 int mad_header_decode(struct mad_header *header, struct mad_stream *stream) 00300 { 00301 register unsigned char const *ptr, *end; 00302 unsigned int pad_slot, N; 00303 00304 ptr = stream->next_frame; 00305 end = stream->bufend; 00306 00307 if (ptr == 0) { 00308 stream->error = MAD_ERROR_BUFPTR; 00309 goto fail; 00310 } 00311 00312 /* stream skip */ 00313 if (stream->skiplen) { 00314 if (!stream->sync) 00315 ptr = stream->this_frame; 00316 00317 if (end - ptr < stream->skiplen) { 00318 stream->skiplen -= end - ptr; 00319 stream->next_frame = end; 00320 00321 stream->error = MAD_ERROR_BUFLEN; 00322 goto fail; 00323 } 00324 00325 ptr += stream->skiplen; 00326 stream->skiplen = 0; 00327 00328 stream->sync = 1; 00329 } 00330 00331 sync: 00332 /* synchronize */ 00333 if (stream->sync) { 00334 if (end - ptr < MAD_BUFFER_GUARD) { 00335 stream->next_frame = ptr; 00336 00337 stream->error = MAD_ERROR_BUFLEN; 00338 goto fail; 00339 } 00340 else if (!(ptr[0] == 0xff && (ptr[1] & 0xe0) == 0xe0)) { 00341 /* mark point where frame sync word was expected */ 00342 stream->this_frame = ptr; 00343 stream->next_frame = ptr + 1; 00344 00345 stream->error = MAD_ERROR_LOSTSYNC; 00346 goto fail; 00347 } 00348 } 00349 else { 00350 mad_bit_init(&stream->ptr, ptr); 00351 00352 if (mad_stream_sync(stream) == -1) { 00353 if (end - stream->next_frame >= MAD_BUFFER_GUARD) 00354 stream->next_frame = end - MAD_BUFFER_GUARD; 00355 00356 stream->error = MAD_ERROR_BUFLEN; 00357 goto fail; 00358 } 00359 00360 ptr = mad_bit_nextbyte(&stream->ptr); 00361 } 00362 00363 /* begin processing */ 00364 stream->this_frame = ptr; 00365 stream->next_frame = ptr + 1; /* possibly bogus sync word */ 00366 00367 mad_bit_init(&stream->ptr, stream->this_frame); 00368 00369 if (decode_header(header, stream) == -1) 00370 goto fail; 00371 00372 /* calculate frame duration */ 00373 mad_timer_set(&header->duration, 0, 00374 32 * MAD_NSBSAMPLES(header), header->samplerate); 00375 00376 /* calculate free bit rate */ 00377 if (header->bitrate == 0) { 00378 if ((stream->freerate == 0 || !stream->sync || 00379 (header->layer == MAD_LAYER_III && stream->freerate > 640000)) && 00380 free_bitrate(stream, header) == -1) 00381 goto fail; 00382 00383 header->bitrate = stream->freerate; 00384 header->flags |= MAD_FLAG_FREEFORMAT; 00385 } 00386 00387 /* calculate beginning of next frame */ 00388 pad_slot = (header->flags & MAD_FLAG_PADDING) ? 1 : 0; 00389 00390 if (header->layer == MAD_LAYER_I) 00391 N = ((12 * header->bitrate / header->samplerate) + pad_slot) * 4; 00392 else { 00393 unsigned int slots_per_frame; 00394 00395 slots_per_frame = (header->layer == MAD_LAYER_III && 00396 (header->flags & MAD_FLAG_LSF_EXT)) ? 72 : 144; 00397 00398 N = (slots_per_frame * header->bitrate / header->samplerate) + pad_slot; 00399 } 00400 00401 /* verify there is enough data left in buffer to decode this frame */ 00402 if (N + MAD_BUFFER_GUARD > end - stream->this_frame) { 00403 stream->next_frame = stream->this_frame; 00404 00405 stream->error = MAD_ERROR_BUFLEN; 00406 goto fail; 00407 } 00408 00409 stream->next_frame = stream->this_frame + N; 00410 00411 if (!stream->sync) { 00412 /* check that a valid frame header follows this frame */ 00413 00414 ptr = stream->next_frame; 00415 if (!(ptr[0] == 0xff && (ptr[1] & 0xe0) == 0xe0)) { 00416 ptr = stream->next_frame = stream->this_frame + 1; 00417 goto sync; 00418 } 00419 00420 stream->sync = 1; 00421 } 00422 00423 header->flags |= MAD_FLAG_INCOMPLETE; 00424 00425 return 0; 00426 00427 fail: 00428 stream->sync = 0; 00429 00430 return -1; 00431 } 00432 00433 /* 00434 * NAME: frame->decode() 00435 * DESCRIPTION: decode a single frame from a bitstream 00436 */ 00437 int mad_frame_decode(struct mad_frame *frame, struct mad_stream *stream) 00438 { 00439 frame->options = stream->options; 00440 00441 /* header() */ 00442 /* error_check() */ 00443 00444 if (!(frame->header.flags & MAD_FLAG_INCOMPLETE) && 00445 mad_header_decode(&frame->header, stream) == -1) 00446 goto fail; 00447 00448 /* audio_data() */ 00449 00450 frame->header.flags &= ~MAD_FLAG_INCOMPLETE; 00451 00452 if (decoder_table[frame->header.layer - 1](stream, frame) == -1) { 00453 if (!MAD_RECOVERABLE(stream->error)) 00454 stream->next_frame = stream->this_frame; 00455 00456 goto fail; 00457 } 00458 00459 /* ancillary_data() */ 00460 00461 if (frame->header.layer != MAD_LAYER_III) { 00462 struct mad_bitptr next_frame; 00463 00464 mad_bit_init(&next_frame, stream->next_frame); 00465 00466 stream->anc_ptr = stream->ptr; 00467 stream->anc_bitlen = mad_bit_length(&stream->ptr, &next_frame); 00468 00469 mad_bit_finish(&next_frame); 00470 } 00471 00472 return 0; 00473 00474 fail: 00475 stream->anc_bitlen = 0; 00476 return -1; 00477 } 00478 00479 /* 00480 * NAME: frame->mute() 00481 * DESCRIPTION: zero all subband values so the frame becomes silent 00482 */ 00483 void mad_frame_mute(struct mad_frame *frame) 00484 { 00485 unsigned int s, sb; 00486 00487 for (s = 0; s < 36; ++s) { 00488 for (sb = 0; sb < 32; ++sb) { 00489 frame->sbsample[0][s][sb] = 00490 frame->sbsample[1][s][sb] = 0; 00491 } 00492 } 00493 00494 if (frame->overlap) { 00495 for (s = 0; s < 18; ++s) { 00496 for (sb = 0; sb < 32; ++sb) { 00497 (frame->overlap)[0][sb][s] = 00498 (frame->overlap)[1][sb][s] = 0; 00499 } 00500 } 00501 } 00502 }
Generated on Tue Jul 12 2022 22:28:17 by 1.7.2