summaryrefslogtreecommitdiff
path: root/firmware
diff options
context:
space:
mode:
Diffstat (limited to 'firmware')
-rw-r--r--firmware/SOURCES1
-rw-r--r--firmware/export/mp3data.h83
-rw-r--r--firmware/mp3data.c782
3 files changed, 0 insertions, 866 deletions
diff --git a/firmware/SOURCES b/firmware/SOURCES
index 2cd1ba131c..3de2077435 100644
--- a/firmware/SOURCES
+++ b/firmware/SOURCES
@@ -180,7 +180,6 @@ drivers/tuner/tea5767.c
180#if CONFIG_CODEC != SWCODEC 180#if CONFIG_CODEC != SWCODEC
181mp3_playback.c 181mp3_playback.c
182#endif /* CONFIG_CODEC != SWCODEC */ 182#endif /* CONFIG_CODEC != SWCODEC */
183mp3data.c
184sound.c 183sound.c
185 184
186#if CONFIG_CODEC == SWCODEC 185#if CONFIG_CODEC == SWCODEC
diff --git a/firmware/export/mp3data.h b/firmware/export/mp3data.h
deleted file mode 100644
index 2a6a27ac2d..0000000000
--- a/firmware/export/mp3data.h
+++ /dev/null
@@ -1,83 +0,0 @@
1/***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2002 by Linus Nielsen Feltzing
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#ifndef _MP3DATA_H_
23#define _MP3DATA_H_
24
25#define MPEG_VERSION1 0
26#define MPEG_VERSION2 1
27#define MPEG_VERSION2_5 2
28
29struct mp3info {
30 /* Standard MP3 frame header fields */
31 int version;
32 int layer;
33 bool protection;
34 int bitrate;
35 long frequency;
36 int padding;
37 int channel_mode;
38 int mode_extension;
39 int emphasis;
40 int frame_size; /* Frame size in bytes */
41 int frame_samples; /* Samples per frame */
42 int ft_num; /* Numerator of frametime in milliseconds */
43 int ft_den; /* Denominator of frametime in milliseconds */
44
45 bool is_vbr; /* True if the file is VBR */
46 bool has_toc; /* True if there is a VBR header in the file */
47 bool is_xing_vbr; /* True if the VBR header is of Xing type */
48 bool is_vbri_vbr; /* True if the VBR header is of VBRI type */
49 unsigned char toc[100];
50 unsigned long frame_count; /* Number of frames in the file (if VBR) */
51 unsigned long byte_count; /* File size in bytes */
52 unsigned long file_time; /* Length of the whole file in milliseconds */
53 unsigned long vbr_header_pos;
54 int enc_delay; /* Encoder delay, fetched from LAME header */
55 int enc_padding; /* Padded samples added to last frame. LAME header */
56};
57
58/* Xing header information */
59#define VBR_FRAMES_FLAG 0x01
60#define VBR_BYTES_FLAG 0x02
61#define VBR_TOC_FLAG 0x04
62#define VBR_QUALITY_FLAG 0x08
63
64#define MAX_XING_HEADER_SIZE 576
65
66unsigned long find_next_frame(int fd, long *offset, long max_offset,
67 unsigned long last_header);
68unsigned long mem_find_next_frame(int startpos, long *offset, long max_offset,
69 unsigned long last_header);
70int get_mp3file_info(int fd, struct mp3info *info);
71int count_mp3_frames(int fd, int startpos, int filesize,
72 void (*progressfunc)(int));
73int create_xing_header(int fd, long startpos, long filesize,
74 unsigned char *buf, unsigned long num_frames,
75 unsigned long rec_time, unsigned long header_template,
76 void (*progressfunc)(int), bool generate_toc);
77
78extern unsigned long bytes2int(unsigned long b0,
79 unsigned long b1,
80 unsigned long b2,
81 unsigned long b3);
82
83#endif
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 */
60static 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 */
65static 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 */
74static 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 */
82static 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
89unsigned 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 */
101static 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
124static 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
199static 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
243static int fileread(int fd, unsigned char *c)
244{
245 return read(fd, c, 1);
246}
247
248unsigned 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__
254static int fnf_read_index;
255static int fnf_buf_len;
256
257static 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
283static 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
306static void buf_init(void)
307{
308 fnf_buf_len = 0;
309 fnf_read_index = 0;
310}
311
312static 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
318static int audiobuflen;
319static int mem_pos;
320static int mem_cnt;
321static int mem_maxlen;
322
323static 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
337unsigned 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
349int 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__
554static 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
562int 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
622static 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 */
626int 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
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-06 01:25:18 +0000