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 const struct tag_resolver taglist
[] = {
490 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
491 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
492 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
493 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
494 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
495 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
496 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
497 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
498 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
499 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
500 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
501 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
502 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
503 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
504 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
505 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
506 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
507 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
508 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
509 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
510 #if CONFIG_CODEC == SWCODEC
511 { "TXXX", 4, 0, &parseuser
, false },
512 { "RVA2", 4, 0, &parserva2
, true },
516 #define TAGLIST_SIZE ((int)(sizeof(taglist) / sizeof(taglist[0])))
518 /* Get the length of an ID3 string in the given encoding. Returns the length
519 * in bytes, including end nil, or -1 if the encoding is unknown.
521 static int unicode_len(char encoding
, const void* string
)
525 if (encoding
== 0x01 || encoding
== 0x02) {
527 const char *s
= string
;
528 /* string might be unaligned, so using short* can crash on ARM and SH1 */
531 } while ((first
| *s
++) != 0);
533 len
= s
- (const char*) string
;
535 len
= strlen((char*) string
) + 1;
541 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
542 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
543 we convert from the default codepage */
544 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
548 unsigned char *str
= (unsigned char *)string
;
550 unsigned char* utf8
= (unsigned char *)utf8buf
;
553 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
556 utf8
= iso_decode(str
, utf8
, -1, *len
);
558 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
561 case 0x01: /* Unicode with or without BOM */
566 /* Handle frames with more than one string
567 (needed for TXXX frames).*/
569 tmp
= bytes2int(0, 0, str
[0], str
[1]);
571 /* Now check if there is a BOM
572 (zero-width non-breaking space, 0xfeff)
573 and if it is in little or big endian format */
574 if(tmp
== 0xfffe) { /* Little endian? */
578 } else if(tmp
== 0xfeff) { /* Big endian? */
582 /* If there is no BOM (which is a specification violation),
583 let's try to guess it. If one of the bytes is 0x00, it is
584 probably the most significant one. */
590 utf8
= utf16LEdecode(str
, utf8
, 1);
592 utf8
= utf16BEdecode(str
, utf8
, 1);
596 } while((str
[0] || str
[1]) && (i
< *len
));
598 *utf8
++ = 0; /* Terminate the string */
599 templen
+= (strlen(&utf8buf
[templen
]) + 1);
606 case 0x03: /* UTF-8 encoded string */
607 for(i
=0; i
< *len
; i
++)
612 default: /* Plain old string */
613 utf8
= iso_decode(str
, utf8
, -1, *len
);
615 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
622 * Sets the title of an MP3 entry based on its ID3v1 tag.
624 * Arguments: file - the MP3 file to scen for a ID3v1 tag
625 * entry - the entry to set the title in
627 * Returns: true if a title was found and created, else false
629 static bool setid3v1title(int fd
, struct mp3entry
*entry
)
631 unsigned char buffer
[128];
632 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
636 if (-1 == lseek(fd
, -128, SEEK_END
))
639 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
642 if (strncmp((char *)buffer
, "TAG", 3))
645 entry
->id3v1len
= 128;
646 entry
->id3version
= ID3_VER_1_0
;
648 for (i
=0; i
< (int)sizeof offsets
; i
++) {
649 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
655 /* kill trailing space in strings */
656 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
658 /* convert string to utf8 */
659 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
660 utf8
= iso_decode(ptr
, utf8
, -1, 30);
661 /* make sure string is terminated */
666 /* kill trailing space in strings */
667 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
669 /* convert string to utf8 */
670 utf8
= (unsigned char *)entry
->id3v1buf
[3];
671 utf8
= iso_decode(ptr
, utf8
, -1, 28);
672 /* make sure string is terminated */
678 entry
->year
= atoi((char *)ptr
);
682 /* id3v1.1 uses last two bytes of comment field for track
683 number: first must be 0 and second is track num */
684 if (!ptr
[0] && ptr
[1]) {
685 entry
->tracknum
= ptr
[1];
686 entry
->id3version
= ID3_VER_1_1
;
692 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
697 entry
->title
= entry
->id3v1buf
[0];
698 entry
->artist
= entry
->id3v1buf
[1];
699 entry
->album
= entry
->id3v1buf
[2];
700 entry
->comment
= entry
->id3v1buf
[3];
707 * Sets the title of an MP3 entry based on its ID3v2 tag.
709 * Arguments: file - the MP3 file to scan for a ID3v2 tag
710 * entry - the entry to set the title in
712 * Returns: true if a title was found and created, else false
714 static void setid3v2title(int fd
, struct mp3entry
*entry
)
718 long bufferpos
= 0, totframelen
, framelen
;
721 unsigned char version
;
722 char *buffer
= entry
->id3v2buf
;
724 int buffersize
= sizeof(entry
->id3v2buf
);
725 unsigned char global_flags
;
728 bool global_unsynch
= false;
729 bool unsynch
= false;
733 global_ff_found
= false;
735 /* Bail out if the tag is shorter than 10 bytes */
736 if(entry
->id3v2len
< 10)
739 /* Read the ID3 tag version from the header */
740 lseek(fd
, 0, SEEK_SET
);
741 if(10 != read(fd
, header
, 10))
744 /* Get the total ID3 tag size */
745 size
= entry
->id3v2len
- 10;
750 version
= ID3_VER_2_2
;
755 version
= ID3_VER_2_3
;
760 version
= ID3_VER_2_4
;
765 /* unsupported id3 version */
768 entry
->id3version
= version
;
769 entry
->tracknum
= entry
->year
= entry
->discnum
= 0;
770 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
772 global_flags
= header
[5];
774 /* Skip the extended header if it is present */
775 if(global_flags
& 0x40) {
776 if(version
== ID3_VER_2_3
) {
777 if(10 != read(fd
, header
, 10))
779 /* The 2.3 extended header size doesn't include the header size
780 field itself. Also, it is not unsynched. */
782 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
784 /* Skip the rest of the header */
785 lseek(fd
, framelen
- 10, SEEK_CUR
);
788 if(version
>= ID3_VER_2_4
) {
789 if(4 != read(fd
, header
, 4))
792 /* The 2.4 extended header size does include the entire header,
793 so here we can just skip it. This header is unsynched. */
794 framelen
= unsync(header
[0], header
[1],
795 header
[2], header
[3]);
797 lseek(fd
, framelen
- 4, SEEK_CUR
);
801 /* Is unsynchronization applied? */
802 if(global_flags
& 0x80) {
803 global_unsynch
= true;
807 * We must have at least minframesize bytes left for the
808 * remaining frames to be interesting
810 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
813 /* Read frame header and check length */
814 if(version
>= ID3_VER_2_3
) {
815 if(global_unsynch
&& version
<= ID3_VER_2_3
)
816 rc
= read_unsynched(fd
, header
, 10);
818 rc
= read(fd
, header
, 10);
821 /* Adjust for the 10 bytes we read */
824 flags
= bytes2int(0, 0, header
[8], header
[9]);
826 if (version
>= ID3_VER_2_4
) {
827 framelen
= unsync(header
[4], header
[5],
828 header
[6], header
[7]);
830 /* version .3 files don't use synchsafe ints for
832 framelen
= bytes2int(header
[4], header
[5],
833 header
[6], header
[7]);
836 if(6 != read(fd
, header
, 6))
838 /* Adjust for the 6 bytes we read */
841 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
844 logf("framelen = %ld", framelen
);
846 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
858 if (version
>= ID3_VER_2_4
) {
859 if(flags
& 0x0040) { /* Grouping identity */
860 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
864 if(flags
& 0x0020) { /* Grouping identity */
865 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
870 if(flags
& 0x000c) /* Compression or encryption */
874 lseek(fd
, framelen
, SEEK_CUR
);
878 if(flags
& 0x0002) /* Unsynchronization */
881 if (version
>= ID3_VER_2_4
) {
882 if(flags
& 0x0001) { /* Data length indicator */
883 if(4 != read(fd
, tmp
, 4))
886 /* We don't need the data length */
892 /* Keep track of the remaining frame size */
893 totframelen
= framelen
;
895 /* If the frame is larger than the remaining buffer space we try
896 to read as much as would fit in the buffer */
897 if(framelen
>= buffersize
- bufferpos
)
898 framelen
= buffersize
- bufferpos
- 1;
900 logf("id3v2 frame: %.4s", header
);
902 /* Check for certain frame headers
904 'size' is the amount of frame bytes remaining. We decrement it by
905 the amount of bytes we read. If we fail to read as many bytes as
906 we expect, we assume that we can't read from this file, and bail
909 For each frame. we will iterate over the list of supported tags,
910 and read the tag into entry's buffer. All tags will be kept as
911 strings, for cases where a number won't do, e.g., YEAR: "circa
912 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
913 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
914 flexible, and as the main use of id3 data is to display it,
915 converting it to an int just means reconverting to display it, at a
918 For tags that the current code does convert to ints, a post
919 processing function will be called via a pointer to function. */
921 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
922 const struct tag_resolver
* tr
= &taglist
[i
];
923 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
927 /* Only ID3_VER_2_2 uses frames with three-character names. */
928 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
929 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
933 /* Note that parser functions sometimes set *ptag to NULL, so
934 * the "!*ptag" check here doesn't always have the desired
935 * effect. Should the parser functions (parsegenre in
936 * particular) be updated to handle the case of being called
937 * multiple times, or should the "*ptag" check be removed?
939 if( (!ptag
|| !*ptag
) && !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
941 /* found a tag matching one in tagList, and not yet filled */
942 tag
= buffer
+ bufferpos
;
944 if(global_unsynch
&& version
<= ID3_VER_2_3
)
945 bytesread
= read_unsynched(fd
, tag
, framelen
);
947 bytesread
= read(fd
, tag
, framelen
);
949 if( bytesread
!= framelen
)
954 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
955 bytesread
= unsynchronize_frame(tag
, bytesread
);
957 /* the COMM frame has a 3 char field to hold an ISO-639-1
958 * language string and an optional short description;
959 * remove them so unicode_munge can work correctly
962 if(!memcmp( header
, "COMM", 4 )) {
964 /* ignore comments with iTunes 7 soundcheck/gapless data */
965 if(!strncmp(tag
+4, "iTun", 4))
967 offset
= 3 + unicode_len(*tag
, tag
+ 4);
968 if(bytesread
> offset
) {
970 memmove(tag
+ 1, tag
+ 1 + offset
, bytesread
- 1);
974 /* Attempt to parse Unicode string only if the tag contents
977 /* UTF-8 could potentially be 3 times larger */
978 /* so we need to create a new buffer */
979 char utf8buf
[(3 * bytesread
) + 1];
981 unicode_munge( tag
, utf8buf
, &bytesread
);
983 if(bytesread
>= buffersize
- bufferpos
)
984 bytesread
= buffersize
- bufferpos
- 1;
986 for (j
= 0; j
< bytesread
; j
++)
989 /* remove trailing spaces */
990 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
995 bufferpos
+= bytesread
+ 1;
1001 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
1003 /* Seek to the next frame */
1004 if(framelen
< totframelen
)
1005 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
1010 if( i
== TAGLIST_SIZE
) {
1011 /* no tag in tagList was found, or it was a repeat.
1012 skip it using the total size */
1014 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
1015 size
-= skip_unsynched(fd
, totframelen
);
1017 size
-= totframelen
;
1018 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
1026 * Calculates the size of the ID3v2 tag.
1028 * Arguments: file - the file to search for a tag.
1030 * Returns: the size of the tag or 0 if none was found
1032 int getid3v2len(int fd
)
1037 /* Make sure file has a ID3 tag */
1038 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
1039 (read(fd
, buf
, 6) != 6) ||
1040 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
1043 /* Now check what the ID3v2 size field says */
1045 if(read(fd
, buf
, 4) != 4)
1048 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
1050 logf("ID3V2 Length: 0x%x", offset
);
1055 * Calculates the length (in milliseconds) of an MP3 file.
1057 * Modified to only use integers.
1059 * Arguments: file - the file to calculate the length upon
1060 * entry - the entry to update with the length
1062 * Returns: the song length in milliseconds,
1063 * 0 means that it couldn't be calculated
1065 static int getsonglength(int fd
, struct mp3entry
*entry
)
1067 unsigned long filetime
= 0;
1068 struct mp3info info
;
1071 /* Start searching after ID3v2 header */
1072 if(-1 == lseek(fd
, entry
->id3v2len
, SEEK_SET
))
1075 bytecount
= get_mp3file_info(fd
, &info
);
1077 logf("Space between ID3V2 tag and first audio frame: 0x%lx bytes",
1083 bytecount
+= entry
->id3v2len
;
1085 /* Validate byte count, in case the file has been edited without
1086 * updating the header.
1088 if (info
.byte_count
)
1090 const unsigned long expected
= entry
->filesize
- entry
->id3v1len
1092 const unsigned long diff
= MAX(10240, info
.byte_count
/ 20);
1094 if ((info
.byte_count
> expected
+ diff
)
1095 || (info
.byte_count
< expected
- diff
))
1097 logf("Note: info.byte_count differs from expected value by "
1098 "%ld bytes", labs((long) (expected
- info
.byte_count
)));
1099 info
.byte_count
= 0;
1100 info
.frame_count
= 0;
1102 info
.enc_padding
= 0;
1104 /* Even if the bitrate was based on "known bad" values, it
1105 * should still be better for VBR files than using the bitrate
1106 * of the first audio frame.
1111 entry
->bitrate
= info
.bitrate
;
1112 entry
->frequency
= info
.frequency
;
1113 entry
->version
= info
.version
;
1114 entry
->layer
= info
.layer
;
1115 switch(entry
->layer
) {
1116 #if CONFIG_CODEC==SWCODEC
1118 entry
->codectype
=AFMT_MPA_L1
;
1122 entry
->codectype
=AFMT_MPA_L2
;
1125 entry
->codectype
=AFMT_MPA_L3
;
1129 /* If the file time hasn't been established, this may be a fixed
1130 rate MP3, so just use the default formula */
1132 filetime
= info
.file_time
;
1136 /* Prevent a division by zero */
1137 if (info
.bitrate
< 8)
1140 filetime
= (entry
->filesize
- bytecount
) / (info
.bitrate
/ 8);
1141 /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
1142 * instead of filesize * 8 is exact, because mpeg audio bitrates are
1143 * always multiples of 8, and it avoids overflows. */
1146 entry
->frame_count
= info
.frame_count
;
1148 entry
->vbr
= info
.is_vbr
;
1149 entry
->has_toc
= info
.has_toc
;
1151 #if CONFIG_CODEC==SWCODEC
1152 entry
->lead_trim
= info
.enc_delay
;
1153 entry
->tail_trim
= info
.enc_padding
;
1156 memcpy(entry
->toc
, info
.toc
, sizeof(info
.toc
));
1158 entry
->vbr_header_pos
= info
.vbr_header_pos
;
1160 /* Update the seek point for the first playable frame */
1161 entry
->first_frame_offset
= bytecount
;
1162 logf("First frame is at %lx", entry
->first_frame_offset
);
1168 * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
1169 * about an MP3 file and updates it's entry accordingly.
1171 Note, that this returns true for successful, false for error! */
1172 bool get_mp3_metadata(int fd
, struct mp3entry
*entry
, const char *filename
)
1174 #if CONFIG_CODEC != SWCODEC
1175 memset(entry
, 0, sizeof(struct mp3entry
));
1178 strncpy(entry
->path
, filename
, sizeof(entry
->path
));
1180 entry
->title
= NULL
;
1181 entry
->filesize
= filesize(fd
);
1182 entry
->id3v2len
= getid3v2len(fd
);
1183 entry
->tracknum
= 0;
1186 if (entry
->id3v2len
)
1187 setid3v2title(fd
, entry
);
1188 int len
= getsonglength(fd
, entry
);
1191 entry
->length
= len
;
1193 /* Subtract the meta information from the file size to get
1194 the true size of the MP3 stream */
1195 entry
->filesize
-= entry
->first_frame_offset
;
1197 /* only seek to end of file if no id3v2 tags were found */
1198 if (!entry
->id3v2len
) {
1199 setid3v1title(fd
, entry
);
1202 if(!entry
->length
|| (entry
->filesize
< 8 ))
1203 /* no song length or less than 8 bytes is hereby considered to be an
1204 invalid mp3 and won't be played by us! */
1210 /* Note, that this returns false for successful, true for error! */
1211 bool mp3info(struct mp3entry
*entry
, const char *filename
)
1216 fd
= open(filename
, O_RDONLY
);
1220 result
= !get_mp3_metadata(fd
, entry
, filename
);
1227 void adjust_mp3entry(struct mp3entry
*entry
, void *dest
, const void *orig
)
1231 offset
= - ((size_t)orig
- (size_t)dest
);
1233 offset
= (size_t)dest
- (size_t)orig
;
1236 entry
->title
+= offset
;
1238 entry
->artist
+= offset
;
1240 entry
->album
+= offset
;
1241 if (entry
->genre_string
&& !id3_is_genre_string(entry
->genre_string
))
1242 /* Don't adjust that if it points to an entry of the "genres" array */
1243 entry
->genre_string
+= offset
;
1244 if (entry
->track_string
)
1245 entry
->track_string
+= offset
;
1246 if (entry
->disc_string
)
1247 entry
->disc_string
+= offset
;
1248 if (entry
->year_string
)
1249 entry
->year_string
+= offset
;
1250 if (entry
->composer
)
1251 entry
->composer
+= offset
;
1253 entry
->comment
+= offset
;
1254 if (entry
->albumartist
)
1255 entry
->albumartist
+= offset
;
1256 if (entry
->grouping
)
1257 entry
->grouping
+= offset
;
1258 #if CONFIG_CODEC == SWCODEC
1259 if (entry
->track_gain_string
)
1260 entry
->track_gain_string
+= offset
;
1261 if (entry
->album_gain_string
)
1262 entry
->album_gain_string
+= offset
;
1266 void copy_mp3entry(struct mp3entry
*dest
, const struct mp3entry
*orig
)
1268 memcpy(dest
, orig
, sizeof(struct mp3entry
));
1269 adjust_mp3entry(dest
, dest
, orig
);
1272 #ifdef DEBUG_STANDALONE
1274 char *secs2str(int ms
)
1276 static char buffer
[32];
1279 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1283 int main(int argc
, char **argv
)
1286 for(i
=1; i
<argc
; i
++) {
1287 struct mp3entry mp3
;
1288 mp3
.album
= "Bogus";
1289 if(mp3info(&mp3
, argv
[i
], false)) {
1290 printf("Failed to get %s\n", argv
[i
]);
1294 printf("****** File: %s\n"
1298 " Genre: %s (%d) \n"
1302 " Length: %s / %d s\n"
1306 mp3
.title
?mp3
.title
:"<blank>",
1307 mp3
.artist
?mp3
.artist
:"<blank>",
1308 mp3
.album
?mp3
.album
:"<blank>",
1309 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1311 mp3
.composer
?mp3
.composer
:"<blank>",
1312 mp3
.year_string
?mp3
.year_string
:"<blank>",
1314 mp3
.track_string
?mp3
.track_string
:"<blank>",
1316 secs2str(mp3
.length
),