1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by Daniel Stenberg
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
18 ****************************************************************************/
20 * Parts of this code has been stolen from the Ample project and was written
21 * by David H�deman. It has since been extended and enhanced pretty much by
22 * all sorts of friendly Rockbox people.
26 /* tagResolver and associated code copyright 2003 Thomas Paul Diffenbach
44 #include "replaygain.h"
45 #include "rbunicode.h"
47 /** Database of audio formats **/
48 const struct afmt_entry audio_formats
[AFMT_NUM_CODECS
] =
50 /* Unknown file format */
52 AFMT_ENTRY("???", NULL
, NULL
, NULL
),
54 /* MPEG Audio layer 1 */
56 AFMT_ENTRY("MP1", "mpa", NULL
, "mp1\0" ),
57 /* MPEG Audio layer 2 */
59 AFMT_ENTRY("MP2", "mpa", NULL
, "mpa\0mp2\0" ),
60 /* MPEG Audio layer 3 */
62 AFMT_ENTRY("MP3", "mpa", "mp3_enc", "mp3\0" ),
64 #if CONFIG_CODEC == SWCODEC
65 /* Audio Interchange File Format */
67 AFMT_ENTRY("AIFF", "aiff", "aiff_enc", "aiff\0aif\0"),
68 /* Uncompressed PCM in a WAV file */
70 AFMT_ENTRY("WAV", "wav", "wav_enc", "wav\0" ),
73 AFMT_ENTRY("Ogg", "vorbis", NULL
, "ogg\0" ),
76 AFMT_ENTRY("FLAC", "flac", NULL
, "flac\0" ),
79 AFMT_ENTRY("MPC", "mpc", NULL
, "mpc\0" ),
80 /* A/52 (aka AC3) audio */
82 AFMT_ENTRY("AC3", "a52", NULL
, "a52\0ac3\0" ),
85 AFMT_ENTRY("WV", "wavpack", "wavpack_enc", "wv\0" ),
86 /* Apple Lossless Audio Codec */
88 AFMT_ENTRY("ALAC", "alac", NULL
, "m4a\0m4b\0" ),
89 /* Advanced Audio Coding in M4A container */
91 AFMT_ENTRY("AAC", "aac", NULL
, "mp4\0" ),
94 AFMT_ENTRY("SHN", "shorten", NULL
, "shn\0" ),
97 AFMT_ENTRY("SID", "sid", NULL
, "sid\0" ),
100 AFMT_ENTRY("ADX", "adx", NULL
, "adx\0" ),
101 /* NESM (NES Sound Format) */
103 AFMT_ENTRY("NSF", "nsf", NULL
, "nsf\0nsfe\0" ),
104 /* Speex File Format */
106 AFMT_ENTRY("Speex","speex", NULL
, "spx\0" ),
107 /* SPC700 Save State */
109 AFMT_ENTRY("SPC", "spc", NULL
, "spc\0" ),
110 /* APE (Monkey's Audio) */
112 AFMT_ENTRY("APE", "ape", NULL
, "ape\0mac\0" ),
113 /* WMA (WMAV1/V2 in ASF) */
115 AFMT_ENTRY("WMA", "wma", NULL
, "wma\0wmv\0asf" ),
119 #if CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING)
120 /* get REC_FORMAT_* corresponding AFMT_* */
121 const int rec_format_afmt
[REC_NUM_FORMATS
] =
123 /* give AFMT_UNKNOWN by default */
124 [0 ... REC_NUM_FORMATS
-1] = AFMT_UNKNOWN
,
125 /* add new entries below this line */
126 [REC_FORMAT_AIFF
] = AFMT_AIFF
,
127 [REC_FORMAT_MPA_L3
] = AFMT_MPA_L3
,
128 [REC_FORMAT_WAVPACK
] = AFMT_WAVPACK
,
129 [REC_FORMAT_PCM_WAV
] = AFMT_PCM_WAV
,
132 /* get AFMT_* corresponding REC_FORMAT_* */
133 const int afmt_rec_format
[AFMT_NUM_CODECS
] =
135 /* give -1 by default */
136 [0 ... AFMT_NUM_CODECS
-1] = -1,
137 /* add new entries below this line */
138 [AFMT_AIFF
] = REC_FORMAT_AIFF
,
139 [AFMT_MPA_L3
] = REC_FORMAT_MPA_L3
,
140 [AFMT_WAVPACK
] = REC_FORMAT_WAVPACK
,
141 [AFMT_PCM_WAV
] = REC_FORMAT_PCM_WAV
,
143 #endif /* CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING) */
146 unsigned long unsync(unsigned long b0
,
151 return (((long)(b0
& 0x7F) << (3*7)) |
152 ((long)(b1
& 0x7F) << (2*7)) |
153 ((long)(b2
& 0x7F) << (1*7)) |
154 ((long)(b3
& 0x7F) << (0*7)));
157 static const char* const genres
[] = {
158 "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
159 "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
160 "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
161 "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
162 "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
163 "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
164 "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
165 "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
166 "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
167 "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
168 "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
169 "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
170 "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
172 /* winamp extensions */
173 "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
174 "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
175 "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
176 "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
177 "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
178 "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
179 "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
180 "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
181 "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
182 "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
183 "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
184 "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
188 char* id3_get_num_genre(const unsigned int genre_num
)
190 if (genre_num
< sizeof(genres
)/sizeof(char*))
191 return (char*)genres
[genre_num
];
195 char* id3_get_codec(const struct mp3entry
* id3
)
197 if (id3
->codectype
< AFMT_NUM_CODECS
) {
198 return (char*)audio_formats
[id3
->codectype
].label
;
205 HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
206 Code and comments by Thomas Paul Diffenbach
208 To add another ID3v2 Tag, do the following:
209 1. add a char* named for the tag to struct mp3entry in id3.h,
210 (I (tpd) prefer to use char* rather than ints, even for what seems like
211 numerical values, for cases where a number won't do, e.g.,
212 YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
213 TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
214 Text is more flexible, and as the main use of id3 data is to
215 display it, converting it to an int just means reconverting to
216 display it, at a runtime cost.)
218 2. If any special processing beyond copying the tag value from the Id3
219 block to the struct mp3entry is rrequired (such as converting to an
220 int), write a function to perform this special processing.
222 This function's prototype must match that of
223 typedef tagPostProcessFunc, that is it must be:
224 int func( struct mp3entry*, char* tag, int bufferpos )
225 the first argument is a pointer to the current mp3entry structure the
226 second argument is a pointer to the null terminated string value of the
227 tag found the third argument is the offset of the next free byte in the
228 mp3entry's buffer your function should return the corrected offset; if
229 you don't lengthen or shorten the tag string, you can return the third
232 Unless you have a good reason no to, make the function static.
233 TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
235 3. add one or more entries to the tagList array, using the format:
236 char* ID3 Tag symbolic name -- see the ID3 specification for these,
237 sizeof() that name minus 1,
238 offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
239 pointer to your special processing function or NULL
240 if you need no special processing
241 flag indicating if this tag is binary or textual
242 Many ID3 symbolic names come in more than one form. You can add both
243 forms, each referencing the same variable in struct mp3entry.
244 If both forms are present, the last found will be used.
245 Note that the offset can be zero, in which case no entry will be set
246 in the mp3entry struct; the frame is still read into the buffer and
247 the special processing function is called (several times, if there
248 are several frames with the same name).
250 4. Alternately, use the TAG_LIST_ENTRY macro with
251 ID3 tag symbolic name,
252 variable in struct mp3entry,
253 special processing function address
255 5. Add code to wps-display.c function get_tag to assign a printf-like
256 format specifier for the tag */
258 /* Structure for ID3 Tag extraction information */
259 struct tag_resolver
{
263 int (*ppFunc
)(struct mp3entry
*, char* tag
, int bufferpos
);
267 static bool global_ff_found
;
269 static int unsynchronize(char* tag
, int len
, bool *ff_found
)
273 unsigned char *rp
, *wp
;
275 wp
= rp
= (unsigned char *)tag
;
277 rp
= (unsigned char *)tag
;
278 for(i
= 0;i
< len
;i
++) {
279 /* Read the next byte and write it back, but don't increment the
284 /* Increment the write pointer if it isn't an unsynch pattern */
294 return (long)wp
- (long)tag
;
297 static int unsynchronize_frame(char* tag
, int len
)
299 bool ff_found
= false;
301 return unsynchronize(tag
, len
, &ff_found
);
304 static int read_unsynched(int fd
, void *buf
, int len
)
316 rc
= read(fd
, rp
, remaining
);
320 i
= unsynchronize(wp
, remaining
, &global_ff_found
);
328 static int skip_unsynched(int fd
, int len
)
336 rlen
= MIN(sizeof(buf
), (unsigned int)remaining
);
337 rc
= read(fd
, buf
, rlen
);
341 remaining
-= unsynchronize(buf
, rlen
, &global_ff_found
);
347 /* parse numeric value from string */
348 static int parsetracknum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
350 entry
->tracknum
= atoi( tag
);
354 /* parse numeric value from string */
355 static int parseyearnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
357 entry
->year
= atoi( tag
);
361 /* parse numeric genre from string, version 2.2 and 2.3 */
362 static int parsegenre( struct mp3entry
* entry
, char* tag
, int bufferpos
)
364 if(entry
->id3version
>= ID3_VER_2_4
) {
365 /* In version 2.4 and up, there are no parentheses, and the genre frame
366 is a list of strings, either numbers or text. */
368 /* Is it a number? */
369 if(isdigit(tag
[0])) {
370 entry
->genre_string
= id3_get_num_genre(atoi( tag
));
371 return tag
- entry
->id3v2buf
;
373 entry
->genre_string
= tag
;
377 if( tag
[0] == '(' && tag
[1] != '(' ) {
378 entry
->genre_string
= id3_get_num_genre(atoi( tag
+ 1 ));
379 return tag
- entry
->id3v2buf
;
382 entry
->genre_string
= tag
;
388 #if CONFIG_CODEC == SWCODEC
389 /* parse user defined text, looking for replaygain information. */
390 static int parseuser( struct mp3entry
* entry
, char* tag
, int bufferpos
)
393 int desc_len
= strlen(tag
);
396 /* Note: for ID3v2.4, parse_replaygain will not overwrite replaygain
397 values already parsed from RVA2 tags */
398 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
399 /* At least part of the value was read, so we can safely try to
402 value
= tag
+ desc_len
+ 1;
403 value_len
= parse_replaygain(tag
, value
, entry
, tag
,
404 bufferpos
- (tag
- entry
->id3v2buf
));
408 bufferpos
= tag
- entry
->id3v2buf
+ value_len
;
410 bufferpos
= tag
- entry
->id3v2buf
;
416 /* parse RVA2 binary data and convert to replaygain information. */
417 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
420 int desc_len
= strlen(tag
);
423 /* Only parse RVA2 replaygain tags if tag version == 2.4 */
424 if (entry
->id3version
== ID3_VER_2_4
&&
425 (tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
426 value
= tag
+ desc_len
+ 1;
427 value_len
= parse_replaygain_rva(tag
, value
, entry
, tag
,
428 bufferpos
- (tag
- entry
->id3v2buf
));
432 bufferpos
= tag
- entry
->id3v2buf
+ value_len
;
434 bufferpos
= tag
- entry
->id3v2buf
;
441 static const struct tag_resolver taglist
[] = {
442 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
443 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
444 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
445 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
446 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
447 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
448 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
449 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
450 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
451 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
452 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
453 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
454 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
455 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
456 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
457 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
458 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
459 #if CONFIG_CODEC == SWCODEC
460 { "TXXX", 4, 0, &parseuser
, false },
461 { "RVA2", 4, 0, &parserva2
, true },
465 #define TAGLIST_SIZE ((int)(sizeof(taglist) / sizeof(taglist[0])))
467 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
468 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
469 we convert from the default codepage */
470 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
474 unsigned char *str
= (unsigned char *)string
;
476 unsigned char* utf8
= (unsigned char *)utf8buf
;
479 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
482 utf8
= iso_decode(str
, utf8
, -1, *len
);
484 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
487 case 0x01: /* Unicode with or without BOM */
492 /* Handle frames with more than one string
493 (needed for TXXX frames).*/
495 tmp
= bytes2int(0, 0, str
[0], str
[1]);
497 /* Now check if there is a BOM
498 (zero-width non-breaking space, 0xfeff)
499 and if it is in little or big endian format */
500 if(tmp
== 0xfffe) { /* Little endian? */
504 } else if(tmp
== 0xfeff) { /* Big endian? */
508 /* If there is no BOM (which is a specification violation),
509 let's try to guess it. If one of the bytes is 0x00, it is
510 probably the most significant one. */
516 utf8
= utf16LEdecode(str
, utf8
, 1);
518 utf8
= utf16BEdecode(str
, utf8
, 1);
522 } while((str
[0] || str
[1]) && (i
< *len
));
524 *utf8
++ = 0; /* Terminate the string */
525 templen
+= (strlen(&utf8buf
[templen
]) + 1);
532 case 0x03: /* UTF-8 encoded string */
533 for(i
=0; i
< *len
; i
++)
538 default: /* Plain old string */
539 utf8
= iso_decode(str
, utf8
, -1, *len
);
541 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
548 * Sets the title of an MP3 entry based on its ID3v1 tag.
550 * Arguments: file - the MP3 file to scen for a ID3v1 tag
551 * entry - the entry to set the title in
553 * Returns: true if a title was found and created, else false
555 static bool setid3v1title(int fd
, struct mp3entry
*entry
)
557 unsigned char buffer
[128];
558 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
562 if (-1 == lseek(fd
, -128, SEEK_END
))
565 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
568 if (strncmp((char *)buffer
, "TAG", 3))
571 entry
->id3v1len
= 128;
572 entry
->id3version
= ID3_VER_1_0
;
574 for (i
=0; i
< (int)sizeof offsets
; i
++) {
575 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
581 /* kill trailing space in strings */
582 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
584 /* convert string to utf8 */
585 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
586 utf8
= iso_decode(ptr
, utf8
, -1, 30);
587 /* make sure string is terminated */
592 /* kill trailing space in strings */
593 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
595 /* convert string to utf8 */
596 utf8
= (unsigned char *)entry
->id3v1buf
[3];
597 utf8
= iso_decode(ptr
, utf8
, -1, 28);
598 /* make sure string is terminated */
604 entry
->year
= atoi((char *)ptr
);
608 /* id3v1.1 uses last two bytes of comment field for track
609 number: first must be 0 and second is track num */
610 if (!ptr
[0] && ptr
[1]) {
611 entry
->tracknum
= ptr
[1];
612 entry
->id3version
= ID3_VER_1_1
;
618 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
623 entry
->title
= entry
->id3v1buf
[0];
624 entry
->artist
= entry
->id3v1buf
[1];
625 entry
->album
= entry
->id3v1buf
[2];
626 entry
->comment
= entry
->id3v1buf
[3];
633 * Sets the title of an MP3 entry based on its ID3v2 tag.
635 * Arguments: file - the MP3 file to scan for a ID3v2 tag
636 * entry - the entry to set the title in
638 * Returns: true if a title was found and created, else false
640 static void setid3v2title(int fd
, struct mp3entry
*entry
)
644 long bufferpos
= 0, totframelen
, framelen
;
647 unsigned char version
;
648 char *buffer
= entry
->id3v2buf
;
650 int buffersize
= sizeof(entry
->id3v2buf
);
651 unsigned char global_flags
;
654 bool global_unsynch
= false;
655 bool unsynch
= false;
660 global_ff_found
= false;
662 /* Bail out if the tag is shorter than 10 bytes */
663 if(entry
->id3v2len
< 10)
666 /* Read the ID3 tag version from the header */
667 lseek(fd
, 0, SEEK_SET
);
668 if(10 != read(fd
, header
, 10))
671 /* Get the total ID3 tag size */
672 size
= entry
->id3v2len
- 10;
677 version
= ID3_VER_2_2
;
682 version
= ID3_VER_2_3
;
687 version
= ID3_VER_2_4
;
692 /* unsupported id3 version */
695 entry
->id3version
= version
;
696 entry
->tracknum
= entry
->year
= 0;
697 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
699 global_flags
= header
[5];
701 /* Skip the extended header if it is present */
702 if(global_flags
& 0x40) {
703 if(version
== ID3_VER_2_3
) {
704 if(10 != read(fd
, header
, 10))
706 /* The 2.3 extended header size doesn't include the header size
707 field itself. Also, it is not unsynched. */
709 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
711 /* Skip the rest of the header */
712 lseek(fd
, framelen
- 10, SEEK_CUR
);
715 if(version
>= ID3_VER_2_4
) {
716 if(4 != read(fd
, header
, 4))
719 /* The 2.4 extended header size does include the entire header,
720 so here we can just skip it. This header is unsynched. */
721 framelen
= unsync(header
[0], header
[1],
722 header
[2], header
[3]);
724 lseek(fd
, framelen
- 4, SEEK_CUR
);
728 /* Is unsynchronization applied? */
729 if(global_flags
& 0x80) {
730 global_unsynch
= true;
734 * We must have at least minframesize bytes left for the
735 * remaining frames to be interesting
737 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
740 /* Read frame header and check length */
741 if(version
>= ID3_VER_2_3
) {
742 if(global_unsynch
&& version
<= ID3_VER_2_3
)
743 rc
= read_unsynched(fd
, header
, 10);
745 rc
= read(fd
, header
, 10);
748 /* Adjust for the 10 bytes we read */
751 flags
= bytes2int(0, 0, header
[8], header
[9]);
753 if (version
>= ID3_VER_2_4
) {
754 framelen
= unsync(header
[4], header
[5],
755 header
[6], header
[7]);
757 /* version .3 files don't use synchsafe ints for
759 framelen
= bytes2int(header
[4], header
[5],
760 header
[6], header
[7]);
763 if(6 != read(fd
, header
, 6))
765 /* Adjust for the 6 bytes we read */
768 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
771 /* Keep track of the total size */
772 totframelen
= framelen
;
774 DEBUGF("framelen = %ld\n", framelen
);
776 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
789 if (version
>= ID3_VER_2_4
) {
790 if(flags
& 0x0040) { /* Grouping identity */
791 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
795 if(flags
& 0x0020) { /* Grouping identity */
796 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
801 if(flags
& 0x000c) /* Compression or encryption */
803 /* Skip it using the total size in case
806 lseek(fd
, totframelen
, SEEK_CUR
);
810 if(flags
& 0x0002) /* Unsynchronization */
813 if (version
>= ID3_VER_2_4
) {
814 if(flags
& 0x0001) { /* Data length indicator */
815 if(4 != read(fd
, tmp
, 4))
818 data_length_ind
= unsync(tmp
[0], tmp
[1], tmp
[2], tmp
[3]);
824 /* If the frame is larger than the remaining buffer space we try
825 to read as much as would fit in the buffer */
826 if(framelen
>= buffersize
- bufferpos
)
827 framelen
= buffersize
- bufferpos
- 1;
829 DEBUGF("id3v2 frame: %.4s\n", header
);
831 /* Check for certain frame headers
833 'size' is the amount of frame bytes remaining. We decrement it by
834 the amount of bytes we read. If we fail to read as many bytes as
835 we expect, we assume that we can't read from this file, and bail
838 For each frame. we will iterate over the list of supported tags,
839 and read the tag into entry's buffer. All tags will be kept as
840 strings, for cases where a number won't do, e.g., YEAR: "circa
841 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
842 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
843 flexible, and as the main use of id3 data is to display it,
844 converting it to an int just means reconverting to display it, at a
847 For tags that the current code does convert to ints, a post
848 processing function will be called via a pointer to function. */
850 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
851 const struct tag_resolver
* tr
= &taglist
[i
];
852 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
857 /* Only ID3_VER_2_2 uses frames with three-character names. */
858 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
859 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
863 /* Note that parser functions sometimes set *ptag to NULL, so
864 * the "!*ptag" check here doesn't always have the desired
865 * effect. Should the parser functions (parsegenre in
866 * particular) be updated to handle the case of being called
867 * multiple times, or should the "*ptag" check be removed?
869 if( (!ptag
|| !*ptag
) && !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
871 /* found a tag matching one in tagList, and not yet filled */
872 tag
= buffer
+ bufferpos
;
874 if(global_unsynch
&& version
<= ID3_VER_2_3
)
875 bytesread
= read_unsynched(fd
, tag
, framelen
);
877 bytesread
= read(fd
, tag
, framelen
);
879 if( bytesread
!= framelen
)
884 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
885 bytesread
= unsynchronize_frame(tag
, bytesread
);
887 /* the COMM frame has a 3 char field to hold an ISO-639-1
888 * language string and an optional short description;
889 * remove them so unicode_munge can work correctly
892 if(!memcmp( header
, "COMM", 4 )) {
893 comm_offset
= 3 + strlen(tag
+4) + 1;
894 if(bytesread
>comm_offset
) {
895 bytesread
-=comm_offset
;
896 memmove(tag
+1, tag
+comm_offset
+1, bytesread
-1);
900 /* Attempt to parse Unicode string only if the tag contents
903 /* UTF-8 could potentially be 3 times larger */
904 /* so we need to create a new buffer */
905 char utf8buf
[(3 * bytesread
) + 1];
907 unicode_munge( tag
, utf8buf
, &bytesread
);
909 if(bytesread
>= buffersize
- bufferpos
)
910 bytesread
= buffersize
- bufferpos
- 1;
912 for (j
= 0; j
< bytesread
; j
++)
915 /* remove trailing spaces */
916 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
921 bufferpos
+= bytesread
+ 1;
927 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
929 /* Seek to the next frame */
930 if(framelen
< totframelen
)
931 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
936 if( i
== TAGLIST_SIZE
) {
937 /* no tag in tagList was found, or it was a repeat.
938 skip it using the total size */
940 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
941 size
-= skip_unsynched(fd
, totframelen
);
944 totframelen
= data_length_ind
;
947 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
955 * Calculates the size of the ID3v2 tag.
957 * Arguments: file - the file to search for a tag.
959 * Returns: the size of the tag or 0 if none was found
961 int getid3v2len(int fd
)
966 /* Make sure file has a ID3 tag */
967 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
968 (read(fd
, buf
, 6) != 6) ||
969 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
972 /* Now check what the ID3v2 size field says */
974 if(read(fd
, buf
, 4) != 4)
977 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
979 DEBUGF("ID3V2 Length: 0x%x\n", offset
);
984 * Calculates the length (in milliseconds) of an MP3 file.
986 * Modified to only use integers.
988 * Arguments: file - the file to calculate the length upon
989 * entry - the entry to update with the length
991 * Returns: the song length in milliseconds,
992 * 0 means that it couldn't be calculated
994 static int getsonglength(int fd
, struct mp3entry
*entry
)
996 unsigned long filetime
= 0;
1000 /* Start searching after ID3v2 header */
1001 if(-1 == lseek(fd
, entry
->id3v2len
, SEEK_SET
))
1004 bytecount
= get_mp3file_info(fd
, &info
);
1006 DEBUGF("Space between ID3V2 tag and first audio frame: 0x%lx bytes\n",
1012 bytecount
+= entry
->id3v2len
;
1014 /* Validate byte count, in case the file has been edited without
1015 * updating the header.
1017 if (info
.byte_count
)
1019 const unsigned long expected
= entry
->filesize
- entry
->id3v1len
1021 const unsigned long diff
= MAX(10240, info
.byte_count
/ 20);
1023 if ((info
.byte_count
> expected
+ diff
)
1024 || (info
.byte_count
< expected
- diff
))
1026 DEBUGF("Note: info.byte_count differs from expected value by "
1027 "%ld bytes\n", labs((long) (expected
- info
.byte_count
)));
1028 info
.byte_count
= 0;
1029 info
.frame_count
= 0;
1031 info
.enc_padding
= 0;
1033 /* Even if the bitrate was based on "known bad" values, it
1034 * should still be better for VBR files than using the bitrate
1035 * of the first audio frame.
1040 entry
->bitrate
= info
.bitrate
;
1041 entry
->frequency
= info
.frequency
;
1042 entry
->version
= info
.version
;
1043 entry
->layer
= info
.layer
;
1044 switch(entry
->layer
) {
1045 #if CONFIG_CODEC==SWCODEC
1047 entry
->codectype
=AFMT_MPA_L1
;
1051 entry
->codectype
=AFMT_MPA_L2
;
1054 entry
->codectype
=AFMT_MPA_L3
;
1058 /* If the file time hasn't been established, this may be a fixed
1059 rate MP3, so just use the default formula */
1061 filetime
= info
.file_time
;
1065 /* Prevent a division by zero */
1066 if (info
.bitrate
< 8)
1069 filetime
= (entry
->filesize
- bytecount
) / (info
.bitrate
/ 8);
1070 /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
1071 * instead of filesize * 8 is exact, because mpeg audio bitrates are
1072 * always multiples of 8, and it avoids overflows. */
1075 entry
->frame_count
= info
.frame_count
;
1077 entry
->vbr
= info
.is_vbr
;
1078 entry
->has_toc
= info
.has_toc
;
1080 #if CONFIG_CODEC==SWCODEC
1081 entry
->lead_trim
= info
.enc_delay
;
1082 entry
->tail_trim
= info
.enc_padding
;
1085 memcpy(entry
->toc
, info
.toc
, sizeof(info
.toc
));
1087 entry
->vbr_header_pos
= info
.vbr_header_pos
;
1089 /* Update the seek point for the first playable frame */
1090 entry
->first_frame_offset
= bytecount
;
1091 DEBUGF("First frame is at %lx\n", entry
->first_frame_offset
);
1097 * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
1098 * about an MP3 file and updates it's entry accordingly.
1100 Note, that this returns true for successful, false for error! */
1101 bool get_mp3_metadata(int fd
, struct mp3entry
*entry
, const char *filename
, bool v1first
)
1103 int v1found
= false;
1105 #if CONFIG_CODEC != SWCODEC
1106 memset(entry
, 0, sizeof(struct mp3entry
));
1109 strncpy(entry
->path
, filename
, sizeof(entry
->path
));
1111 entry
->title
= NULL
;
1112 entry
->filesize
= filesize(fd
);
1113 entry
->id3v2len
= getid3v2len(fd
);
1114 entry
->tracknum
= 0;
1117 v1found
= setid3v1title(fd
, entry
);
1119 if (!v1found
&& entry
->id3v2len
)
1120 setid3v2title(fd
, entry
);
1121 entry
->length
= getsonglength(fd
, entry
);
1123 /* Subtract the meta information from the file size to get
1124 the true size of the MP3 stream */
1125 entry
->filesize
-= entry
->first_frame_offset
;
1127 /* only seek to end of file if no id3v2 tags were found,
1128 and we already haven't looked for a v1 tag */
1129 if (!v1first
&& !entry
->id3v2len
) {
1130 setid3v1title(fd
, entry
);
1133 if(!entry
->length
|| (entry
->filesize
< 8 ))
1134 /* no song length or less than 8 bytes is hereby considered to be an
1135 invalid mp3 and won't be played by us! */
1141 /* Note, that this returns false for successful, true for error! */
1142 bool mp3info(struct mp3entry
*entry
, const char *filename
, bool v1first
)
1147 fd
= open(filename
, O_RDONLY
);
1151 result
= !get_mp3_metadata(fd
, entry
, filename
, v1first
);
1158 void adjust_mp3entry(struct mp3entry
*entry
, void *dest
, void *orig
)
1162 offset
= - ((size_t)orig
- (size_t)dest
);
1164 offset
= (size_t)dest
- (size_t)orig
;
1167 entry
->title
+= offset
;
1169 entry
->artist
+= offset
;
1171 entry
->album
+= offset
;
1172 if (entry
->genre_string
)
1173 entry
->genre_string
+= offset
;
1174 if (entry
->track_string
)
1175 entry
->track_string
+= offset
;
1176 if (entry
->year_string
)
1177 entry
->year_string
+= offset
;
1178 if (entry
->composer
)
1179 entry
->composer
+= offset
;
1181 entry
->comment
+= offset
;
1182 if (entry
->albumartist
)
1183 entry
->albumartist
+= offset
;
1184 #if CONFIG_CODEC == SWCODEC
1185 if (entry
->track_gain_string
)
1186 entry
->track_gain_string
+= offset
;
1187 if (entry
->album_gain_string
)
1188 entry
->album_gain_string
+= offset
;
1192 void copy_mp3entry(struct mp3entry
*dest
, struct mp3entry
*orig
)
1194 memcpy(dest
, orig
, sizeof(struct mp3entry
));
1195 adjust_mp3entry(dest
, dest
, orig
);
1198 #ifdef DEBUG_STANDALONE
1200 char *secs2str(int ms
)
1202 static char buffer
[32];
1205 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1209 int main(int argc
, char **argv
)
1212 for(i
=1; i
<argc
; i
++) {
1213 struct mp3entry mp3
;
1214 mp3
.album
= "Bogus";
1215 if(mp3info(&mp3
, argv
[i
], false)) {
1216 printf("Failed to get %s\n", argv
[i
]);
1220 printf("****** File: %s\n"
1224 " Genre: %s (%d) \n"
1228 " Length: %s / %d s\n"
1232 mp3
.title
?mp3
.title
:"<blank>",
1233 mp3
.artist
?mp3
.artist
:"<blank>",
1234 mp3
.album
?mp3
.album
:"<blank>",
1235 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1237 mp3
.composer
?mp3
.composer
:"<blank>",
1238 mp3
.year_string
?mp3
.year_string
:"<blank>",
1240 mp3
.track_string
?mp3
.track_string
:"<blank>",
1242 secs2str(mp3
.length
),