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" ),
123 #if CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING)
124 /* get REC_FORMAT_* corresponding AFMT_* */
125 const int rec_format_afmt
[REC_NUM_FORMATS
] =
127 /* give AFMT_UNKNOWN by default */
128 [0 ... REC_NUM_FORMATS
-1] = AFMT_UNKNOWN
,
129 /* add new entries below this line */
130 [REC_FORMAT_AIFF
] = AFMT_AIFF
,
131 [REC_FORMAT_MPA_L3
] = AFMT_MPA_L3
,
132 [REC_FORMAT_WAVPACK
] = AFMT_WAVPACK
,
133 [REC_FORMAT_PCM_WAV
] = AFMT_PCM_WAV
,
136 /* get AFMT_* corresponding REC_FORMAT_* */
137 const int afmt_rec_format
[AFMT_NUM_CODECS
] =
139 /* give -1 by default */
140 [0 ... AFMT_NUM_CODECS
-1] = -1,
141 /* add new entries below this line */
142 [AFMT_AIFF
] = REC_FORMAT_AIFF
,
143 [AFMT_MPA_L3
] = REC_FORMAT_MPA_L3
,
144 [AFMT_WAVPACK
] = REC_FORMAT_WAVPACK
,
145 [AFMT_PCM_WAV
] = REC_FORMAT_PCM_WAV
,
147 #endif /* CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING) */
150 static unsigned long unsync(unsigned long b0
,
155 return (((long)(b0
& 0x7F) << (3*7)) |
156 ((long)(b1
& 0x7F) << (2*7)) |
157 ((long)(b2
& 0x7F) << (1*7)) |
158 ((long)(b3
& 0x7F) << (0*7)));
161 static const char* const genres
[] = {
162 "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
163 "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
164 "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
165 "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
166 "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
167 "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
168 "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
169 "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
170 "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
171 "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
172 "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
173 "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
174 "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
176 /* winamp extensions */
177 "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
178 "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
179 "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
180 "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
181 "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
182 "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
183 "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
184 "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
185 "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
186 "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
187 "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
188 "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
192 char* id3_get_num_genre(unsigned int genre_num
)
194 if (genre_num
< sizeof(genres
)/sizeof(char*))
195 return (char*)genres
[genre_num
];
199 /* True if the string is from the "genres" array */
200 static bool id3_is_genre_string(const char *string
)
202 return ( string
>= genres
[0] &&
203 string
<= genres
[sizeof(genres
)/sizeof(char*) - 1] );
207 HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
208 Code and comments by Thomas Paul Diffenbach
210 To add another ID3v2 Tag, do the following:
211 1. add a char* named for the tag to struct mp3entry in id3.h,
212 (I (tpd) prefer to use char* rather than ints, even for what seems like
213 numerical values, for cases where a number won't do, e.g.,
214 YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
215 TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
216 Text is more flexible, and as the main use of id3 data is to
217 display it, converting it to an int just means reconverting to
218 display it, at a runtime cost.)
220 2. If any special processing beyond copying the tag value from the Id3
221 block to the struct mp3entry is rrequired (such as converting to an
222 int), write a function to perform this special processing.
224 This function's prototype must match that of
225 typedef tagPostProcessFunc, that is it must be:
226 int func( struct mp3entry*, char* tag, int bufferpos )
227 the first argument is a pointer to the current mp3entry structure the
228 second argument is a pointer to the null terminated string value of the
229 tag found the third argument is the offset of the next free byte in the
230 mp3entry's buffer your function should return the corrected offset; if
231 you don't lengthen or shorten the tag string, you can return the third
234 Unless you have a good reason no to, make the function static.
235 TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
237 3. add one or more entries to the tagList array, using the format:
238 char* ID3 Tag symbolic name -- see the ID3 specification for these,
239 sizeof() that name minus 1,
240 offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
241 pointer to your special processing function or NULL
242 if you need no special processing
243 flag indicating if this tag is binary or textual
244 Many ID3 symbolic names come in more than one form. You can add both
245 forms, each referencing the same variable in struct mp3entry.
246 If both forms are present, the last found will be used.
247 Note that the offset can be zero, in which case no entry will be set
248 in the mp3entry struct; the frame is still read into the buffer and
249 the special processing function is called (several times, if there
250 are several frames with the same name).
252 4. Alternately, use the TAG_LIST_ENTRY macro with
253 ID3 tag symbolic name,
254 variable in struct mp3entry,
255 special processing function address
257 5. Add code to wps-display.c function get_tag to assign a printf-like
258 format specifier for the tag */
260 /* Structure for ID3 Tag extraction information */
261 struct tag_resolver
{
265 int (*ppFunc
)(struct mp3entry
*, char* tag
, int bufferpos
);
269 static bool global_ff_found
;
271 static int unsynchronize(char* tag
, int len
, bool *ff_found
)
275 unsigned char *rp
, *wp
;
277 wp
= rp
= (unsigned char *)tag
;
279 rp
= (unsigned char *)tag
;
280 for(i
= 0;i
< len
;i
++) {
281 /* Read the next byte and write it back, but don't increment the
286 /* Increment the write pointer if it isn't an unsynch pattern */
296 return (long)wp
- (long)tag
;
299 static int unsynchronize_frame(char* tag
, int len
)
301 bool ff_found
= false;
303 return unsynchronize(tag
, len
, &ff_found
);
306 static int read_unsynched(int fd
, void *buf
, int len
)
318 rc
= read(fd
, rp
, remaining
);
322 i
= unsynchronize(wp
, remaining
, &global_ff_found
);
330 static int skip_unsynched(int fd
, int len
)
338 rlen
= MIN(sizeof(buf
), (unsigned int)remaining
);
339 rc
= read(fd
, buf
, rlen
);
343 remaining
-= unsynchronize(buf
, rlen
, &global_ff_found
);
349 /* parse numeric value from string */
350 static int parsetracknum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
352 entry
->tracknum
= atoi( tag
);
356 /* parse numeric value from string */
357 static int parsediscnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
359 entry
->discnum
= atoi( tag
);
363 /* parse numeric value from string */
364 static int parseyearnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
366 entry
->year
= atoi( tag
);
370 /* parse numeric genre from string, version 2.2 and 2.3 */
371 static int parsegenre( struct mp3entry
* entry
, char* tag
, int bufferpos
)
373 if(entry
->id3version
>= ID3_VER_2_4
) {
374 /* In version 2.4 and up, there are no parentheses, and the genre frame
375 is a list of strings, either numbers or text. */
377 /* Is it a number? */
378 if(isdigit(tag
[0])) {
379 entry
->genre_string
= id3_get_num_genre(atoi( tag
));
380 return tag
- entry
->id3v2buf
;
382 entry
->genre_string
= tag
;
386 if( tag
[0] == '(' && tag
[1] != '(' ) {
387 entry
->genre_string
= id3_get_num_genre(atoi( tag
+ 1 ));
388 return tag
- entry
->id3v2buf
;
391 entry
->genre_string
= tag
;
397 #if CONFIG_CODEC == SWCODEC
398 /* parse user defined text, looking for replaygain information. */
399 static int parseuser( struct mp3entry
* entry
, char* tag
, int bufferpos
)
402 int desc_len
= strlen(tag
);
405 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
406 /* At least part of the value was read, so we can safely try to
409 value
= tag
+ desc_len
+ 1;
410 value_len
= parse_replaygain(tag
, value
, entry
, tag
,
411 bufferpos
- (tag
- entry
->id3v2buf
));
414 return tag
- entry
->id3v2buf
+ value_len
;
417 /* parse RVA2 binary data and convert to replaygain information. */
418 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
420 int desc_len
= strlen(tag
);
421 int start_pos
= tag
- entry
->id3v2buf
;
422 int end_pos
= start_pos
+ desc_len
+ 5;
424 unsigned char* value
= tag
+ desc_len
+ 1;
426 /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
427 * type is master volume.
429 if (entry
->id3version
== ID3_VER_2_4
&& end_pos
< bufferpos
437 /* The RVA2 specification is unclear on some things (id string and
438 * peak volume), but this matches how Quod Libet use them.
441 gain
= (int16_t) ((value
[0] << 8) | value
[1]);
444 peakbytes
= (peakbits
+ 7) / 8;
446 /* Only use the topmost 24 bits for peak volume */
451 /* Make sure the peak bits were read */
452 if (end_pos
+ peakbytes
< bufferpos
) {
453 long shift
= ((8 - (peakbits
& 7)) & 7) + (3 - peakbytes
) * 8;
455 for ( ; peakbytes
; peakbytes
--) {
463 peak
+= *value
>> (8 - shift
);
467 if (strcasecmp(tag
, "album") == 0) {
469 } else if (strcasecmp(tag
, "track") != 0) {
470 /* Only accept non-track values if we don't have any previous
473 if (entry
->track_gain
!= 0) {
478 value_len
= parse_replaygain_int(album
, gain
, peak
* 2, entry
,
479 tag
, sizeof(entry
->id3v2buf
) - start_pos
);
482 return start_pos
+ value_len
;
486 static const struct tag_resolver taglist
[] = {
487 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
488 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
489 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
490 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
491 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
492 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
493 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
494 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
495 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
496 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
497 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
498 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
499 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
500 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
501 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
502 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
503 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
504 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
505 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
506 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
507 #if CONFIG_CODEC == SWCODEC
508 { "TXXX", 4, 0, &parseuser
, false },
509 { "RVA2", 4, 0, &parserva2
, true },
513 #define TAGLIST_SIZE ((int)(sizeof(taglist) / sizeof(taglist[0])))
515 /* Get the length of an ID3 string in the given encoding. Returns the length
516 * in bytes, including end nil, or -1 if the encoding is unknown.
518 static int unicode_len(char encoding
, const void* string
)
522 if (encoding
== 0x01 || encoding
== 0x02) {
524 const char *s
= string
;
525 /* string might be unaligned, so using short* can crash on ARM and SH1 */
528 } while ((first
| *s
++) != 0);
530 len
= s
- (const char*) string
;
532 len
= strlen((char*) string
) + 1;
538 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
539 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
540 we convert from the default codepage */
541 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
545 unsigned char *str
= (unsigned char *)string
;
547 unsigned char* utf8
= (unsigned char *)utf8buf
;
550 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
553 utf8
= iso_decode(str
, utf8
, -1, *len
);
555 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
558 case 0x01: /* Unicode with or without BOM */
563 /* Handle frames with more than one string
564 (needed for TXXX frames).*/
566 tmp
= bytes2int(0, 0, str
[0], str
[1]);
568 /* Now check if there is a BOM
569 (zero-width non-breaking space, 0xfeff)
570 and if it is in little or big endian format */
571 if(tmp
== 0xfffe) { /* Little endian? */
575 } else if(tmp
== 0xfeff) { /* Big endian? */
579 /* If there is no BOM (which is a specification violation),
580 let's try to guess it. If one of the bytes is 0x00, it is
581 probably the most significant one. */
587 utf8
= utf16LEdecode(str
, utf8
, 1);
589 utf8
= utf16BEdecode(str
, utf8
, 1);
593 } while((str
[0] || str
[1]) && (i
< *len
));
595 *utf8
++ = 0; /* Terminate the string */
596 templen
+= (strlen(&utf8buf
[templen
]) + 1);
603 case 0x03: /* UTF-8 encoded string */
604 for(i
=0; i
< *len
; i
++)
609 default: /* Plain old string */
610 utf8
= iso_decode(str
, utf8
, -1, *len
);
612 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
619 * Sets the title of an MP3 entry based on its ID3v1 tag.
621 * Arguments: file - the MP3 file to scen for a ID3v1 tag
622 * entry - the entry to set the title in
624 * Returns: true if a title was found and created, else false
626 static bool setid3v1title(int fd
, struct mp3entry
*entry
)
628 unsigned char buffer
[128];
629 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
633 if (-1 == lseek(fd
, -128, SEEK_END
))
636 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
639 if (strncmp((char *)buffer
, "TAG", 3))
642 entry
->id3v1len
= 128;
643 entry
->id3version
= ID3_VER_1_0
;
645 for (i
=0; i
< (int)sizeof offsets
; i
++) {
646 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
652 /* kill trailing space in strings */
653 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
655 /* convert string to utf8 */
656 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
657 utf8
= iso_decode(ptr
, utf8
, -1, 30);
658 /* make sure string is terminated */
663 /* kill trailing space in strings */
664 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
666 /* convert string to utf8 */
667 utf8
= (unsigned char *)entry
->id3v1buf
[3];
668 utf8
= iso_decode(ptr
, utf8
, -1, 28);
669 /* make sure string is terminated */
675 entry
->year
= atoi((char *)ptr
);
679 /* id3v1.1 uses last two bytes of comment field for track
680 number: first must be 0 and second is track num */
681 if (!ptr
[0] && ptr
[1]) {
682 entry
->tracknum
= ptr
[1];
683 entry
->id3version
= ID3_VER_1_1
;
689 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
694 entry
->title
= entry
->id3v1buf
[0];
695 entry
->artist
= entry
->id3v1buf
[1];
696 entry
->album
= entry
->id3v1buf
[2];
697 entry
->comment
= entry
->id3v1buf
[3];
704 * Sets the title of an MP3 entry based on its ID3v2 tag.
706 * Arguments: file - the MP3 file to scan for a ID3v2 tag
707 * entry - the entry to set the title in
709 * Returns: true if a title was found and created, else false
711 static void setid3v2title(int fd
, struct mp3entry
*entry
)
715 long bufferpos
= 0, totframelen
, framelen
;
718 unsigned char version
;
719 char *buffer
= entry
->id3v2buf
;
721 int buffersize
= sizeof(entry
->id3v2buf
);
722 unsigned char global_flags
;
725 bool global_unsynch
= false;
726 bool unsynch
= false;
731 global_ff_found
= false;
733 /* Bail out if the tag is shorter than 10 bytes */
734 if(entry
->id3v2len
< 10)
737 /* Read the ID3 tag version from the header */
738 lseek(fd
, 0, SEEK_SET
);
739 if(10 != read(fd
, header
, 10))
742 /* Get the total ID3 tag size */
743 size
= entry
->id3v2len
- 10;
748 version
= ID3_VER_2_2
;
753 version
= ID3_VER_2_3
;
758 version
= ID3_VER_2_4
;
763 /* unsupported id3 version */
766 entry
->id3version
= version
;
767 entry
->tracknum
= entry
->year
= entry
->discnum
= 0;
768 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
770 global_flags
= header
[5];
772 /* Skip the extended header if it is present */
773 if(global_flags
& 0x40) {
774 if(version
== ID3_VER_2_3
) {
775 if(10 != read(fd
, header
, 10))
777 /* The 2.3 extended header size doesn't include the header size
778 field itself. Also, it is not unsynched. */
780 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
782 /* Skip the rest of the header */
783 lseek(fd
, framelen
- 10, SEEK_CUR
);
786 if(version
>= ID3_VER_2_4
) {
787 if(4 != read(fd
, header
, 4))
790 /* The 2.4 extended header size does include the entire header,
791 so here we can just skip it. This header is unsynched. */
792 framelen
= unsync(header
[0], header
[1],
793 header
[2], header
[3]);
795 lseek(fd
, framelen
- 4, SEEK_CUR
);
799 /* Is unsynchronization applied? */
800 if(global_flags
& 0x80) {
801 global_unsynch
= true;
805 * We must have at least minframesize bytes left for the
806 * remaining frames to be interesting
808 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
811 /* Read frame header and check length */
812 if(version
>= ID3_VER_2_3
) {
813 if(global_unsynch
&& version
<= ID3_VER_2_3
)
814 rc
= read_unsynched(fd
, header
, 10);
816 rc
= read(fd
, header
, 10);
819 /* Adjust for the 10 bytes we read */
822 flags
= bytes2int(0, 0, header
[8], header
[9]);
824 if (version
>= ID3_VER_2_4
) {
825 framelen
= unsync(header
[4], header
[5],
826 header
[6], header
[7]);
828 /* version .3 files don't use synchsafe ints for
830 framelen
= bytes2int(header
[4], header
[5],
831 header
[6], header
[7]);
834 if(6 != read(fd
, header
, 6))
836 /* Adjust for the 6 bytes we read */
839 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
842 logf("framelen = %ld", framelen
);
844 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
857 if (version
>= ID3_VER_2_4
) {
858 if(flags
& 0x0040) { /* Grouping identity */
859 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
863 if(flags
& 0x0020) { /* Grouping identity */
864 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
869 if(flags
& 0x000c) /* Compression or encryption */
873 lseek(fd
, framelen
, SEEK_CUR
);
877 if(flags
& 0x0002) /* Unsynchronization */
880 if (version
>= ID3_VER_2_4
) {
881 if(flags
& 0x0001) { /* Data length indicator */
882 if(4 != read(fd
, tmp
, 4))
885 data_length_ind
= unsync(tmp
[0], tmp
[1], tmp
[2], tmp
[3]);
891 /* Keep track of the remaining frame size */
892 totframelen
= framelen
;
894 /* If the frame is larger than the remaining buffer space we try
895 to read as much as would fit in the buffer */
896 if(framelen
>= buffersize
- bufferpos
)
897 framelen
= buffersize
- bufferpos
- 1;
899 logf("id3v2 frame: %.4s", header
);
901 /* Check for certain frame headers
903 'size' is the amount of frame bytes remaining. We decrement it by
904 the amount of bytes we read. If we fail to read as many bytes as
905 we expect, we assume that we can't read from this file, and bail
908 For each frame. we will iterate over the list of supported tags,
909 and read the tag into entry's buffer. All tags will be kept as
910 strings, for cases where a number won't do, e.g., YEAR: "circa
911 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
912 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
913 flexible, and as the main use of id3 data is to display it,
914 converting it to an int just means reconverting to display it, at a
917 For tags that the current code does convert to ints, a post
918 processing function will be called via a pointer to function. */
920 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
921 const struct tag_resolver
* tr
= &taglist
[i
];
922 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
926 /* Only ID3_VER_2_2 uses frames with three-character names. */
927 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
928 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
932 /* Note that parser functions sometimes set *ptag to NULL, so
933 * the "!*ptag" check here doesn't always have the desired
934 * effect. Should the parser functions (parsegenre in
935 * particular) be updated to handle the case of being called
936 * multiple times, or should the "*ptag" check be removed?
938 if( (!ptag
|| !*ptag
) && !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
940 /* found a tag matching one in tagList, and not yet filled */
941 tag
= buffer
+ bufferpos
;
943 if(global_unsynch
&& version
<= ID3_VER_2_3
)
944 bytesread
= read_unsynched(fd
, tag
, framelen
);
946 bytesread
= read(fd
, tag
, framelen
);
948 if( bytesread
!= framelen
)
953 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
954 bytesread
= unsynchronize_frame(tag
, bytesread
);
956 /* the COMM frame has a 3 char field to hold an ISO-639-1
957 * language string and an optional short description;
958 * remove them so unicode_munge can work correctly
961 if(!memcmp( header
, "COMM", 4 )) {
963 /* ignore comments with iTunes 7 soundcheck/gapless data */
964 if(!strncmp(tag
+4, "iTun", 4))
966 offset
= 3 + unicode_len(*tag
, tag
+ 4);
967 if(bytesread
> offset
) {
969 memmove(tag
+ 1, tag
+ 1 + offset
, bytesread
- 1);
973 /* Attempt to parse Unicode string only if the tag contents
976 /* UTF-8 could potentially be 3 times larger */
977 /* so we need to create a new buffer */
978 char utf8buf
[(3 * bytesread
) + 1];
980 unicode_munge( tag
, utf8buf
, &bytesread
);
982 if(bytesread
>= buffersize
- bufferpos
)
983 bytesread
= buffersize
- bufferpos
- 1;
985 for (j
= 0; j
< bytesread
; j
++)
988 /* remove trailing spaces */
989 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
994 bufferpos
+= bytesread
+ 1;
1000 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
1002 /* Seek to the next frame */
1003 if(framelen
< totframelen
)
1004 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
1009 if( i
== TAGLIST_SIZE
) {
1010 /* no tag in tagList was found, or it was a repeat.
1011 skip it using the total size */
1013 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
1014 size
-= skip_unsynched(fd
, totframelen
);
1017 totframelen
= data_length_ind
;
1019 size
-= totframelen
;
1020 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
1028 * Calculates the size of the ID3v2 tag.
1030 * Arguments: file - the file to search for a tag.
1032 * Returns: the size of the tag or 0 if none was found
1034 int getid3v2len(int fd
)
1039 /* Make sure file has a ID3 tag */
1040 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
1041 (read(fd
, buf
, 6) != 6) ||
1042 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
1045 /* Now check what the ID3v2 size field says */
1047 if(read(fd
, buf
, 4) != 4)
1050 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
1052 logf("ID3V2 Length: 0x%x", offset
);
1057 * Calculates the length (in milliseconds) of an MP3 file.
1059 * Modified to only use integers.
1061 * Arguments: file - the file to calculate the length upon
1062 * entry - the entry to update with the length
1064 * Returns: the song length in milliseconds,
1065 * 0 means that it couldn't be calculated
1067 static int getsonglength(int fd
, struct mp3entry
*entry
)
1069 unsigned long filetime
= 0;
1070 struct mp3info info
;
1073 /* Start searching after ID3v2 header */
1074 if(-1 == lseek(fd
, entry
->id3v2len
, SEEK_SET
))
1077 bytecount
= get_mp3file_info(fd
, &info
);
1079 logf("Space between ID3V2 tag and first audio frame: 0x%lx bytes",
1085 bytecount
+= entry
->id3v2len
;
1087 /* Validate byte count, in case the file has been edited without
1088 * updating the header.
1090 if (info
.byte_count
)
1092 const unsigned long expected
= entry
->filesize
- entry
->id3v1len
1094 const unsigned long diff
= MAX(10240, info
.byte_count
/ 20);
1096 if ((info
.byte_count
> expected
+ diff
)
1097 || (info
.byte_count
< expected
- diff
))
1099 logf("Note: info.byte_count differs from expected value by "
1100 "%ld bytes", labs((long) (expected
- info
.byte_count
)));
1101 info
.byte_count
= 0;
1102 info
.frame_count
= 0;
1104 info
.enc_padding
= 0;
1106 /* Even if the bitrate was based on "known bad" values, it
1107 * should still be better for VBR files than using the bitrate
1108 * of the first audio frame.
1113 entry
->bitrate
= info
.bitrate
;
1114 entry
->frequency
= info
.frequency
;
1115 entry
->version
= info
.version
;
1116 entry
->layer
= info
.layer
;
1117 switch(entry
->layer
) {
1118 #if CONFIG_CODEC==SWCODEC
1120 entry
->codectype
=AFMT_MPA_L1
;
1124 entry
->codectype
=AFMT_MPA_L2
;
1127 entry
->codectype
=AFMT_MPA_L3
;
1131 /* If the file time hasn't been established, this may be a fixed
1132 rate MP3, so just use the default formula */
1134 filetime
= info
.file_time
;
1138 /* Prevent a division by zero */
1139 if (info
.bitrate
< 8)
1142 filetime
= (entry
->filesize
- bytecount
) / (info
.bitrate
/ 8);
1143 /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
1144 * instead of filesize * 8 is exact, because mpeg audio bitrates are
1145 * always multiples of 8, and it avoids overflows. */
1148 entry
->frame_count
= info
.frame_count
;
1150 entry
->vbr
= info
.is_vbr
;
1151 entry
->has_toc
= info
.has_toc
;
1153 #if CONFIG_CODEC==SWCODEC
1154 entry
->lead_trim
= info
.enc_delay
;
1155 entry
->tail_trim
= info
.enc_padding
;
1158 memcpy(entry
->toc
, info
.toc
, sizeof(info
.toc
));
1160 entry
->vbr_header_pos
= info
.vbr_header_pos
;
1162 /* Update the seek point for the first playable frame */
1163 entry
->first_frame_offset
= bytecount
;
1164 logf("First frame is at %lx", entry
->first_frame_offset
);
1170 * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
1171 * about an MP3 file and updates it's entry accordingly.
1173 Note, that this returns true for successful, false for error! */
1174 bool get_mp3_metadata(int fd
, struct mp3entry
*entry
, const char *filename
)
1176 #if CONFIG_CODEC != SWCODEC
1177 memset(entry
, 0, sizeof(struct mp3entry
));
1180 strncpy(entry
->path
, filename
, sizeof(entry
->path
));
1182 entry
->title
= NULL
;
1183 entry
->filesize
= filesize(fd
);
1184 entry
->id3v2len
= getid3v2len(fd
);
1185 entry
->tracknum
= 0;
1188 if (entry
->id3v2len
)
1189 setid3v2title(fd
, entry
);
1190 int len
= getsonglength(fd
, entry
);
1193 entry
->length
= len
;
1195 /* Subtract the meta information from the file size to get
1196 the true size of the MP3 stream */
1197 entry
->filesize
-= entry
->first_frame_offset
;
1199 /* only seek to end of file if no id3v2 tags were found */
1200 if (!entry
->id3v2len
) {
1201 setid3v1title(fd
, entry
);
1204 if(!entry
->length
|| (entry
->filesize
< 8 ))
1205 /* no song length or less than 8 bytes is hereby considered to be an
1206 invalid mp3 and won't be played by us! */
1212 /* Note, that this returns false for successful, true for error! */
1213 bool mp3info(struct mp3entry
*entry
, const char *filename
)
1218 fd
= open(filename
, O_RDONLY
);
1222 result
= !get_mp3_metadata(fd
, entry
, filename
);
1229 void adjust_mp3entry(struct mp3entry
*entry
, void *dest
, const void *orig
)
1233 offset
= - ((size_t)orig
- (size_t)dest
);
1235 offset
= (size_t)dest
- (size_t)orig
;
1238 entry
->title
+= offset
;
1240 entry
->artist
+= offset
;
1242 entry
->album
+= offset
;
1243 if (entry
->genre_string
&& !id3_is_genre_string(entry
->genre_string
))
1244 /* Don't adjust that if it points to an entry of the "genres" array */
1245 entry
->genre_string
+= offset
;
1246 if (entry
->track_string
)
1247 entry
->track_string
+= offset
;
1248 if (entry
->disc_string
)
1249 entry
->disc_string
+= offset
;
1250 if (entry
->year_string
)
1251 entry
->year_string
+= offset
;
1252 if (entry
->composer
)
1253 entry
->composer
+= offset
;
1255 entry
->comment
+= offset
;
1256 if (entry
->albumartist
)
1257 entry
->albumartist
+= offset
;
1258 if (entry
->grouping
)
1259 entry
->grouping
+= offset
;
1260 #if CONFIG_CODEC == SWCODEC
1261 if (entry
->track_gain_string
)
1262 entry
->track_gain_string
+= offset
;
1263 if (entry
->album_gain_string
)
1264 entry
->album_gain_string
+= offset
;
1268 void copy_mp3entry(struct mp3entry
*dest
, const struct mp3entry
*orig
)
1270 memcpy(dest
, orig
, sizeof(struct mp3entry
));
1271 adjust_mp3entry(dest
, dest
, orig
);
1274 #ifdef DEBUG_STANDALONE
1276 char *secs2str(int ms
)
1278 static char buffer
[32];
1281 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1285 int main(int argc
, char **argv
)
1288 for(i
=1; i
<argc
; i
++) {
1289 struct mp3entry mp3
;
1290 mp3
.album
= "Bogus";
1291 if(mp3info(&mp3
, argv
[i
], false)) {
1292 printf("Failed to get %s\n", argv
[i
]);
1296 printf("****** File: %s\n"
1300 " Genre: %s (%d) \n"
1304 " Length: %s / %d s\n"
1308 mp3
.title
?mp3
.title
:"<blank>",
1309 mp3
.artist
?mp3
.artist
:"<blank>",
1310 mp3
.album
?mp3
.album
:"<blank>",
1311 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1313 mp3
.composer
?mp3
.composer
:"<blank>",
1314 mp3
.year_string
?mp3
.year_string
:"<blank>",
1316 mp3
.track_string
?mp3
.track_string
:"<blank>",
1318 secs2str(mp3
.length
),