1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by Daniel Stenberg
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
22 * Parts of this code has been stolen from the Ample project and was written
23 * by David H�deman. It has since been extended and enhanced pretty much by
24 * all sorts of friendly Rockbox people.
28 /* tagResolver and associated code copyright 2003 Thomas Paul Diffenbach
45 #include "replaygain.h"
46 #include "rbunicode.h"
48 /** Database of audio formats **/
49 const struct afmt_entry audio_formats
[AFMT_NUM_CODECS
] =
51 /* Unknown file format */
53 AFMT_ENTRY("???", NULL
, NULL
, NULL
),
55 /* MPEG Audio layer 1 */
57 AFMT_ENTRY("MP1", "mpa", NULL
, "mp1\0" ),
58 /* MPEG Audio layer 2 */
60 AFMT_ENTRY("MP2", "mpa", NULL
, "mpa\0mp2\0" ),
61 /* MPEG Audio layer 3 */
63 AFMT_ENTRY("MP3", "mpa", "mp3_enc", "mp3\0" ),
65 #if CONFIG_CODEC == SWCODEC
66 /* Audio Interchange File Format */
68 AFMT_ENTRY("AIFF", "aiff", "aiff_enc", "aiff\0aif\0"),
69 /* Uncompressed PCM in a WAV file */
71 AFMT_ENTRY("WAV", "wav", "wav_enc", "wav\0" ),
74 AFMT_ENTRY("Ogg", "vorbis", NULL
, "ogg\0" ),
77 AFMT_ENTRY("FLAC", "flac", NULL
, "flac\0" ),
80 AFMT_ENTRY("MPC", "mpc", NULL
, "mpc\0" ),
81 /* A/52 (aka AC3) audio */
83 AFMT_ENTRY("AC3", "a52", NULL
, "a52\0ac3\0" ),
86 AFMT_ENTRY("WV", "wavpack", "wavpack_enc", "wv\0" ),
87 /* Apple Lossless Audio Codec */
89 AFMT_ENTRY("ALAC", "alac", NULL
, "m4a\0m4b\0" ),
90 /* Advanced Audio Coding in M4A container */
92 AFMT_ENTRY("AAC", "aac", NULL
, "mp4\0" ),
95 AFMT_ENTRY("SHN", "shorten", NULL
, "shn\0" ),
98 AFMT_ENTRY("SID", "sid", NULL
, "sid\0" ),
101 AFMT_ENTRY("ADX", "adx", NULL
, "adx\0" ),
102 /* NESM (NES Sound Format) */
104 AFMT_ENTRY("NSF", "nsf", NULL
, "nsf\0nsfe\0" ),
105 /* Speex File Format */
107 AFMT_ENTRY("Speex","speex", NULL
, "spx\0" ),
108 /* SPC700 Save State */
110 AFMT_ENTRY("SPC", "spc", NULL
, "spc\0" ),
111 /* APE (Monkey's Audio) */
113 AFMT_ENTRY("APE", "ape", NULL
, "ape\0mac\0" ),
114 /* WMA (WMAV1/V2 in ASF) */
116 AFMT_ENTRY("WMA", "wma", NULL
, "wma\0wmv\0asf\0" ),
119 AFMT_ENTRY("MOD", "mod", NULL
, "mod\0" ),
122 AFMT_ENTRY("SAP", "asap", NULL
, "sap\0" ),
126 #if CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING)
127 /* get REC_FORMAT_* corresponding AFMT_* */
128 const int rec_format_afmt
[REC_NUM_FORMATS
] =
130 /* give AFMT_UNKNOWN by default */
131 [0 ... REC_NUM_FORMATS
-1] = AFMT_UNKNOWN
,
132 /* add new entries below this line */
133 [REC_FORMAT_AIFF
] = AFMT_AIFF
,
134 [REC_FORMAT_MPA_L3
] = AFMT_MPA_L3
,
135 [REC_FORMAT_WAVPACK
] = AFMT_WAVPACK
,
136 [REC_FORMAT_PCM_WAV
] = AFMT_PCM_WAV
,
139 /* get AFMT_* corresponding REC_FORMAT_* */
140 const int afmt_rec_format
[AFMT_NUM_CODECS
] =
142 /* give -1 by default */
143 [0 ... AFMT_NUM_CODECS
-1] = -1,
144 /* add new entries below this line */
145 [AFMT_AIFF
] = REC_FORMAT_AIFF
,
146 [AFMT_MPA_L3
] = REC_FORMAT_MPA_L3
,
147 [AFMT_WAVPACK
] = REC_FORMAT_WAVPACK
,
148 [AFMT_PCM_WAV
] = REC_FORMAT_PCM_WAV
,
150 #endif /* CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING) */
153 static unsigned long unsync(unsigned long b0
,
158 return (((long)(b0
& 0x7F) << (3*7)) |
159 ((long)(b1
& 0x7F) << (2*7)) |
160 ((long)(b2
& 0x7F) << (1*7)) |
161 ((long)(b3
& 0x7F) << (0*7)));
164 static const char* const genres
[] = {
165 "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
166 "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
167 "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
168 "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
169 "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
170 "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
171 "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
172 "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
173 "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
174 "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
175 "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
176 "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
177 "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
179 /* winamp extensions */
180 "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
181 "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
182 "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
183 "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
184 "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
185 "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
186 "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
187 "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
188 "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
189 "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
190 "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
191 "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
195 char* id3_get_num_genre(unsigned int genre_num
)
197 if (genre_num
< sizeof(genres
)/sizeof(char*))
198 return (char*)genres
[genre_num
];
202 /* True if the string is from the "genres" array */
203 static bool id3_is_genre_string(const char *string
)
205 return ( string
>= genres
[0] &&
206 string
<= genres
[sizeof(genres
)/sizeof(char*) - 1] );
210 HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
211 Code and comments by Thomas Paul Diffenbach
213 To add another ID3v2 Tag, do the following:
214 1. add a char* named for the tag to struct mp3entry in id3.h,
215 (I (tpd) prefer to use char* rather than ints, even for what seems like
216 numerical values, for cases where a number won't do, e.g.,
217 YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
218 TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
219 Text is more flexible, and as the main use of id3 data is to
220 display it, converting it to an int just means reconverting to
221 display it, at a runtime cost.)
223 2. If any special processing beyond copying the tag value from the Id3
224 block to the struct mp3entry is rrequired (such as converting to an
225 int), write a function to perform this special processing.
227 This function's prototype must match that of
228 typedef tagPostProcessFunc, that is it must be:
229 int func( struct mp3entry*, char* tag, int bufferpos )
230 the first argument is a pointer to the current mp3entry structure the
231 second argument is a pointer to the null terminated string value of the
232 tag found the third argument is the offset of the next free byte in the
233 mp3entry's buffer your function should return the corrected offset; if
234 you don't lengthen or shorten the tag string, you can return the third
237 Unless you have a good reason no to, make the function static.
238 TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
240 3. add one or more entries to the tagList array, using the format:
241 char* ID3 Tag symbolic name -- see the ID3 specification for these,
242 sizeof() that name minus 1,
243 offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
244 pointer to your special processing function or NULL
245 if you need no special processing
246 flag indicating if this tag is binary or textual
247 Many ID3 symbolic names come in more than one form. You can add both
248 forms, each referencing the same variable in struct mp3entry.
249 If both forms are present, the last found will be used.
250 Note that the offset can be zero, in which case no entry will be set
251 in the mp3entry struct; the frame is still read into the buffer and
252 the special processing function is called (several times, if there
253 are several frames with the same name).
255 4. Alternately, use the TAG_LIST_ENTRY macro with
256 ID3 tag symbolic name,
257 variable in struct mp3entry,
258 special processing function address
260 5. Add code to wps-display.c function get_tag to assign a printf-like
261 format specifier for the tag */
263 /* Structure for ID3 Tag extraction information */
264 struct tag_resolver
{
268 int (*ppFunc
)(struct mp3entry
*, char* tag
, int bufferpos
);
272 static bool global_ff_found
;
274 static int unsynchronize(char* tag
, int len
, bool *ff_found
)
278 unsigned char *rp
, *wp
;
280 wp
= rp
= (unsigned char *)tag
;
282 rp
= (unsigned char *)tag
;
283 for(i
= 0;i
< len
;i
++) {
284 /* Read the next byte and write it back, but don't increment the
289 /* Increment the write pointer if it isn't an unsynch pattern */
299 return (long)wp
- (long)tag
;
302 static int unsynchronize_frame(char* tag
, int len
)
304 bool ff_found
= false;
306 return unsynchronize(tag
, len
, &ff_found
);
309 static int read_unsynched(int fd
, void *buf
, int len
)
321 rc
= read(fd
, rp
, remaining
);
325 i
= unsynchronize(wp
, remaining
, &global_ff_found
);
333 static int skip_unsynched(int fd
, int len
)
341 rlen
= MIN(sizeof(buf
), (unsigned int)remaining
);
342 rc
= read(fd
, buf
, rlen
);
346 remaining
-= unsynchronize(buf
, rlen
, &global_ff_found
);
352 /* parse numeric value from string */
353 static int parsetracknum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
355 entry
->tracknum
= atoi( tag
);
359 /* parse numeric value from string */
360 static int parsediscnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
362 entry
->discnum
= atoi( tag
);
366 /* parse numeric value from string */
367 static int parseyearnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
369 entry
->year
= atoi( tag
);
373 /* parse numeric genre from string, version 2.2 and 2.3 */
374 static int parsegenre( struct mp3entry
* entry
, char* tag
, int bufferpos
)
376 if(entry
->id3version
>= ID3_VER_2_4
) {
377 /* In version 2.4 and up, there are no parentheses, and the genre frame
378 is a list of strings, either numbers or text. */
380 /* Is it a number? */
381 if(isdigit(tag
[0])) {
382 entry
->genre_string
= id3_get_num_genre(atoi( tag
));
383 return tag
- entry
->id3v2buf
;
385 entry
->genre_string
= tag
;
389 if( tag
[0] == '(' && tag
[1] != '(' ) {
390 entry
->genre_string
= id3_get_num_genre(atoi( tag
+ 1 ));
391 return tag
- entry
->id3v2buf
;
394 entry
->genre_string
= tag
;
400 #if CONFIG_CODEC == SWCODEC
401 /* parse user defined text, looking for replaygain information. */
402 static int parseuser( struct mp3entry
* entry
, char* tag
, int bufferpos
)
405 int desc_len
= strlen(tag
);
408 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
409 /* At least part of the value was read, so we can safely try to
412 value
= tag
+ desc_len
+ 1;
413 value_len
= parse_replaygain(tag
, value
, entry
, tag
,
414 bufferpos
- (tag
- entry
->id3v2buf
));
417 return tag
- entry
->id3v2buf
+ value_len
;
420 /* parse RVA2 binary data and convert to replaygain information. */
421 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
423 int desc_len
= strlen(tag
);
424 int start_pos
= tag
- entry
->id3v2buf
;
425 int end_pos
= start_pos
+ desc_len
+ 5;
427 unsigned char* value
= tag
+ desc_len
+ 1;
429 /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
430 * type is master volume.
432 if (entry
->id3version
== ID3_VER_2_4
&& end_pos
< bufferpos
440 /* The RVA2 specification is unclear on some things (id string and
441 * peak volume), but this matches how Quod Libet use them.
444 gain
= (int16_t) ((value
[0] << 8) | value
[1]);
447 peakbytes
= (peakbits
+ 7) / 8;
449 /* Only use the topmost 24 bits for peak volume */
454 /* Make sure the peak bits were read */
455 if (end_pos
+ peakbytes
< bufferpos
) {
456 long shift
= ((8 - (peakbits
& 7)) & 7) + (3 - peakbytes
) * 8;
458 for ( ; peakbytes
; peakbytes
--) {
466 peak
+= *value
>> (8 - shift
);
470 if (strcasecmp(tag
, "album") == 0) {
472 } else if (strcasecmp(tag
, "track") != 0) {
473 /* Only accept non-track values if we don't have any previous
476 if (entry
->track_gain
!= 0) {
481 value_len
= parse_replaygain_int(album
, gain
, peak
* 2, entry
,
482 tag
, sizeof(entry
->id3v2buf
) - start_pos
);
485 return start_pos
+ value_len
;
489 static const struct tag_resolver taglist
[] = {
490 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
491 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
492 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
493 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
494 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
495 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
496 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
497 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
498 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
499 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
500 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
501 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
502 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
503 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
504 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
505 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
506 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
507 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
508 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
509 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
510 #if CONFIG_CODEC == SWCODEC
511 { "TXXX", 4, 0, &parseuser
, false },
512 { "RVA2", 4, 0, &parserva2
, true },
516 #define TAGLIST_SIZE ((int)(sizeof(taglist) / sizeof(taglist[0])))
518 /* Get the length of an ID3 string in the given encoding. Returns the length
519 * in bytes, including end nil, or -1 if the encoding is unknown.
521 static int unicode_len(char encoding
, const void* string
)
525 if (encoding
== 0x01 || encoding
== 0x02) {
527 const char *s
= string
;
528 /* string might be unaligned, so using short* can crash on ARM and SH1 */
531 } while ((first
| *s
++) != 0);
533 len
= s
- (const char*) string
;
535 len
= strlen((char*) string
) + 1;
541 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
542 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
543 we convert from the default codepage */
544 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
548 unsigned char *str
= (unsigned char *)string
;
550 unsigned char* utf8
= (unsigned char *)utf8buf
;
553 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
556 utf8
= iso_decode(str
, utf8
, -1, *len
);
558 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
561 case 0x01: /* Unicode with or without BOM */
566 /* Handle frames with more than one string
567 (needed for TXXX frames).*/
569 tmp
= bytes2int(0, 0, str
[0], str
[1]);
571 /* Now check if there is a BOM
572 (zero-width non-breaking space, 0xfeff)
573 and if it is in little or big endian format */
574 if(tmp
== 0xfffe) { /* Little endian? */
578 } else if(tmp
== 0xfeff) { /* Big endian? */
582 /* If there is no BOM (which is a specification violation),
583 let's try to guess it. If one of the bytes is 0x00, it is
584 probably the most significant one. */
590 utf8
= utf16LEdecode(str
, utf8
, 1);
592 utf8
= utf16BEdecode(str
, utf8
, 1);
596 } while((str
[0] || str
[1]) && (i
< *len
));
598 *utf8
++ = 0; /* Terminate the string */
599 templen
+= (strlen(&utf8buf
[templen
]) + 1);
606 case 0x03: /* UTF-8 encoded string */
607 for(i
=0; i
< *len
; i
++)
612 default: /* Plain old string */
613 utf8
= iso_decode(str
, utf8
, -1, *len
);
615 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
622 * Sets the title of an MP3 entry based on its ID3v1 tag.
624 * Arguments: file - the MP3 file to scen for a ID3v1 tag
625 * entry - the entry to set the title in
627 * Returns: true if a title was found and created, else false
629 static bool setid3v1title(int fd
, struct mp3entry
*entry
)
631 unsigned char buffer
[128];
632 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
636 if (-1 == lseek(fd
, -128, SEEK_END
))
639 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
642 if (strncmp((char *)buffer
, "TAG", 3))
645 entry
->id3v1len
= 128;
646 entry
->id3version
= ID3_VER_1_0
;
648 for (i
=0; i
< (int)sizeof offsets
; i
++) {
649 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
655 /* kill trailing space in strings */
656 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
658 /* convert string to utf8 */
659 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
660 utf8
= iso_decode(ptr
, utf8
, -1, 30);
661 /* make sure string is terminated */
666 /* kill trailing space in strings */
667 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
669 /* convert string to utf8 */
670 utf8
= (unsigned char *)entry
->id3v1buf
[3];
671 utf8
= iso_decode(ptr
, utf8
, -1, 28);
672 /* make sure string is terminated */
678 entry
->year
= atoi((char *)ptr
);
682 /* id3v1.1 uses last two bytes of comment field for track
683 number: first must be 0 and second is track num */
684 if (!ptr
[0] && ptr
[1]) {
685 entry
->tracknum
= ptr
[1];
686 entry
->id3version
= ID3_VER_1_1
;
692 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
697 entry
->title
= entry
->id3v1buf
[0];
698 entry
->artist
= entry
->id3v1buf
[1];
699 entry
->album
= entry
->id3v1buf
[2];
700 entry
->comment
= entry
->id3v1buf
[3];
707 * Sets the title of an MP3 entry based on its ID3v2 tag.
709 * Arguments: file - the MP3 file to scan for a ID3v2 tag
710 * entry - the entry to set the title in
712 * Returns: true if a title was found and created, else false
714 static void setid3v2title(int fd
, struct mp3entry
*entry
)
718 long bufferpos
= 0, totframelen
, framelen
;
721 unsigned char version
;
722 char *buffer
= entry
->id3v2buf
;
724 int buffersize
= sizeof(entry
->id3v2buf
);
725 unsigned char global_flags
;
728 bool global_unsynch
= false;
729 bool unsynch
= false;
734 global_ff_found
= false;
736 /* Bail out if the tag is shorter than 10 bytes */
737 if(entry
->id3v2len
< 10)
740 /* Read the ID3 tag version from the header */
741 lseek(fd
, 0, SEEK_SET
);
742 if(10 != read(fd
, header
, 10))
745 /* Get the total ID3 tag size */
746 size
= entry
->id3v2len
- 10;
751 version
= ID3_VER_2_2
;
756 version
= ID3_VER_2_3
;
761 version
= ID3_VER_2_4
;
766 /* unsupported id3 version */
769 entry
->id3version
= version
;
770 entry
->tracknum
= entry
->year
= entry
->discnum
= 0;
771 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
773 global_flags
= header
[5];
775 /* Skip the extended header if it is present */
776 if(global_flags
& 0x40) {
777 if(version
== ID3_VER_2_3
) {
778 if(10 != read(fd
, header
, 10))
780 /* The 2.3 extended header size doesn't include the header size
781 field itself. Also, it is not unsynched. */
783 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
785 /* Skip the rest of the header */
786 lseek(fd
, framelen
- 10, SEEK_CUR
);
789 if(version
>= ID3_VER_2_4
) {
790 if(4 != read(fd
, header
, 4))
793 /* The 2.4 extended header size does include the entire header,
794 so here we can just skip it. This header is unsynched. */
795 framelen
= unsync(header
[0], header
[1],
796 header
[2], header
[3]);
798 lseek(fd
, framelen
- 4, SEEK_CUR
);
802 /* Is unsynchronization applied? */
803 if(global_flags
& 0x80) {
804 global_unsynch
= true;
808 * We must have at least minframesize bytes left for the
809 * remaining frames to be interesting
811 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
814 /* Read frame header and check length */
815 if(version
>= ID3_VER_2_3
) {
816 if(global_unsynch
&& version
<= ID3_VER_2_3
)
817 rc
= read_unsynched(fd
, header
, 10);
819 rc
= read(fd
, header
, 10);
822 /* Adjust for the 10 bytes we read */
825 flags
= bytes2int(0, 0, header
[8], header
[9]);
827 if (version
>= ID3_VER_2_4
) {
828 framelen
= unsync(header
[4], header
[5],
829 header
[6], header
[7]);
831 /* version .3 files don't use synchsafe ints for
833 framelen
= bytes2int(header
[4], header
[5],
834 header
[6], header
[7]);
837 if(6 != read(fd
, header
, 6))
839 /* Adjust for the 6 bytes we read */
842 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
845 logf("framelen = %ld", framelen
);
847 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
860 if (version
>= ID3_VER_2_4
) {
861 if(flags
& 0x0040) { /* Grouping identity */
862 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
866 if(flags
& 0x0020) { /* Grouping identity */
867 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
872 if(flags
& 0x000c) /* Compression or encryption */
876 lseek(fd
, framelen
, SEEK_CUR
);
880 if(flags
& 0x0002) /* Unsynchronization */
883 if (version
>= ID3_VER_2_4
) {
884 if(flags
& 0x0001) { /* Data length indicator */
885 if(4 != read(fd
, tmp
, 4))
888 data_length_ind
= unsync(tmp
[0], tmp
[1], tmp
[2], tmp
[3]);
894 /* Keep track of the remaining frame size */
895 totframelen
= framelen
;
897 /* If the frame is larger than the remaining buffer space we try
898 to read as much as would fit in the buffer */
899 if(framelen
>= buffersize
- bufferpos
)
900 framelen
= buffersize
- bufferpos
- 1;
902 logf("id3v2 frame: %.4s", header
);
904 /* Check for certain frame headers
906 'size' is the amount of frame bytes remaining. We decrement it by
907 the amount of bytes we read. If we fail to read as many bytes as
908 we expect, we assume that we can't read from this file, and bail
911 For each frame. we will iterate over the list of supported tags,
912 and read the tag into entry's buffer. All tags will be kept as
913 strings, for cases where a number won't do, e.g., YEAR: "circa
914 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
915 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
916 flexible, and as the main use of id3 data is to display it,
917 converting it to an int just means reconverting to display it, at a
920 For tags that the current code does convert to ints, a post
921 processing function will be called via a pointer to function. */
923 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
924 const struct tag_resolver
* tr
= &taglist
[i
];
925 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
929 /* Only ID3_VER_2_2 uses frames with three-character names. */
930 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
931 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
935 /* Note that parser functions sometimes set *ptag to NULL, so
936 * the "!*ptag" check here doesn't always have the desired
937 * effect. Should the parser functions (parsegenre in
938 * particular) be updated to handle the case of being called
939 * multiple times, or should the "*ptag" check be removed?
941 if( (!ptag
|| !*ptag
) && !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
943 /* found a tag matching one in tagList, and not yet filled */
944 tag
= buffer
+ bufferpos
;
946 if(global_unsynch
&& version
<= ID3_VER_2_3
)
947 bytesread
= read_unsynched(fd
, tag
, framelen
);
949 bytesread
= read(fd
, tag
, framelen
);
951 if( bytesread
!= framelen
)
956 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
957 bytesread
= unsynchronize_frame(tag
, bytesread
);
959 /* the COMM frame has a 3 char field to hold an ISO-639-1
960 * language string and an optional short description;
961 * remove them so unicode_munge can work correctly
964 if(!memcmp( header
, "COMM", 4 )) {
966 /* ignore comments with iTunes 7 soundcheck/gapless data */
967 if(!strncmp(tag
+4, "iTun", 4))
969 offset
= 3 + unicode_len(*tag
, tag
+ 4);
970 if(bytesread
> offset
) {
972 memmove(tag
+ 1, tag
+ 1 + offset
, bytesread
- 1);
976 /* Attempt to parse Unicode string only if the tag contents
979 /* UTF-8 could potentially be 3 times larger */
980 /* so we need to create a new buffer */
981 char utf8buf
[(3 * bytesread
) + 1];
983 unicode_munge( tag
, utf8buf
, &bytesread
);
985 if(bytesread
>= buffersize
- bufferpos
)
986 bytesread
= buffersize
- bufferpos
- 1;
988 for (j
= 0; j
< bytesread
; j
++)
991 /* remove trailing spaces */
992 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
997 bufferpos
+= bytesread
+ 1;
1003 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
1005 /* Seek to the next frame */
1006 if(framelen
< totframelen
)
1007 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
1012 if( i
== TAGLIST_SIZE
) {
1013 /* no tag in tagList was found, or it was a repeat.
1014 skip it using the total size */
1016 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
1017 size
-= skip_unsynched(fd
, totframelen
);
1020 totframelen
= data_length_ind
;
1022 size
-= totframelen
;
1023 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
1031 * Calculates the size of the ID3v2 tag.
1033 * Arguments: file - the file to search for a tag.
1035 * Returns: the size of the tag or 0 if none was found
1037 int getid3v2len(int fd
)
1042 /* Make sure file has a ID3 tag */
1043 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
1044 (read(fd
, buf
, 6) != 6) ||
1045 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
1048 /* Now check what the ID3v2 size field says */
1050 if(read(fd
, buf
, 4) != 4)
1053 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
1055 logf("ID3V2 Length: 0x%x", offset
);
1060 * Calculates the length (in milliseconds) of an MP3 file.
1062 * Modified to only use integers.
1064 * Arguments: file - the file to calculate the length upon
1065 * entry - the entry to update with the length
1067 * Returns: the song length in milliseconds,
1068 * 0 means that it couldn't be calculated
1070 static int getsonglength(int fd
, struct mp3entry
*entry
)
1072 unsigned long filetime
= 0;
1073 struct mp3info info
;
1076 /* Start searching after ID3v2 header */
1077 if(-1 == lseek(fd
, entry
->id3v2len
, SEEK_SET
))
1080 bytecount
= get_mp3file_info(fd
, &info
);
1082 logf("Space between ID3V2 tag and first audio frame: 0x%lx bytes",
1088 bytecount
+= entry
->id3v2len
;
1090 /* Validate byte count, in case the file has been edited without
1091 * updating the header.
1093 if (info
.byte_count
)
1095 const unsigned long expected
= entry
->filesize
- entry
->id3v1len
1097 const unsigned long diff
= MAX(10240, info
.byte_count
/ 20);
1099 if ((info
.byte_count
> expected
+ diff
)
1100 || (info
.byte_count
< expected
- diff
))
1102 logf("Note: info.byte_count differs from expected value by "
1103 "%ld bytes", labs((long) (expected
- info
.byte_count
)));
1104 info
.byte_count
= 0;
1105 info
.frame_count
= 0;
1107 info
.enc_padding
= 0;
1109 /* Even if the bitrate was based on "known bad" values, it
1110 * should still be better for VBR files than using the bitrate
1111 * of the first audio frame.
1116 entry
->bitrate
= info
.bitrate
;
1117 entry
->frequency
= info
.frequency
;
1118 entry
->version
= info
.version
;
1119 entry
->layer
= info
.layer
;
1120 switch(entry
->layer
) {
1121 #if CONFIG_CODEC==SWCODEC
1123 entry
->codectype
=AFMT_MPA_L1
;
1127 entry
->codectype
=AFMT_MPA_L2
;
1130 entry
->codectype
=AFMT_MPA_L3
;
1134 /* If the file time hasn't been established, this may be a fixed
1135 rate MP3, so just use the default formula */
1137 filetime
= info
.file_time
;
1141 /* Prevent a division by zero */
1142 if (info
.bitrate
< 8)
1145 filetime
= (entry
->filesize
- bytecount
) / (info
.bitrate
/ 8);
1146 /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
1147 * instead of filesize * 8 is exact, because mpeg audio bitrates are
1148 * always multiples of 8, and it avoids overflows. */
1151 entry
->frame_count
= info
.frame_count
;
1153 entry
->vbr
= info
.is_vbr
;
1154 entry
->has_toc
= info
.has_toc
;
1156 #if CONFIG_CODEC==SWCODEC
1157 entry
->lead_trim
= info
.enc_delay
;
1158 entry
->tail_trim
= info
.enc_padding
;
1161 memcpy(entry
->toc
, info
.toc
, sizeof(info
.toc
));
1163 entry
->vbr_header_pos
= info
.vbr_header_pos
;
1165 /* Update the seek point for the first playable frame */
1166 entry
->first_frame_offset
= bytecount
;
1167 logf("First frame is at %lx", entry
->first_frame_offset
);
1173 * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
1174 * about an MP3 file and updates it's entry accordingly.
1176 Note, that this returns true for successful, false for error! */
1177 bool get_mp3_metadata(int fd
, struct mp3entry
*entry
, const char *filename
)
1179 #if CONFIG_CODEC != SWCODEC
1180 memset(entry
, 0, sizeof(struct mp3entry
));
1183 strncpy(entry
->path
, filename
, sizeof(entry
->path
));
1185 entry
->title
= NULL
;
1186 entry
->filesize
= filesize(fd
);
1187 entry
->id3v2len
= getid3v2len(fd
);
1188 entry
->tracknum
= 0;
1191 if (entry
->id3v2len
)
1192 setid3v2title(fd
, entry
);
1193 int len
= getsonglength(fd
, entry
);
1196 entry
->length
= len
;
1198 /* Subtract the meta information from the file size to get
1199 the true size of the MP3 stream */
1200 entry
->filesize
-= entry
->first_frame_offset
;
1202 /* only seek to end of file if no id3v2 tags were found */
1203 if (!entry
->id3v2len
) {
1204 setid3v1title(fd
, entry
);
1207 if(!entry
->length
|| (entry
->filesize
< 8 ))
1208 /* no song length or less than 8 bytes is hereby considered to be an
1209 invalid mp3 and won't be played by us! */
1215 /* Note, that this returns false for successful, true for error! */
1216 bool mp3info(struct mp3entry
*entry
, const char *filename
)
1221 fd
= open(filename
, O_RDONLY
);
1225 result
= !get_mp3_metadata(fd
, entry
, filename
);
1232 void adjust_mp3entry(struct mp3entry
*entry
, void *dest
, const void *orig
)
1236 offset
= - ((size_t)orig
- (size_t)dest
);
1238 offset
= (size_t)dest
- (size_t)orig
;
1241 entry
->title
+= offset
;
1243 entry
->artist
+= offset
;
1245 entry
->album
+= offset
;
1246 if (entry
->genre_string
&& !id3_is_genre_string(entry
->genre_string
))
1247 /* Don't adjust that if it points to an entry of the "genres" array */
1248 entry
->genre_string
+= offset
;
1249 if (entry
->track_string
)
1250 entry
->track_string
+= offset
;
1251 if (entry
->disc_string
)
1252 entry
->disc_string
+= offset
;
1253 if (entry
->year_string
)
1254 entry
->year_string
+= offset
;
1255 if (entry
->composer
)
1256 entry
->composer
+= offset
;
1258 entry
->comment
+= offset
;
1259 if (entry
->albumartist
)
1260 entry
->albumartist
+= offset
;
1261 if (entry
->grouping
)
1262 entry
->grouping
+= offset
;
1263 #if CONFIG_CODEC == SWCODEC
1264 if (entry
->track_gain_string
)
1265 entry
->track_gain_string
+= offset
;
1266 if (entry
->album_gain_string
)
1267 entry
->album_gain_string
+= offset
;
1271 void copy_mp3entry(struct mp3entry
*dest
, const struct mp3entry
*orig
)
1273 memcpy(dest
, orig
, sizeof(struct mp3entry
));
1274 adjust_mp3entry(dest
, dest
, orig
);
1277 #ifdef DEBUG_STANDALONE
1279 char *secs2str(int ms
)
1281 static char buffer
[32];
1284 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1288 int main(int argc
, char **argv
)
1291 for(i
=1; i
<argc
; i
++) {
1292 struct mp3entry mp3
;
1293 mp3
.album
= "Bogus";
1294 if(mp3info(&mp3
, argv
[i
], false)) {
1295 printf("Failed to get %s\n", argv
[i
]);
1299 printf("****** File: %s\n"
1303 " Genre: %s (%d) \n"
1307 " Length: %s / %d s\n"
1311 mp3
.title
?mp3
.title
:"<blank>",
1312 mp3
.artist
?mp3
.artist
:"<blank>",
1313 mp3
.album
?mp3
.album
:"<blank>",
1314 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1316 mp3
.composer
?mp3
.composer
:"<blank>",
1317 mp3
.year_string
?mp3
.year_string
:"<blank>",
1319 mp3
.track_string
?mp3
.track_string
:"<blank>",
1321 secs2str(mp3
.length
),