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" ),
117 AFMT_ENTRY("MOD", "mod", NULL
, "mod\0" ),
121 #if CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING)
122 /* get REC_FORMAT_* corresponding AFMT_* */
123 const int rec_format_afmt
[REC_NUM_FORMATS
] =
125 /* give AFMT_UNKNOWN by default */
126 [0 ... REC_NUM_FORMATS
-1] = AFMT_UNKNOWN
,
127 /* add new entries below this line */
128 [REC_FORMAT_AIFF
] = AFMT_AIFF
,
129 [REC_FORMAT_MPA_L3
] = AFMT_MPA_L3
,
130 [REC_FORMAT_WAVPACK
] = AFMT_WAVPACK
,
131 [REC_FORMAT_PCM_WAV
] = AFMT_PCM_WAV
,
134 /* get AFMT_* corresponding REC_FORMAT_* */
135 const int afmt_rec_format
[AFMT_NUM_CODECS
] =
137 /* give -1 by default */
138 [0 ... AFMT_NUM_CODECS
-1] = -1,
139 /* add new entries below this line */
140 [AFMT_AIFF
] = REC_FORMAT_AIFF
,
141 [AFMT_MPA_L3
] = REC_FORMAT_MPA_L3
,
142 [AFMT_WAVPACK
] = REC_FORMAT_WAVPACK
,
143 [AFMT_PCM_WAV
] = REC_FORMAT_PCM_WAV
,
145 #endif /* CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING) */
148 static unsigned long unsync(unsigned long b0
,
153 return (((long)(b0
& 0x7F) << (3*7)) |
154 ((long)(b1
& 0x7F) << (2*7)) |
155 ((long)(b2
& 0x7F) << (1*7)) |
156 ((long)(b3
& 0x7F) << (0*7)));
159 static const char* const genres
[] = {
160 "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
161 "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
162 "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
163 "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
164 "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
165 "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
166 "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
167 "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
168 "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
169 "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
170 "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
171 "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
172 "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
174 /* winamp extensions */
175 "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
176 "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
177 "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
178 "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
179 "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
180 "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
181 "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
182 "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
183 "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
184 "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
185 "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
186 "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
190 char* id3_get_num_genre(unsigned int genre_num
)
192 if (genre_num
< sizeof(genres
)/sizeof(char*))
193 return (char*)genres
[genre_num
];
197 /* True if the string is from the "genres" array */
198 static bool id3_is_genre_string(const char *string
)
200 return ( string
>= genres
[0] &&
201 string
<= genres
[sizeof(genres
)/sizeof(char*) - 1] );
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 start_pos
= tag
- entry
->id3v2buf
;
420 int end_pos
= start_pos
+ desc_len
+ 5;
422 unsigned char* value
= tag
+ desc_len
+ 1;
424 /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
425 * type is master volume.
427 if (entry
->id3version
== ID3_VER_2_4
&& end_pos
< bufferpos
435 /* The RVA2 specification is unclear on some things (id string and
436 * peak volume), but this matches how Quod Libet use them.
439 gain
= (int16_t) ((value
[0] << 8) | value
[1]);
442 peakbytes
= (peakbits
+ 7) / 8;
444 /* Only use the topmost 24 bits for peak volume */
449 /* Make sure the peak bits were read */
450 if (end_pos
+ peakbytes
< bufferpos
) {
451 long shift
= ((8 - (peakbits
& 7)) & 7) + (3 - peakbytes
) * 8;
453 for ( ; peakbytes
; peakbytes
--) {
461 peak
+= *value
>> (8 - shift
);
465 if (strcasecmp(tag
, "album") == 0) {
467 } else if (strcasecmp(tag
, "track") != 0) {
468 /* Only accept non-track values if we don't have any previous
471 if (entry
->track_gain
!= 0) {
476 value_len
= parse_replaygain_int(album
, gain
, peak
* 2, entry
,
477 tag
, sizeof(entry
->id3v2buf
) - start_pos
);
480 return start_pos
+ value_len
;
484 static const struct tag_resolver taglist
[] = {
485 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
486 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
487 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
488 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
489 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
490 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
491 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
492 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
493 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
494 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
495 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
496 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
497 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
498 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
499 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
500 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
501 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
502 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
503 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
504 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
505 #if CONFIG_CODEC == SWCODEC
506 { "TXXX", 4, 0, &parseuser
, false },
507 { "RVA2", 4, 0, &parserva2
, true },
511 #define TAGLIST_SIZE ((int)(sizeof(taglist) / sizeof(taglist[0])))
513 /* Get the length of an ID3 string in the given encoding. Returns the length
514 * in bytes, including end nil, or -1 if the encoding is unknown.
516 static int unicode_len(char encoding
, const void* string
)
520 if (encoding
== 0x01 || encoding
== 0x02) {
522 const char *s
= string
;
523 /* string might be unaligned, so using short* can crash on ARM and SH1 */
526 } while ((first
| *s
++) != 0);
528 len
= s
- (const char*) string
;
530 len
= strlen((char*) string
) + 1;
536 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
537 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
538 we convert from the default codepage */
539 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
543 unsigned char *str
= (unsigned char *)string
;
545 unsigned char* utf8
= (unsigned char *)utf8buf
;
548 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
551 utf8
= iso_decode(str
, utf8
, -1, *len
);
553 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
556 case 0x01: /* Unicode with or without BOM */
561 /* Handle frames with more than one string
562 (needed for TXXX frames).*/
564 tmp
= bytes2int(0, 0, str
[0], str
[1]);
566 /* Now check if there is a BOM
567 (zero-width non-breaking space, 0xfeff)
568 and if it is in little or big endian format */
569 if(tmp
== 0xfffe) { /* Little endian? */
573 } else if(tmp
== 0xfeff) { /* Big endian? */
577 /* If there is no BOM (which is a specification violation),
578 let's try to guess it. If one of the bytes is 0x00, it is
579 probably the most significant one. */
585 utf8
= utf16LEdecode(str
, utf8
, 1);
587 utf8
= utf16BEdecode(str
, utf8
, 1);
591 } while((str
[0] || str
[1]) && (i
< *len
));
593 *utf8
++ = 0; /* Terminate the string */
594 templen
+= (strlen(&utf8buf
[templen
]) + 1);
601 case 0x03: /* UTF-8 encoded string */
602 for(i
=0; i
< *len
; i
++)
607 default: /* Plain old string */
608 utf8
= iso_decode(str
, utf8
, -1, *len
);
610 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
617 * Sets the title of an MP3 entry based on its ID3v1 tag.
619 * Arguments: file - the MP3 file to scen for a ID3v1 tag
620 * entry - the entry to set the title in
622 * Returns: true if a title was found and created, else false
624 static bool setid3v1title(int fd
, struct mp3entry
*entry
)
626 unsigned char buffer
[128];
627 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
631 if (-1 == lseek(fd
, -128, SEEK_END
))
634 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
637 if (strncmp((char *)buffer
, "TAG", 3))
640 entry
->id3v1len
= 128;
641 entry
->id3version
= ID3_VER_1_0
;
643 for (i
=0; i
< (int)sizeof offsets
; i
++) {
644 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
650 /* kill trailing space in strings */
651 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
653 /* convert string to utf8 */
654 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
655 utf8
= iso_decode(ptr
, utf8
, -1, 30);
656 /* make sure string is terminated */
661 /* kill trailing space in strings */
662 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
664 /* convert string to utf8 */
665 utf8
= (unsigned char *)entry
->id3v1buf
[3];
666 utf8
= iso_decode(ptr
, utf8
, -1, 28);
667 /* make sure string is terminated */
673 entry
->year
= atoi((char *)ptr
);
677 /* id3v1.1 uses last two bytes of comment field for track
678 number: first must be 0 and second is track num */
679 if (!ptr
[0] && ptr
[1]) {
680 entry
->tracknum
= ptr
[1];
681 entry
->id3version
= ID3_VER_1_1
;
687 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
692 entry
->title
= entry
->id3v1buf
[0];
693 entry
->artist
= entry
->id3v1buf
[1];
694 entry
->album
= entry
->id3v1buf
[2];
695 entry
->comment
= entry
->id3v1buf
[3];
702 * Sets the title of an MP3 entry based on its ID3v2 tag.
704 * Arguments: file - the MP3 file to scan for a ID3v2 tag
705 * entry - the entry to set the title in
707 * Returns: true if a title was found and created, else false
709 static void setid3v2title(int fd
, struct mp3entry
*entry
)
713 long bufferpos
= 0, totframelen
, framelen
;
716 unsigned char version
;
717 char *buffer
= entry
->id3v2buf
;
719 int buffersize
= sizeof(entry
->id3v2buf
);
720 unsigned char global_flags
;
723 bool global_unsynch
= false;
724 bool unsynch
= false;
729 global_ff_found
= false;
731 /* Bail out if the tag is shorter than 10 bytes */
732 if(entry
->id3v2len
< 10)
735 /* Read the ID3 tag version from the header */
736 lseek(fd
, 0, SEEK_SET
);
737 if(10 != read(fd
, header
, 10))
740 /* Get the total ID3 tag size */
741 size
= entry
->id3v2len
- 10;
746 version
= ID3_VER_2_2
;
751 version
= ID3_VER_2_3
;
756 version
= ID3_VER_2_4
;
761 /* unsupported id3 version */
764 entry
->id3version
= version
;
765 entry
->tracknum
= entry
->year
= entry
->discnum
= 0;
766 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
768 global_flags
= header
[5];
770 /* Skip the extended header if it is present */
771 if(global_flags
& 0x40) {
772 if(version
== ID3_VER_2_3
) {
773 if(10 != read(fd
, header
, 10))
775 /* The 2.3 extended header size doesn't include the header size
776 field itself. Also, it is not unsynched. */
778 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
780 /* Skip the rest of the header */
781 lseek(fd
, framelen
- 10, SEEK_CUR
);
784 if(version
>= ID3_VER_2_4
) {
785 if(4 != read(fd
, header
, 4))
788 /* The 2.4 extended header size does include the entire header,
789 so here we can just skip it. This header is unsynched. */
790 framelen
= unsync(header
[0], header
[1],
791 header
[2], header
[3]);
793 lseek(fd
, framelen
- 4, SEEK_CUR
);
797 /* Is unsynchronization applied? */
798 if(global_flags
& 0x80) {
799 global_unsynch
= true;
803 * We must have at least minframesize bytes left for the
804 * remaining frames to be interesting
806 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
809 /* Read frame header and check length */
810 if(version
>= ID3_VER_2_3
) {
811 if(global_unsynch
&& version
<= ID3_VER_2_3
)
812 rc
= read_unsynched(fd
, header
, 10);
814 rc
= read(fd
, header
, 10);
817 /* Adjust for the 10 bytes we read */
820 flags
= bytes2int(0, 0, header
[8], header
[9]);
822 if (version
>= ID3_VER_2_4
) {
823 framelen
= unsync(header
[4], header
[5],
824 header
[6], header
[7]);
826 /* version .3 files don't use synchsafe ints for
828 framelen
= bytes2int(header
[4], header
[5],
829 header
[6], header
[7]);
832 if(6 != read(fd
, header
, 6))
834 /* Adjust for the 6 bytes we read */
837 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
840 logf("framelen = %ld", framelen
);
842 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
855 if (version
>= ID3_VER_2_4
) {
856 if(flags
& 0x0040) { /* Grouping identity */
857 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
861 if(flags
& 0x0020) { /* Grouping identity */
862 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
867 if(flags
& 0x000c) /* Compression or encryption */
871 lseek(fd
, framelen
, SEEK_CUR
);
875 if(flags
& 0x0002) /* Unsynchronization */
878 if (version
>= ID3_VER_2_4
) {
879 if(flags
& 0x0001) { /* Data length indicator */
880 if(4 != read(fd
, tmp
, 4))
883 data_length_ind
= unsync(tmp
[0], tmp
[1], tmp
[2], tmp
[3]);
889 /* Keep track of the remaining frame size */
890 totframelen
= framelen
;
892 /* If the frame is larger than the remaining buffer space we try
893 to read as much as would fit in the buffer */
894 if(framelen
>= buffersize
- bufferpos
)
895 framelen
= buffersize
- bufferpos
- 1;
897 logf("id3v2 frame: %.4s", header
);
899 /* Check for certain frame headers
901 'size' is the amount of frame bytes remaining. We decrement it by
902 the amount of bytes we read. If we fail to read as many bytes as
903 we expect, we assume that we can't read from this file, and bail
906 For each frame. we will iterate over the list of supported tags,
907 and read the tag into entry's buffer. All tags will be kept as
908 strings, for cases where a number won't do, e.g., YEAR: "circa
909 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
910 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
911 flexible, and as the main use of id3 data is to display it,
912 converting it to an int just means reconverting to display it, at a
915 For tags that the current code does convert to ints, a post
916 processing function will be called via a pointer to function. */
918 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
919 const struct tag_resolver
* tr
= &taglist
[i
];
920 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
924 /* Only ID3_VER_2_2 uses frames with three-character names. */
925 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
926 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
930 /* Note that parser functions sometimes set *ptag to NULL, so
931 * the "!*ptag" check here doesn't always have the desired
932 * effect. Should the parser functions (parsegenre in
933 * particular) be updated to handle the case of being called
934 * multiple times, or should the "*ptag" check be removed?
936 if( (!ptag
|| !*ptag
) && !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
938 /* found a tag matching one in tagList, and not yet filled */
939 tag
= buffer
+ bufferpos
;
941 if(global_unsynch
&& version
<= ID3_VER_2_3
)
942 bytesread
= read_unsynched(fd
, tag
, framelen
);
944 bytesread
= read(fd
, tag
, framelen
);
946 if( bytesread
!= framelen
)
951 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
952 bytesread
= unsynchronize_frame(tag
, bytesread
);
954 /* the COMM frame has a 3 char field to hold an ISO-639-1
955 * language string and an optional short description;
956 * remove them so unicode_munge can work correctly
959 if(!memcmp( header
, "COMM", 4 )) {
961 /* ignore comments with iTunes 7 soundcheck/gapless data */
962 if(!strncmp(tag
+4, "iTun", 4))
964 offset
= 3 + unicode_len(*tag
, tag
+ 4);
965 if(bytesread
> offset
) {
967 memmove(tag
+ 1, tag
+ 1 + offset
, bytesread
- 1);
971 /* Attempt to parse Unicode string only if the tag contents
974 /* UTF-8 could potentially be 3 times larger */
975 /* so we need to create a new buffer */
976 char utf8buf
[(3 * bytesread
) + 1];
978 unicode_munge( tag
, utf8buf
, &bytesread
);
980 if(bytesread
>= buffersize
- bufferpos
)
981 bytesread
= buffersize
- bufferpos
- 1;
983 for (j
= 0; j
< bytesread
; j
++)
986 /* remove trailing spaces */
987 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
992 bufferpos
+= bytesread
+ 1;
998 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
1000 /* Seek to the next frame */
1001 if(framelen
< totframelen
)
1002 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
1007 if( i
== TAGLIST_SIZE
) {
1008 /* no tag in tagList was found, or it was a repeat.
1009 skip it using the total size */
1011 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
1012 size
-= skip_unsynched(fd
, totframelen
);
1015 totframelen
= data_length_ind
;
1017 size
-= totframelen
;
1018 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
1026 * Calculates the size of the ID3v2 tag.
1028 * Arguments: file - the file to search for a tag.
1030 * Returns: the size of the tag or 0 if none was found
1032 int getid3v2len(int fd
)
1037 /* Make sure file has a ID3 tag */
1038 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
1039 (read(fd
, buf
, 6) != 6) ||
1040 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
1043 /* Now check what the ID3v2 size field says */
1045 if(read(fd
, buf
, 4) != 4)
1048 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
1050 logf("ID3V2 Length: 0x%x", offset
);
1055 * Calculates the length (in milliseconds) of an MP3 file.
1057 * Modified to only use integers.
1059 * Arguments: file - the file to calculate the length upon
1060 * entry - the entry to update with the length
1062 * Returns: the song length in milliseconds,
1063 * 0 means that it couldn't be calculated
1065 static int getsonglength(int fd
, struct mp3entry
*entry
)
1067 unsigned long filetime
= 0;
1068 struct mp3info info
;
1071 /* Start searching after ID3v2 header */
1072 if(-1 == lseek(fd
, entry
->id3v2len
, SEEK_SET
))
1075 bytecount
= get_mp3file_info(fd
, &info
);
1077 logf("Space between ID3V2 tag and first audio frame: 0x%lx bytes",
1083 bytecount
+= entry
->id3v2len
;
1085 /* Validate byte count, in case the file has been edited without
1086 * updating the header.
1088 if (info
.byte_count
)
1090 const unsigned long expected
= entry
->filesize
- entry
->id3v1len
1092 const unsigned long diff
= MAX(10240, info
.byte_count
/ 20);
1094 if ((info
.byte_count
> expected
+ diff
)
1095 || (info
.byte_count
< expected
- diff
))
1097 logf("Note: info.byte_count differs from expected value by "
1098 "%ld bytes", labs((long) (expected
- info
.byte_count
)));
1099 info
.byte_count
= 0;
1100 info
.frame_count
= 0;
1102 info
.enc_padding
= 0;
1104 /* Even if the bitrate was based on "known bad" values, it
1105 * should still be better for VBR files than using the bitrate
1106 * of the first audio frame.
1111 entry
->bitrate
= info
.bitrate
;
1112 entry
->frequency
= info
.frequency
;
1113 entry
->version
= info
.version
;
1114 entry
->layer
= info
.layer
;
1115 switch(entry
->layer
) {
1116 #if CONFIG_CODEC==SWCODEC
1118 entry
->codectype
=AFMT_MPA_L1
;
1122 entry
->codectype
=AFMT_MPA_L2
;
1125 entry
->codectype
=AFMT_MPA_L3
;
1129 /* If the file time hasn't been established, this may be a fixed
1130 rate MP3, so just use the default formula */
1132 filetime
= info
.file_time
;
1136 /* Prevent a division by zero */
1137 if (info
.bitrate
< 8)
1140 filetime
= (entry
->filesize
- bytecount
) / (info
.bitrate
/ 8);
1141 /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
1142 * instead of filesize * 8 is exact, because mpeg audio bitrates are
1143 * always multiples of 8, and it avoids overflows. */
1146 entry
->frame_count
= info
.frame_count
;
1148 entry
->vbr
= info
.is_vbr
;
1149 entry
->has_toc
= info
.has_toc
;
1151 #if CONFIG_CODEC==SWCODEC
1152 entry
->lead_trim
= info
.enc_delay
;
1153 entry
->tail_trim
= info
.enc_padding
;
1156 memcpy(entry
->toc
, info
.toc
, sizeof(info
.toc
));
1158 entry
->vbr_header_pos
= info
.vbr_header_pos
;
1160 /* Update the seek point for the first playable frame */
1161 entry
->first_frame_offset
= bytecount
;
1162 logf("First frame is at %lx", entry
->first_frame_offset
);
1168 * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
1169 * about an MP3 file and updates it's entry accordingly.
1171 Note, that this returns true for successful, false for error! */
1172 bool get_mp3_metadata(int fd
, struct mp3entry
*entry
, const char *filename
)
1174 #if CONFIG_CODEC != SWCODEC
1175 memset(entry
, 0, sizeof(struct mp3entry
));
1178 strncpy(entry
->path
, filename
, sizeof(entry
->path
));
1180 entry
->title
= NULL
;
1181 entry
->filesize
= filesize(fd
);
1182 entry
->id3v2len
= getid3v2len(fd
);
1183 entry
->tracknum
= 0;
1186 if (entry
->id3v2len
)
1187 setid3v2title(fd
, entry
);
1188 int len
= getsonglength(fd
, entry
);
1191 entry
->length
= len
;
1193 /* Subtract the meta information from the file size to get
1194 the true size of the MP3 stream */
1195 entry
->filesize
-= entry
->first_frame_offset
;
1197 /* only seek to end of file if no id3v2 tags were found */
1198 if (!entry
->id3v2len
) {
1199 setid3v1title(fd
, entry
);
1202 if(!entry
->length
|| (entry
->filesize
< 8 ))
1203 /* no song length or less than 8 bytes is hereby considered to be an
1204 invalid mp3 and won't be played by us! */
1210 /* Note, that this returns false for successful, true for error! */
1211 bool mp3info(struct mp3entry
*entry
, const char *filename
)
1216 fd
= open(filename
, O_RDONLY
);
1220 result
= !get_mp3_metadata(fd
, entry
, filename
);
1227 void adjust_mp3entry(struct mp3entry
*entry
, void *dest
, const void *orig
)
1231 offset
= - ((size_t)orig
- (size_t)dest
);
1233 offset
= (size_t)dest
- (size_t)orig
;
1236 entry
->title
+= offset
;
1238 entry
->artist
+= offset
;
1240 entry
->album
+= offset
;
1241 if (entry
->genre_string
&& !id3_is_genre_string(entry
->genre_string
))
1242 /* Don't adjust that if it points to an entry of the "genres" array */
1243 entry
->genre_string
+= offset
;
1244 if (entry
->track_string
)
1245 entry
->track_string
+= offset
;
1246 if (entry
->disc_string
)
1247 entry
->disc_string
+= offset
;
1248 if (entry
->year_string
)
1249 entry
->year_string
+= offset
;
1250 if (entry
->composer
)
1251 entry
->composer
+= offset
;
1253 entry
->comment
+= offset
;
1254 if (entry
->albumartist
)
1255 entry
->albumartist
+= offset
;
1256 if (entry
->grouping
)
1257 entry
->grouping
+= offset
;
1258 #if CONFIG_CODEC == SWCODEC
1259 if (entry
->track_gain_string
)
1260 entry
->track_gain_string
+= offset
;
1261 if (entry
->album_gain_string
)
1262 entry
->album_gain_string
+= offset
;
1266 void copy_mp3entry(struct mp3entry
*dest
, const struct mp3entry
*orig
)
1268 memcpy(dest
, orig
, sizeof(struct mp3entry
));
1269 adjust_mp3entry(dest
, dest
, orig
);
1272 #ifdef DEBUG_STANDALONE
1274 char *secs2str(int ms
)
1276 static char buffer
[32];
1279 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1283 int main(int argc
, char **argv
)
1286 for(i
=1; i
<argc
; i
++) {
1287 struct mp3entry mp3
;
1288 mp3
.album
= "Bogus";
1289 if(mp3info(&mp3
, argv
[i
], false)) {
1290 printf("Failed to get %s\n", argv
[i
]);
1294 printf("****** File: %s\n"
1298 " Genre: %s (%d) \n"
1302 " Length: %s / %d s\n"
1306 mp3
.title
?mp3
.title
:"<blank>",
1307 mp3
.artist
?mp3
.artist
:"<blank>",
1308 mp3
.album
?mp3
.album
:"<blank>",
1309 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1311 mp3
.composer
?mp3
.composer
:"<blank>",
1312 mp3
.year_string
?mp3
.year_string
:"<blank>",
1314 mp3
.track_string
?mp3
.track_string
:"<blank>",
1316 secs2str(mp3
.length
),