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
43 #include "replaygain.h"
44 #include "rbunicode.h"
46 /** Database of audio formats **/
47 const struct afmt_entry audio_formats
[AFMT_NUM_CODECS
] =
49 /* Unknown file format */
51 AFMT_ENTRY("???", NULL
, NULL
, NULL
),
53 /* MPEG Audio layer 1 */
55 AFMT_ENTRY("MP1", "mpa", NULL
, "mp1\0" ),
56 /* MPEG Audio layer 2 */
58 AFMT_ENTRY("MP2", "mpa", NULL
, "mpa\0mp2\0" ),
59 /* MPEG Audio layer 3 */
61 AFMT_ENTRY("MP3", "mpa", "mp3_enc", "mp3\0" ),
63 #if CONFIG_CODEC == SWCODEC
64 /* Audio Interchange File Format */
66 AFMT_ENTRY("AIFF", "aiff", "aiff_enc", "aiff\0aif\0"),
67 /* Uncompressed PCM in a WAV file */
69 AFMT_ENTRY("WAV", "wav", "wav_enc", "wav\0" ),
72 AFMT_ENTRY("Ogg", "vorbis", NULL
, "ogg\0" ),
75 AFMT_ENTRY("FLAC", "flac", NULL
, "flac\0" ),
78 AFMT_ENTRY("MPC", "mpc", NULL
, "mpc\0" ),
79 /* A/52 (aka AC3) audio */
81 AFMT_ENTRY("AC3", "a52", NULL
, "a52\0ac3\0" ),
84 AFMT_ENTRY("WV", "wavpack", "wavpack_enc", "wv\0" ),
85 /* Apple Lossless Audio Codec */
87 AFMT_ENTRY("ALAC", "alac", NULL
, "m4a\0m4b\0" ),
88 /* Advanced Audio Coding in M4A container */
90 AFMT_ENTRY("AAC", "aac", NULL
, "mp4\0" ),
93 AFMT_ENTRY("SHN", "shorten", NULL
, "shn\0" ),
96 AFMT_ENTRY("SID", "sid", NULL
, "sid\0" ),
99 AFMT_ENTRY("ADX", "adx", NULL
, "adx\0" ),
100 /* NESM (NES Sound Format) */
102 AFMT_ENTRY("NSF", "nsf", NULL
, "nsf\0nsfe\0" ),
103 /* Speex File Format */
105 AFMT_ENTRY("Speex","speex", NULL
, "spx\0" ),
106 /* SPC700 Save State */
108 AFMT_ENTRY("SPC", "spc", NULL
, "spc\0" ),
109 /* APE (Monkey's Audio) */
111 AFMT_ENTRY("APE", "ape", NULL
, "ape\0mac\0" ),
112 /* WMA (WMAV1/V2 in ASF) */
114 AFMT_ENTRY("WMA", "wma", NULL
, "wma\0wmv\0asf\0" ),
118 #if CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING)
119 /* get REC_FORMAT_* corresponding AFMT_* */
120 const int rec_format_afmt
[REC_NUM_FORMATS
] =
122 /* give AFMT_UNKNOWN by default */
123 [0 ... REC_NUM_FORMATS
-1] = AFMT_UNKNOWN
,
124 /* add new entries below this line */
125 [REC_FORMAT_AIFF
] = AFMT_AIFF
,
126 [REC_FORMAT_MPA_L3
] = AFMT_MPA_L3
,
127 [REC_FORMAT_WAVPACK
] = AFMT_WAVPACK
,
128 [REC_FORMAT_PCM_WAV
] = AFMT_PCM_WAV
,
131 /* get AFMT_* corresponding REC_FORMAT_* */
132 const int afmt_rec_format
[AFMT_NUM_CODECS
] =
134 /* give -1 by default */
135 [0 ... AFMT_NUM_CODECS
-1] = -1,
136 /* add new entries below this line */
137 [AFMT_AIFF
] = REC_FORMAT_AIFF
,
138 [AFMT_MPA_L3
] = REC_FORMAT_MPA_L3
,
139 [AFMT_WAVPACK
] = REC_FORMAT_WAVPACK
,
140 [AFMT_PCM_WAV
] = REC_FORMAT_PCM_WAV
,
142 #endif /* CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING) */
145 static unsigned long unsync(unsigned long b0
,
150 return (((long)(b0
& 0x7F) << (3*7)) |
151 ((long)(b1
& 0x7F) << (2*7)) |
152 ((long)(b2
& 0x7F) << (1*7)) |
153 ((long)(b3
& 0x7F) << (0*7)));
156 static const char* const genres
[] = {
157 "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
158 "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
159 "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
160 "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
161 "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
162 "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
163 "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
164 "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
165 "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
166 "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
167 "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
168 "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
169 "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
171 /* winamp extensions */
172 "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
173 "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
174 "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
175 "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
176 "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
177 "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
178 "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
179 "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
180 "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
181 "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
182 "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
183 "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
187 char* id3_get_num_genre(unsigned int genre_num
)
189 if (genre_num
< sizeof(genres
)/sizeof(char*))
190 return (char*)genres
[genre_num
];
194 /* True if the string is from the "genres" array */
195 static bool id3_is_genre_string(const char *string
)
197 return ( string
>= genres
[0] &&
198 string
<= genres
[sizeof(genres
)/sizeof(char*) - 1] );
202 HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
203 Code and comments by Thomas Paul Diffenbach
205 To add another ID3v2 Tag, do the following:
206 1. add a char* named for the tag to struct mp3entry in id3.h,
207 (I (tpd) prefer to use char* rather than ints, even for what seems like
208 numerical values, for cases where a number won't do, e.g.,
209 YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
210 TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
211 Text is more flexible, and as the main use of id3 data is to
212 display it, converting it to an int just means reconverting to
213 display it, at a runtime cost.)
215 2. If any special processing beyond copying the tag value from the Id3
216 block to the struct mp3entry is rrequired (such as converting to an
217 int), write a function to perform this special processing.
219 This function's prototype must match that of
220 typedef tagPostProcessFunc, that is it must be:
221 int func( struct mp3entry*, char* tag, int bufferpos )
222 the first argument is a pointer to the current mp3entry structure the
223 second argument is a pointer to the null terminated string value of the
224 tag found the third argument is the offset of the next free byte in the
225 mp3entry's buffer your function should return the corrected offset; if
226 you don't lengthen or shorten the tag string, you can return the third
229 Unless you have a good reason no to, make the function static.
230 TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
232 3. add one or more entries to the tagList array, using the format:
233 char* ID3 Tag symbolic name -- see the ID3 specification for these,
234 sizeof() that name minus 1,
235 offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
236 pointer to your special processing function or NULL
237 if you need no special processing
238 flag indicating if this tag is binary or textual
239 Many ID3 symbolic names come in more than one form. You can add both
240 forms, each referencing the same variable in struct mp3entry.
241 If both forms are present, the last found will be used.
242 Note that the offset can be zero, in which case no entry will be set
243 in the mp3entry struct; the frame is still read into the buffer and
244 the special processing function is called (several times, if there
245 are several frames with the same name).
247 4. Alternately, use the TAG_LIST_ENTRY macro with
248 ID3 tag symbolic name,
249 variable in struct mp3entry,
250 special processing function address
252 5. Add code to wps-display.c function get_tag to assign a printf-like
253 format specifier for the tag */
255 /* Structure for ID3 Tag extraction information */
256 struct tag_resolver
{
260 int (*ppFunc
)(struct mp3entry
*, char* tag
, int bufferpos
);
264 static bool global_ff_found
;
266 static int unsynchronize(char* tag
, int len
, bool *ff_found
)
270 unsigned char *rp
, *wp
;
272 wp
= rp
= (unsigned char *)tag
;
274 rp
= (unsigned char *)tag
;
275 for(i
= 0;i
< len
;i
++) {
276 /* Read the next byte and write it back, but don't increment the
281 /* Increment the write pointer if it isn't an unsynch pattern */
291 return (long)wp
- (long)tag
;
294 static int unsynchronize_frame(char* tag
, int len
)
296 bool ff_found
= false;
298 return unsynchronize(tag
, len
, &ff_found
);
301 static int read_unsynched(int fd
, void *buf
, int len
)
313 rc
= read(fd
, rp
, remaining
);
317 i
= unsynchronize(wp
, remaining
, &global_ff_found
);
325 static int skip_unsynched(int fd
, int len
)
333 rlen
= MIN(sizeof(buf
), (unsigned int)remaining
);
334 rc
= read(fd
, buf
, rlen
);
338 remaining
-= unsynchronize(buf
, rlen
, &global_ff_found
);
344 /* parse numeric value from string */
345 static int parsetracknum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
347 entry
->tracknum
= atoi( tag
);
351 /* parse numeric value from string */
352 static int parsediscnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
354 entry
->discnum
= atoi( tag
);
358 /* parse numeric value from string */
359 static int parseyearnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
361 entry
->year
= atoi( tag
);
365 /* parse numeric genre from string, version 2.2 and 2.3 */
366 static int parsegenre( struct mp3entry
* entry
, char* tag
, int bufferpos
)
368 if(entry
->id3version
>= ID3_VER_2_4
) {
369 /* In version 2.4 and up, there are no parentheses, and the genre frame
370 is a list of strings, either numbers or text. */
372 /* Is it a number? */
373 if(isdigit(tag
[0])) {
374 entry
->genre_string
= id3_get_num_genre(atoi( tag
));
375 return tag
- entry
->id3v2buf
;
377 entry
->genre_string
= tag
;
381 if( tag
[0] == '(' && tag
[1] != '(' ) {
382 entry
->genre_string
= id3_get_num_genre(atoi( tag
+ 1 ));
383 return tag
- entry
->id3v2buf
;
386 entry
->genre_string
= tag
;
392 #if CONFIG_CODEC == SWCODEC
393 /* parse user defined text, looking for replaygain information. */
394 static int parseuser( struct mp3entry
* entry
, char* tag
, int bufferpos
)
397 int desc_len
= strlen(tag
);
400 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
401 /* At least part of the value was read, so we can safely try to
404 value
= tag
+ desc_len
+ 1;
405 value_len
= parse_replaygain(tag
, value
, entry
, tag
,
406 bufferpos
- (tag
- entry
->id3v2buf
));
409 return tag
- entry
->id3v2buf
+ value_len
;
412 /* parse RVA2 binary data and convert to replaygain information. */
413 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
415 int desc_len
= strlen(tag
);
416 int start_pos
= tag
- entry
->id3v2buf
;
417 int end_pos
= start_pos
+ desc_len
+ 5;
419 unsigned char* value
= tag
+ desc_len
+ 1;
421 /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
422 * type is master volume.
424 if (entry
->id3version
== ID3_VER_2_4
&& end_pos
< bufferpos
432 /* The RVA2 specification is unclear on some things (id string and
433 * peak volume), but this matches how Quod Libet use them.
436 gain
= (int16_t) ((value
[0] << 8) | value
[1]);
439 peakbytes
= (peakbits
+ 7) / 8;
441 /* Only use the topmost 24 bits for peak volume */
446 /* Make sure the peak bits were read */
447 if (end_pos
+ peakbytes
< bufferpos
) {
448 long shift
= ((8 - (peakbits
& 7)) & 7) + (3 - peakbytes
) * 8;
450 for ( ; peakbytes
; peakbytes
--) {
458 peak
+= *value
>> (8 - shift
);
462 if (strcasecmp(tag
, "album") == 0) {
464 } else if (strcasecmp(tag
, "track") != 0) {
465 /* Only accept non-track values if we don't have any previous
468 if (entry
->track_gain
!= 0) {
473 value_len
= parse_replaygain_int(album
, gain
, peak
* 2, entry
,
474 tag
, sizeof(entry
->id3v2buf
) - start_pos
);
477 return start_pos
+ value_len
;
481 static const struct tag_resolver taglist
[] = {
482 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
483 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
484 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
485 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
486 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
487 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
488 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
489 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
490 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
491 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
492 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
493 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
494 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
495 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
496 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
497 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
498 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
499 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
500 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
501 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
502 #if CONFIG_CODEC == SWCODEC
503 { "TXXX", 4, 0, &parseuser
, false },
504 { "RVA2", 4, 0, &parserva2
, true },
508 #define TAGLIST_SIZE ((int)(sizeof(taglist) / sizeof(taglist[0])))
510 /* Get the length of an ID3 string in the given encoding. Returns the length
511 * in bytes, including end nil, or -1 if the encoding is unknown.
513 static int unicode_len(char encoding
, const void* string
)
517 if (encoding
== 0x01 || encoding
== 0x02) {
519 const char *s
= string
;
520 /* string might be unaligned, so using short* can crash on ARM and SH1 */
523 } while ((first
| *s
++) != 0);
525 len
= s
- (const char*) string
;
527 len
= strlen((char*) string
) + 1;
533 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
534 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
535 we convert from the default codepage */
536 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
540 unsigned char *str
= (unsigned char *)string
;
542 unsigned char* utf8
= (unsigned char *)utf8buf
;
545 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
548 utf8
= iso_decode(str
, utf8
, -1, *len
);
550 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
553 case 0x01: /* Unicode with or without BOM */
558 /* Handle frames with more than one string
559 (needed for TXXX frames).*/
561 tmp
= bytes2int(0, 0, str
[0], str
[1]);
563 /* Now check if there is a BOM
564 (zero-width non-breaking space, 0xfeff)
565 and if it is in little or big endian format */
566 if(tmp
== 0xfffe) { /* Little endian? */
570 } else if(tmp
== 0xfeff) { /* Big endian? */
574 /* If there is no BOM (which is a specification violation),
575 let's try to guess it. If one of the bytes is 0x00, it is
576 probably the most significant one. */
582 utf8
= utf16LEdecode(str
, utf8
, 1);
584 utf8
= utf16BEdecode(str
, utf8
, 1);
588 } while((str
[0] || str
[1]) && (i
< *len
));
590 *utf8
++ = 0; /* Terminate the string */
591 templen
+= (strlen(&utf8buf
[templen
]) + 1);
598 case 0x03: /* UTF-8 encoded string */
599 for(i
=0; i
< *len
; i
++)
604 default: /* Plain old string */
605 utf8
= iso_decode(str
, utf8
, -1, *len
);
607 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
614 * Sets the title of an MP3 entry based on its ID3v1 tag.
616 * Arguments: file - the MP3 file to scen for a ID3v1 tag
617 * entry - the entry to set the title in
619 * Returns: true if a title was found and created, else false
621 static bool setid3v1title(int fd
, struct mp3entry
*entry
)
623 unsigned char buffer
[128];
624 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
628 if (-1 == lseek(fd
, -128, SEEK_END
))
631 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
634 if (strncmp((char *)buffer
, "TAG", 3))
637 entry
->id3v1len
= 128;
638 entry
->id3version
= ID3_VER_1_0
;
640 for (i
=0; i
< (int)sizeof offsets
; i
++) {
641 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
647 /* kill trailing space in strings */
648 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
650 /* convert string to utf8 */
651 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
652 utf8
= iso_decode(ptr
, utf8
, -1, 30);
653 /* make sure string is terminated */
658 /* kill trailing space in strings */
659 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
661 /* convert string to utf8 */
662 utf8
= (unsigned char *)entry
->id3v1buf
[3];
663 utf8
= iso_decode(ptr
, utf8
, -1, 28);
664 /* make sure string is terminated */
670 entry
->year
= atoi((char *)ptr
);
674 /* id3v1.1 uses last two bytes of comment field for track
675 number: first must be 0 and second is track num */
676 if (!ptr
[0] && ptr
[1]) {
677 entry
->tracknum
= ptr
[1];
678 entry
->id3version
= ID3_VER_1_1
;
684 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
689 entry
->title
= entry
->id3v1buf
[0];
690 entry
->artist
= entry
->id3v1buf
[1];
691 entry
->album
= entry
->id3v1buf
[2];
692 entry
->comment
= entry
->id3v1buf
[3];
699 * Sets the title of an MP3 entry based on its ID3v2 tag.
701 * Arguments: file - the MP3 file to scan for a ID3v2 tag
702 * entry - the entry to set the title in
704 * Returns: true if a title was found and created, else false
706 static void setid3v2title(int fd
, struct mp3entry
*entry
)
710 long bufferpos
= 0, totframelen
, framelen
;
713 unsigned char version
;
714 char *buffer
= entry
->id3v2buf
;
716 int buffersize
= sizeof(entry
->id3v2buf
);
717 unsigned char global_flags
;
720 bool global_unsynch
= false;
721 bool unsynch
= false;
726 global_ff_found
= false;
728 /* Bail out if the tag is shorter than 10 bytes */
729 if(entry
->id3v2len
< 10)
732 /* Read the ID3 tag version from the header */
733 lseek(fd
, 0, SEEK_SET
);
734 if(10 != read(fd
, header
, 10))
737 /* Get the total ID3 tag size */
738 size
= entry
->id3v2len
- 10;
743 version
= ID3_VER_2_2
;
748 version
= ID3_VER_2_3
;
753 version
= ID3_VER_2_4
;
758 /* unsupported id3 version */
761 entry
->id3version
= version
;
762 entry
->tracknum
= entry
->year
= entry
->discnum
= 0;
763 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
765 global_flags
= header
[5];
767 /* Skip the extended header if it is present */
768 if(global_flags
& 0x40) {
769 if(version
== ID3_VER_2_3
) {
770 if(10 != read(fd
, header
, 10))
772 /* The 2.3 extended header size doesn't include the header size
773 field itself. Also, it is not unsynched. */
775 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
777 /* Skip the rest of the header */
778 lseek(fd
, framelen
- 10, SEEK_CUR
);
781 if(version
>= ID3_VER_2_4
) {
782 if(4 != read(fd
, header
, 4))
785 /* The 2.4 extended header size does include the entire header,
786 so here we can just skip it. This header is unsynched. */
787 framelen
= unsync(header
[0], header
[1],
788 header
[2], header
[3]);
790 lseek(fd
, framelen
- 4, SEEK_CUR
);
794 /* Is unsynchronization applied? */
795 if(global_flags
& 0x80) {
796 global_unsynch
= true;
800 * We must have at least minframesize bytes left for the
801 * remaining frames to be interesting
803 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
806 /* Read frame header and check length */
807 if(version
>= ID3_VER_2_3
) {
808 if(global_unsynch
&& version
<= ID3_VER_2_3
)
809 rc
= read_unsynched(fd
, header
, 10);
811 rc
= read(fd
, header
, 10);
814 /* Adjust for the 10 bytes we read */
817 flags
= bytes2int(0, 0, header
[8], header
[9]);
819 if (version
>= ID3_VER_2_4
) {
820 framelen
= unsync(header
[4], header
[5],
821 header
[6], header
[7]);
823 /* version .3 files don't use synchsafe ints for
825 framelen
= bytes2int(header
[4], header
[5],
826 header
[6], header
[7]);
829 if(6 != read(fd
, header
, 6))
831 /* Adjust for the 6 bytes we read */
834 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
837 logf("framelen = %ld", framelen
);
839 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
852 if (version
>= ID3_VER_2_4
) {
853 if(flags
& 0x0040) { /* Grouping identity */
854 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
858 if(flags
& 0x0020) { /* Grouping identity */
859 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
864 if(flags
& 0x000c) /* Compression or encryption */
868 lseek(fd
, framelen
, SEEK_CUR
);
872 if(flags
& 0x0002) /* Unsynchronization */
875 if (version
>= ID3_VER_2_4
) {
876 if(flags
& 0x0001) { /* Data length indicator */
877 if(4 != read(fd
, tmp
, 4))
880 data_length_ind
= unsync(tmp
[0], tmp
[1], tmp
[2], tmp
[3]);
886 /* Keep track of the remaining frame size */
887 totframelen
= framelen
;
889 /* If the frame is larger than the remaining buffer space we try
890 to read as much as would fit in the buffer */
891 if(framelen
>= buffersize
- bufferpos
)
892 framelen
= buffersize
- bufferpos
- 1;
894 logf("id3v2 frame: %.4s", header
);
896 /* Check for certain frame headers
898 'size' is the amount of frame bytes remaining. We decrement it by
899 the amount of bytes we read. If we fail to read as many bytes as
900 we expect, we assume that we can't read from this file, and bail
903 For each frame. we will iterate over the list of supported tags,
904 and read the tag into entry's buffer. All tags will be kept as
905 strings, for cases where a number won't do, e.g., YEAR: "circa
906 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
907 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
908 flexible, and as the main use of id3 data is to display it,
909 converting it to an int just means reconverting to display it, at a
912 For tags that the current code does convert to ints, a post
913 processing function will be called via a pointer to function. */
915 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
916 const struct tag_resolver
* tr
= &taglist
[i
];
917 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
921 /* Only ID3_VER_2_2 uses frames with three-character names. */
922 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
923 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
927 /* Note that parser functions sometimes set *ptag to NULL, so
928 * the "!*ptag" check here doesn't always have the desired
929 * effect. Should the parser functions (parsegenre in
930 * particular) be updated to handle the case of being called
931 * multiple times, or should the "*ptag" check be removed?
933 if( (!ptag
|| !*ptag
) && !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
935 /* found a tag matching one in tagList, and not yet filled */
936 tag
= buffer
+ bufferpos
;
938 if(global_unsynch
&& version
<= ID3_VER_2_3
)
939 bytesread
= read_unsynched(fd
, tag
, framelen
);
941 bytesread
= read(fd
, tag
, framelen
);
943 if( bytesread
!= framelen
)
948 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
949 bytesread
= unsynchronize_frame(tag
, bytesread
);
951 /* the COMM frame has a 3 char field to hold an ISO-639-1
952 * language string and an optional short description;
953 * remove them so unicode_munge can work correctly
956 if(!memcmp( header
, "COMM", 4 )) {
958 /* ignore comments with iTunes 7 soundcheck/gapless data */
959 if(!strncmp(tag
+4, "iTun", 4))
961 offset
= 3 + unicode_len(*tag
, tag
+ 4);
962 if(bytesread
> offset
) {
964 memmove(tag
+ 1, tag
+ 1 + offset
, bytesread
- 1);
968 /* Attempt to parse Unicode string only if the tag contents
971 /* UTF-8 could potentially be 3 times larger */
972 /* so we need to create a new buffer */
973 char utf8buf
[(3 * bytesread
) + 1];
975 unicode_munge( tag
, utf8buf
, &bytesread
);
977 if(bytesread
>= buffersize
- bufferpos
)
978 bytesread
= buffersize
- bufferpos
- 1;
980 for (j
= 0; j
< bytesread
; j
++)
983 /* remove trailing spaces */
984 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
989 bufferpos
+= bytesread
+ 1;
995 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
997 /* Seek to the next frame */
998 if(framelen
< totframelen
)
999 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
1004 if( i
== TAGLIST_SIZE
) {
1005 /* no tag in tagList was found, or it was a repeat.
1006 skip it using the total size */
1008 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
1009 size
-= skip_unsynched(fd
, totframelen
);
1012 totframelen
= data_length_ind
;
1014 size
-= totframelen
;
1015 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
1023 * Calculates the size of the ID3v2 tag.
1025 * Arguments: file - the file to search for a tag.
1027 * Returns: the size of the tag or 0 if none was found
1029 int getid3v2len(int fd
)
1034 /* Make sure file has a ID3 tag */
1035 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
1036 (read(fd
, buf
, 6) != 6) ||
1037 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
1040 /* Now check what the ID3v2 size field says */
1042 if(read(fd
, buf
, 4) != 4)
1045 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
1047 logf("ID3V2 Length: 0x%x", offset
);
1052 * Calculates the length (in milliseconds) of an MP3 file.
1054 * Modified to only use integers.
1056 * Arguments: file - the file to calculate the length upon
1057 * entry - the entry to update with the length
1059 * Returns: the song length in milliseconds,
1060 * 0 means that it couldn't be calculated
1062 static int getsonglength(int fd
, struct mp3entry
*entry
)
1064 unsigned long filetime
= 0;
1065 struct mp3info info
;
1068 /* Start searching after ID3v2 header */
1069 if(-1 == lseek(fd
, entry
->id3v2len
, SEEK_SET
))
1072 bytecount
= get_mp3file_info(fd
, &info
);
1074 logf("Space between ID3V2 tag and first audio frame: 0x%lx bytes",
1080 bytecount
+= entry
->id3v2len
;
1082 /* Validate byte count, in case the file has been edited without
1083 * updating the header.
1085 if (info
.byte_count
)
1087 const unsigned long expected
= entry
->filesize
- entry
->id3v1len
1089 const unsigned long diff
= MAX(10240, info
.byte_count
/ 20);
1091 if ((info
.byte_count
> expected
+ diff
)
1092 || (info
.byte_count
< expected
- diff
))
1094 logf("Note: info.byte_count differs from expected value by "
1095 "%ld bytes", labs((long) (expected
- info
.byte_count
)));
1096 info
.byte_count
= 0;
1097 info
.frame_count
= 0;
1099 info
.enc_padding
= 0;
1101 /* Even if the bitrate was based on "known bad" values, it
1102 * should still be better for VBR files than using the bitrate
1103 * of the first audio frame.
1108 entry
->bitrate
= info
.bitrate
;
1109 entry
->frequency
= info
.frequency
;
1110 entry
->version
= info
.version
;
1111 entry
->layer
= info
.layer
;
1112 switch(entry
->layer
) {
1113 #if CONFIG_CODEC==SWCODEC
1115 entry
->codectype
=AFMT_MPA_L1
;
1119 entry
->codectype
=AFMT_MPA_L2
;
1122 entry
->codectype
=AFMT_MPA_L3
;
1126 /* If the file time hasn't been established, this may be a fixed
1127 rate MP3, so just use the default formula */
1129 filetime
= info
.file_time
;
1133 /* Prevent a division by zero */
1134 if (info
.bitrate
< 8)
1137 filetime
= (entry
->filesize
- bytecount
) / (info
.bitrate
/ 8);
1138 /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
1139 * instead of filesize * 8 is exact, because mpeg audio bitrates are
1140 * always multiples of 8, and it avoids overflows. */
1143 entry
->frame_count
= info
.frame_count
;
1145 entry
->vbr
= info
.is_vbr
;
1146 entry
->has_toc
= info
.has_toc
;
1148 #if CONFIG_CODEC==SWCODEC
1149 entry
->lead_trim
= info
.enc_delay
;
1150 entry
->tail_trim
= info
.enc_padding
;
1153 memcpy(entry
->toc
, info
.toc
, sizeof(info
.toc
));
1155 entry
->vbr_header_pos
= info
.vbr_header_pos
;
1157 /* Update the seek point for the first playable frame */
1158 entry
->first_frame_offset
= bytecount
;
1159 logf("First frame is at %lx", entry
->first_frame_offset
);
1165 * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
1166 * about an MP3 file and updates it's entry accordingly.
1168 Note, that this returns true for successful, false for error! */
1169 bool get_mp3_metadata(int fd
, struct mp3entry
*entry
, const char *filename
)
1171 #if CONFIG_CODEC != SWCODEC
1172 memset(entry
, 0, sizeof(struct mp3entry
));
1175 strncpy(entry
->path
, filename
, sizeof(entry
->path
));
1177 entry
->title
= NULL
;
1178 entry
->filesize
= filesize(fd
);
1179 entry
->id3v2len
= getid3v2len(fd
);
1180 entry
->tracknum
= 0;
1183 if (entry
->id3v2len
)
1184 setid3v2title(fd
, entry
);
1185 int len
= getsonglength(fd
, entry
);
1188 entry
->length
= len
;
1190 /* Subtract the meta information from the file size to get
1191 the true size of the MP3 stream */
1192 entry
->filesize
-= entry
->first_frame_offset
;
1194 /* only seek to end of file if no id3v2 tags were found */
1195 if (!entry
->id3v2len
) {
1196 setid3v1title(fd
, entry
);
1199 if(!entry
->length
|| (entry
->filesize
< 8 ))
1200 /* no song length or less than 8 bytes is hereby considered to be an
1201 invalid mp3 and won't be played by us! */
1207 /* Note, that this returns false for successful, true for error! */
1208 bool mp3info(struct mp3entry
*entry
, const char *filename
)
1213 fd
= open(filename
, O_RDONLY
);
1217 result
= !get_mp3_metadata(fd
, entry
, filename
);
1224 void adjust_mp3entry(struct mp3entry
*entry
, void *dest
, const void *orig
)
1228 offset
= - ((size_t)orig
- (size_t)dest
);
1230 offset
= (size_t)dest
- (size_t)orig
;
1233 entry
->title
+= offset
;
1235 entry
->artist
+= offset
;
1237 entry
->album
+= offset
;
1238 if (entry
->genre_string
&& !id3_is_genre_string(entry
->genre_string
))
1239 /* Don't adjust that if it points to an entry of the "genres" array */
1240 entry
->genre_string
+= offset
;
1241 if (entry
->track_string
)
1242 entry
->track_string
+= offset
;
1243 if (entry
->disc_string
)
1244 entry
->disc_string
+= offset
;
1245 if (entry
->year_string
)
1246 entry
->year_string
+= offset
;
1247 if (entry
->composer
)
1248 entry
->composer
+= offset
;
1250 entry
->comment
+= offset
;
1251 if (entry
->albumartist
)
1252 entry
->albumartist
+= offset
;
1253 if (entry
->grouping
)
1254 entry
->grouping
+= offset
;
1255 #if CONFIG_CODEC == SWCODEC
1256 if (entry
->track_gain_string
)
1257 entry
->track_gain_string
+= offset
;
1258 if (entry
->album_gain_string
)
1259 entry
->album_gain_string
+= offset
;
1263 void copy_mp3entry(struct mp3entry
*dest
, const struct mp3entry
*orig
)
1265 memcpy(dest
, orig
, sizeof(struct mp3entry
));
1266 adjust_mp3entry(dest
, dest
, orig
);
1269 #ifdef DEBUG_STANDALONE
1271 char *secs2str(int ms
)
1273 static char buffer
[32];
1276 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1280 int main(int argc
, char **argv
)
1283 for(i
=1; i
<argc
; i
++) {
1284 struct mp3entry mp3
;
1285 mp3
.album
= "Bogus";
1286 if(mp3info(&mp3
, argv
[i
], false)) {
1287 printf("Failed to get %s\n", argv
[i
]);
1291 printf("****** File: %s\n"
1295 " Genre: %s (%d) \n"
1299 " Length: %s / %d s\n"
1303 mp3
.title
?mp3
.title
:"<blank>",
1304 mp3
.artist
?mp3
.artist
:"<blank>",
1305 mp3
.album
?mp3
.album
:"<blank>",
1306 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1308 mp3
.composer
?mp3
.composer
:"<blank>",
1309 mp3
.year_string
?mp3
.year_string
:"<blank>",
1311 mp3
.track_string
?mp3
.track_string
:"<blank>",
1313 secs2str(mp3
.length
),