1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by Daniel Stenberg
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.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
22 * Parts of this code has been stolen from the Ample project and was written
23 * by David H�deman. It has since been extended and enhanced pretty much by
24 * all sorts of friendly Rockbox people.
28 /* tagResolver and associated code copyright 2003 Thomas Paul Diffenbach
45 #include "replaygain.h"
46 #include "rbunicode.h"
48 /** Database of audio formats **/
49 const struct afmt_entry audio_formats
[AFMT_NUM_CODECS
] =
51 /* Unknown file format */
53 AFMT_ENTRY("???", NULL
, NULL
, NULL
),
55 /* MPEG Audio layer 1 */
57 AFMT_ENTRY("MP1", "mpa", NULL
, "mp1\0" ),
58 /* MPEG Audio layer 2 */
60 AFMT_ENTRY("MP2", "mpa", NULL
, "mpa\0mp2\0" ),
61 /* MPEG Audio layer 3 */
63 AFMT_ENTRY("MP3", "mpa", "mp3_enc", "mp3\0" ),
65 #if CONFIG_CODEC == SWCODEC
66 /* Audio Interchange File Format */
68 AFMT_ENTRY("AIFF", "aiff", "aiff_enc", "aiff\0aif\0"),
69 /* Uncompressed PCM in a WAV file */
71 AFMT_ENTRY("WAV", "wav", "wav_enc", "wav\0" ),
74 AFMT_ENTRY("Ogg", "vorbis", NULL
, "ogg\0" ),
77 AFMT_ENTRY("FLAC", "flac", NULL
, "flac\0" ),
80 AFMT_ENTRY("MPC", "mpc", NULL
, "mpc\0" ),
81 /* A/52 (aka AC3) audio */
83 AFMT_ENTRY("AC3", "a52", NULL
, "a52\0ac3\0" ),
86 AFMT_ENTRY("WV", "wavpack", "wavpack_enc", "wv\0" ),
87 /* Apple Lossless Audio Codec */
89 AFMT_ENTRY("ALAC", "alac", NULL
, "m4a\0m4b\0" ),
90 /* Advanced Audio Coding in M4A container */
92 AFMT_ENTRY("AAC", "aac", NULL
, "mp4\0" ),
95 AFMT_ENTRY("SHN", "shorten", NULL
, "shn\0" ),
98 AFMT_ENTRY("SID", "sid", NULL
, "sid\0" ),
101 AFMT_ENTRY("ADX", "adx", NULL
, "adx\0" ),
102 /* NESM (NES Sound Format) */
104 AFMT_ENTRY("NSF", "nsf", NULL
, "nsf\0nsfe\0" ),
105 /* Speex File Format */
107 AFMT_ENTRY("Speex","speex", NULL
, "spx\0" ),
108 /* SPC700 Save State */
110 AFMT_ENTRY("SPC", "spc", NULL
, "spc\0" ),
111 /* APE (Monkey's Audio) */
113 AFMT_ENTRY("APE", "ape", NULL
, "ape\0mac\0" ),
114 /* WMA (WMAV1/V2 in ASF) */
116 AFMT_ENTRY("WMA", "wma", NULL
, "wma\0wmv\0asf\0" ),
119 AFMT_ENTRY("MOD", "mod", NULL
, "mod\0" ),
122 AFMT_ENTRY("SAP", "asap", NULL
, "sap\0" ),
126 #if CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING)
127 /* get REC_FORMAT_* corresponding AFMT_* */
128 const int rec_format_afmt
[REC_NUM_FORMATS
] =
130 /* give AFMT_UNKNOWN by default */
131 [0 ... REC_NUM_FORMATS
-1] = AFMT_UNKNOWN
,
132 /* add new entries below this line */
133 [REC_FORMAT_AIFF
] = AFMT_AIFF
,
134 [REC_FORMAT_MPA_L3
] = AFMT_MPA_L3
,
135 [REC_FORMAT_WAVPACK
] = AFMT_WAVPACK
,
136 [REC_FORMAT_PCM_WAV
] = AFMT_PCM_WAV
,
139 /* get AFMT_* corresponding REC_FORMAT_* */
140 const int afmt_rec_format
[AFMT_NUM_CODECS
] =
142 /* give -1 by default */
143 [0 ... AFMT_NUM_CODECS
-1] = -1,
144 /* add new entries below this line */
145 [AFMT_AIFF
] = REC_FORMAT_AIFF
,
146 [AFMT_MPA_L3
] = REC_FORMAT_MPA_L3
,
147 [AFMT_WAVPACK
] = REC_FORMAT_WAVPACK
,
148 [AFMT_PCM_WAV
] = REC_FORMAT_PCM_WAV
,
150 #endif /* CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING) */
153 static unsigned long unsync(unsigned long b0
,
158 return (((long)(b0
& 0x7F) << (3*7)) |
159 ((long)(b1
& 0x7F) << (2*7)) |
160 ((long)(b2
& 0x7F) << (1*7)) |
161 ((long)(b3
& 0x7F) << (0*7)));
164 static const char* const genres
[] = {
165 "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
166 "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
167 "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
168 "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
169 "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
170 "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
171 "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
172 "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
173 "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
174 "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
175 "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
176 "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
177 "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
179 /* winamp extensions */
180 "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
181 "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
182 "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
183 "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
184 "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
185 "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
186 "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
187 "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
188 "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
189 "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
190 "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
191 "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
195 char* id3_get_num_genre(unsigned int genre_num
)
197 if (genre_num
< sizeof(genres
)/sizeof(char*))
198 return (char*)genres
[genre_num
];
202 /* True if the string is from the "genres" array */
203 static bool id3_is_genre_string(const char *string
)
205 return ( string
>= genres
[0] &&
206 string
<= genres
[sizeof(genres
)/sizeof(char*) - 1] );
210 HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
211 Code and comments by Thomas Paul Diffenbach
213 To add another ID3v2 Tag, do the following:
214 1. add a char* named for the tag to struct mp3entry in id3.h,
215 (I (tpd) prefer to use char* rather than ints, even for what seems like
216 numerical values, for cases where a number won't do, e.g.,
217 YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
218 TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
219 Text is more flexible, and as the main use of id3 data is to
220 display it, converting it to an int just means reconverting to
221 display it, at a runtime cost.)
223 2. If any special processing beyond copying the tag value from the Id3
224 block to the struct mp3entry is rrequired (such as converting to an
225 int), write a function to perform this special processing.
227 This function's prototype must match that of
228 typedef tagPostProcessFunc, that is it must be:
229 int func( struct mp3entry*, char* tag, int bufferpos )
230 the first argument is a pointer to the current mp3entry structure the
231 second argument is a pointer to the null terminated string value of the
232 tag found the third argument is the offset of the next free byte in the
233 mp3entry's buffer your function should return the corrected offset; if
234 you don't lengthen or shorten the tag string, you can return the third
237 Unless you have a good reason no to, make the function static.
238 TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
240 3. add one or more entries to the tagList array, using the format:
241 char* ID3 Tag symbolic name -- see the ID3 specification for these,
242 sizeof() that name minus 1,
243 offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
244 pointer to your special processing function or NULL
245 if you need no special processing
246 flag indicating if this tag is binary or textual
247 Many ID3 symbolic names come in more than one form. You can add both
248 forms, each referencing the same variable in struct mp3entry.
249 If both forms are present, the last found will be used.
250 Note that the offset can be zero, in which case no entry will be set
251 in the mp3entry struct; the frame is still read into the buffer and
252 the special processing function is called (several times, if there
253 are several frames with the same name).
255 4. Alternately, use the TAG_LIST_ENTRY macro with
256 ID3 tag symbolic name,
257 variable in struct mp3entry,
258 special processing function address
260 5. Add code to wps-display.c function get_tag to assign a printf-like
261 format specifier for the tag */
263 /* Structure for ID3 Tag extraction information */
264 struct tag_resolver
{
268 int (*ppFunc
)(struct mp3entry
*, char* tag
, int bufferpos
);
272 static bool global_ff_found
;
274 static int unsynchronize(char* tag
, int len
, bool *ff_found
)
278 unsigned char *rp
, *wp
;
280 wp
= rp
= (unsigned char *)tag
;
282 rp
= (unsigned char *)tag
;
283 for(i
= 0;i
< len
;i
++) {
284 /* Read the next byte and write it back, but don't increment the
289 /* Increment the write pointer if it isn't an unsynch pattern */
299 return (long)wp
- (long)tag
;
302 static int unsynchronize_frame(char* tag
, int len
)
304 bool ff_found
= false;
306 return unsynchronize(tag
, len
, &ff_found
);
309 static int read_unsynched(int fd
, void *buf
, int len
)
321 rc
= read(fd
, rp
, remaining
);
325 i
= unsynchronize(wp
, remaining
, &global_ff_found
);
333 static int skip_unsynched(int fd
, int len
)
341 rlen
= MIN(sizeof(buf
), (unsigned int)remaining
);
342 rc
= read(fd
, buf
, rlen
);
346 remaining
-= unsynchronize(buf
, rlen
, &global_ff_found
);
352 /* parse numeric value from string */
353 static int parsetracknum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
355 entry
->tracknum
= atoi( tag
);
359 /* parse numeric value from string */
360 static int parsediscnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
362 entry
->discnum
= atoi( tag
);
366 /* parse numeric value from string */
367 static int parseyearnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
369 entry
->year
= atoi( tag
);
373 /* parse numeric genre from string, version 2.2 and 2.3 */
374 static int parsegenre( struct mp3entry
* entry
, char* tag
, int bufferpos
)
376 if(entry
->id3version
>= ID3_VER_2_4
) {
377 /* In version 2.4 and up, there are no parentheses, and the genre frame
378 is a list of strings, either numbers or text. */
380 /* Is it a number? */
381 if(isdigit(tag
[0])) {
382 entry
->genre_string
= id3_get_num_genre(atoi( tag
));
383 return tag
- entry
->id3v2buf
;
385 entry
->genre_string
= tag
;
389 if( tag
[0] == '(' && tag
[1] != '(' ) {
390 entry
->genre_string
= id3_get_num_genre(atoi( tag
+ 1 ));
391 return tag
- entry
->id3v2buf
;
394 entry
->genre_string
= tag
;
400 #if CONFIG_CODEC == SWCODEC
401 /* parse user defined text, looking for replaygain information. */
402 static int parseuser( struct mp3entry
* entry
, char* tag
, int bufferpos
)
405 int desc_len
= strlen(tag
);
408 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
409 /* At least part of the value was read, so we can safely try to
412 value
= tag
+ desc_len
+ 1;
413 value_len
= parse_replaygain(tag
, value
, entry
, tag
,
414 bufferpos
- (tag
- entry
->id3v2buf
));
417 return tag
- entry
->id3v2buf
+ value_len
;
420 /* parse RVA2 binary data and convert to replaygain information. */
421 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
423 int desc_len
= strlen(tag
);
424 int start_pos
= tag
- entry
->id3v2buf
;
425 int end_pos
= start_pos
+ desc_len
+ 5;
427 unsigned char* value
= tag
+ desc_len
+ 1;
429 /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
430 * type is master volume.
432 if (entry
->id3version
== ID3_VER_2_4
&& end_pos
< bufferpos
440 /* The RVA2 specification is unclear on some things (id string and
441 * peak volume), but this matches how Quod Libet use them.
444 gain
= (int16_t) ((value
[0] << 8) | value
[1]);
447 peakbytes
= (peakbits
+ 7) / 8;
449 /* Only use the topmost 24 bits for peak volume */
454 /* Make sure the peak bits were read */
455 if (end_pos
+ peakbytes
< bufferpos
) {
456 long shift
= ((8 - (peakbits
& 7)) & 7) + (3 - peakbytes
) * 8;
458 for ( ; peakbytes
; peakbytes
--) {
466 peak
+= *value
>> (8 - shift
);
470 if (strcasecmp(tag
, "album") == 0) {
472 } else if (strcasecmp(tag
, "track") != 0) {
473 /* Only accept non-track values if we don't have any previous
476 if (entry
->track_gain
!= 0) {
481 value_len
= parse_replaygain_int(album
, gain
, peak
* 2, entry
,
482 tag
, sizeof(entry
->id3v2buf
) - start_pos
);
485 return start_pos
+ value_len
;
489 static int parsembtid( struct mp3entry
* entry
, char* tag
, int bufferpos
)
492 int desc_len
= strlen(tag
);
493 /*DEBUGF("MBID len: %d\n", desc_len);*/
496 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
)
498 value
= tag
+ desc_len
+ 1;
500 if (strcasecmp(tag
, "http://musicbrainz.org") == 0)
502 /* Musicbrainz track IDs are always 36 chars long plus null */
505 entry
->mb_track_id
= value
;
507 /*DEBUGF("ENTRY: %s LEN: %d\n", entry->mb_track_id, strlen(entry->mb_track_id));*/
511 return tag
- entry
->id3v2buf
+ value_len
;
514 static const struct tag_resolver taglist
[] = {
515 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
516 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
517 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
518 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
519 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
520 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
521 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
522 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
523 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
524 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
525 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
526 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
527 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
528 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
529 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
530 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
531 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
532 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
533 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
534 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
535 #if CONFIG_CODEC == SWCODEC
536 { "TXXX", 4, 0, &parseuser
, false },
537 { "RVA2", 4, 0, &parserva2
, true },
539 { "UFID", 4, 0, &parsembtid
, false },
542 #define TAGLIST_SIZE ((int)(sizeof(taglist) / sizeof(taglist[0])))
544 /* Get the length of an ID3 string in the given encoding. Returns the length
545 * in bytes, including end nil, or -1 if the encoding is unknown.
547 static int unicode_len(char encoding
, const void* string
)
551 if (encoding
== 0x01 || encoding
== 0x02) {
553 const char *s
= string
;
554 /* string might be unaligned, so using short* can crash on ARM and SH1 */
557 } while ((first
| *s
++) != 0);
559 len
= s
- (const char*) string
;
561 len
= strlen((char*) string
) + 1;
567 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
568 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
569 we convert from the default codepage */
570 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
574 unsigned char *str
= (unsigned char *)string
;
576 unsigned char* utf8
= (unsigned char *)utf8buf
;
579 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
582 utf8
= iso_decode(str
, utf8
, -1, *len
);
584 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
587 case 0x01: /* Unicode with or without BOM */
592 /* Handle frames with more than one string
593 (needed for TXXX frames).*/
595 tmp
= bytes2int(0, 0, str
[0], str
[1]);
597 /* Now check if there is a BOM
598 (zero-width non-breaking space, 0xfeff)
599 and if it is in little or big endian format */
600 if(tmp
== 0xfffe) { /* Little endian? */
604 } else if(tmp
== 0xfeff) { /* Big endian? */
608 /* If there is no BOM (which is a specification violation),
609 let's try to guess it. If one of the bytes is 0x00, it is
610 probably the most significant one. */
616 utf8
= utf16LEdecode(str
, utf8
, 1);
618 utf8
= utf16BEdecode(str
, utf8
, 1);
622 } while((str
[0] || str
[1]) && (i
< *len
));
624 *utf8
++ = 0; /* Terminate the string */
625 templen
+= (strlen(&utf8buf
[templen
]) + 1);
632 case 0x03: /* UTF-8 encoded string */
633 for(i
=0; i
< *len
; i
++)
638 default: /* Plain old string */
639 utf8
= iso_decode(str
, utf8
, -1, *len
);
641 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
648 * Sets the title of an MP3 entry based on its ID3v1 tag.
650 * Arguments: file - the MP3 file to scen for a ID3v1 tag
651 * entry - the entry to set the title in
653 * Returns: true if a title was found and created, else false
655 static bool setid3v1title(int fd
, struct mp3entry
*entry
)
657 unsigned char buffer
[128];
658 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
662 if (-1 == lseek(fd
, -128, SEEK_END
))
665 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
668 if (strncmp((char *)buffer
, "TAG", 3))
671 entry
->id3v1len
= 128;
672 entry
->id3version
= ID3_VER_1_0
;
674 for (i
=0; i
< (int)sizeof offsets
; i
++) {
675 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
681 /* kill trailing space in strings */
682 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
684 /* convert string to utf8 */
685 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
686 utf8
= iso_decode(ptr
, utf8
, -1, 30);
687 /* make sure string is terminated */
692 /* kill trailing space in strings */
693 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
695 /* convert string to utf8 */
696 utf8
= (unsigned char *)entry
->id3v1buf
[3];
697 utf8
= iso_decode(ptr
, utf8
, -1, 28);
698 /* make sure string is terminated */
704 entry
->year
= atoi((char *)ptr
);
708 /* id3v1.1 uses last two bytes of comment field for track
709 number: first must be 0 and second is track num */
710 if (!ptr
[0] && ptr
[1]) {
711 entry
->tracknum
= ptr
[1];
712 entry
->id3version
= ID3_VER_1_1
;
718 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
723 entry
->title
= entry
->id3v1buf
[0];
724 entry
->artist
= entry
->id3v1buf
[1];
725 entry
->album
= entry
->id3v1buf
[2];
726 entry
->comment
= entry
->id3v1buf
[3];
733 * Sets the title of an MP3 entry based on its ID3v2 tag.
735 * Arguments: file - the MP3 file to scan for a ID3v2 tag
736 * entry - the entry to set the title in
738 * Returns: true if a title was found and created, else false
740 static void setid3v2title(int fd
, struct mp3entry
*entry
)
744 long bufferpos
= 0, totframelen
, framelen
;
747 unsigned char version
;
748 char *buffer
= entry
->id3v2buf
;
750 int buffersize
= sizeof(entry
->id3v2buf
);
751 unsigned char global_flags
;
754 bool global_unsynch
= false;
755 bool unsynch
= false;
759 global_ff_found
= false;
761 /* Bail out if the tag is shorter than 10 bytes */
762 if(entry
->id3v2len
< 10)
765 /* Read the ID3 tag version from the header */
766 lseek(fd
, 0, SEEK_SET
);
767 if(10 != read(fd
, header
, 10))
770 /* Get the total ID3 tag size */
771 size
= entry
->id3v2len
- 10;
776 version
= ID3_VER_2_2
;
781 version
= ID3_VER_2_3
;
786 version
= ID3_VER_2_4
;
791 /* unsupported id3 version */
794 entry
->id3version
= version
;
795 entry
->tracknum
= entry
->year
= entry
->discnum
= 0;
796 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
798 global_flags
= header
[5];
800 /* Skip the extended header if it is present */
801 if(global_flags
& 0x40) {
802 if(version
== ID3_VER_2_3
) {
803 if(10 != read(fd
, header
, 10))
805 /* The 2.3 extended header size doesn't include the header size
806 field itself. Also, it is not unsynched. */
808 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
810 /* Skip the rest of the header */
811 lseek(fd
, framelen
- 10, SEEK_CUR
);
814 if(version
>= ID3_VER_2_4
) {
815 if(4 != read(fd
, header
, 4))
818 /* The 2.4 extended header size does include the entire header,
819 so here we can just skip it. This header is unsynched. */
820 framelen
= unsync(header
[0], header
[1],
821 header
[2], header
[3]);
823 lseek(fd
, framelen
- 4, SEEK_CUR
);
827 /* Is unsynchronization applied? */
828 if(global_flags
& 0x80) {
829 global_unsynch
= true;
833 * We must have at least minframesize bytes left for the
834 * remaining frames to be interesting
836 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
839 /* Read frame header and check length */
840 if(version
>= ID3_VER_2_3
) {
841 if(global_unsynch
&& version
<= ID3_VER_2_3
)
842 rc
= read_unsynched(fd
, header
, 10);
844 rc
= read(fd
, header
, 10);
847 /* Adjust for the 10 bytes we read */
850 flags
= bytes2int(0, 0, header
[8], header
[9]);
852 if (version
>= ID3_VER_2_4
) {
853 framelen
= unsync(header
[4], header
[5],
854 header
[6], header
[7]);
856 /* version .3 files don't use synchsafe ints for
858 framelen
= bytes2int(header
[4], header
[5],
859 header
[6], header
[7]);
862 if(6 != read(fd
, header
, 6))
864 /* Adjust for the 6 bytes we read */
867 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
870 logf("framelen = %ld", framelen
);
872 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
884 if (version
>= ID3_VER_2_4
) {
885 if(flags
& 0x0040) { /* Grouping identity */
886 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
890 if(flags
& 0x0020) { /* Grouping identity */
891 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
896 if(flags
& 0x000c) /* Compression or encryption */
900 lseek(fd
, framelen
, SEEK_CUR
);
904 if(flags
& 0x0002) /* Unsynchronization */
907 if (version
>= ID3_VER_2_4
) {
908 if(flags
& 0x0001) { /* Data length indicator */
909 if(4 != read(fd
, tmp
, 4))
912 /* We don't need the data length */
918 /* Keep track of the remaining frame size */
919 totframelen
= framelen
;
921 /* If the frame is larger than the remaining buffer space we try
922 to read as much as would fit in the buffer */
923 if(framelen
>= buffersize
- bufferpos
)
924 framelen
= buffersize
- bufferpos
- 1;
926 logf("id3v2 frame: %.4s", header
);
928 /* Check for certain frame headers
930 'size' is the amount of frame bytes remaining. We decrement it by
931 the amount of bytes we read. If we fail to read as many bytes as
932 we expect, we assume that we can't read from this file, and bail
935 For each frame. we will iterate over the list of supported tags,
936 and read the tag into entry's buffer. All tags will be kept as
937 strings, for cases where a number won't do, e.g., YEAR: "circa
938 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
939 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
940 flexible, and as the main use of id3 data is to display it,
941 converting it to an int just means reconverting to display it, at a
944 For tags that the current code does convert to ints, a post
945 processing function will be called via a pointer to function. */
947 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
948 const struct tag_resolver
* tr
= &taglist
[i
];
949 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
953 /* Only ID3_VER_2_2 uses frames with three-character names. */
954 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
955 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
959 /* Note that parser functions sometimes set *ptag to NULL, so
960 * the "!*ptag" check here doesn't always have the desired
961 * effect. Should the parser functions (parsegenre in
962 * particular) be updated to handle the case of being called
963 * multiple times, or should the "*ptag" check be removed?
965 if( (!ptag
|| !*ptag
) && !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
967 /* found a tag matching one in tagList, and not yet filled */
968 tag
= buffer
+ bufferpos
;
970 if(global_unsynch
&& version
<= ID3_VER_2_3
)
971 bytesread
= read_unsynched(fd
, tag
, framelen
);
973 bytesread
= read(fd
, tag
, framelen
);
975 if( bytesread
!= framelen
)
980 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
981 bytesread
= unsynchronize_frame(tag
, bytesread
);
983 /* the COMM frame has a 3 char field to hold an ISO-639-1
984 * language string and an optional short description;
985 * remove them so unicode_munge can work correctly
988 if(!memcmp( header
, "COMM", 4 )) {
990 /* ignore comments with iTunes 7 soundcheck/gapless data */
991 if(!strncmp(tag
+4, "iTun", 4))
993 offset
= 3 + unicode_len(*tag
, tag
+ 4);
994 if(bytesread
> offset
) {
996 memmove(tag
+ 1, tag
+ 1 + offset
, bytesread
- 1);
1000 /* Attempt to parse Unicode string only if the tag contents
1003 /* UTF-8 could potentially be 3 times larger */
1004 /* so we need to create a new buffer */
1005 char utf8buf
[(3 * bytesread
) + 1];
1007 unicode_munge( tag
, utf8buf
, &bytesread
);
1009 if(bytesread
>= buffersize
- bufferpos
)
1010 bytesread
= buffersize
- bufferpos
- 1;
1012 for (j
= 0; j
< bytesread
; j
++)
1013 tag
[j
] = utf8buf
[j
];
1015 /* remove trailing spaces */
1016 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
1021 bufferpos
+= bytesread
+ 1;
1027 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
1029 /* Seek to the next frame */
1030 if(framelen
< totframelen
)
1031 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
1036 if( i
== TAGLIST_SIZE
) {
1037 /* no tag in tagList was found, or it was a repeat.
1038 skip it using the total size */
1040 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
1041 size
-= skip_unsynched(fd
, totframelen
);
1043 size
-= totframelen
;
1044 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
1052 * Calculates the size of the ID3v2 tag.
1054 * Arguments: file - the file to search for a tag.
1056 * Returns: the size of the tag or 0 if none was found
1058 int getid3v2len(int fd
)
1063 /* Make sure file has a ID3 tag */
1064 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
1065 (read(fd
, buf
, 6) != 6) ||
1066 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
1069 /* Now check what the ID3v2 size field says */
1071 if(read(fd
, buf
, 4) != 4)
1074 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
1076 logf("ID3V2 Length: 0x%x", offset
);
1081 * Calculates the length (in milliseconds) of an MP3 file.
1083 * Modified to only use integers.
1085 * Arguments: file - the file to calculate the length upon
1086 * entry - the entry to update with the length
1088 * Returns: the song length in milliseconds,
1089 * 0 means that it couldn't be calculated
1091 static int getsonglength(int fd
, struct mp3entry
*entry
)
1093 unsigned long filetime
= 0;
1094 struct mp3info info
;
1097 /* Start searching after ID3v2 header */
1098 if(-1 == lseek(fd
, entry
->id3v2len
, SEEK_SET
))
1101 bytecount
= get_mp3file_info(fd
, &info
);
1103 logf("Space between ID3V2 tag and first audio frame: 0x%lx bytes",
1109 bytecount
+= entry
->id3v2len
;
1111 /* Validate byte count, in case the file has been edited without
1112 * updating the header.
1114 if (info
.byte_count
)
1116 const unsigned long expected
= entry
->filesize
- entry
->id3v1len
1118 const unsigned long diff
= MAX(10240, info
.byte_count
/ 20);
1120 if ((info
.byte_count
> expected
+ diff
)
1121 || (info
.byte_count
< expected
- diff
))
1123 logf("Note: info.byte_count differs from expected value by "
1124 "%ld bytes", labs((long) (expected
- info
.byte_count
)));
1125 info
.byte_count
= 0;
1126 info
.frame_count
= 0;
1128 info
.enc_padding
= 0;
1130 /* Even if the bitrate was based on "known bad" values, it
1131 * should still be better for VBR files than using the bitrate
1132 * of the first audio frame.
1137 entry
->bitrate
= info
.bitrate
;
1138 entry
->frequency
= info
.frequency
;
1139 entry
->version
= info
.version
;
1140 entry
->layer
= info
.layer
;
1141 switch(entry
->layer
) {
1142 #if CONFIG_CODEC==SWCODEC
1144 entry
->codectype
=AFMT_MPA_L1
;
1148 entry
->codectype
=AFMT_MPA_L2
;
1151 entry
->codectype
=AFMT_MPA_L3
;
1155 /* If the file time hasn't been established, this may be a fixed
1156 rate MP3, so just use the default formula */
1158 filetime
= info
.file_time
;
1162 /* Prevent a division by zero */
1163 if (info
.bitrate
< 8)
1166 filetime
= (entry
->filesize
- bytecount
) / (info
.bitrate
/ 8);
1167 /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
1168 * instead of filesize * 8 is exact, because mpeg audio bitrates are
1169 * always multiples of 8, and it avoids overflows. */
1172 entry
->frame_count
= info
.frame_count
;
1174 entry
->vbr
= info
.is_vbr
;
1175 entry
->has_toc
= info
.has_toc
;
1177 #if CONFIG_CODEC==SWCODEC
1178 entry
->lead_trim
= info
.enc_delay
;
1179 entry
->tail_trim
= info
.enc_padding
;
1182 memcpy(entry
->toc
, info
.toc
, sizeof(info
.toc
));
1184 entry
->vbr_header_pos
= info
.vbr_header_pos
;
1186 /* Update the seek point for the first playable frame */
1187 entry
->first_frame_offset
= bytecount
;
1188 logf("First frame is at %lx", entry
->first_frame_offset
);
1194 * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
1195 * about an MP3 file and updates it's entry accordingly.
1197 Note, that this returns true for successful, false for error! */
1198 bool get_mp3_metadata(int fd
, struct mp3entry
*entry
, const char *filename
)
1200 #if CONFIG_CODEC != SWCODEC
1201 memset(entry
, 0, sizeof(struct mp3entry
));
1204 strncpy(entry
->path
, filename
, sizeof(entry
->path
));
1206 entry
->title
= NULL
;
1207 entry
->filesize
= filesize(fd
);
1208 entry
->id3v2len
= getid3v2len(fd
);
1209 entry
->tracknum
= 0;
1212 if (entry
->id3v2len
)
1213 setid3v2title(fd
, entry
);
1214 int len
= getsonglength(fd
, entry
);
1217 entry
->length
= len
;
1219 /* Subtract the meta information from the file size to get
1220 the true size of the MP3 stream */
1221 entry
->filesize
-= entry
->first_frame_offset
;
1223 /* only seek to end of file if no id3v2 tags were found */
1224 if (!entry
->id3v2len
) {
1225 setid3v1title(fd
, entry
);
1228 if(!entry
->length
|| (entry
->filesize
< 8 ))
1229 /* no song length or less than 8 bytes is hereby considered to be an
1230 invalid mp3 and won't be played by us! */
1236 /* Note, that this returns false for successful, true for error! */
1237 bool mp3info(struct mp3entry
*entry
, const char *filename
)
1242 fd
= open(filename
, O_RDONLY
);
1246 result
= !get_mp3_metadata(fd
, entry
, filename
);
1253 void adjust_mp3entry(struct mp3entry
*entry
, void *dest
, const void *orig
)
1257 offset
= - ((size_t)orig
- (size_t)dest
);
1259 offset
= (size_t)dest
- (size_t)orig
;
1262 entry
->title
+= offset
;
1264 entry
->artist
+= offset
;
1266 entry
->album
+= offset
;
1267 if (entry
->genre_string
&& !id3_is_genre_string(entry
->genre_string
))
1268 /* Don't adjust that if it points to an entry of the "genres" array */
1269 entry
->genre_string
+= offset
;
1270 if (entry
->track_string
)
1271 entry
->track_string
+= offset
;
1272 if (entry
->disc_string
)
1273 entry
->disc_string
+= offset
;
1274 if (entry
->year_string
)
1275 entry
->year_string
+= offset
;
1276 if (entry
->composer
)
1277 entry
->composer
+= offset
;
1279 entry
->comment
+= offset
;
1280 if (entry
->albumartist
)
1281 entry
->albumartist
+= offset
;
1282 if (entry
->grouping
)
1283 entry
->grouping
+= offset
;
1284 #if CONFIG_CODEC == SWCODEC
1285 if (entry
->track_gain_string
)
1286 entry
->track_gain_string
+= offset
;
1287 if (entry
->album_gain_string
)
1288 entry
->album_gain_string
+= offset
;
1290 if (entry
->mb_track_id
)
1291 entry
->mb_track_id
+= offset
;
1294 void copy_mp3entry(struct mp3entry
*dest
, const struct mp3entry
*orig
)
1296 memcpy(dest
, orig
, sizeof(struct mp3entry
));
1297 adjust_mp3entry(dest
, dest
, orig
);
1300 #ifdef DEBUG_STANDALONE
1302 char *secs2str(int ms
)
1304 static char buffer
[32];
1307 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1311 int main(int argc
, char **argv
)
1314 for(i
=1; i
<argc
; i
++) {
1315 struct mp3entry mp3
;
1316 mp3
.album
= "Bogus";
1317 if(mp3info(&mp3
, argv
[i
], false)) {
1318 printf("Failed to get %s\n", argv
[i
]);
1322 printf("****** File: %s\n"
1326 " Genre: %s (%d) \n"
1330 " Length: %s / %d s\n"
1334 mp3
.title
?mp3
.title
:"<blank>",
1335 mp3
.artist
?mp3
.artist
:"<blank>",
1336 mp3
.album
?mp3
.album
:"<blank>",
1337 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1339 mp3
.composer
?mp3
.composer
:"<blank>",
1340 mp3
.year_string
?mp3
.year_string
:"<blank>",
1342 mp3
.track_string
?mp3
.track_string
:"<blank>",
1344 secs2str(mp3
.length
),