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" ),
113 #if CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING)
114 /* get REC_FORMAT_* corresponding AFMT_* */
115 const int rec_format_afmt
[REC_NUM_FORMATS
] =
117 /* give AFMT_UNKNOWN by default */
118 [0 ... REC_NUM_FORMATS
-1] = AFMT_UNKNOWN
,
119 /* add new entries below this line */
120 [REC_FORMAT_AIFF
] = AFMT_AIFF
,
121 [REC_FORMAT_MPA_L3
] = AFMT_MPA_L3
,
122 [REC_FORMAT_WAVPACK
] = AFMT_WAVPACK
,
123 [REC_FORMAT_PCM_WAV
] = AFMT_PCM_WAV
,
126 /* get AFMT_* corresponding REC_FORMAT_* */
127 const int afmt_rec_format
[AFMT_NUM_CODECS
] =
129 /* give -1 by default */
130 [0 ... AFMT_NUM_CODECS
-1] = -1,
131 /* add new entries below this line */
132 [AFMT_AIFF
] = REC_FORMAT_AIFF
,
133 [AFMT_MPA_L3
] = REC_FORMAT_MPA_L3
,
134 [AFMT_WAVPACK
] = REC_FORMAT_WAVPACK
,
135 [AFMT_PCM_WAV
] = REC_FORMAT_PCM_WAV
,
137 #endif /* CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING) */
140 unsigned long unsync(unsigned long b0
,
145 return (((long)(b0
& 0x7F) << (3*7)) |
146 ((long)(b1
& 0x7F) << (2*7)) |
147 ((long)(b2
& 0x7F) << (1*7)) |
148 ((long)(b3
& 0x7F) << (0*7)));
151 static const char* const genres
[] = {
152 "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
153 "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
154 "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
155 "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
156 "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
157 "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
158 "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
159 "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
160 "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
161 "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
162 "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
163 "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
164 "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
166 /* winamp extensions */
167 "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
168 "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
169 "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
170 "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
171 "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
172 "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
173 "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
174 "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
175 "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
176 "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
177 "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
178 "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
182 char* id3_get_num_genre(const unsigned int genre_num
)
184 if (genre_num
< sizeof(genres
)/sizeof(char*))
185 return (char*)genres
[genre_num
];
189 char* id3_get_codec(const struct mp3entry
* id3
)
191 if (id3
->codectype
< AFMT_NUM_CODECS
) {
192 return (char*)audio_formats
[id3
->codectype
].label
;
199 HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
200 Code and comments by Thomas Paul Diffenbach
202 To add another ID3v2 Tag, do the following:
203 1. add a char* named for the tag to struct mp3entry in id3.h,
204 (I (tpd) prefer to use char* rather than ints, even for what seems like
205 numerical values, for cases where a number won't do, e.g.,
206 YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
207 TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
208 Text is more flexible, and as the main use of id3 data is to
209 display it, converting it to an int just means reconverting to
210 display it, at a runtime cost.)
212 2. If any special processing beyond copying the tag value from the Id3
213 block to the struct mp3entry is rrequired (such as converting to an
214 int), write a function to perform this special processing.
216 This function's prototype must match that of
217 typedef tagPostProcessFunc, that is it must be:
218 int func( struct mp3entry*, char* tag, int bufferpos )
219 the first argument is a pointer to the current mp3entry structure the
220 second argument is a pointer to the null terminated string value of the
221 tag found the third argument is the offset of the next free byte in the
222 mp3entry's buffer your function should return the corrected offset; if
223 you don't lengthen or shorten the tag string, you can return the third
226 Unless you have a good reason no to, make the function static.
227 TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
229 3. add one or more entries to the tagList array, using the format:
230 char* ID3 Tag symbolic name -- see the ID3 specification for these,
231 sizeof() that name minus 1,
232 offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
233 pointer to your special processing function or NULL
234 if you need no special processing
235 flag indicating if this tag is binary or textual
236 Many ID3 symbolic names come in more than one form. You can add both
237 forms, each referencing the same variable in struct mp3entry.
238 If both forms are present, the last found will be used.
239 Note that the offset can be zero, in which case no entry will be set
240 in the mp3entry struct; the frame is still read into the buffer and
241 the special processing function is called (several times, if there
242 are several frames with the same name).
244 4. Alternately, use the TAG_LIST_ENTRY macro with
245 ID3 tag symbolic name,
246 variable in struct mp3entry,
247 special processing function address
249 5. Add code to wps-display.c function get_tag to assign a printf-like
250 format specifier for the tag */
252 /* Structure for ID3 Tag extraction information */
253 struct tag_resolver
{
257 int (*ppFunc
)(struct mp3entry
*, char* tag
, int bufferpos
);
261 static bool global_ff_found
;
263 static int unsynchronize(char* tag
, int len
, bool *ff_found
)
267 unsigned char *rp
, *wp
;
269 wp
= rp
= (unsigned char *)tag
;
271 rp
= (unsigned char *)tag
;
272 for(i
= 0;i
< len
;i
++) {
273 /* Read the next byte and write it back, but don't increment the
278 /* Increment the write pointer if it isn't an unsynch pattern */
288 return (long)wp
- (long)tag
;
291 static int unsynchronize_frame(char* tag
, int len
)
293 bool ff_found
= false;
295 return unsynchronize(tag
, len
, &ff_found
);
298 static int read_unsynched(int fd
, void *buf
, int len
)
310 rc
= read(fd
, rp
, remaining
);
314 i
= unsynchronize(wp
, remaining
, &global_ff_found
);
322 static int skip_unsynched(int fd
, int len
)
330 rlen
= MIN(sizeof(buf
), (unsigned int)remaining
);
331 rc
= read(fd
, buf
, rlen
);
335 remaining
-= unsynchronize(buf
, rlen
, &global_ff_found
);
341 /* parse numeric value from string */
342 static int parsetracknum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
344 entry
->tracknum
= atoi( tag
);
348 /* parse numeric value from string */
349 static int parseyearnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
351 entry
->year
= atoi( tag
);
355 /* parse numeric genre from string, version 2.2 and 2.3 */
356 static int parsegenre( struct mp3entry
* entry
, char* tag
, int bufferpos
)
358 if(entry
->id3version
>= ID3_VER_2_4
) {
359 /* In version 2.4 and up, there are no parentheses, and the genre frame
360 is a list of strings, either numbers or text. */
362 /* Is it a number? */
363 if(isdigit(tag
[0])) {
364 entry
->genre_string
= id3_get_num_genre(atoi( tag
));
365 return tag
- entry
->id3v2buf
;
367 entry
->genre_string
= tag
;
371 if( tag
[0] == '(' && tag
[1] != '(' ) {
372 entry
->genre_string
= id3_get_num_genre(atoi( tag
+ 1 ));
373 return tag
- entry
->id3v2buf
;
376 entry
->genre_string
= tag
;
382 #if CONFIG_CODEC == SWCODEC
383 /* parse user defined text, looking for replaygain information. */
384 static int parseuser( struct mp3entry
* entry
, char* tag
, int bufferpos
)
387 int desc_len
= strlen(tag
);
390 /* Note: for ID3v2.4, parse_replaygain will not overwrite replaygain
391 values already parsed from RVA2 tags */
392 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
393 /* At least part of the value was read, so we can safely try to
396 value
= tag
+ desc_len
+ 1;
397 value_len
= parse_replaygain(tag
, value
, entry
, tag
,
398 bufferpos
- (tag
- entry
->id3v2buf
));
402 bufferpos
= tag
- entry
->id3v2buf
+ value_len
;
404 bufferpos
= tag
- entry
->id3v2buf
;
410 /* parse RVA2 binary data and convert to replaygain information. */
411 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
414 int desc_len
= strlen(tag
);
417 /* Only parse RVA2 replaygain tags if tag version == 2.4 */
418 if (entry
->id3version
== ID3_VER_2_4
&&
419 (tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
420 value
= tag
+ desc_len
+ 1;
421 value_len
= parse_replaygain_rva(tag
, value
, entry
, tag
,
422 bufferpos
- (tag
- entry
->id3v2buf
));
426 bufferpos
= tag
- entry
->id3v2buf
+ value_len
;
428 bufferpos
= tag
- entry
->id3v2buf
;
435 static const struct tag_resolver taglist
[] = {
436 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
437 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
438 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
439 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
440 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
441 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
442 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
443 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
444 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
445 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
446 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
447 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
448 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
449 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
450 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
451 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
452 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
453 #if CONFIG_CODEC == SWCODEC
454 { "TXXX", 4, 0, &parseuser
, false },
455 { "RVA2", 4, 0, &parserva2
, true },
459 #define TAGLIST_SIZE ((int)(sizeof(taglist) / sizeof(taglist[0])))
461 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
462 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
463 we convert from the default codepage */
464 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
468 unsigned char *str
= (unsigned char *)string
;
470 unsigned char* utf8
= (unsigned char *)utf8buf
;
473 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
476 utf8
= iso_decode(str
, utf8
, -1, *len
);
478 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
481 case 0x01: /* Unicode with or without BOM */
486 /* Handle frames with more than one string
487 (needed for TXXX frames).*/
489 tmp
= bytes2int(0, 0, str
[0], str
[1]);
491 /* Now check if there is a BOM
492 (zero-width non-breaking space, 0xfeff)
493 and if it is in little or big endian format */
494 if(tmp
== 0xfffe) { /* Little endian? */
498 } else if(tmp
== 0xfeff) { /* Big endian? */
502 /* If there is no BOM (which is a specification violation),
503 let's try to guess it. If one of the bytes is 0x00, it is
504 probably the most significant one. */
510 utf8
= utf16LEdecode(str
, utf8
, 1);
512 utf8
= utf16BEdecode(str
, utf8
, 1);
516 } while((str
[0] || str
[1]) && (i
< *len
));
518 *utf8
++ = 0; /* Terminate the string */
519 templen
+= (strlen(&utf8buf
[templen
]) + 1);
526 case 0x03: /* UTF-8 encoded string */
527 for(i
=0; i
< *len
; i
++)
532 default: /* Plain old string */
533 utf8
= iso_decode(str
, utf8
, -1, *len
);
535 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
542 * Sets the title of an MP3 entry based on its ID3v1 tag.
544 * Arguments: file - the MP3 file to scen for a ID3v1 tag
545 * entry - the entry to set the title in
547 * Returns: true if a title was found and created, else false
549 static bool setid3v1title(int fd
, struct mp3entry
*entry
)
551 unsigned char buffer
[128];
552 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
556 if (-1 == lseek(fd
, -128, SEEK_END
))
559 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
562 if (strncmp((char *)buffer
, "TAG", 3))
565 entry
->id3v1len
= 128;
566 entry
->id3version
= ID3_VER_1_0
;
568 for (i
=0; i
< (int)sizeof offsets
; i
++) {
569 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
575 /* kill trailing space in strings */
576 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
578 /* convert string to utf8 */
579 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
580 utf8
= iso_decode(ptr
, utf8
, -1, 30);
581 /* make sure string is terminated */
586 /* kill trailing space in strings */
587 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
589 /* convert string to utf8 */
590 utf8
= (unsigned char *)entry
->id3v1buf
[3];
591 utf8
= iso_decode(ptr
, utf8
, -1, 28);
592 /* make sure string is terminated */
598 entry
->year
= atoi((char *)ptr
);
602 /* id3v1.1 uses last two bytes of comment field for track
603 number: first must be 0 and second is track num */
604 if (!ptr
[0] && ptr
[1]) {
605 entry
->tracknum
= ptr
[1];
606 entry
->id3version
= ID3_VER_1_1
;
612 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
617 entry
->title
= entry
->id3v1buf
[0];
618 entry
->artist
= entry
->id3v1buf
[1];
619 entry
->album
= entry
->id3v1buf
[2];
620 entry
->comment
= entry
->id3v1buf
[3];
627 * Sets the title of an MP3 entry based on its ID3v2 tag.
629 * Arguments: file - the MP3 file to scan for a ID3v2 tag
630 * entry - the entry to set the title in
632 * Returns: true if a title was found and created, else false
634 static void setid3v2title(int fd
, struct mp3entry
*entry
)
638 long bufferpos
= 0, totframelen
, framelen
;
641 unsigned char version
;
642 char *buffer
= entry
->id3v2buf
;
644 int buffersize
= sizeof(entry
->id3v2buf
);
645 unsigned char global_flags
;
648 bool global_unsynch
= false;
649 bool unsynch
= false;
654 global_ff_found
= false;
656 /* Bail out if the tag is shorter than 10 bytes */
657 if(entry
->id3v2len
< 10)
660 /* Read the ID3 tag version from the header */
661 lseek(fd
, 0, SEEK_SET
);
662 if(10 != read(fd
, header
, 10))
665 /* Get the total ID3 tag size */
666 size
= entry
->id3v2len
- 10;
671 version
= ID3_VER_2_2
;
676 version
= ID3_VER_2_3
;
681 version
= ID3_VER_2_4
;
686 /* unsupported id3 version */
689 entry
->id3version
= version
;
690 entry
->tracknum
= entry
->year
= 0;
691 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
693 global_flags
= header
[5];
695 /* Skip the extended header if it is present */
696 if(global_flags
& 0x40) {
697 if(version
== ID3_VER_2_3
) {
698 if(10 != read(fd
, header
, 10))
700 /* The 2.3 extended header size doesn't include the following
701 data, so we have to find out the size by checking the flags.
702 Also, it is not unsynched. */
703 framelen
= bytes2int(header
[0], header
[1], header
[2], header
[3]) +
704 bytes2int(header
[6], header
[7], header
[8], header
[9]);
705 flags
= bytes2int(0, 0, header
[4], header
[5]);
707 framelen
+= 4; /* CRC */
709 lseek(fd
, framelen
- 10, SEEK_CUR
);
712 if(version
>= ID3_VER_2_4
) {
713 if(4 != read(fd
, header
, 4))
716 /* The 2.4 extended header size does include the entire header,
717 so here we can just skip it. This header is unsynched. */
718 framelen
= unsync(header
[0], header
[1],
719 header
[2], header
[3]);
721 lseek(fd
, framelen
- 4, SEEK_CUR
);
725 /* Is unsynchronization applied? */
726 if(global_flags
& 0x80) {
727 global_unsynch
= true;
731 * We must have at least minframesize bytes left for the
732 * remaining frames to be interesting
734 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
737 /* Read frame header and check length */
738 if(version
>= ID3_VER_2_3
) {
739 if(global_unsynch
&& version
<= ID3_VER_2_3
)
740 rc
= read_unsynched(fd
, header
, 10);
742 rc
= read(fd
, header
, 10);
745 /* Adjust for the 10 bytes we read */
748 flags
= bytes2int(0, 0, header
[8], header
[9]);
750 if (version
>= ID3_VER_2_4
) {
751 framelen
= unsync(header
[4], header
[5],
752 header
[6], header
[7]);
754 /* version .3 files don't use synchsafe ints for
756 framelen
= bytes2int(header
[4], header
[5],
757 header
[6], header
[7]);
760 if(6 != read(fd
, header
, 6))
762 /* Adjust for the 6 bytes we read */
765 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
768 /* Keep track of the total size */
769 totframelen
= framelen
;
771 DEBUGF("framelen = %d\n", framelen
);
773 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
786 if (version
>= ID3_VER_2_4
) {
787 if(flags
& 0x0040) { /* Grouping identity */
788 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
792 if(flags
& 0x0020) { /* Grouping identity */
793 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
798 if(flags
& 0x000c) /* Compression or encryption */
800 /* Skip it using the total size in case
803 lseek(fd
, totframelen
, SEEK_CUR
);
807 if(flags
& 0x0002) /* Unsynchronization */
810 if (version
>= ID3_VER_2_4
) {
811 if(flags
& 0x0001) { /* Data length indicator */
812 if(4 != read(fd
, tmp
, 4))
815 data_length_ind
= unsync(tmp
[0], tmp
[1], tmp
[2], tmp
[3]);
821 /* If the frame is larger than the remaining buffer space we try
822 to read as much as would fit in the buffer */
823 if(framelen
>= buffersize
- bufferpos
)
824 framelen
= buffersize
- bufferpos
- 1;
826 DEBUGF("id3v2 frame: %.4s\n", header
);
828 /* Check for certain frame headers
830 'size' is the amount of frame bytes remaining. We decrement it by
831 the amount of bytes we read. If we fail to read as many bytes as
832 we expect, we assume that we can't read from this file, and bail
835 For each frame. we will iterate over the list of supported tags,
836 and read the tag into entry's buffer. All tags will be kept as
837 strings, for cases where a number won't do, e.g., YEAR: "circa
838 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
839 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
840 flexible, and as the main use of id3 data is to display it,
841 converting it to an int just means reconverting to display it, at a
844 For tags that the current code does convert to ints, a post
845 processing function will be called via a pointer to function. */
847 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
848 const struct tag_resolver
* tr
= &taglist
[i
];
849 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
854 /* Only ID3_VER_2_2 uses frames with three-character names. */
855 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
856 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
860 /* Note that parser functions sometimes set *ptag to NULL, so
861 * the "!*ptag" check here doesn't always have the desired
862 * effect. Should the parser functions (parsegenre in
863 * particular) be updated to handle the case of being called
864 * multiple times, or should the "*ptag" check be removed?
866 if( (!ptag
|| !*ptag
) && !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
868 /* found a tag matching one in tagList, and not yet filled */
869 tag
= buffer
+ bufferpos
;
871 if(global_unsynch
&& version
<= ID3_VER_2_3
)
872 bytesread
= read_unsynched(fd
, tag
, framelen
);
874 bytesread
= read(fd
, tag
, framelen
);
876 if( bytesread
!= framelen
)
881 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
882 bytesread
= unsynchronize_frame(tag
, bytesread
);
884 /* the COMM frame has a 3 char field to hold an ISO-639-1
885 * language string and an optional short description;
886 * remove them so unicode_munge can work correctly
889 if(!memcmp( header
, "COMM", 4 )) {
890 comm_offset
= 3 + strlen(tag
+4) + 1;
891 if(bytesread
>comm_offset
) {
892 bytesread
-=comm_offset
;
893 memmove(tag
+1, tag
+comm_offset
+1, bytesread
-1);
897 /* Attempt to parse Unicode string only if the tag contents
900 /* UTF-8 could potentially be 3 times larger */
901 /* so we need to create a new buffer */
902 char utf8buf
[(3 * bytesread
) + 1];
904 unicode_munge( tag
, utf8buf
, &bytesread
);
906 if(bytesread
>= buffersize
- bufferpos
)
907 bytesread
= buffersize
- bufferpos
- 1;
909 for (j
= 0; j
< bytesread
; j
++)
912 /* remove trailing spaces */
913 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
918 bufferpos
+= bytesread
+ 1;
924 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
926 /* Seek to the next frame */
927 if(framelen
< totframelen
)
928 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
933 if( i
== TAGLIST_SIZE
) {
934 /* no tag in tagList was found, or it was a repeat.
935 skip it using the total size */
937 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
938 size
-= skip_unsynched(fd
, totframelen
);
941 totframelen
= data_length_ind
;
944 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
952 * Calculates the size of the ID3v2 tag.
954 * Arguments: file - the file to search for a tag.
956 * Returns: the size of the tag or 0 if none was found
958 int getid3v2len(int fd
)
963 /* Make sure file has a ID3 tag */
964 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
965 (read(fd
, buf
, 6) != 6) ||
966 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
969 /* Now check what the ID3v2 size field says */
971 if(read(fd
, buf
, 4) != 4)
974 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
976 DEBUGF("ID3V2 Length: 0x%x\n", offset
);
981 * Calculates the length (in milliseconds) of an MP3 file.
983 * Modified to only use integers.
985 * Arguments: file - the file to calculate the length upon
986 * entry - the entry to update with the length
988 * Returns: the song length in milliseconds,
989 * 0 means that it couldn't be calculated
991 static int getsonglength(int fd
, struct mp3entry
*entry
)
993 unsigned long filetime
= 0;
997 /* Start searching after ID3v2 header */
998 if(-1 == lseek(fd
, entry
->id3v2len
, SEEK_SET
))
1001 bytecount
= get_mp3file_info(fd
, &info
);
1003 DEBUGF("Space between ID3V2 tag and first audio frame: 0x%x bytes\n",
1009 bytecount
+= entry
->id3v2len
;
1011 /* Validate byte count, in case the file has been edited without
1012 * updating the header.
1014 if (info
.byte_count
)
1016 const unsigned long expected
= entry
->filesize
- entry
->id3v1len
1018 const unsigned long diff
= MAX(10240, info
.byte_count
/ 20);
1020 if ((info
.byte_count
> expected
+ diff
)
1021 || (info
.byte_count
< expected
- diff
))
1023 DEBUGF("Note: info.byte_count differs from expected value by "
1024 "%d bytes\n", labs((long) (expected
- info
.byte_count
)));
1025 info
.byte_count
= 0;
1026 info
.frame_count
= 0;
1028 info
.enc_padding
= 0;
1030 /* Even if the bitrate was based on "known bad" values, it
1031 * should still be better for VBR files than using the bitrate
1032 * of the first audio frame.
1037 entry
->bitrate
= info
.bitrate
;
1038 entry
->frequency
= info
.frequency
;
1039 entry
->version
= info
.version
;
1040 entry
->layer
= info
.layer
;
1041 switch(entry
->layer
) {
1042 #if CONFIG_CODEC==SWCODEC
1044 entry
->codectype
=AFMT_MPA_L1
;
1048 entry
->codectype
=AFMT_MPA_L2
;
1051 entry
->codectype
=AFMT_MPA_L3
;
1055 /* If the file time hasn't been established, this may be a fixed
1056 rate MP3, so just use the default formula */
1058 filetime
= info
.file_time
;
1062 /* Prevent a division by zero */
1063 if (info
.bitrate
< 8)
1066 filetime
= (entry
->filesize
- bytecount
) / (info
.bitrate
/ 8);
1067 /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
1068 * instead of filesize * 8 is exact, because mpeg audio bitrates are
1069 * always multiples of 8, and it avoids overflows. */
1072 entry
->frame_count
= info
.frame_count
;
1074 entry
->vbr
= info
.is_vbr
;
1075 entry
->has_toc
= info
.has_toc
;
1077 #if CONFIG_CODEC==SWCODEC
1078 entry
->lead_trim
= info
.enc_delay
;
1079 entry
->tail_trim
= info
.enc_padding
;
1082 memcpy(entry
->toc
, info
.toc
, sizeof(info
.toc
));
1084 entry
->vbr_header_pos
= info
.vbr_header_pos
;
1086 /* Update the seek point for the first playable frame */
1087 entry
->first_frame_offset
= bytecount
;
1088 DEBUGF("First frame is at %x\n", entry
->first_frame_offset
);
1094 * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
1095 * about an MP3 file and updates it's entry accordingly.
1097 Note, that this returns true for successful, false for error! */
1098 bool get_mp3_metadata(int fd
, struct mp3entry
*entry
, const char *filename
, bool v1first
)
1100 int v1found
= false;
1102 #if CONFIG_CODEC != SWCODEC
1103 memset(entry
, 0, sizeof(struct mp3entry
));
1106 strncpy(entry
->path
, filename
, sizeof(entry
->path
));
1108 entry
->title
= NULL
;
1109 entry
->filesize
= filesize(fd
);
1110 entry
->id3v2len
= getid3v2len(fd
);
1111 entry
->tracknum
= 0;
1114 v1found
= setid3v1title(fd
, entry
);
1116 if (!v1found
&& entry
->id3v2len
)
1117 setid3v2title(fd
, entry
);
1118 entry
->length
= getsonglength(fd
, entry
);
1120 /* Subtract the meta information from the file size to get
1121 the true size of the MP3 stream */
1122 entry
->filesize
-= entry
->first_frame_offset
;
1124 /* only seek to end of file if no id3v2 tags were found,
1125 and we already haven't looked for a v1 tag */
1126 if (!v1first
&& !entry
->id3v2len
) {
1127 setid3v1title(fd
, entry
);
1130 if(!entry
->length
|| (entry
->filesize
< 8 ))
1131 /* no song length or less than 8 bytes is hereby considered to be an
1132 invalid mp3 and won't be played by us! */
1138 /* Note, that this returns false for successful, true for error! */
1139 bool mp3info(struct mp3entry
*entry
, const char *filename
, bool v1first
)
1144 fd
= open(filename
, O_RDONLY
);
1148 result
= !get_mp3_metadata(fd
, entry
, filename
, v1first
);
1155 void adjust_mp3entry(struct mp3entry
*entry
, void *dest
, void *orig
)
1159 offset
= - ((size_t)orig
- (size_t)dest
);
1161 offset
= (size_t)dest
- (size_t)orig
;
1164 entry
->title
+= offset
;
1166 entry
->artist
+= offset
;
1168 entry
->album
+= offset
;
1169 if (entry
->genre_string
)
1170 entry
->genre_string
+= offset
;
1171 if (entry
->track_string
)
1172 entry
->track_string
+= offset
;
1173 if (entry
->year_string
)
1174 entry
->year_string
+= offset
;
1175 if (entry
->composer
)
1176 entry
->composer
+= offset
;
1178 entry
->comment
+= offset
;
1179 if (entry
->albumartist
)
1180 entry
->albumartist
+= offset
;
1181 #if CONFIG_CODEC == SWCODEC
1182 if (entry
->track_gain_string
)
1183 entry
->track_gain_string
+= offset
;
1184 if (entry
->album_gain_string
)
1185 entry
->album_gain_string
+= offset
;
1189 void copy_mp3entry(struct mp3entry
*dest
, struct mp3entry
*orig
)
1191 memcpy(dest
, orig
, sizeof(struct mp3entry
));
1192 adjust_mp3entry(dest
, dest
, orig
);
1195 #ifdef DEBUG_STANDALONE
1197 char *secs2str(int ms
)
1199 static char buffer
[32];
1202 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1206 int main(int argc
, char **argv
)
1209 for(i
=1; i
<argc
; i
++) {
1210 struct mp3entry mp3
;
1211 mp3
.album
= "Bogus";
1212 if(mp3info(&mp3
, argv
[i
], false)) {
1213 printf("Failed to get %s\n", argv
[i
]);
1217 printf("****** File: %s\n"
1221 " Genre: %s (%d) \n"
1225 " Length: %s / %d s\n"
1229 mp3
.title
?mp3
.title
:"<blank>",
1230 mp3
.artist
?mp3
.artist
:"<blank>",
1231 mp3
.album
?mp3
.album
:"<blank>",
1232 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1234 mp3
.composer
?mp3
.composer
:"<blank>",
1235 mp3
.year_string
?mp3
.year_string
:"<blank>",
1237 mp3
.track_string
?mp3
.track_string
:"<blank>",
1239 secs2str(mp3
.length
),