/*************************************************************************** * __________ __ ___. * Open \______ \ ____ ____ | | _\_ |__ _______ ___ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ * \/ \/ \/ \/ \/ * $Id$ * * Copyright (C) 2002 by Daniel Stenberg * * All files in this archive are subject to the GNU General Public License. * See the file COPYING in the source tree root for full license agreement. * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * ****************************************************************************/ /* * Parts of this code has been stolen from the Ample project and was written * by David Härdeman. It has since been extended and enhanced pretty much by * all sorts of friendly Rockbox people. * * A nice reference for MPEG header info: * http://rockbox.haxx.se/docs/mpeghdr.html * */ #include #include #include #include #include "debug.h" #include "mp3data.h" #include "file.h" #define DEBUG_VERBOSE #define BYTES2INT(b1,b2,b3,b4) (((b1 & 0xFF) << (3*8)) | \ ((b2 & 0xFF) << (2*8)) | \ ((b3 & 0xFF) << (1*8)) | \ ((b4 & 0xFF) << (0*8))) #define SYNC_MASK (0x7ff << 21) #define VERSION_MASK (3 << 19) #define LAYER_MASK (3 << 17) #define PROTECTION_MASK (1 << 16) #define BITRATE_MASK (0xf << 12) #define SAMPLERATE_MASK (3 << 10) #define PADDING_MASK (1 << 9) #define PRIVATE_MASK (1 << 8) #define CHANNELMODE_MASK (3 << 6) #define MODE_EXT_MASK (3 << 4) #define COPYRIGHT_MASK (1 << 3) #define ORIGINAL_MASK (1 << 2) #define EMPHASIS_MASK 3 /* Table of bitrates for MP3 files, all values in kilo. * Indexed by version, layer and value of bit 15-12 in header. */ const int bitrate_table[2][3][16] = { { {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,0}, {0,32,48,56, 64,80, 96, 112,128,160,192,224,256,320,384,0}, {0,32,40,48, 56,64, 80, 96, 112,128,160,192,224,256,320,0} }, { {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,0}, {0, 8,16,24,32,40,48, 56, 64, 80, 96,112,128,144,160,0}, {0, 8,16,24,32,40,48, 56, 64, 80, 96,112,128,144,160,0} } }; /* Table of samples per frame for MP3 files. * Indexed by layer. Multiplied with 1000. */ const int bs[3] = {384000, 1152000, 1152000}; /* Table of sample frequency for MP3 files. * Indexed by version and layer. */ const int freqtab[][4] = { {11025, 12000, 8000, 0}, /* MPEG version 2.5 */ {44100, 48000, 32000, 0}, /* MPEG Version 1 */ {22050, 24000, 16000, 0}, /* MPEG version 2 */ }; /* check if 'head' is a valid mp3 frame header */ static bool is_mp3frameheader(unsigned long head) { if ((head & SYNC_MASK) != (unsigned long)SYNC_MASK) /* bad sync? */ return false; if ((head & VERSION_MASK) == (1 << 19)) /* bad version? */ return false; if (!(head & LAYER_MASK)) /* no layer? */ return false; if ((head & BITRATE_MASK) == BITRATE_MASK) /* bad bitrate? */ return false; if (!(head & BITRATE_MASK)) /* no bitrate? */ return false; if ((head & SAMPLERATE_MASK) == SAMPLERATE_MASK) /* bad sample rate? */ return false; if (((head >> 19) & 1) == 1 && ((head >> 17) & 3) == 3 && ((head >> 16) & 1) == 1) return false; if ((head & 0xffff0000) == 0xfffe0000) return false; return true; } static bool mp3headerinfo(struct mp3info *info, unsigned long header) { int bittable = 0; int bitindex; int freqindex; /* MPEG Audio Version */ switch(header & VERSION_MASK) { case 0: /* MPEG version 2.5 is not an official standard */ info->version = MPEG_VERSION2_5; bittable = MPEG_VERSION2 - 1; /* use the V2 bit rate table */ break; case (1 << 19): return false; case (2 << 19): /* MPEG version 2 (ISO/IEC 13818-3) */ info->version = MPEG_VERSION2; bittable = MPEG_VERSION2 - 1; break; case (3 << 19): /* MPEG version 1 (ISO/IEC 11172-3) */ info->version = MPEG_VERSION1; bittable = MPEG_VERSION1 - 1; break; } switch(header & LAYER_MASK) { case 0: return false; case (1 << 17): info->layer = 2; break; case (2 << 17): info->layer = 1; break; case (3 << 17): info->layer = 0; break; } info->protection = (header & PROTECTION_MASK)?true:false; /* Bitrate */ bitindex = (header & 0xf000) >> 12; info->bitrate = bitrate_table[bittable][info->layer][bitindex]; if(info->bitrate == 0) return false; /* Sampling frequency */ freqindex = (header & 0x0C00) >> 10; info->frequency = freqtab[info->version][freqindex]; if(info->frequency == 0) return false; info->padding = (header & 0x0200)?1:0; /* Calculate number of bytes, calculation depends on layer */ switch(info->layer) { case 0: info->frame_size = info->bitrate * 48000; info->frame_size /= freqtab[info->version][freqindex] << bittable; break; case 1: case 2: info->frame_size = info->bitrate * 144000; info->frame_size /= freqtab[info->version][freqindex] << bittable; break; default: info->frame_size = 1; } info->frame_size += info->padding; /* Calculate time per frame */ info->frame_time = bs[info->layer] / (freqtab[info->version][freqindex] << bittable); info->channel_mode = (header & 0xc0) >> 6; info->mode_extension = (header & 0x30) >> 4; info->emphasis = header & 3; #ifdef DEBUG_VERBOSE DEBUGF( "Header: %08x, Ver %d, lay %d, bitr %d, freq %d, " "chmode %d, mode_ext %d, emph %d, bytes: %d time: %d\n", header, info->version, info->layer, info->bitrate, info->frequency, info->channel_mode, info->mode_extension, info->emphasis, info->frame_size, info->frame_time); #endif return true; } unsigned long find_next_frame(int fd, int *offset, int max_offset, unsigned long last_header) { unsigned long header=0; unsigned char tmp; int i; int pos = 0; /* We remember the last header we found, to use as a template to see if the header we find has the same frequency, layer etc */ last_header &= 0xffff0c00; /* Fill up header with first 24 bits */ for(i = 0; i < 3; i++) { header <<= 8; if(!read(fd, &tmp, 1)) return 0; header |= tmp; pos++; } do { header <<= 8; if(!read(fd, &tmp, 1)) return 0; header |= tmp; pos++; if(max_offset > 0 && pos > max_offset) return 0; } while(!is_mp3frameheader(header) || (last_header?((header & 0xffff0c00) != last_header):false)); *offset = pos - 4; #ifdef DEBUG if(*offset) DEBUGF("Warning: skipping %d bytes of garbage\n", *offset); #endif return header; } #ifdef SIMULATOR unsigned char mp3buf[0x100000]; unsigned char mp3end[1]; #else extern unsigned char mp3buf[]; extern unsigned char mp3end[]; #endif static int fnf_read_index; static int fnf_buf_len; static int buf_getbyte(int fd, unsigned char *c) { if(fnf_read_index < fnf_buf_len) { *c = mp3buf[fnf_read_index++]; return 1; } else { fnf_buf_len = read(fd, mp3buf, mp3end - mp3buf); if(fnf_buf_len < 0) return -1; fnf_read_index = 0; if(fnf_buf_len > 0) { *c = mp3buf[fnf_read_index++]; return 1; } else return 0; } return 0; } static int buf_seek(int fd, int len) { fnf_read_index += len; if(fnf_read_index > fnf_buf_len) { len = fnf_read_index - fnf_buf_len; fnf_buf_len = read(fd, mp3buf, mp3end - mp3buf); if(fnf_buf_len < 0) return -1; fnf_read_index = 0; fnf_read_index += len; } if(fnf_read_index > fnf_buf_len) { return -1; } else return 0; } static void buf_init(void) { fnf_buf_len = 0; fnf_read_index = 0; } unsigned long buf_find_next_frame(int fd, int *offset, int max_offset, unsigned long last_header) { unsigned long header=0; unsigned char tmp; int i; int pos = 0; /* We remember the last header we found, to use as a template to see if the header we find has the same frequency, layer etc */ last_header &= 0xffff0c00; /* Fill up header with first 24 bits */ for(i = 0; i < 3; i++) { header <<= 8; if(!buf_getbyte(fd, &tmp)) return 0; header |= tmp; pos++; } do { header <<= 8; if(!buf_getbyte(fd, &tmp)) return 0; header |= tmp; pos++; if(max_offset > 0 && pos > max_offset) return 0; } while(!is_mp3frameheader(header) || (last_header?((header & 0xffff0c00) != last_header):false)); *offset = pos - 4; #ifdef DEBUG if(*offset) DEBUGF("Warning: skipping %d bytes of garbage\n", *offset); #endif return header; } int get_mp3file_info(int fd, struct mp3info *info) { unsigned char frame[1500]; unsigned char *vbrheader; unsigned long header; int bytecount; int num_offsets; int frames_per_entry; int i; int offset; int j; int tmp; header = find_next_frame(fd, &bytecount, 0x20000, 0); /* Quit if we haven't found a valid header within 128K */ if(header == 0) return -1; memset(info, 0, sizeof(struct mp3info)); if(!mp3headerinfo(info, header)) return -2; /* OK, we have found a frame. Let's see if it has a Xing header */ if(read(fd, frame, info->frame_size-4) < 0) return -3; /* calculate position of VBR header */ if ( info->version == MPEG_VERSION1 ) { if (info->channel_mode == 3) /* mono */ vbrheader = frame + 17; else vbrheader = frame + 32; } else { if (info->channel_mode == 3) /* mono */ vbrheader = frame + 9; else vbrheader = frame + 17; } if (vbrheader[0] == 'X' && vbrheader[1] == 'i' && vbrheader[2] == 'n' && vbrheader[3] == 'g') { int i = 8; /* Where to start parsing info */ DEBUGF("Xing header\n"); /* Remember where in the file the Xing header is */ info->vbr_header_pos = lseek(fd, 0, SEEK_CUR) - info->frame_size; /* We want to skip the Xing frame when playing the stream */ bytecount += info->frame_size; /* Now get the next frame to find out the real info about the mp3 stream */ header = find_next_frame(fd, &tmp, 0x20000, 0); if(header == 0) return -4; if(!mp3headerinfo(info, header)) return -5; /* Yes, it is a VBR file */ info->is_vbr = true; info->is_xing_vbr = true; if(vbrheader[7] & VBR_FRAMES_FLAG) /* Is the frame count there? */ { info->frame_count = BYTES2INT(vbrheader[i], vbrheader[i+1], vbrheader[i+2], vbrheader[i+3]); info->file_time = info->frame_count * info->frame_time; i += 4; } if(vbrheader[7] & VBR_BYTES_FLAG) /* Is byte count there? */ { info->byte_count = BYTES2INT(vbrheader[i], vbrheader[i+1], vbrheader[i+2], vbrheader[i+3]); i += 4; } if(info->file_time && info->byte_count) info->bitrate = info->byte_count * 8 / info->file_time; else info->bitrate = 0; if(vbrheader[7] & VBR_TOC_FLAG) /* Is table-of-contents there? */ { memcpy( info->toc, vbrheader+i, 100 ); } } if (vbrheader[0] == 'V' && vbrheader[1] == 'B' && vbrheader[2] == 'R' && vbrheader[3] == 'I') { DEBUGF("VBRI header\n"); /* We want to skip the VBRI frame when playing the stream */ bytecount += info->frame_size; /* Now get the next frame to find out the real info about the mp3 stream */ header = find_next_frame(fd, &bytecount, 0x20000, 0); if(header == 0) return -6; if(!mp3headerinfo(info, header)) return -7; DEBUGF("%04x: %04x %04x ", 0, header >> 16, header & 0xffff); for(i = 4;i < (int)sizeof(frame)-4;i+=2) { if(i % 16 == 0) { DEBUGF("\n%04x: ", i-4); } DEBUGF("%04x ", (frame[i-4] << 8) | frame[i-4+1]); } DEBUGF("\n"); /* Yes, it is a FhG VBR file */ info->is_vbr = true; info->is_vbri_vbr = true; info->has_toc = false; /* We don't parse the TOC (yet) */ info->byte_count = BYTES2INT(vbrheader[10], vbrheader[11], vbrheader[12], vbrheader[13]); info->frame_count = BYTES2INT(vbrheader[14], vbrheader[15], vbrheader[16], vbrheader[17]); info->file_time = info->frame_count * info->frame_time; info->bitrate = info->byte_count * 8 / info->file_time; /* We don't parse the TOC, since we don't yet know how to (FIXME) */ num_offsets = BYTES2INT(0, 0, vbrheader[18], vbrheader[19]); frames_per_entry = BYTES2INT(0, 0, vbrheader[24], vbrheader[25]); DEBUGF("Frame size (%dkpbs): %d bytes (0x%x)\n", info->bitrate, info->frame_size, info->frame_size); DEBUGF("Frame count: %x\n", info->frame_count); DEBUGF("Byte count: %x\n", info->byte_count); DEBUGF("Offsets: %d\n", num_offsets); DEBUGF("Frames/entry: %d\n", frames_per_entry); offset = 0; for(i = 0;i < num_offsets;i++) { j = BYTES2INT(0, 0, vbrheader[26+i*2], vbrheader[27+i*2]); offset += j; DEBUGF("%03d: %x (%x)\n", i, offset - bytecount, j); } } /* Is it a LAME Info frame? */ if (vbrheader[0] == 'I' && vbrheader[1] == 'n' && vbrheader[2] == 'f' && vbrheader[3] == 'o') { /* Make sure we skip this frame in playback */ bytecount += info->frame_size; } return bytecount; } /* This is an MP3 header, 128kbit/s, with silence MPEG version and sample frequency are not set */ static const unsigned char xing_frame_header[] = { 0xff, 0xe2, 0x90, 0x64, 0x86, 0x1f }; static const char cooltext[] = "Rockbox rocks"; static void int2bytes(unsigned char *buf, int val) { buf[0] = (val >> 24) & 0xff; buf[1] = (val >> 16) & 0xff; buf[2] = (val >> 8) & 0xff; buf[3] = val & 0xff; } int count_mp3_frames(int fd, int startpos, int filesize, void (*progressfunc)(int)) { unsigned long header = 0; struct mp3info info; int num_frames; int bytes; int cnt; int progress_chunk = filesize / 50; /* Max is 50%, in 1% increments */ int progress_cnt = 0; bool is_vbr = false; int last_bitrate = 0; if(lseek(fd, startpos, SEEK_SET) < 0) return -1; buf_init(); /* Find out the total number of frames */ num_frames = 0; cnt = 0; while((header = buf_find_next_frame(fd, &bytes, -1, header))) { mp3headerinfo(&info, header); /* See if this really is a VBR file */ if(last_bitrate && info.bitrate != last_bitrate) { is_vbr = true; } last_bitrate = info.bitrate; buf_seek(fd, info.frame_size-4); num_frames++; if(progressfunc) { cnt += bytes + info.frame_size; if(cnt > progress_chunk) { progress_cnt++; progressfunc(progress_cnt); cnt = 0; } } } DEBUGF("Total number of frames: %d\n", num_frames); if(is_vbr) return num_frames; else { DEBUGF("Not a VBR file\n"); return 0; } } /* Note: mpeg_version and sample_rate are 2-bit values, as specified by the MPEG frame standard. See the tables above. */ int create_xing_header(int fd, int startpos, int filesize, unsigned char *buf, int num_frames, int mpeg_version, int sample_rate, void (*progressfunc)(int), bool generate_toc) { unsigned long header = 0; unsigned long saved_header; struct mp3info info; int pos, last_pos; int i, j; int bytes; int filepos; int tocentry; int x; int index; DEBUGF("create_xing_header()\n"); /* Create the frame header */ memset(buf, 0, 1500); memcpy(buf, xing_frame_header, 6); lseek(fd, startpos, SEEK_SET); buf_init(); buf[36] = 'X'; buf[36+1] = 'i'; buf[36+2] = 'n'; buf[36+3] = 'g'; int2bytes(&buf[36+4], ((num_frames?VBR_FRAMES_FLAG:0) | (filesize?VBR_BYTES_FLAG:0) | (generate_toc?VBR_TOC_FLAG:0))); index = 36+8; if(num_frames) { int2bytes(&buf[index], num_frames); index += 4; } if(filesize) { int2bytes(&buf[index], filesize - startpos); index += 4; } if(generate_toc) { /* Generate filepos table */ last_pos = 0; filepos = 0; header = 0; x = 0; for(i = 0;i < 100;i++) { /* Calculate the absolute frame number for this seek point */ pos = i * num_frames / 100; /* Advance from the last seek point to this one */ for(j = 0;j < pos - last_pos;j++) { DEBUGF("fpos: %x frame no: %x\n", filepos, x++); header = buf_find_next_frame(fd, &bytes, -1, header); mp3headerinfo(&info, header); buf_seek(fd, info.frame_size-4); filepos += info.frame_size; } /* Save one header for later use */ if(i == 1) saved_header = header; if(progressfunc) { progressfunc(50 + i/2); } tocentry = filepos * 256 / filesize; DEBUGF("Pos %d: %d relpos: %d filepos: %x tocentry: %x\n", i, pos, pos-last_pos, filepos, tocentry); /* Fill in the TOC entry */ buf[index + i] = tocentry; last_pos = pos; } } memcpy(buf + index + 100, cooltext, sizeof(cooltext)); /* We must fill in the correct sample rate and mpeg version. If the TOC should be generated, we take that data from the actual stream. If not, we use the supplied parameters. */ if(generate_toc) { saved_header &= (VERSION_MASK | SAMPLERATE_MASK); buf[1] |= (saved_header >> 16) & 0xff; buf[2] |= (saved_header >> 8) & 0xff; } else { buf[1] |= mpeg_version << 3; buf[2] |= sample_rate << 2; } /* Now get the length of the newly created frame */ header = BYTES2INT(buf[0], buf[1], buf[2], buf[3]); mp3headerinfo(&info, header); #ifdef DEBUG for(i = 0;i < 417;i++) { if(i && !(i % 16)) DEBUGF("\n"); DEBUGF("%02x ", buf[i]); } #endif return info.frame_size; }