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 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
404 /* At least part of the value was read, so we can safely try to
407 value
= tag
+ desc_len
+ 1;
408 value_len
= parse_replaygain(tag
, value
, entry
, tag
,
409 bufferpos
- (tag
- entry
->id3v2buf
));
412 return tag
- entry
->id3v2buf
+ value_len
;
415 /* parse RVA2 binary data and convert to replaygain information. */
416 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
418 int desc_len
= strlen(tag
);
419 int end_pos
= tag
- entry
->id3v2buf
+ desc_len
+ 5;
421 unsigned char* value
= tag
+ desc_len
+ 1;
423 /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
424 * type is master volume.
426 if (entry
->id3version
== ID3_VER_2_4
&& end_pos
< bufferpos
434 /* The RVA2 specification is unclear on some things (id string and
435 * peak volume), but this matches how Quod Libet use them.
438 gain
= (int16_t) ((value
[0] << 8) | value
[1]);
441 peakbytes
= (peakbits
+ 7) / 8;
443 /* Only use the topmost 24 bits for peak volume */
448 /* Make sure the peak bits were read */
449 if (end_pos
+ peakbytes
< bufferpos
) {
450 long shift
= ((8 - (peakbits
& 7)) & 7) + (3 - peakbytes
) * 8;
452 for ( ; peakbytes
; peakbytes
--) {
460 peak
+= *value
>> (8 - shift
);
464 if (strcasecmp(tag
, "album") == 0) {
466 } else if (strcasecmp(tag
, "track") != 0) {
470 value_len
= parse_replaygain_int(album
, gain
, peak
* 2, entry
,
471 tag
, sizeof(entry
->id3v2buf
) - (tag
- entry
->id3v2buf
));
474 return tag
- entry
->id3v2buf
+ value_len
;
478 static const struct tag_resolver taglist
[] = {
479 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
480 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
481 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
482 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
483 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
484 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
485 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
486 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
487 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
488 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
489 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
490 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
491 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
492 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
493 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
494 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
495 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
496 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
497 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
498 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
499 #if CONFIG_CODEC == SWCODEC
500 { "TXXX", 4, 0, &parseuser
, false },
501 { "RVA2", 4, 0, &parserva2
, true },
505 #define TAGLIST_SIZE ((int)(sizeof(taglist) / sizeof(taglist[0])))
507 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
508 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
509 we convert from the default codepage */
510 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
514 unsigned char *str
= (unsigned char *)string
;
516 unsigned char* utf8
= (unsigned char *)utf8buf
;
519 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
522 utf8
= iso_decode(str
, utf8
, -1, *len
);
524 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
527 case 0x01: /* Unicode with or without BOM */
532 /* Handle frames with more than one string
533 (needed for TXXX frames).*/
535 tmp
= bytes2int(0, 0, str
[0], str
[1]);
537 /* Now check if there is a BOM
538 (zero-width non-breaking space, 0xfeff)
539 and if it is in little or big endian format */
540 if(tmp
== 0xfffe) { /* Little endian? */
544 } else if(tmp
== 0xfeff) { /* Big endian? */
548 /* If there is no BOM (which is a specification violation),
549 let's try to guess it. If one of the bytes is 0x00, it is
550 probably the most significant one. */
556 utf8
= utf16LEdecode(str
, utf8
, 1);
558 utf8
= utf16BEdecode(str
, utf8
, 1);
562 } while((str
[0] || str
[1]) && (i
< *len
));
564 *utf8
++ = 0; /* Terminate the string */
565 templen
+= (strlen(&utf8buf
[templen
]) + 1);
572 case 0x03: /* UTF-8 encoded string */
573 for(i
=0; i
< *len
; i
++)
578 default: /* Plain old string */
579 utf8
= iso_decode(str
, utf8
, -1, *len
);
581 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
588 * Sets the title of an MP3 entry based on its ID3v1 tag.
590 * Arguments: file - the MP3 file to scen for a ID3v1 tag
591 * entry - the entry to set the title in
593 * Returns: true if a title was found and created, else false
595 static bool setid3v1title(int fd
, struct mp3entry
*entry
)
597 unsigned char buffer
[128];
598 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
602 if (-1 == lseek(fd
, -128, SEEK_END
))
605 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
608 if (strncmp((char *)buffer
, "TAG", 3))
611 entry
->id3v1len
= 128;
612 entry
->id3version
= ID3_VER_1_0
;
614 for (i
=0; i
< (int)sizeof offsets
; i
++) {
615 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
621 /* kill trailing space in strings */
622 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
624 /* convert string to utf8 */
625 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
626 utf8
= iso_decode(ptr
, utf8
, -1, 30);
627 /* make sure string is terminated */
632 /* kill trailing space in strings */
633 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
635 /* convert string to utf8 */
636 utf8
= (unsigned char *)entry
->id3v1buf
[3];
637 utf8
= iso_decode(ptr
, utf8
, -1, 28);
638 /* make sure string is terminated */
644 entry
->year
= atoi((char *)ptr
);
648 /* id3v1.1 uses last two bytes of comment field for track
649 number: first must be 0 and second is track num */
650 if (!ptr
[0] && ptr
[1]) {
651 entry
->tracknum
= ptr
[1];
652 entry
->id3version
= ID3_VER_1_1
;
658 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
663 entry
->title
= entry
->id3v1buf
[0];
664 entry
->artist
= entry
->id3v1buf
[1];
665 entry
->album
= entry
->id3v1buf
[2];
666 entry
->comment
= entry
->id3v1buf
[3];
673 * Sets the title of an MP3 entry based on its ID3v2 tag.
675 * Arguments: file - the MP3 file to scan for a ID3v2 tag
676 * entry - the entry to set the title in
678 * Returns: true if a title was found and created, else false
680 static void setid3v2title(int fd
, struct mp3entry
*entry
)
684 long bufferpos
= 0, totframelen
, framelen
;
687 unsigned char version
;
688 char *buffer
= entry
->id3v2buf
;
690 int buffersize
= sizeof(entry
->id3v2buf
);
691 unsigned char global_flags
;
694 bool global_unsynch
= false;
695 bool unsynch
= false;
700 global_ff_found
= false;
702 /* Bail out if the tag is shorter than 10 bytes */
703 if(entry
->id3v2len
< 10)
706 /* Read the ID3 tag version from the header */
707 lseek(fd
, 0, SEEK_SET
);
708 if(10 != read(fd
, header
, 10))
711 /* Get the total ID3 tag size */
712 size
= entry
->id3v2len
- 10;
717 version
= ID3_VER_2_2
;
722 version
= ID3_VER_2_3
;
727 version
= ID3_VER_2_4
;
732 /* unsupported id3 version */
735 entry
->id3version
= version
;
736 entry
->tracknum
= entry
->year
= entry
->discnum
= 0;
737 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
739 global_flags
= header
[5];
741 /* Skip the extended header if it is present */
742 if(global_flags
& 0x40) {
743 if(version
== ID3_VER_2_3
) {
744 if(10 != read(fd
, header
, 10))
746 /* The 2.3 extended header size doesn't include the header size
747 field itself. Also, it is not unsynched. */
749 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
751 /* Skip the rest of the header */
752 lseek(fd
, framelen
- 10, SEEK_CUR
);
755 if(version
>= ID3_VER_2_4
) {
756 if(4 != read(fd
, header
, 4))
759 /* The 2.4 extended header size does include the entire header,
760 so here we can just skip it. This header is unsynched. */
761 framelen
= unsync(header
[0], header
[1],
762 header
[2], header
[3]);
764 lseek(fd
, framelen
- 4, SEEK_CUR
);
768 /* Is unsynchronization applied? */
769 if(global_flags
& 0x80) {
770 global_unsynch
= true;
774 * We must have at least minframesize bytes left for the
775 * remaining frames to be interesting
777 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
780 /* Read frame header and check length */
781 if(version
>= ID3_VER_2_3
) {
782 if(global_unsynch
&& version
<= ID3_VER_2_3
)
783 rc
= read_unsynched(fd
, header
, 10);
785 rc
= read(fd
, header
, 10);
788 /* Adjust for the 10 bytes we read */
791 flags
= bytes2int(0, 0, header
[8], header
[9]);
793 if (version
>= ID3_VER_2_4
) {
794 framelen
= unsync(header
[4], header
[5],
795 header
[6], header
[7]);
797 /* version .3 files don't use synchsafe ints for
799 framelen
= bytes2int(header
[4], header
[5],
800 header
[6], header
[7]);
803 if(6 != read(fd
, header
, 6))
805 /* Adjust for the 6 bytes we read */
808 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
811 /* Keep track of the total size */
812 totframelen
= framelen
;
814 DEBUGF("framelen = %ld\n", framelen
);
816 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
829 if (version
>= ID3_VER_2_4
) {
830 if(flags
& 0x0040) { /* Grouping identity */
831 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
835 if(flags
& 0x0020) { /* Grouping identity */
836 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
841 if(flags
& 0x000c) /* Compression or encryption */
843 /* Skip it using the total size in case
846 lseek(fd
, totframelen
, SEEK_CUR
);
850 if(flags
& 0x0002) /* Unsynchronization */
853 if (version
>= ID3_VER_2_4
) {
854 if(flags
& 0x0001) { /* Data length indicator */
855 if(4 != read(fd
, tmp
, 4))
858 data_length_ind
= unsync(tmp
[0], tmp
[1], tmp
[2], tmp
[3]);
864 /* If the frame is larger than the remaining buffer space we try
865 to read as much as would fit in the buffer */
866 if(framelen
>= buffersize
- bufferpos
)
867 framelen
= buffersize
- bufferpos
- 1;
869 DEBUGF("id3v2 frame: %.4s\n", header
);
871 /* Check for certain frame headers
873 'size' is the amount of frame bytes remaining. We decrement it by
874 the amount of bytes we read. If we fail to read as many bytes as
875 we expect, we assume that we can't read from this file, and bail
878 For each frame. we will iterate over the list of supported tags,
879 and read the tag into entry's buffer. All tags will be kept as
880 strings, for cases where a number won't do, e.g., YEAR: "circa
881 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
882 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
883 flexible, and as the main use of id3 data is to display it,
884 converting it to an int just means reconverting to display it, at a
887 For tags that the current code does convert to ints, a post
888 processing function will be called via a pointer to function. */
890 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
891 const struct tag_resolver
* tr
= &taglist
[i
];
892 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
897 /* Only ID3_VER_2_2 uses frames with three-character names. */
898 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
899 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
903 /* Note that parser functions sometimes set *ptag to NULL, so
904 * the "!*ptag" check here doesn't always have the desired
905 * effect. Should the parser functions (parsegenre in
906 * particular) be updated to handle the case of being called
907 * multiple times, or should the "*ptag" check be removed?
909 if( (!ptag
|| !*ptag
) && !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
911 /* found a tag matching one in tagList, and not yet filled */
912 tag
= buffer
+ bufferpos
;
914 if(global_unsynch
&& version
<= ID3_VER_2_3
)
915 bytesread
= read_unsynched(fd
, tag
, framelen
);
917 bytesread
= read(fd
, tag
, framelen
);
919 if( bytesread
!= framelen
)
924 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
925 bytesread
= unsynchronize_frame(tag
, bytesread
);
927 /* the COMM frame has a 3 char field to hold an ISO-639-1
928 * language string and an optional short description;
929 * remove them so unicode_munge can work correctly
932 if(!memcmp( header
, "COMM", 4 )) {
933 /* ignore comments with iTunes 7 gapless data */
934 if(!strcmp(tag
+4, "iTunNORM"))
936 comm_offset
= 3 + strlen(tag
+4) + 1;
937 if(bytesread
>comm_offset
) {
938 bytesread
-=comm_offset
;
939 memmove(tag
+1, tag
+comm_offset
+1, bytesread
-1);
943 /* Attempt to parse Unicode string only if the tag contents
946 /* UTF-8 could potentially be 3 times larger */
947 /* so we need to create a new buffer */
948 char utf8buf
[(3 * bytesread
) + 1];
950 unicode_munge( tag
, utf8buf
, &bytesread
);
952 if(bytesread
>= buffersize
- bufferpos
)
953 bytesread
= buffersize
- bufferpos
- 1;
955 for (j
= 0; j
< bytesread
; j
++)
958 /* remove trailing spaces */
959 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
964 bufferpos
+= bytesread
+ 1;
970 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
972 /* Seek to the next frame */
973 if(framelen
< totframelen
)
974 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
979 if( i
== TAGLIST_SIZE
) {
980 /* no tag in tagList was found, or it was a repeat.
981 skip it using the total size */
983 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
984 size
-= skip_unsynched(fd
, totframelen
);
987 totframelen
= data_length_ind
;
990 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
998 * Calculates the size of the ID3v2 tag.
1000 * Arguments: file - the file to search for a tag.
1002 * Returns: the size of the tag or 0 if none was found
1004 int getid3v2len(int fd
)
1009 /* Make sure file has a ID3 tag */
1010 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
1011 (read(fd
, buf
, 6) != 6) ||
1012 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
1015 /* Now check what the ID3v2 size field says */
1017 if(read(fd
, buf
, 4) != 4)
1020 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
1022 DEBUGF("ID3V2 Length: 0x%x\n", offset
);
1027 * Calculates the length (in milliseconds) of an MP3 file.
1029 * Modified to only use integers.
1031 * Arguments: file - the file to calculate the length upon
1032 * entry - the entry to update with the length
1034 * Returns: the song length in milliseconds,
1035 * 0 means that it couldn't be calculated
1037 static int getsonglength(int fd
, struct mp3entry
*entry
)
1039 unsigned long filetime
= 0;
1040 struct mp3info info
;
1043 /* Start searching after ID3v2 header */
1044 if(-1 == lseek(fd
, entry
->id3v2len
, SEEK_SET
))
1047 bytecount
= get_mp3file_info(fd
, &info
);
1049 DEBUGF("Space between ID3V2 tag and first audio frame: 0x%lx bytes\n",
1055 bytecount
+= entry
->id3v2len
;
1057 /* Validate byte count, in case the file has been edited without
1058 * updating the header.
1060 if (info
.byte_count
)
1062 const unsigned long expected
= entry
->filesize
- entry
->id3v1len
1064 const unsigned long diff
= MAX(10240, info
.byte_count
/ 20);
1066 if ((info
.byte_count
> expected
+ diff
)
1067 || (info
.byte_count
< expected
- diff
))
1069 DEBUGF("Note: info.byte_count differs from expected value by "
1070 "%ld bytes\n", labs((long) (expected
- info
.byte_count
)));
1071 info
.byte_count
= 0;
1072 info
.frame_count
= 0;
1074 info
.enc_padding
= 0;
1076 /* Even if the bitrate was based on "known bad" values, it
1077 * should still be better for VBR files than using the bitrate
1078 * of the first audio frame.
1083 entry
->bitrate
= info
.bitrate
;
1084 entry
->frequency
= info
.frequency
;
1085 entry
->version
= info
.version
;
1086 entry
->layer
= info
.layer
;
1087 switch(entry
->layer
) {
1088 #if CONFIG_CODEC==SWCODEC
1090 entry
->codectype
=AFMT_MPA_L1
;
1094 entry
->codectype
=AFMT_MPA_L2
;
1097 entry
->codectype
=AFMT_MPA_L3
;
1101 /* If the file time hasn't been established, this may be a fixed
1102 rate MP3, so just use the default formula */
1104 filetime
= info
.file_time
;
1108 /* Prevent a division by zero */
1109 if (info
.bitrate
< 8)
1112 filetime
= (entry
->filesize
- bytecount
) / (info
.bitrate
/ 8);
1113 /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
1114 * instead of filesize * 8 is exact, because mpeg audio bitrates are
1115 * always multiples of 8, and it avoids overflows. */
1118 entry
->frame_count
= info
.frame_count
;
1120 entry
->vbr
= info
.is_vbr
;
1121 entry
->has_toc
= info
.has_toc
;
1123 #if CONFIG_CODEC==SWCODEC
1124 entry
->lead_trim
= info
.enc_delay
;
1125 entry
->tail_trim
= info
.enc_padding
;
1128 memcpy(entry
->toc
, info
.toc
, sizeof(info
.toc
));
1130 entry
->vbr_header_pos
= info
.vbr_header_pos
;
1132 /* Update the seek point for the first playable frame */
1133 entry
->first_frame_offset
= bytecount
;
1134 DEBUGF("First frame is at %lx\n", entry
->first_frame_offset
);
1140 * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
1141 * about an MP3 file and updates it's entry accordingly.
1143 Note, that this returns true for successful, false for error! */
1144 bool get_mp3_metadata(int fd
, struct mp3entry
*entry
, const char *filename
, bool v1first
)
1146 int v1found
= false;
1148 #if CONFIG_CODEC != SWCODEC
1149 memset(entry
, 0, sizeof(struct mp3entry
));
1152 strncpy(entry
->path
, filename
, sizeof(entry
->path
));
1154 entry
->title
= NULL
;
1155 entry
->filesize
= filesize(fd
);
1156 entry
->id3v2len
= getid3v2len(fd
);
1157 entry
->tracknum
= 0;
1161 v1found
= setid3v1title(fd
, entry
);
1163 if (!v1found
&& entry
->id3v2len
)
1164 setid3v2title(fd
, entry
);
1165 int len
= getsonglength(fd
, entry
);
1168 entry
->length
= len
;
1170 /* Subtract the meta information from the file size to get
1171 the true size of the MP3 stream */
1172 entry
->filesize
-= entry
->first_frame_offset
;
1174 /* only seek to end of file if no id3v2 tags were found,
1175 and we already haven't looked for a v1 tag */
1176 if (!v1first
&& !entry
->id3v2len
) {
1177 setid3v1title(fd
, entry
);
1180 if(!entry
->length
|| (entry
->filesize
< 8 ))
1181 /* no song length or less than 8 bytes is hereby considered to be an
1182 invalid mp3 and won't be played by us! */
1188 /* Note, that this returns false for successful, true for error! */
1189 bool mp3info(struct mp3entry
*entry
, const char *filename
, bool v1first
)
1194 fd
= open(filename
, O_RDONLY
);
1198 result
= !get_mp3_metadata(fd
, entry
, filename
, v1first
);
1205 void adjust_mp3entry(struct mp3entry
*entry
, void *dest
, void *orig
)
1209 offset
= - ((size_t)orig
- (size_t)dest
);
1211 offset
= (size_t)dest
- (size_t)orig
;
1214 entry
->title
+= offset
;
1216 entry
->artist
+= offset
;
1218 entry
->album
+= offset
;
1219 if (entry
->genre_string
)
1220 entry
->genre_string
+= offset
;
1221 if (entry
->track_string
)
1222 entry
->track_string
+= offset
;
1223 if (entry
->disc_string
)
1224 entry
->disc_string
+= offset
;
1225 if (entry
->year_string
)
1226 entry
->year_string
+= offset
;
1227 if (entry
->composer
)
1228 entry
->composer
+= offset
;
1230 entry
->comment
+= offset
;
1231 if (entry
->albumartist
)
1232 entry
->albumartist
+= offset
;
1233 if (entry
->grouping
)
1234 entry
->grouping
+= offset
;
1235 #if CONFIG_CODEC == SWCODEC
1236 if (entry
->track_gain_string
)
1237 entry
->track_gain_string
+= offset
;
1238 if (entry
->album_gain_string
)
1239 entry
->album_gain_string
+= offset
;
1243 void copy_mp3entry(struct mp3entry
*dest
, struct mp3entry
*orig
)
1245 memcpy(dest
, orig
, sizeof(struct mp3entry
));
1246 adjust_mp3entry(dest
, dest
, orig
);
1249 #ifdef DEBUG_STANDALONE
1251 char *secs2str(int ms
)
1253 static char buffer
[32];
1256 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1260 int main(int argc
, char **argv
)
1263 for(i
=1; i
<argc
; i
++) {
1264 struct mp3entry mp3
;
1265 mp3
.album
= "Bogus";
1266 if(mp3info(&mp3
, argv
[i
], false)) {
1267 printf("Failed to get %s\n", argv
[i
]);
1271 printf("****** File: %s\n"
1275 " Genre: %s (%d) \n"
1279 " Length: %s / %d s\n"
1283 mp3
.title
?mp3
.title
:"<blank>",
1284 mp3
.artist
?mp3
.artist
:"<blank>",
1285 mp3
.album
?mp3
.album
:"<blank>",
1286 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1288 mp3
.composer
?mp3
.composer
:"<blank>",
1289 mp3
.year_string
?mp3
.year_string
:"<blank>",
1291 mp3
.track_string
?mp3
.track_string
:"<blank>",
1293 secs2str(mp3
.length
),