diff options
Diffstat (limited to 'firmware/mp3data.c')
-rw-r--r-- | firmware/mp3data.c | 782 |
1 files changed, 0 insertions, 782 deletions
diff --git a/firmware/mp3data.c b/firmware/mp3data.c deleted file mode 100644 index 80870cd8cd..0000000000 --- a/firmware/mp3data.c +++ /dev/null | |||
@@ -1,782 +0,0 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2002 by Daniel Stenberg | ||
11 | * | ||
12 | * This program is free software; you can redistribute it and/or | ||
13 | * modify it under the terms of the GNU General Public License | ||
14 | * as published by the Free Software Foundation; either version 2 | ||
15 | * of the License, or (at your option) any later version. | ||
16 | * | ||
17 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
18 | * KIND, either express or implied. | ||
19 | * | ||
20 | ****************************************************************************/ | ||
21 | |||
22 | /* | ||
23 | * Parts of this code has been stolen from the Ample project and was written | ||
24 | * by David Härdeman. It has since been extended and enhanced pretty much by | ||
25 | * all sorts of friendly Rockbox people. | ||
26 | * | ||
27 | * A nice reference for MPEG header info: | ||
28 | * http://rockbox.haxx.se/docs/mpeghdr.html | ||
29 | * | ||
30 | */ | ||
31 | |||
32 | #include <stdio.h> | ||
33 | #include <stdlib.h> | ||
34 | #include <string.h> | ||
35 | #include <stdbool.h> | ||
36 | #include <limits.h> | ||
37 | #include "debug.h" | ||
38 | #include "logf.h" | ||
39 | #include "mp3data.h" | ||
40 | #include "file.h" | ||
41 | #include "buffer.h" | ||
42 | |||
43 | // #define DEBUG_VERBOSE | ||
44 | |||
45 | #define SYNC_MASK (0x7ffL << 21) | ||
46 | #define VERSION_MASK (3L << 19) | ||
47 | #define LAYER_MASK (3L << 17) | ||
48 | #define PROTECTION_MASK (1L << 16) | ||
49 | #define BITRATE_MASK (0xfL << 12) | ||
50 | #define SAMPLERATE_MASK (3L << 10) | ||
51 | #define PADDING_MASK (1L << 9) | ||
52 | #define PRIVATE_MASK (1L << 8) | ||
53 | #define CHANNELMODE_MASK (3L << 6) | ||
54 | #define MODE_EXT_MASK (3L << 4) | ||
55 | #define COPYRIGHT_MASK (1L << 3) | ||
56 | #define ORIGINAL_MASK (1L << 2) | ||
57 | #define EMPHASIS_MASK 3L | ||
58 | |||
59 | /* MPEG Version table, sorted by version index */ | ||
60 | static const signed char version_table[4] = { | ||
61 | MPEG_VERSION2_5, -1, MPEG_VERSION2, MPEG_VERSION1 | ||
62 | }; | ||
63 | |||
64 | /* Bitrate table for mpeg audio, indexed by row index and birate index */ | ||
65 | static const short bitrates[5][16] = { | ||
66 | {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,0}, /* V1 L1 */ | ||
67 | {0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,0}, /* V1 L2 */ | ||
68 | {0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,0}, /* V1 L3 */ | ||
69 | {0,32,48,56, 64, 80, 96,112,128,144,160,176,192,224,256,0}, /* V2 L1 */ | ||
70 | {0, 8,16,24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160,0} /* V2 L2+L3 */ | ||
71 | }; | ||
72 | |||
73 | /* Bitrate pointer table, indexed by version and layer */ | ||
74 | static const short *bitrate_table[3][3] = | ||
75 | { | ||
76 | {bitrates[0], bitrates[1], bitrates[2]}, | ||
77 | {bitrates[3], bitrates[4], bitrates[4]}, | ||
78 | {bitrates[3], bitrates[4], bitrates[4]} | ||
79 | }; | ||
80 | |||
81 | /* Sampling frequency table, indexed by version and frequency index */ | ||
82 | static const unsigned short freq_table[3][3] = | ||
83 | { | ||
84 | {44100, 48000, 32000}, /* MPEG Version 1 */ | ||
85 | {22050, 24000, 16000}, /* MPEG version 2 */ | ||
86 | {11025, 12000, 8000}, /* MPEG version 2.5 */ | ||
87 | }; | ||
88 | |||
89 | unsigned long bytes2int(unsigned long b0, | ||
90 | unsigned long b1, | ||
91 | unsigned long b2, | ||
92 | unsigned long b3) | ||
93 | { | ||
94 | return (((long)(b0 & 0xFF) << (3*8)) | | ||
95 | ((long)(b1 & 0xFF) << (2*8)) | | ||
96 | ((long)(b2 & 0xFF) << (1*8)) | | ||
97 | ((long)(b3 & 0xFF) << (0*8))); | ||
98 | } | ||
99 | |||
100 | /* check if 'head' is a valid mp3 frame header */ | ||
101 | static bool is_mp3frameheader(unsigned long head) | ||
102 | { | ||
103 | if ((head & SYNC_MASK) != (unsigned long)SYNC_MASK) /* bad sync? */ | ||
104 | return false; | ||
105 | if ((head & VERSION_MASK) == (1L << 19)) /* bad version? */ | ||
106 | return false; | ||
107 | if (!(head & LAYER_MASK)) /* no layer? */ | ||
108 | return false; | ||
109 | #if CONFIG_CODEC != SWCODEC | ||
110 | /* The MAS can't decode layer 1, so treat layer 1 data as invalid */ | ||
111 | if ((head & LAYER_MASK) == LAYER_MASK) | ||
112 | return false; | ||
113 | #endif | ||
114 | if ((head & BITRATE_MASK) == BITRATE_MASK) /* bad bitrate? */ | ||
115 | return false; | ||
116 | if (!(head & BITRATE_MASK)) /* no bitrate? */ | ||
117 | return false; | ||
118 | if ((head & SAMPLERATE_MASK) == SAMPLERATE_MASK) /* bad sample rate? */ | ||
119 | return false; | ||
120 | |||
121 | return true; | ||
122 | } | ||
123 | |||
124 | static bool mp3headerinfo(struct mp3info *info, unsigned long header) | ||
125 | { | ||
126 | int bitindex, freqindex; | ||
127 | |||
128 | /* MPEG Audio Version */ | ||
129 | if ((header & VERSION_MASK) >> 19 >= sizeof(version_table)) | ||
130 | return false; | ||
131 | |||
132 | info->version = version_table[(header & VERSION_MASK) >> 19]; | ||
133 | if (info->version < 0) | ||
134 | return false; | ||
135 | |||
136 | /* Layer */ | ||
137 | info->layer = 3 - ((header & LAYER_MASK) >> 17); | ||
138 | if (info->layer == 3) | ||
139 | return false; | ||
140 | |||
141 | info->protection = (header & PROTECTION_MASK) ? true : false; | ||
142 | |||
143 | /* Bitrate */ | ||
144 | bitindex = (header & BITRATE_MASK) >> 12; | ||
145 | info->bitrate = bitrate_table[info->version][info->layer][bitindex]; | ||
146 | if(info->bitrate == 0) | ||
147 | return false; | ||
148 | |||
149 | /* Sampling frequency */ | ||
150 | freqindex = (header & SAMPLERATE_MASK) >> 10; | ||
151 | if (freqindex == 3) | ||
152 | return false; | ||
153 | info->frequency = freq_table[info->version][freqindex]; | ||
154 | |||
155 | info->padding = (header & PADDING_MASK) ? 1 : 0; | ||
156 | |||
157 | /* Calculate number of bytes, calculation depends on layer */ | ||
158 | if (info->layer == 0) { | ||
159 | info->frame_samples = 384; | ||
160 | info->frame_size = (12000 * info->bitrate / info->frequency | ||
161 | + info->padding) * 4; | ||
162 | } | ||
163 | else { | ||
164 | if ((info->version > MPEG_VERSION1) && (info->layer == 2)) | ||
165 | info->frame_samples = 576; | ||
166 | else | ||
167 | info->frame_samples = 1152; | ||
168 | info->frame_size = (1000/8) * info->frame_samples * info->bitrate | ||
169 | / info->frequency + info->padding; | ||
170 | } | ||
171 | |||
172 | /* Frametime fraction denominator */ | ||
173 | if (freqindex != 0) { /* 48/32/24/16/12/8 kHz */ | ||
174 | info->ft_den = 1; /* integer number of milliseconds */ | ||
175 | } | ||
176 | else { /* 44.1/22.05/11.025 kHz */ | ||
177 | if (info->layer == 0) /* layer 1 */ | ||
178 | info->ft_den = 147; | ||
179 | else /* layer 2+3 */ | ||
180 | info->ft_den = 49; | ||
181 | } | ||
182 | /* Frametime fraction numerator */ | ||
183 | info->ft_num = 1000 * info->ft_den * info->frame_samples / info->frequency; | ||
184 | |||
185 | info->channel_mode = (header & CHANNELMODE_MASK) >> 6; | ||
186 | info->mode_extension = (header & MODE_EXT_MASK) >> 4; | ||
187 | info->emphasis = header & EMPHASIS_MASK; | ||
188 | |||
189 | #ifdef DEBUG_VERBOSE | ||
190 | DEBUGF( "Header: %08lx, Ver %d, lay %d, bitr %d, freq %ld, " | ||
191 | "chmode %d, mode_ext %d, emph %d, bytes: %d time: %d/%d\n", | ||
192 | header, info->version, info->layer+1, info->bitrate, | ||
193 | info->frequency, info->channel_mode, info->mode_extension, | ||
194 | info->emphasis, info->frame_size, info->ft_num, info->ft_den); | ||
195 | #endif | ||
196 | return true; | ||
197 | } | ||
198 | |||
199 | static unsigned long __find_next_frame(int fd, long *offset, long max_offset, | ||
200 | unsigned long last_header, | ||
201 | int(*getfunc)(int fd, unsigned char *c)) | ||
202 | { | ||
203 | unsigned long header=0; | ||
204 | unsigned char tmp; | ||
205 | int i; | ||
206 | |||
207 | long pos = 0; | ||
208 | |||
209 | /* We remember the last header we found, to use as a template to see if | ||
210 | the header we find has the same frequency, layer etc */ | ||
211 | last_header &= 0xffff0c00; | ||
212 | |||
213 | /* Fill up header with first 24 bits */ | ||
214 | for(i = 0; i < 3; i++) { | ||
215 | header <<= 8; | ||
216 | if(!getfunc(fd, &tmp)) | ||
217 | return 0; | ||
218 | header |= tmp; | ||
219 | pos++; | ||
220 | } | ||
221 | |||
222 | do { | ||
223 | header <<= 8; | ||
224 | if(!getfunc(fd, &tmp)) | ||
225 | return 0; | ||
226 | header |= tmp; | ||
227 | pos++; | ||
228 | if(max_offset > 0 && pos > max_offset) | ||
229 | return 0; | ||
230 | } while(!is_mp3frameheader(header) || | ||
231 | (last_header?((header & 0xffff0c00) != last_header):false)); | ||
232 | |||
233 | *offset = pos - 4; | ||
234 | |||
235 | #if defined(DEBUG) | ||
236 | if(*offset) | ||
237 | DEBUGF("Warning: skipping %ld bytes of garbage\n", *offset); | ||
238 | #endif | ||
239 | |||
240 | return header; | ||
241 | } | ||
242 | |||
243 | static int fileread(int fd, unsigned char *c) | ||
244 | { | ||
245 | return read(fd, c, 1); | ||
246 | } | ||
247 | |||
248 | unsigned long find_next_frame(int fd, long *offset, long max_offset, unsigned long last_header) | ||
249 | { | ||
250 | return __find_next_frame(fd, offset, max_offset, last_header, fileread); | ||
251 | } | ||
252 | |||
253 | #ifndef __PCTOOL__ | ||
254 | static int fnf_read_index; | ||
255 | static int fnf_buf_len; | ||
256 | |||
257 | static int buf_getbyte(int fd, unsigned char *c) | ||
258 | { | ||
259 | if(fnf_read_index < fnf_buf_len) | ||
260 | { | ||
261 | *c = audiobuf[fnf_read_index++]; | ||
262 | return 1; | ||
263 | } | ||
264 | else | ||
265 | { | ||
266 | fnf_buf_len = read(fd, audiobuf, audiobufend - audiobuf); | ||
267 | if(fnf_buf_len < 0) | ||
268 | return -1; | ||
269 | |||
270 | fnf_read_index = 0; | ||
271 | |||
272 | if(fnf_buf_len > 0) | ||
273 | { | ||
274 | *c = audiobuf[fnf_read_index++]; | ||
275 | return 1; | ||
276 | } | ||
277 | else | ||
278 | return 0; | ||
279 | } | ||
280 | return 0; | ||
281 | } | ||
282 | |||
283 | static int buf_seek(int fd, int len) | ||
284 | { | ||
285 | fnf_read_index += len; | ||
286 | if(fnf_read_index > fnf_buf_len) | ||
287 | { | ||
288 | len = fnf_read_index - fnf_buf_len; | ||
289 | |||
290 | fnf_buf_len = read(fd, audiobuf, audiobufend - audiobuf); | ||
291 | if(fnf_buf_len < 0) | ||
292 | return -1; | ||
293 | |||
294 | fnf_read_index = 0; | ||
295 | fnf_read_index += len; | ||
296 | } | ||
297 | |||
298 | if(fnf_read_index > fnf_buf_len) | ||
299 | { | ||
300 | return -1; | ||
301 | } | ||
302 | else | ||
303 | return 0; | ||
304 | } | ||
305 | |||
306 | static void buf_init(void) | ||
307 | { | ||
308 | fnf_buf_len = 0; | ||
309 | fnf_read_index = 0; | ||
310 | } | ||
311 | |||
312 | static unsigned long buf_find_next_frame(int fd, long *offset, long max_offset, | ||
313 | unsigned long last_header) | ||
314 | { | ||
315 | return __find_next_frame(fd, offset, max_offset, last_header, buf_getbyte); | ||
316 | } | ||
317 | |||
318 | static int audiobuflen; | ||
319 | static int mem_pos; | ||
320 | static int mem_cnt; | ||
321 | static int mem_maxlen; | ||
322 | |||
323 | static int mem_getbyte(int dummy, unsigned char *c) | ||
324 | { | ||
325 | dummy = dummy; | ||
326 | |||
327 | *c = audiobuf[mem_pos++]; | ||
328 | if(mem_pos >= audiobuflen) | ||
329 | mem_pos = 0; | ||
330 | |||
331 | if(mem_cnt++ >= mem_maxlen) | ||
332 | return 0; | ||
333 | else | ||
334 | return 1; | ||
335 | } | ||
336 | |||
337 | unsigned long mem_find_next_frame(int startpos, long *offset, long max_offset, | ||
338 | unsigned long last_header) | ||
339 | { | ||
340 | audiobuflen = audiobufend - audiobuf; | ||
341 | mem_pos = startpos; | ||
342 | mem_cnt = 0; | ||
343 | mem_maxlen = max_offset; | ||
344 | |||
345 | return __find_next_frame(0, offset, max_offset, last_header, mem_getbyte); | ||
346 | } | ||
347 | #endif | ||
348 | |||
349 | int get_mp3file_info(int fd, struct mp3info *info) | ||
350 | { | ||
351 | unsigned char frame[1800]; | ||
352 | unsigned char *vbrheader; | ||
353 | unsigned long header; | ||
354 | long bytecount; | ||
355 | int num_offsets; | ||
356 | int frames_per_entry; | ||
357 | int i; | ||
358 | long offset; | ||
359 | int j; | ||
360 | long tmp; | ||
361 | |||
362 | header = find_next_frame(fd, &bytecount, 0x20000, 0); | ||
363 | /* Quit if we haven't found a valid header within 128K */ | ||
364 | if(header == 0) | ||
365 | return -1; | ||
366 | |||
367 | memset(info, 0, sizeof(struct mp3info)); | ||
368 | #if CONFIG_CODEC==SWCODEC | ||
369 | /* These two are needed for proper LAME gapless MP3 playback */ | ||
370 | info->enc_delay = -1; | ||
371 | info->enc_padding = -1; | ||
372 | #endif | ||
373 | if(!mp3headerinfo(info, header)) | ||
374 | return -2; | ||
375 | |||
376 | /* OK, we have found a frame. Let's see if it has a Xing header */ | ||
377 | if (info->frame_size-4 >= (int)sizeof(frame)) | ||
378 | { | ||
379 | #if defined(DEBUG) | ||
380 | DEBUGF("Error: Invalid id3 header, frame_size: %d\n", info->frame_size); | ||
381 | #endif | ||
382 | return -8; | ||
383 | } | ||
384 | |||
385 | if(read(fd, frame, info->frame_size-4) < 0) | ||
386 | return -3; | ||
387 | |||
388 | /* calculate position of VBR header */ | ||
389 | if ( info->version == MPEG_VERSION1 ) { | ||
390 | if (info->channel_mode == 3) /* mono */ | ||
391 | vbrheader = frame + 17; | ||
392 | else | ||
393 | vbrheader = frame + 32; | ||
394 | } | ||
395 | else { | ||
396 | if (info->channel_mode == 3) /* mono */ | ||
397 | vbrheader = frame + 9; | ||
398 | else | ||
399 | vbrheader = frame + 17; | ||
400 | } | ||
401 | |||
402 | if (!memcmp(vbrheader, "Xing", 4) | ||
403 | || !memcmp(vbrheader, "Info", 4)) | ||
404 | { | ||
405 | int i = 8; /* Where to start parsing info */ | ||
406 | |||
407 | /* DEBUGF("Xing/Info header\n"); */ | ||
408 | |||
409 | /* Remember where in the file the Xing header is */ | ||
410 | info->vbr_header_pos = lseek(fd, 0, SEEK_CUR) - info->frame_size; | ||
411 | |||
412 | /* We want to skip the Xing frame when playing the stream */ | ||
413 | bytecount += info->frame_size; | ||
414 | |||
415 | /* Now get the next frame to find out the real info about | ||
416 | the mp3 stream */ | ||
417 | header = find_next_frame(fd, &tmp, 0x20000, 0); | ||
418 | if(header == 0) | ||
419 | return -4; | ||
420 | |||
421 | if(!mp3headerinfo(info, header)) | ||
422 | return -5; | ||
423 | |||
424 | /* Is it a VBR file? */ | ||
425 | info->is_vbr = info->is_xing_vbr = !memcmp(vbrheader, "Xing", 4); | ||
426 | |||
427 | if (vbrheader[7] & VBR_FRAMES_FLAG) /* Is the frame count there? */ | ||
428 | { | ||
429 | info->frame_count = bytes2int(vbrheader[i], vbrheader[i+1], | ||
430 | vbrheader[i+2], vbrheader[i+3]); | ||
431 | if (info->frame_count <= ULONG_MAX / info->ft_num) | ||
432 | info->file_time = info->frame_count * info->ft_num / info->ft_den; | ||
433 | else | ||
434 | info->file_time = info->frame_count / info->ft_den * info->ft_num; | ||
435 | i += 4; | ||
436 | } | ||
437 | |||
438 | if (vbrheader[7] & VBR_BYTES_FLAG) /* Is byte count there? */ | ||
439 | { | ||
440 | info->byte_count = bytes2int(vbrheader[i], vbrheader[i+1], | ||
441 | vbrheader[i+2], vbrheader[i+3]); | ||
442 | i += 4; | ||
443 | } | ||
444 | |||
445 | if (info->file_time && info->byte_count) | ||
446 | { | ||
447 | if (info->byte_count <= (ULONG_MAX/8)) | ||
448 | info->bitrate = info->byte_count * 8 / info->file_time; | ||
449 | else | ||
450 | info->bitrate = info->byte_count / (info->file_time >> 3); | ||
451 | } | ||
452 | else | ||
453 | info->bitrate = 0; | ||
454 | |||
455 | if (vbrheader[7] & VBR_TOC_FLAG) /* Is table-of-contents there? */ | ||
456 | { | ||
457 | info->has_toc = true; | ||
458 | memcpy( info->toc, vbrheader+i, 100 ); | ||
459 | i += 100; | ||
460 | } | ||
461 | if (vbrheader[7] & VBR_QUALITY_FLAG) | ||
462 | { | ||
463 | /* We don't care about this, but need to skip it */ | ||
464 | i += 4; | ||
465 | } | ||
466 | #if CONFIG_CODEC==SWCODEC | ||
467 | i += 21; | ||
468 | info->enc_delay = (vbrheader[i] << 4) | (vbrheader[i + 1] >> 4); | ||
469 | info->enc_padding = ((vbrheader[i + 1] & 0x0f) << 8) | vbrheader[i + 2]; | ||
470 | /* TODO: This sanity checking is rather silly, seeing as how the LAME | ||
471 | header contains a CRC field that can be used to verify integrity. */ | ||
472 | if (!(info->enc_delay >= 0 && info->enc_delay <= 2880 && | ||
473 | info->enc_padding >= 0 && info->enc_padding <= 2*1152)) | ||
474 | { | ||
475 | /* Invalid data */ | ||
476 | info->enc_delay = -1; | ||
477 | info->enc_padding = -1; | ||
478 | } | ||
479 | #endif | ||
480 | } | ||
481 | |||
482 | if (!memcmp(vbrheader, "VBRI", 4)) | ||
483 | { | ||
484 | DEBUGF("VBRI header\n"); | ||
485 | |||
486 | /* We want to skip the VBRI frame when playing the stream */ | ||
487 | bytecount += info->frame_size; | ||
488 | |||
489 | /* Now get the next frame to find out the real info about | ||
490 | the mp3 stream */ | ||
491 | header = find_next_frame(fd, &tmp, 0x20000, 0); | ||
492 | if(header == 0) | ||
493 | return -6; | ||
494 | |||
495 | bytecount += tmp; | ||
496 | |||
497 | if(!mp3headerinfo(info, header)) | ||
498 | return -7; | ||
499 | |||
500 | DEBUGF("%04x: %04x %04x ", 0, (short)(header >> 16), | ||
501 | (short)(header & 0xffff)); | ||
502 | for(i = 4;i < (int)sizeof(frame)-4;i+=2) { | ||
503 | if(i % 16 == 0) { | ||
504 | DEBUGF("\n%04x: ", i-4); | ||
505 | } | ||
506 | DEBUGF("%04x ", (frame[i-4] << 8) | frame[i-4+1]); | ||
507 | } | ||
508 | |||
509 | DEBUGF("\n"); | ||
510 | |||
511 | /* Yes, it is a FhG VBR file */ | ||
512 | info->is_vbr = true; | ||
513 | info->is_vbri_vbr = true; | ||
514 | info->has_toc = false; /* We don't parse the TOC (yet) */ | ||
515 | |||
516 | info->byte_count = bytes2int(vbrheader[10], vbrheader[11], | ||
517 | vbrheader[12], vbrheader[13]); | ||
518 | info->frame_count = bytes2int(vbrheader[14], vbrheader[15], | ||
519 | vbrheader[16], vbrheader[17]); | ||
520 | if (info->frame_count <= ULONG_MAX / info->ft_num) | ||
521 | info->file_time = info->frame_count * info->ft_num / info->ft_den; | ||
522 | else | ||
523 | info->file_time = info->frame_count / info->ft_den * info->ft_num; | ||
524 | |||
525 | if (info->byte_count <= (ULONG_MAX/8)) | ||
526 | info->bitrate = info->byte_count * 8 / info->file_time; | ||
527 | else | ||
528 | info->bitrate = info->byte_count / (info->file_time >> 3); | ||
529 | |||
530 | /* We don't parse the TOC, since we don't yet know how to (FIXME) */ | ||
531 | num_offsets = bytes2int(0, 0, vbrheader[18], vbrheader[19]); | ||
532 | frames_per_entry = bytes2int(0, 0, vbrheader[24], vbrheader[25]); | ||
533 | DEBUGF("Frame size (%dkpbs): %d bytes (0x%x)\n", | ||
534 | info->bitrate, info->frame_size, info->frame_size); | ||
535 | DEBUGF("Frame count: %lx\n", info->frame_count); | ||
536 | DEBUGF("Byte count: %lx\n", info->byte_count); | ||
537 | DEBUGF("Offsets: %d\n", num_offsets); | ||
538 | DEBUGF("Frames/entry: %d\n", frames_per_entry); | ||
539 | |||
540 | offset = 0; | ||
541 | |||
542 | for(i = 0;i < num_offsets;i++) | ||
543 | { | ||
544 | j = bytes2int(0, 0, vbrheader[26+i*2], vbrheader[27+i*2]); | ||
545 | offset += j; | ||
546 | DEBUGF("%03d: %lx (%x)\n", i, offset - bytecount, j); | ||
547 | } | ||
548 | } | ||
549 | |||
550 | return bytecount; | ||
551 | } | ||
552 | |||
553 | #ifndef __PCTOOL__ | ||
554 | static void long2bytes(unsigned char *buf, long val) | ||
555 | { | ||
556 | buf[0] = (val >> 24) & 0xff; | ||
557 | buf[1] = (val >> 16) & 0xff; | ||
558 | buf[2] = (val >> 8) & 0xff; | ||
559 | buf[3] = val & 0xff; | ||
560 | } | ||
561 | |||
562 | int count_mp3_frames(int fd, int startpos, int filesize, | ||
563 | void (*progressfunc)(int)) | ||
564 | { | ||
565 | unsigned long header = 0; | ||
566 | struct mp3info info; | ||
567 | int num_frames; | ||
568 | long bytes; | ||
569 | int cnt; | ||
570 | long progress_chunk = filesize / 50; /* Max is 50%, in 1% increments */ | ||
571 | int progress_cnt = 0; | ||
572 | bool is_vbr = false; | ||
573 | int last_bitrate = 0; | ||
574 | int header_template = 0; | ||
575 | |||
576 | if(lseek(fd, startpos, SEEK_SET) < 0) | ||
577 | return -1; | ||
578 | |||
579 | buf_init(); | ||
580 | |||
581 | /* Find out the total number of frames */ | ||
582 | num_frames = 0; | ||
583 | cnt = 0; | ||
584 | |||
585 | while((header = buf_find_next_frame(fd, &bytes, -1, header_template))) { | ||
586 | mp3headerinfo(&info, header); | ||
587 | |||
588 | if(!header_template) | ||
589 | header_template = header; | ||
590 | |||
591 | /* See if this really is a VBR file */ | ||
592 | if(last_bitrate && info.bitrate != last_bitrate) | ||
593 | { | ||
594 | is_vbr = true; | ||
595 | } | ||
596 | last_bitrate = info.bitrate; | ||
597 | |||
598 | buf_seek(fd, info.frame_size-4); | ||
599 | num_frames++; | ||
600 | if(progressfunc) | ||
601 | { | ||
602 | cnt += bytes + info.frame_size; | ||
603 | if(cnt > progress_chunk) | ||
604 | { | ||
605 | progress_cnt++; | ||
606 | progressfunc(progress_cnt); | ||
607 | cnt = 0; | ||
608 | } | ||
609 | } | ||
610 | } | ||
611 | DEBUGF("Total number of frames: %d\n", num_frames); | ||
612 | |||
613 | if(is_vbr) | ||
614 | return num_frames; | ||
615 | else | ||
616 | { | ||
617 | DEBUGF("Not a VBR file\n"); | ||
618 | return 0; | ||
619 | } | ||
620 | } | ||
621 | |||
622 | static const char cooltext[] = "Rockbox - rocks your box"; | ||
623 | |||
624 | /* buf needs to be the audio buffer with TOC generation enabled, | ||
625 | and at least MAX_XING_HEADER_SIZE bytes otherwise */ | ||
626 | int create_xing_header(int fd, long startpos, long filesize, | ||
627 | unsigned char *buf, unsigned long num_frames, | ||
628 | unsigned long rec_time, unsigned long header_template, | ||
629 | void (*progressfunc)(int), bool generate_toc) | ||
630 | { | ||
631 | struct mp3info info; | ||
632 | unsigned char toc[100]; | ||
633 | unsigned long header = 0; | ||
634 | unsigned long xing_header_template = header_template; | ||
635 | unsigned long filepos; | ||
636 | long pos, last_pos; | ||
637 | long j; | ||
638 | long bytes; | ||
639 | int i; | ||
640 | int index; | ||
641 | |||
642 | DEBUGF("create_xing_header()\n"); | ||
643 | |||
644 | if(generate_toc) | ||
645 | { | ||
646 | lseek(fd, startpos, SEEK_SET); | ||
647 | buf_init(); | ||
648 | |||
649 | /* Generate filepos table */ | ||
650 | last_pos = 0; | ||
651 | filepos = 0; | ||
652 | header = 0; | ||
653 | for(i = 0;i < 100;i++) { | ||
654 | /* Calculate the absolute frame number for this seek point */ | ||
655 | pos = i * num_frames / 100; | ||
656 | |||
657 | /* Advance from the last seek point to this one */ | ||
658 | for(j = 0;j < pos - last_pos;j++) | ||
659 | { | ||
660 | header = buf_find_next_frame(fd, &bytes, -1, header_template); | ||
661 | filepos += bytes; | ||
662 | mp3headerinfo(&info, header); | ||
663 | buf_seek(fd, info.frame_size-4); | ||
664 | filepos += info.frame_size; | ||
665 | |||
666 | if(!header_template) | ||
667 | header_template = header; | ||
668 | } | ||
669 | |||
670 | /* Save a header for later use if header_template is empty. | ||
671 | We only save one header, and we want to save one in the | ||
672 | middle of the stream, just in case the first and the last | ||
673 | headers are corrupt. */ | ||
674 | if(!xing_header_template && i == 1) | ||
675 | xing_header_template = header; | ||
676 | |||
677 | if(progressfunc) | ||
678 | { | ||
679 | progressfunc(50 + i/2); | ||
680 | } | ||
681 | |||
682 | /* Fill in the TOC entry */ | ||
683 | /* each toc is a single byte indicating how many 256ths of the | ||
684 | * way through the file, is that percent of the way through the | ||
685 | * song. the easy method, filepos*256/filesize, chokes when | ||
686 | * the upper 8 bits of the file position are nonzero | ||
687 | * (i.e. files over 16mb in size). | ||
688 | */ | ||
689 | if (filepos > (ULONG_MAX/256)) | ||
690 | { | ||
691 | /* instead of multiplying filepos by 256, we divide | ||
692 | * filesize by 256. | ||
693 | */ | ||
694 | toc[i] = filepos / (filesize >> 8); | ||
695 | } | ||
696 | else | ||
697 | { | ||
698 | toc[i] = filepos * 256 / filesize; | ||
699 | } | ||
700 | |||
701 | DEBUGF("Pos %d: %ld relpos: %ld filepos: %lx tocentry: %x\n", | ||
702 | i, pos, pos-last_pos, filepos, toc[i]); | ||
703 | |||
704 | last_pos = pos; | ||
705 | } | ||
706 | } | ||
707 | |||
708 | /* Use the template header and create a new one. | ||
709 | We ignore the Protection bit even if the rest of the stream is | ||
710 | protected. */ | ||
711 | header = xing_header_template & ~(BITRATE_MASK|PROTECTION_MASK|PADDING_MASK); | ||
712 | header |= 8 << 12; /* This gives us plenty of space, 192..576 bytes */ | ||
713 | |||
714 | if (!mp3headerinfo(&info, header)) | ||
715 | return 0; /* invalid header */ | ||
716 | |||
717 | if (num_frames == 0 && rec_time) { | ||
718 | /* estimate the number of frames based on the recording time */ | ||
719 | if (rec_time <= ULONG_MAX / info.ft_den) | ||
720 | num_frames = rec_time * info.ft_den / info.ft_num; | ||
721 | else | ||
722 | num_frames = rec_time / info.ft_num * info.ft_den; | ||
723 | } | ||
724 | |||
725 | /* Clear the frame */ | ||
726 | memset(buf, 0, MAX_XING_HEADER_SIZE); | ||
727 | |||
728 | /* Write the header to the buffer */ | ||
729 | long2bytes(buf, header); | ||
730 | |||
731 | /* Calculate position of VBR header */ | ||
732 | if (info.version == MPEG_VERSION1) { | ||
733 | if (info.channel_mode == 3) /* mono */ | ||
734 | index = 21; | ||
735 | else | ||
736 | index = 36; | ||
737 | } | ||
738 | else { | ||
739 | if (info.channel_mode == 3) /* mono */ | ||
740 | index = 13; | ||
741 | else | ||
742 | index = 21; | ||
743 | } | ||
744 | |||
745 | /* Create the Xing data */ | ||
746 | memcpy(&buf[index], "Xing", 4); | ||
747 | long2bytes(&buf[index+4], (num_frames ? VBR_FRAMES_FLAG : 0) | ||
748 | | (filesize ? VBR_BYTES_FLAG : 0) | ||
749 | | (generate_toc ? VBR_TOC_FLAG : 0)); | ||
750 | index += 8; | ||
751 | if(num_frames) | ||
752 | { | ||
753 | long2bytes(&buf[index], num_frames); | ||
754 | index += 4; | ||
755 | } | ||
756 | |||
757 | if(filesize) | ||
758 | { | ||
759 | long2bytes(&buf[index], filesize - startpos); | ||
760 | index += 4; | ||
761 | } | ||
762 | |||
763 | /* Copy the TOC */ | ||
764 | memcpy(buf + index, toc, 100); | ||
765 | |||
766 | /* And some extra cool info */ | ||
767 | memcpy(buf + index + 100, cooltext, sizeof(cooltext)); | ||
768 | |||
769 | #ifdef DEBUG | ||
770 | for(i = 0;i < info.frame_size;i++) | ||
771 | { | ||
772 | if(i && !(i % 16)) | ||
773 | DEBUGF("\n"); | ||
774 | |||
775 | DEBUGF("%02x ", buf[i]); | ||
776 | } | ||
777 | #endif | ||
778 | |||
779 | return info.frame_size; | ||
780 | } | ||
781 | |||
782 | #endif | ||