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\0" ),
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 static 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(unsigned int genre_num
)
190 if (genre_num
< sizeof(genres
)/sizeof(char*))
191 return (char*)genres
[genre_num
];
195 /* True if the string is from the "genres" array */
196 static bool id3_is_genre_string(const char *string
)
198 return ( string
>= genres
[0] &&
199 string
<= genres
[sizeof(genres
)/sizeof(char*) - 1] );
203 HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
204 Code and comments by Thomas Paul Diffenbach
206 To add another ID3v2 Tag, do the following:
207 1. add a char* named for the tag to struct mp3entry in id3.h,
208 (I (tpd) prefer to use char* rather than ints, even for what seems like
209 numerical values, for cases where a number won't do, e.g.,
210 YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
211 TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
212 Text is more flexible, and as the main use of id3 data is to
213 display it, converting it to an int just means reconverting to
214 display it, at a runtime cost.)
216 2. If any special processing beyond copying the tag value from the Id3
217 block to the struct mp3entry is rrequired (such as converting to an
218 int), write a function to perform this special processing.
220 This function's prototype must match that of
221 typedef tagPostProcessFunc, that is it must be:
222 int func( struct mp3entry*, char* tag, int bufferpos )
223 the first argument is a pointer to the current mp3entry structure the
224 second argument is a pointer to the null terminated string value of the
225 tag found the third argument is the offset of the next free byte in the
226 mp3entry's buffer your function should return the corrected offset; if
227 you don't lengthen or shorten the tag string, you can return the third
230 Unless you have a good reason no to, make the function static.
231 TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
233 3. add one or more entries to the tagList array, using the format:
234 char* ID3 Tag symbolic name -- see the ID3 specification for these,
235 sizeof() that name minus 1,
236 offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
237 pointer to your special processing function or NULL
238 if you need no special processing
239 flag indicating if this tag is binary or textual
240 Many ID3 symbolic names come in more than one form. You can add both
241 forms, each referencing the same variable in struct mp3entry.
242 If both forms are present, the last found will be used.
243 Note that the offset can be zero, in which case no entry will be set
244 in the mp3entry struct; the frame is still read into the buffer and
245 the special processing function is called (several times, if there
246 are several frames with the same name).
248 4. Alternately, use the TAG_LIST_ENTRY macro with
249 ID3 tag symbolic name,
250 variable in struct mp3entry,
251 special processing function address
253 5. Add code to wps-display.c function get_tag to assign a printf-like
254 format specifier for the tag */
256 /* Structure for ID3 Tag extraction information */
257 struct tag_resolver
{
261 int (*ppFunc
)(struct mp3entry
*, char* tag
, int bufferpos
);
265 static bool global_ff_found
;
267 static int unsynchronize(char* tag
, int len
, bool *ff_found
)
271 unsigned char *rp
, *wp
;
273 wp
= rp
= (unsigned char *)tag
;
275 rp
= (unsigned char *)tag
;
276 for(i
= 0;i
< len
;i
++) {
277 /* Read the next byte and write it back, but don't increment the
282 /* Increment the write pointer if it isn't an unsynch pattern */
292 return (long)wp
- (long)tag
;
295 static int unsynchronize_frame(char* tag
, int len
)
297 bool ff_found
= false;
299 return unsynchronize(tag
, len
, &ff_found
);
302 static int read_unsynched(int fd
, void *buf
, int len
)
314 rc
= read(fd
, rp
, remaining
);
318 i
= unsynchronize(wp
, remaining
, &global_ff_found
);
326 static int skip_unsynched(int fd
, int len
)
334 rlen
= MIN(sizeof(buf
), (unsigned int)remaining
);
335 rc
= read(fd
, buf
, rlen
);
339 remaining
-= unsynchronize(buf
, rlen
, &global_ff_found
);
345 /* parse numeric value from string */
346 static int parsetracknum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
348 entry
->tracknum
= atoi( tag
);
352 /* parse numeric value from string */
353 static int parsediscnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
355 entry
->discnum
= atoi( tag
);
359 /* parse numeric value from string */
360 static int parseyearnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
362 entry
->year
= atoi( tag
);
366 /* parse numeric genre from string, version 2.2 and 2.3 */
367 static int parsegenre( struct mp3entry
* entry
, char* tag
, int bufferpos
)
369 if(entry
->id3version
>= ID3_VER_2_4
) {
370 /* In version 2.4 and up, there are no parentheses, and the genre frame
371 is a list of strings, either numbers or text. */
373 /* Is it a number? */
374 if(isdigit(tag
[0])) {
375 entry
->genre_string
= id3_get_num_genre(atoi( tag
));
376 return tag
- entry
->id3v2buf
;
378 entry
->genre_string
= tag
;
382 if( tag
[0] == '(' && tag
[1] != '(' ) {
383 entry
->genre_string
= id3_get_num_genre(atoi( tag
+ 1 ));
384 return tag
- entry
->id3v2buf
;
387 entry
->genre_string
= tag
;
393 #if CONFIG_CODEC == SWCODEC
394 /* parse user defined text, looking for replaygain information. */
395 static int parseuser( struct mp3entry
* entry
, char* tag
, int bufferpos
)
398 int desc_len
= strlen(tag
);
401 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
402 /* At least part of the value was read, so we can safely try to
405 value
= tag
+ desc_len
+ 1;
406 value_len
= parse_replaygain(tag
, value
, entry
, tag
,
407 bufferpos
- (tag
- entry
->id3v2buf
));
410 return tag
- entry
->id3v2buf
+ value_len
;
413 /* parse RVA2 binary data and convert to replaygain information. */
414 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
416 int desc_len
= strlen(tag
);
417 int start_pos
= tag
- entry
->id3v2buf
;
418 int end_pos
= start_pos
+ desc_len
+ 5;
420 unsigned char* value
= tag
+ desc_len
+ 1;
422 /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
423 * type is master volume.
425 if (entry
->id3version
== ID3_VER_2_4
&& end_pos
< bufferpos
433 /* The RVA2 specification is unclear on some things (id string and
434 * peak volume), but this matches how Quod Libet use them.
437 gain
= (int16_t) ((value
[0] << 8) | value
[1]);
440 peakbytes
= (peakbits
+ 7) / 8;
442 /* Only use the topmost 24 bits for peak volume */
447 /* Make sure the peak bits were read */
448 if (end_pos
+ peakbytes
< bufferpos
) {
449 long shift
= ((8 - (peakbits
& 7)) & 7) + (3 - peakbytes
) * 8;
451 for ( ; peakbytes
; peakbytes
--) {
459 peak
+= *value
>> (8 - shift
);
463 if (strcasecmp(tag
, "album") == 0) {
465 } else if (strcasecmp(tag
, "track") != 0) {
466 /* Only accept non-track values if we don't have any previous
469 if (entry
->track_gain
!= 0) {
474 value_len
= parse_replaygain_int(album
, gain
, peak
* 2, entry
,
475 tag
, sizeof(entry
->id3v2buf
) - start_pos
);
478 return start_pos
+ value_len
;
482 static const struct tag_resolver taglist
[] = {
483 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
484 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
485 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
486 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
487 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
488 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
489 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
490 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
491 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
492 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
493 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
494 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
495 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
496 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
497 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
498 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
499 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
500 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
501 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
502 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
503 #if CONFIG_CODEC == SWCODEC
504 { "TXXX", 4, 0, &parseuser
, false },
505 { "RVA2", 4, 0, &parserva2
, true },
509 #define TAGLIST_SIZE ((int)(sizeof(taglist) / sizeof(taglist[0])))
511 /* Get the length of an ID3 string in the given encoding. Returns the length
512 * in bytes, including end nil, or -1 if the encoding is unknown.
514 static int unicode_len(char encoding
, const void* string
)
518 if (encoding
== 0x01 || encoding
== 0x02) {
520 const char *s
= string
;
521 /* string might be unaligned, so using short* can crash on ARM and SH1 */
524 } while ((first
| *s
++) != 0);
526 len
= s
- (const char*) string
;
528 len
= strlen((char*) string
) + 1;
534 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
535 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
536 we convert from the default codepage */
537 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
541 unsigned char *str
= (unsigned char *)string
;
543 unsigned char* utf8
= (unsigned char *)utf8buf
;
546 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
549 utf8
= iso_decode(str
, utf8
, -1, *len
);
551 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
554 case 0x01: /* Unicode with or without BOM */
559 /* Handle frames with more than one string
560 (needed for TXXX frames).*/
562 tmp
= bytes2int(0, 0, str
[0], str
[1]);
564 /* Now check if there is a BOM
565 (zero-width non-breaking space, 0xfeff)
566 and if it is in little or big endian format */
567 if(tmp
== 0xfffe) { /* Little endian? */
571 } else if(tmp
== 0xfeff) { /* Big endian? */
575 /* If there is no BOM (which is a specification violation),
576 let's try to guess it. If one of the bytes is 0x00, it is
577 probably the most significant one. */
583 utf8
= utf16LEdecode(str
, utf8
, 1);
585 utf8
= utf16BEdecode(str
, utf8
, 1);
589 } while((str
[0] || str
[1]) && (i
< *len
));
591 *utf8
++ = 0; /* Terminate the string */
592 templen
+= (strlen(&utf8buf
[templen
]) + 1);
599 case 0x03: /* UTF-8 encoded string */
600 for(i
=0; i
< *len
; i
++)
605 default: /* Plain old string */
606 utf8
= iso_decode(str
, utf8
, -1, *len
);
608 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
615 * Sets the title of an MP3 entry based on its ID3v1 tag.
617 * Arguments: file - the MP3 file to scen for a ID3v1 tag
618 * entry - the entry to set the title in
620 * Returns: true if a title was found and created, else false
622 static bool setid3v1title(int fd
, struct mp3entry
*entry
)
624 unsigned char buffer
[128];
625 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
629 if (-1 == lseek(fd
, -128, SEEK_END
))
632 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
635 if (strncmp((char *)buffer
, "TAG", 3))
638 entry
->id3v1len
= 128;
639 entry
->id3version
= ID3_VER_1_0
;
641 for (i
=0; i
< (int)sizeof offsets
; i
++) {
642 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
648 /* kill trailing space in strings */
649 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
651 /* convert string to utf8 */
652 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
653 utf8
= iso_decode(ptr
, utf8
, -1, 30);
654 /* make sure string is terminated */
659 /* kill trailing space in strings */
660 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
662 /* convert string to utf8 */
663 utf8
= (unsigned char *)entry
->id3v1buf
[3];
664 utf8
= iso_decode(ptr
, utf8
, -1, 28);
665 /* make sure string is terminated */
671 entry
->year
= atoi((char *)ptr
);
675 /* id3v1.1 uses last two bytes of comment field for track
676 number: first must be 0 and second is track num */
677 if (!ptr
[0] && ptr
[1]) {
678 entry
->tracknum
= ptr
[1];
679 entry
->id3version
= ID3_VER_1_1
;
685 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
690 entry
->title
= entry
->id3v1buf
[0];
691 entry
->artist
= entry
->id3v1buf
[1];
692 entry
->album
= entry
->id3v1buf
[2];
693 entry
->comment
= entry
->id3v1buf
[3];
700 * Sets the title of an MP3 entry based on its ID3v2 tag.
702 * Arguments: file - the MP3 file to scan for a ID3v2 tag
703 * entry - the entry to set the title in
705 * Returns: true if a title was found and created, else false
707 static void setid3v2title(int fd
, struct mp3entry
*entry
)
711 long bufferpos
= 0, totframelen
, framelen
;
714 unsigned char version
;
715 char *buffer
= entry
->id3v2buf
;
717 int buffersize
= sizeof(entry
->id3v2buf
);
718 unsigned char global_flags
;
721 bool global_unsynch
= false;
722 bool unsynch
= false;
727 global_ff_found
= false;
729 /* Bail out if the tag is shorter than 10 bytes */
730 if(entry
->id3v2len
< 10)
733 /* Read the ID3 tag version from the header */
734 lseek(fd
, 0, SEEK_SET
);
735 if(10 != read(fd
, header
, 10))
738 /* Get the total ID3 tag size */
739 size
= entry
->id3v2len
- 10;
744 version
= ID3_VER_2_2
;
749 version
= ID3_VER_2_3
;
754 version
= ID3_VER_2_4
;
759 /* unsupported id3 version */
762 entry
->id3version
= version
;
763 entry
->tracknum
= entry
->year
= entry
->discnum
= 0;
764 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
766 global_flags
= header
[5];
768 /* Skip the extended header if it is present */
769 if(global_flags
& 0x40) {
770 if(version
== ID3_VER_2_3
) {
771 if(10 != read(fd
, header
, 10))
773 /* The 2.3 extended header size doesn't include the header size
774 field itself. Also, it is not unsynched. */
776 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
778 /* Skip the rest of the header */
779 lseek(fd
, framelen
- 10, SEEK_CUR
);
782 if(version
>= ID3_VER_2_4
) {
783 if(4 != read(fd
, header
, 4))
786 /* The 2.4 extended header size does include the entire header,
787 so here we can just skip it. This header is unsynched. */
788 framelen
= unsync(header
[0], header
[1],
789 header
[2], header
[3]);
791 lseek(fd
, framelen
- 4, SEEK_CUR
);
795 /* Is unsynchronization applied? */
796 if(global_flags
& 0x80) {
797 global_unsynch
= true;
801 * We must have at least minframesize bytes left for the
802 * remaining frames to be interesting
804 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
807 /* Read frame header and check length */
808 if(version
>= ID3_VER_2_3
) {
809 if(global_unsynch
&& version
<= ID3_VER_2_3
)
810 rc
= read_unsynched(fd
, header
, 10);
812 rc
= read(fd
, header
, 10);
815 /* Adjust for the 10 bytes we read */
818 flags
= bytes2int(0, 0, header
[8], header
[9]);
820 if (version
>= ID3_VER_2_4
) {
821 framelen
= unsync(header
[4], header
[5],
822 header
[6], header
[7]);
824 /* version .3 files don't use synchsafe ints for
826 framelen
= bytes2int(header
[4], header
[5],
827 header
[6], header
[7]);
830 if(6 != read(fd
, header
, 6))
832 /* Adjust for the 6 bytes we read */
835 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
838 logf("framelen = %ld", framelen
);
840 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
853 if (version
>= ID3_VER_2_4
) {
854 if(flags
& 0x0040) { /* Grouping identity */
855 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
859 if(flags
& 0x0020) { /* Grouping identity */
860 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
865 if(flags
& 0x000c) /* Compression or encryption */
869 lseek(fd
, framelen
, SEEK_CUR
);
873 if(flags
& 0x0002) /* Unsynchronization */
876 if (version
>= ID3_VER_2_4
) {
877 if(flags
& 0x0001) { /* Data length indicator */
878 if(4 != read(fd
, tmp
, 4))
881 data_length_ind
= unsync(tmp
[0], tmp
[1], tmp
[2], tmp
[3]);
887 /* Keep track of the remaining frame size */
888 totframelen
= framelen
;
890 /* If the frame is larger than the remaining buffer space we try
891 to read as much as would fit in the buffer */
892 if(framelen
>= buffersize
- bufferpos
)
893 framelen
= buffersize
- bufferpos
- 1;
895 logf("id3v2 frame: %.4s", header
);
897 /* Check for certain frame headers
899 'size' is the amount of frame bytes remaining. We decrement it by
900 the amount of bytes we read. If we fail to read as many bytes as
901 we expect, we assume that we can't read from this file, and bail
904 For each frame. we will iterate over the list of supported tags,
905 and read the tag into entry's buffer. All tags will be kept as
906 strings, for cases where a number won't do, e.g., YEAR: "circa
907 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
908 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
909 flexible, and as the main use of id3 data is to display it,
910 converting it to an int just means reconverting to display it, at a
913 For tags that the current code does convert to ints, a post
914 processing function will be called via a pointer to function. */
916 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
917 const struct tag_resolver
* tr
= &taglist
[i
];
918 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
922 /* Only ID3_VER_2_2 uses frames with three-character names. */
923 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
924 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
928 /* Note that parser functions sometimes set *ptag to NULL, so
929 * the "!*ptag" check here doesn't always have the desired
930 * effect. Should the parser functions (parsegenre in
931 * particular) be updated to handle the case of being called
932 * multiple times, or should the "*ptag" check be removed?
934 if( (!ptag
|| !*ptag
) && !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
936 /* found a tag matching one in tagList, and not yet filled */
937 tag
= buffer
+ bufferpos
;
939 if(global_unsynch
&& version
<= ID3_VER_2_3
)
940 bytesread
= read_unsynched(fd
, tag
, framelen
);
942 bytesread
= read(fd
, tag
, framelen
);
944 if( bytesread
!= framelen
)
949 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
950 bytesread
= unsynchronize_frame(tag
, bytesread
);
952 /* the COMM frame has a 3 char field to hold an ISO-639-1
953 * language string and an optional short description;
954 * remove them so unicode_munge can work correctly
957 if(!memcmp( header
, "COMM", 4 )) {
959 /* ignore comments with iTunes 7 soundcheck/gapless data */
960 if(!strncmp(tag
+4, "iTun", 4))
962 offset
= 3 + unicode_len(*tag
, tag
+ 4);
963 if(bytesread
> offset
) {
965 memmove(tag
+ 1, tag
+ 1 + offset
, bytesread
- 1);
969 /* Attempt to parse Unicode string only if the tag contents
972 /* UTF-8 could potentially be 3 times larger */
973 /* so we need to create a new buffer */
974 char utf8buf
[(3 * bytesread
) + 1];
976 unicode_munge( tag
, utf8buf
, &bytesread
);
978 if(bytesread
>= buffersize
- bufferpos
)
979 bytesread
= buffersize
- bufferpos
- 1;
981 for (j
= 0; j
< bytesread
; j
++)
984 /* remove trailing spaces */
985 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
990 bufferpos
+= bytesread
+ 1;
996 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
998 /* Seek to the next frame */
999 if(framelen
< totframelen
)
1000 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
1005 if( i
== TAGLIST_SIZE
) {
1006 /* no tag in tagList was found, or it was a repeat.
1007 skip it using the total size */
1009 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
1010 size
-= skip_unsynched(fd
, totframelen
);
1013 totframelen
= data_length_ind
;
1015 size
-= totframelen
;
1016 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
1024 * Calculates the size of the ID3v2 tag.
1026 * Arguments: file - the file to search for a tag.
1028 * Returns: the size of the tag or 0 if none was found
1030 int getid3v2len(int fd
)
1035 /* Make sure file has a ID3 tag */
1036 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
1037 (read(fd
, buf
, 6) != 6) ||
1038 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
1041 /* Now check what the ID3v2 size field says */
1043 if(read(fd
, buf
, 4) != 4)
1046 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
1048 logf("ID3V2 Length: 0x%x", offset
);
1053 * Calculates the length (in milliseconds) of an MP3 file.
1055 * Modified to only use integers.
1057 * Arguments: file - the file to calculate the length upon
1058 * entry - the entry to update with the length
1060 * Returns: the song length in milliseconds,
1061 * 0 means that it couldn't be calculated
1063 static int getsonglength(int fd
, struct mp3entry
*entry
)
1065 unsigned long filetime
= 0;
1066 struct mp3info info
;
1069 /* Start searching after ID3v2 header */
1070 if(-1 == lseek(fd
, entry
->id3v2len
, SEEK_SET
))
1073 bytecount
= get_mp3file_info(fd
, &info
);
1075 logf("Space between ID3V2 tag and first audio frame: 0x%lx bytes",
1081 bytecount
+= entry
->id3v2len
;
1083 /* Validate byte count, in case the file has been edited without
1084 * updating the header.
1086 if (info
.byte_count
)
1088 const unsigned long expected
= entry
->filesize
- entry
->id3v1len
1090 const unsigned long diff
= MAX(10240, info
.byte_count
/ 20);
1092 if ((info
.byte_count
> expected
+ diff
)
1093 || (info
.byte_count
< expected
- diff
))
1095 logf("Note: info.byte_count differs from expected value by "
1096 "%ld bytes", labs((long) (expected
- info
.byte_count
)));
1097 info
.byte_count
= 0;
1098 info
.frame_count
= 0;
1100 info
.enc_padding
= 0;
1102 /* Even if the bitrate was based on "known bad" values, it
1103 * should still be better for VBR files than using the bitrate
1104 * of the first audio frame.
1109 entry
->bitrate
= info
.bitrate
;
1110 entry
->frequency
= info
.frequency
;
1111 entry
->version
= info
.version
;
1112 entry
->layer
= info
.layer
;
1113 switch(entry
->layer
) {
1114 #if CONFIG_CODEC==SWCODEC
1116 entry
->codectype
=AFMT_MPA_L1
;
1120 entry
->codectype
=AFMT_MPA_L2
;
1123 entry
->codectype
=AFMT_MPA_L3
;
1127 /* If the file time hasn't been established, this may be a fixed
1128 rate MP3, so just use the default formula */
1130 filetime
= info
.file_time
;
1134 /* Prevent a division by zero */
1135 if (info
.bitrate
< 8)
1138 filetime
= (entry
->filesize
- bytecount
) / (info
.bitrate
/ 8);
1139 /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
1140 * instead of filesize * 8 is exact, because mpeg audio bitrates are
1141 * always multiples of 8, and it avoids overflows. */
1144 entry
->frame_count
= info
.frame_count
;
1146 entry
->vbr
= info
.is_vbr
;
1147 entry
->has_toc
= info
.has_toc
;
1149 #if CONFIG_CODEC==SWCODEC
1150 entry
->lead_trim
= info
.enc_delay
;
1151 entry
->tail_trim
= info
.enc_padding
;
1154 memcpy(entry
->toc
, info
.toc
, sizeof(info
.toc
));
1156 entry
->vbr_header_pos
= info
.vbr_header_pos
;
1158 /* Update the seek point for the first playable frame */
1159 entry
->first_frame_offset
= bytecount
;
1160 logf("First frame is at %lx", entry
->first_frame_offset
);
1166 * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
1167 * about an MP3 file and updates it's entry accordingly.
1169 Note, that this returns true for successful, false for error! */
1170 bool get_mp3_metadata(int fd
, struct mp3entry
*entry
, const char *filename
)
1172 #if CONFIG_CODEC != SWCODEC
1173 memset(entry
, 0, sizeof(struct mp3entry
));
1176 strncpy(entry
->path
, filename
, sizeof(entry
->path
));
1178 entry
->title
= NULL
;
1179 entry
->filesize
= filesize(fd
);
1180 entry
->id3v2len
= getid3v2len(fd
);
1181 entry
->tracknum
= 0;
1184 if (entry
->id3v2len
)
1185 setid3v2title(fd
, entry
);
1186 int len
= getsonglength(fd
, entry
);
1189 entry
->length
= len
;
1191 /* Subtract the meta information from the file size to get
1192 the true size of the MP3 stream */
1193 entry
->filesize
-= entry
->first_frame_offset
;
1195 /* only seek to end of file if no id3v2 tags were found */
1196 if (!entry
->id3v2len
) {
1197 setid3v1title(fd
, entry
);
1200 if(!entry
->length
|| (entry
->filesize
< 8 ))
1201 /* no song length or less than 8 bytes is hereby considered to be an
1202 invalid mp3 and won't be played by us! */
1208 /* Note, that this returns false for successful, true for error! */
1209 bool mp3info(struct mp3entry
*entry
, const char *filename
)
1214 fd
= open(filename
, O_RDONLY
);
1218 result
= !get_mp3_metadata(fd
, entry
, filename
);
1225 void adjust_mp3entry(struct mp3entry
*entry
, void *dest
, const void *orig
)
1229 offset
= - ((size_t)orig
- (size_t)dest
);
1231 offset
= (size_t)dest
- (size_t)orig
;
1234 entry
->title
+= offset
;
1236 entry
->artist
+= offset
;
1238 entry
->album
+= offset
;
1239 if (entry
->genre_string
&& !id3_is_genre_string(entry
->genre_string
))
1240 /* Don't adjust that if it points to an entry of the "genres" array */
1241 entry
->genre_string
+= offset
;
1242 if (entry
->track_string
)
1243 entry
->track_string
+= offset
;
1244 if (entry
->disc_string
)
1245 entry
->disc_string
+= offset
;
1246 if (entry
->year_string
)
1247 entry
->year_string
+= offset
;
1248 if (entry
->composer
)
1249 entry
->composer
+= offset
;
1251 entry
->comment
+= offset
;
1252 if (entry
->albumartist
)
1253 entry
->albumartist
+= offset
;
1254 if (entry
->grouping
)
1255 entry
->grouping
+= offset
;
1256 #if CONFIG_CODEC == SWCODEC
1257 if (entry
->track_gain_string
)
1258 entry
->track_gain_string
+= offset
;
1259 if (entry
->album_gain_string
)
1260 entry
->album_gain_string
+= offset
;
1264 void copy_mp3entry(struct mp3entry
*dest
, const struct mp3entry
*orig
)
1266 memcpy(dest
, orig
, sizeof(struct mp3entry
));
1267 adjust_mp3entry(dest
, dest
, orig
);
1270 #ifdef DEBUG_STANDALONE
1272 char *secs2str(int ms
)
1274 static char buffer
[32];
1277 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1281 int main(int argc
, char **argv
)
1284 for(i
=1; i
<argc
; i
++) {
1285 struct mp3entry mp3
;
1286 mp3
.album
= "Bogus";
1287 if(mp3info(&mp3
, argv
[i
], false)) {
1288 printf("Failed to get %s\n", argv
[i
]);
1292 printf("****** File: %s\n"
1296 " Genre: %s (%d) \n"
1300 " Length: %s / %d s\n"
1304 mp3
.title
?mp3
.title
:"<blank>",
1305 mp3
.artist
?mp3
.artist
:"<blank>",
1306 mp3
.album
?mp3
.album
:"<blank>",
1307 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1309 mp3
.composer
?mp3
.composer
:"<blank>",
1310 mp3
.year_string
?mp3
.year_string
:"<blank>",
1312 mp3
.track_string
?mp3
.track_string
:"<blank>",
1314 secs2str(mp3
.length
),