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 unsigned long unsync(unsigned long b0
,
151 return (((long)(b0
& 0x7F) << (3*7)) |
152 ((long)(b1
& 0x7F) << (2*7)) |
153 ((long)(b2
& 0x7F) << (1*7)) |
154 ((long)(b3
& 0x7F) << (0*7)));
157 static const char* const genres
[] = {
158 "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
159 "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
160 "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
161 "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
162 "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
163 "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
164 "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
165 "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
166 "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
167 "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
168 "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
169 "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
170 "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
172 /* winamp extensions */
173 "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
174 "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
175 "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
176 "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
177 "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
178 "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
179 "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
180 "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
181 "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
182 "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
183 "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
184 "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
188 char* id3_get_num_genre(const unsigned int genre_num
)
190 if (genre_num
< sizeof(genres
)/sizeof(char*))
191 return (char*)genres
[genre_num
];
195 char* id3_get_codec(const struct mp3entry
* id3
)
197 if (id3
->codectype
< AFMT_NUM_CODECS
) {
198 return (char*)audio_formats
[id3
->codectype
].label
;
205 HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
206 Code and comments by Thomas Paul Diffenbach
208 To add another ID3v2 Tag, do the following:
209 1. add a char* named for the tag to struct mp3entry in id3.h,
210 (I (tpd) prefer to use char* rather than ints, even for what seems like
211 numerical values, for cases where a number won't do, e.g.,
212 YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
213 TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
214 Text is more flexible, and as the main use of id3 data is to
215 display it, converting it to an int just means reconverting to
216 display it, at a runtime cost.)
218 2. If any special processing beyond copying the tag value from the Id3
219 block to the struct mp3entry is rrequired (such as converting to an
220 int), write a function to perform this special processing.
222 This function's prototype must match that of
223 typedef tagPostProcessFunc, that is it must be:
224 int func( struct mp3entry*, char* tag, int bufferpos )
225 the first argument is a pointer to the current mp3entry structure the
226 second argument is a pointer to the null terminated string value of the
227 tag found the third argument is the offset of the next free byte in the
228 mp3entry's buffer your function should return the corrected offset; if
229 you don't lengthen or shorten the tag string, you can return the third
232 Unless you have a good reason no to, make the function static.
233 TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
235 3. add one or more entries to the tagList array, using the format:
236 char* ID3 Tag symbolic name -- see the ID3 specification for these,
237 sizeof() that name minus 1,
238 offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
239 pointer to your special processing function or NULL
240 if you need no special processing
241 flag indicating if this tag is binary or textual
242 Many ID3 symbolic names come in more than one form. You can add both
243 forms, each referencing the same variable in struct mp3entry.
244 If both forms are present, the last found will be used.
245 Note that the offset can be zero, in which case no entry will be set
246 in the mp3entry struct; the frame is still read into the buffer and
247 the special processing function is called (several times, if there
248 are several frames with the same name).
250 4. Alternately, use the TAG_LIST_ENTRY macro with
251 ID3 tag symbolic name,
252 variable in struct mp3entry,
253 special processing function address
255 5. Add code to wps-display.c function get_tag to assign a printf-like
256 format specifier for the tag */
258 /* Structure for ID3 Tag extraction information */
259 struct tag_resolver
{
263 int (*ppFunc
)(struct mp3entry
*, char* tag
, int bufferpos
);
267 static bool global_ff_found
;
269 static int unsynchronize(char* tag
, int len
, bool *ff_found
)
273 unsigned char *rp
, *wp
;
275 wp
= rp
= (unsigned char *)tag
;
277 rp
= (unsigned char *)tag
;
278 for(i
= 0;i
< len
;i
++) {
279 /* Read the next byte and write it back, but don't increment the
284 /* Increment the write pointer if it isn't an unsynch pattern */
294 return (long)wp
- (long)tag
;
297 static int unsynchronize_frame(char* tag
, int len
)
299 bool ff_found
= false;
301 return unsynchronize(tag
, len
, &ff_found
);
304 static int read_unsynched(int fd
, void *buf
, int len
)
316 rc
= read(fd
, rp
, remaining
);
320 i
= unsynchronize(wp
, remaining
, &global_ff_found
);
328 static int skip_unsynched(int fd
, int len
)
336 rlen
= MIN(sizeof(buf
), (unsigned int)remaining
);
337 rc
= read(fd
, buf
, rlen
);
341 remaining
-= unsynchronize(buf
, rlen
, &global_ff_found
);
347 /* parse numeric value from string */
348 static int parsetracknum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
350 entry
->tracknum
= atoi( tag
);
354 /* parse numeric value from string */
355 static int parsediscnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
357 entry
->discnum
= atoi( tag
);
361 /* parse numeric value from string */
362 static int parseyearnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
364 entry
->year
= atoi( tag
);
368 /* parse numeric genre from string, version 2.2 and 2.3 */
369 static int parsegenre( struct mp3entry
* entry
, char* tag
, int bufferpos
)
371 if(entry
->id3version
>= ID3_VER_2_4
) {
372 /* In version 2.4 and up, there are no parentheses, and the genre frame
373 is a list of strings, either numbers or text. */
375 /* Is it a number? */
376 if(isdigit(tag
[0])) {
377 entry
->genre_string
= id3_get_num_genre(atoi( tag
));
378 return tag
- entry
->id3v2buf
;
380 entry
->genre_string
= tag
;
384 if( tag
[0] == '(' && tag
[1] != '(' ) {
385 entry
->genre_string
= id3_get_num_genre(atoi( tag
+ 1 ));
386 return tag
- entry
->id3v2buf
;
389 entry
->genre_string
= tag
;
395 #if CONFIG_CODEC == SWCODEC
396 /* parse user defined text, looking for replaygain information. */
397 static int parseuser( struct mp3entry
* entry
, char* tag
, int bufferpos
)
400 int desc_len
= strlen(tag
);
403 /* Note: for ID3v2.4, parse_replaygain will not overwrite replaygain
404 values already parsed from RVA2 tags */
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
));
415 bufferpos
= tag
- entry
->id3v2buf
+ value_len
;
417 bufferpos
= tag
- entry
->id3v2buf
;
423 /* parse RVA2 binary data and convert to replaygain information. */
424 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
427 int desc_len
= strlen(tag
);
430 /* Only parse RVA2 replaygain tags if tag version == 2.4 */
431 if (entry
->id3version
== ID3_VER_2_4
&&
432 (tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
433 value
= tag
+ desc_len
+ 1;
434 value_len
= parse_replaygain_rva(tag
, value
, entry
, tag
,
435 bufferpos
- (tag
- entry
->id3v2buf
));
439 bufferpos
= tag
- entry
->id3v2buf
+ value_len
;
441 bufferpos
= tag
- entry
->id3v2buf
;
448 static const struct tag_resolver taglist
[] = {
449 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
450 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
451 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
452 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
453 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
454 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
455 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
456 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
457 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
458 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
459 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
460 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
461 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
462 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
463 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
464 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
465 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
466 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
467 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
468 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
469 #if CONFIG_CODEC == SWCODEC
470 { "TXXX", 4, 0, &parseuser
, false },
471 { "RVA2", 4, 0, &parserva2
, true },
475 #define TAGLIST_SIZE ((int)(sizeof(taglist) / sizeof(taglist[0])))
477 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
478 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
479 we convert from the default codepage */
480 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
484 unsigned char *str
= (unsigned char *)string
;
486 unsigned char* utf8
= (unsigned char *)utf8buf
;
489 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
492 utf8
= iso_decode(str
, utf8
, -1, *len
);
494 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
497 case 0x01: /* Unicode with or without BOM */
502 /* Handle frames with more than one string
503 (needed for TXXX frames).*/
505 tmp
= bytes2int(0, 0, str
[0], str
[1]);
507 /* Now check if there is a BOM
508 (zero-width non-breaking space, 0xfeff)
509 and if it is in little or big endian format */
510 if(tmp
== 0xfffe) { /* Little endian? */
514 } else if(tmp
== 0xfeff) { /* Big endian? */
518 /* If there is no BOM (which is a specification violation),
519 let's try to guess it. If one of the bytes is 0x00, it is
520 probably the most significant one. */
526 utf8
= utf16LEdecode(str
, utf8
, 1);
528 utf8
= utf16BEdecode(str
, utf8
, 1);
532 } while((str
[0] || str
[1]) && (i
< *len
));
534 *utf8
++ = 0; /* Terminate the string */
535 templen
+= (strlen(&utf8buf
[templen
]) + 1);
542 case 0x03: /* UTF-8 encoded string */
543 for(i
=0; i
< *len
; i
++)
548 default: /* Plain old string */
549 utf8
= iso_decode(str
, utf8
, -1, *len
);
551 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
558 * Sets the title of an MP3 entry based on its ID3v1 tag.
560 * Arguments: file - the MP3 file to scen for a ID3v1 tag
561 * entry - the entry to set the title in
563 * Returns: true if a title was found and created, else false
565 static bool setid3v1title(int fd
, struct mp3entry
*entry
)
567 unsigned char buffer
[128];
568 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
572 if (-1 == lseek(fd
, -128, SEEK_END
))
575 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
578 if (strncmp((char *)buffer
, "TAG", 3))
581 entry
->id3v1len
= 128;
582 entry
->id3version
= ID3_VER_1_0
;
584 for (i
=0; i
< (int)sizeof offsets
; i
++) {
585 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
591 /* kill trailing space in strings */
592 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
594 /* convert string to utf8 */
595 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
596 utf8
= iso_decode(ptr
, utf8
, -1, 30);
597 /* make sure string is terminated */
602 /* kill trailing space in strings */
603 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
605 /* convert string to utf8 */
606 utf8
= (unsigned char *)entry
->id3v1buf
[3];
607 utf8
= iso_decode(ptr
, utf8
, -1, 28);
608 /* make sure string is terminated */
614 entry
->year
= atoi((char *)ptr
);
618 /* id3v1.1 uses last two bytes of comment field for track
619 number: first must be 0 and second is track num */
620 if (!ptr
[0] && ptr
[1]) {
621 entry
->tracknum
= ptr
[1];
622 entry
->id3version
= ID3_VER_1_1
;
628 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
633 entry
->title
= entry
->id3v1buf
[0];
634 entry
->artist
= entry
->id3v1buf
[1];
635 entry
->album
= entry
->id3v1buf
[2];
636 entry
->comment
= entry
->id3v1buf
[3];
643 * Sets the title of an MP3 entry based on its ID3v2 tag.
645 * Arguments: file - the MP3 file to scan for a ID3v2 tag
646 * entry - the entry to set the title in
648 * Returns: true if a title was found and created, else false
650 static void setid3v2title(int fd
, struct mp3entry
*entry
)
654 long bufferpos
= 0, totframelen
, framelen
;
657 unsigned char version
;
658 char *buffer
= entry
->id3v2buf
;
660 int buffersize
= sizeof(entry
->id3v2buf
);
661 unsigned char global_flags
;
664 bool global_unsynch
= false;
665 bool unsynch
= false;
670 global_ff_found
= false;
672 /* Bail out if the tag is shorter than 10 bytes */
673 if(entry
->id3v2len
< 10)
676 /* Read the ID3 tag version from the header */
677 lseek(fd
, 0, SEEK_SET
);
678 if(10 != read(fd
, header
, 10))
681 /* Get the total ID3 tag size */
682 size
= entry
->id3v2len
- 10;
687 version
= ID3_VER_2_2
;
692 version
= ID3_VER_2_3
;
697 version
= ID3_VER_2_4
;
702 /* unsupported id3 version */
705 entry
->id3version
= version
;
706 entry
->tracknum
= entry
->year
= entry
->discnum
= 0;
707 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
709 global_flags
= header
[5];
711 /* Skip the extended header if it is present */
712 if(global_flags
& 0x40) {
713 if(version
== ID3_VER_2_3
) {
714 if(10 != read(fd
, header
, 10))
716 /* The 2.3 extended header size doesn't include the header size
717 field itself. Also, it is not unsynched. */
719 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
721 /* Skip the rest of the header */
722 lseek(fd
, framelen
- 10, SEEK_CUR
);
725 if(version
>= ID3_VER_2_4
) {
726 if(4 != read(fd
, header
, 4))
729 /* The 2.4 extended header size does include the entire header,
730 so here we can just skip it. This header is unsynched. */
731 framelen
= unsync(header
[0], header
[1],
732 header
[2], header
[3]);
734 lseek(fd
, framelen
- 4, SEEK_CUR
);
738 /* Is unsynchronization applied? */
739 if(global_flags
& 0x80) {
740 global_unsynch
= true;
744 * We must have at least minframesize bytes left for the
745 * remaining frames to be interesting
747 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
750 /* Read frame header and check length */
751 if(version
>= ID3_VER_2_3
) {
752 if(global_unsynch
&& version
<= ID3_VER_2_3
)
753 rc
= read_unsynched(fd
, header
, 10);
755 rc
= read(fd
, header
, 10);
758 /* Adjust for the 10 bytes we read */
761 flags
= bytes2int(0, 0, header
[8], header
[9]);
763 if (version
>= ID3_VER_2_4
) {
764 framelen
= unsync(header
[4], header
[5],
765 header
[6], header
[7]);
767 /* version .3 files don't use synchsafe ints for
769 framelen
= bytes2int(header
[4], header
[5],
770 header
[6], header
[7]);
773 if(6 != read(fd
, header
, 6))
775 /* Adjust for the 6 bytes we read */
778 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
781 /* Keep track of the total size */
782 totframelen
= framelen
;
784 DEBUGF("framelen = %ld\n", framelen
);
786 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
799 if (version
>= ID3_VER_2_4
) {
800 if(flags
& 0x0040) { /* Grouping identity */
801 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
805 if(flags
& 0x0020) { /* Grouping identity */
806 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
811 if(flags
& 0x000c) /* Compression or encryption */
813 /* Skip it using the total size in case
816 lseek(fd
, totframelen
, SEEK_CUR
);
820 if(flags
& 0x0002) /* Unsynchronization */
823 if (version
>= ID3_VER_2_4
) {
824 if(flags
& 0x0001) { /* Data length indicator */
825 if(4 != read(fd
, tmp
, 4))
828 data_length_ind
= unsync(tmp
[0], tmp
[1], tmp
[2], tmp
[3]);
834 /* If the frame is larger than the remaining buffer space we try
835 to read as much as would fit in the buffer */
836 if(framelen
>= buffersize
- bufferpos
)
837 framelen
= buffersize
- bufferpos
- 1;
839 DEBUGF("id3v2 frame: %.4s\n", header
);
841 /* Check for certain frame headers
843 'size' is the amount of frame bytes remaining. We decrement it by
844 the amount of bytes we read. If we fail to read as many bytes as
845 we expect, we assume that we can't read from this file, and bail
848 For each frame. we will iterate over the list of supported tags,
849 and read the tag into entry's buffer. All tags will be kept as
850 strings, for cases where a number won't do, e.g., YEAR: "circa
851 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
852 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
853 flexible, and as the main use of id3 data is to display it,
854 converting it to an int just means reconverting to display it, at a
857 For tags that the current code does convert to ints, a post
858 processing function will be called via a pointer to function. */
860 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
861 const struct tag_resolver
* tr
= &taglist
[i
];
862 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
867 /* Only ID3_VER_2_2 uses frames with three-character names. */
868 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
869 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
873 /* Note that parser functions sometimes set *ptag to NULL, so
874 * the "!*ptag" check here doesn't always have the desired
875 * effect. Should the parser functions (parsegenre in
876 * particular) be updated to handle the case of being called
877 * multiple times, or should the "*ptag" check be removed?
879 if( (!ptag
|| !*ptag
) && !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
881 /* found a tag matching one in tagList, and not yet filled */
882 tag
= buffer
+ bufferpos
;
884 if(global_unsynch
&& version
<= ID3_VER_2_3
)
885 bytesread
= read_unsynched(fd
, tag
, framelen
);
887 bytesread
= read(fd
, tag
, framelen
);
889 if( bytesread
!= framelen
)
894 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
895 bytesread
= unsynchronize_frame(tag
, bytesread
);
897 /* the COMM frame has a 3 char field to hold an ISO-639-1
898 * language string and an optional short description;
899 * remove them so unicode_munge can work correctly
902 if(!memcmp( header
, "COMM", 4 )) {
903 /* ignore comments with iTunes 7 gapless data */
904 if(!strcmp(tag
+4, "iTunNORM"))
906 comm_offset
= 3 + strlen(tag
+4) + 1;
907 if(bytesread
>comm_offset
) {
908 bytesread
-=comm_offset
;
909 memmove(tag
+1, tag
+comm_offset
+1, bytesread
-1);
913 /* Attempt to parse Unicode string only if the tag contents
916 /* UTF-8 could potentially be 3 times larger */
917 /* so we need to create a new buffer */
918 char utf8buf
[(3 * bytesread
) + 1];
920 unicode_munge( tag
, utf8buf
, &bytesread
);
922 if(bytesread
>= buffersize
- bufferpos
)
923 bytesread
= buffersize
- bufferpos
- 1;
925 for (j
= 0; j
< bytesread
; j
++)
928 /* remove trailing spaces */
929 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
934 bufferpos
+= bytesread
+ 1;
940 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
942 /* Seek to the next frame */
943 if(framelen
< totframelen
)
944 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
949 if( i
== TAGLIST_SIZE
) {
950 /* no tag in tagList was found, or it was a repeat.
951 skip it using the total size */
953 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
954 size
-= skip_unsynched(fd
, totframelen
);
957 totframelen
= data_length_ind
;
960 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
968 * Calculates the size of the ID3v2 tag.
970 * Arguments: file - the file to search for a tag.
972 * Returns: the size of the tag or 0 if none was found
974 int getid3v2len(int fd
)
979 /* Make sure file has a ID3 tag */
980 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
981 (read(fd
, buf
, 6) != 6) ||
982 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
985 /* Now check what the ID3v2 size field says */
987 if(read(fd
, buf
, 4) != 4)
990 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
992 DEBUGF("ID3V2 Length: 0x%x\n", offset
);
997 * Calculates the length (in milliseconds) of an MP3 file.
999 * Modified to only use integers.
1001 * Arguments: file - the file to calculate the length upon
1002 * entry - the entry to update with the length
1004 * Returns: the song length in milliseconds,
1005 * 0 means that it couldn't be calculated
1007 static int getsonglength(int fd
, struct mp3entry
*entry
)
1009 unsigned long filetime
= 0;
1010 struct mp3info info
;
1013 /* Start searching after ID3v2 header */
1014 if(-1 == lseek(fd
, entry
->id3v2len
, SEEK_SET
))
1017 bytecount
= get_mp3file_info(fd
, &info
);
1019 DEBUGF("Space between ID3V2 tag and first audio frame: 0x%lx bytes\n",
1025 bytecount
+= entry
->id3v2len
;
1027 /* Validate byte count, in case the file has been edited without
1028 * updating the header.
1030 if (info
.byte_count
)
1032 const unsigned long expected
= entry
->filesize
- entry
->id3v1len
1034 const unsigned long diff
= MAX(10240, info
.byte_count
/ 20);
1036 if ((info
.byte_count
> expected
+ diff
)
1037 || (info
.byte_count
< expected
- diff
))
1039 DEBUGF("Note: info.byte_count differs from expected value by "
1040 "%ld bytes\n", labs((long) (expected
- info
.byte_count
)));
1041 info
.byte_count
= 0;
1042 info
.frame_count
= 0;
1044 info
.enc_padding
= 0;
1046 /* Even if the bitrate was based on "known bad" values, it
1047 * should still be better for VBR files than using the bitrate
1048 * of the first audio frame.
1053 entry
->bitrate
= info
.bitrate
;
1054 entry
->frequency
= info
.frequency
;
1055 entry
->version
= info
.version
;
1056 entry
->layer
= info
.layer
;
1057 switch(entry
->layer
) {
1058 #if CONFIG_CODEC==SWCODEC
1060 entry
->codectype
=AFMT_MPA_L1
;
1064 entry
->codectype
=AFMT_MPA_L2
;
1067 entry
->codectype
=AFMT_MPA_L3
;
1071 /* If the file time hasn't been established, this may be a fixed
1072 rate MP3, so just use the default formula */
1074 filetime
= info
.file_time
;
1078 /* Prevent a division by zero */
1079 if (info
.bitrate
< 8)
1082 filetime
= (entry
->filesize
- bytecount
) / (info
.bitrate
/ 8);
1083 /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
1084 * instead of filesize * 8 is exact, because mpeg audio bitrates are
1085 * always multiples of 8, and it avoids overflows. */
1088 entry
->frame_count
= info
.frame_count
;
1090 entry
->vbr
= info
.is_vbr
;
1091 entry
->has_toc
= info
.has_toc
;
1093 #if CONFIG_CODEC==SWCODEC
1094 entry
->lead_trim
= info
.enc_delay
;
1095 entry
->tail_trim
= info
.enc_padding
;
1098 memcpy(entry
->toc
, info
.toc
, sizeof(info
.toc
));
1100 entry
->vbr_header_pos
= info
.vbr_header_pos
;
1102 /* Update the seek point for the first playable frame */
1103 entry
->first_frame_offset
= bytecount
;
1104 DEBUGF("First frame is at %lx\n", entry
->first_frame_offset
);
1110 * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
1111 * about an MP3 file and updates it's entry accordingly.
1113 Note, that this returns true for successful, false for error! */
1114 bool get_mp3_metadata(int fd
, struct mp3entry
*entry
, const char *filename
, bool v1first
)
1116 int v1found
= false;
1118 #if CONFIG_CODEC != SWCODEC
1119 memset(entry
, 0, sizeof(struct mp3entry
));
1122 strncpy(entry
->path
, filename
, sizeof(entry
->path
));
1124 entry
->title
= NULL
;
1125 entry
->filesize
= filesize(fd
);
1126 entry
->id3v2len
= getid3v2len(fd
);
1127 entry
->tracknum
= 0;
1131 v1found
= setid3v1title(fd
, entry
);
1133 if (!v1found
&& entry
->id3v2len
)
1134 setid3v2title(fd
, entry
);
1135 int len
= getsonglength(fd
, entry
);
1138 entry
->length
= len
;
1140 /* Subtract the meta information from the file size to get
1141 the true size of the MP3 stream */
1142 entry
->filesize
-= entry
->first_frame_offset
;
1144 /* only seek to end of file if no id3v2 tags were found,
1145 and we already haven't looked for a v1 tag */
1146 if (!v1first
&& !entry
->id3v2len
) {
1147 setid3v1title(fd
, entry
);
1150 if(!entry
->length
|| (entry
->filesize
< 8 ))
1151 /* no song length or less than 8 bytes is hereby considered to be an
1152 invalid mp3 and won't be played by us! */
1158 /* Note, that this returns false for successful, true for error! */
1159 bool mp3info(struct mp3entry
*entry
, const char *filename
, bool v1first
)
1164 fd
= open(filename
, O_RDONLY
);
1168 result
= !get_mp3_metadata(fd
, entry
, filename
, v1first
);
1175 void adjust_mp3entry(struct mp3entry
*entry
, void *dest
, void *orig
)
1179 offset
= - ((size_t)orig
- (size_t)dest
);
1181 offset
= (size_t)dest
- (size_t)orig
;
1184 entry
->title
+= offset
;
1186 entry
->artist
+= offset
;
1188 entry
->album
+= offset
;
1189 if (entry
->genre_string
)
1190 entry
->genre_string
+= offset
;
1191 if (entry
->track_string
)
1192 entry
->track_string
+= offset
;
1193 if (entry
->disc_string
)
1194 entry
->disc_string
+= offset
;
1195 if (entry
->year_string
)
1196 entry
->year_string
+= offset
;
1197 if (entry
->composer
)
1198 entry
->composer
+= offset
;
1200 entry
->comment
+= offset
;
1201 if (entry
->albumartist
)
1202 entry
->albumartist
+= offset
;
1203 if (entry
->grouping
)
1204 entry
->grouping
+= offset
;
1205 #if CONFIG_CODEC == SWCODEC
1206 if (entry
->track_gain_string
)
1207 entry
->track_gain_string
+= offset
;
1208 if (entry
->album_gain_string
)
1209 entry
->album_gain_string
+= offset
;
1213 void copy_mp3entry(struct mp3entry
*dest
, struct mp3entry
*orig
)
1215 memcpy(dest
, orig
, sizeof(struct mp3entry
));
1216 adjust_mp3entry(dest
, dest
, orig
);
1219 #ifdef DEBUG_STANDALONE
1221 char *secs2str(int ms
)
1223 static char buffer
[32];
1226 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1230 int main(int argc
, char **argv
)
1233 for(i
=1; i
<argc
; i
++) {
1234 struct mp3entry mp3
;
1235 mp3
.album
= "Bogus";
1236 if(mp3info(&mp3
, argv
[i
], false)) {
1237 printf("Failed to get %s\n", argv
[i
]);
1241 printf("****** File: %s\n"
1245 " Genre: %s (%d) \n"
1249 " Length: %s / %d s\n"
1253 mp3
.title
?mp3
.title
:"<blank>",
1254 mp3
.artist
?mp3
.artist
:"<blank>",
1255 mp3
.album
?mp3
.album
:"<blank>",
1256 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1258 mp3
.composer
?mp3
.composer
:"<blank>",
1259 mp3
.year_string
?mp3
.year_string
:"<blank>",
1261 mp3
.track_string
?mp3
.track_string
:"<blank>",
1263 secs2str(mp3
.length
),