1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by Daniel Stenberg
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
18 ****************************************************************************/
20 * Parts of this code has been stolen from the Ample project and was written
21 * by David H�deman. It has since been extended and enhanced pretty much by
22 * all sorts of friendly Rockbox people.
26 /* tagResolver and associated code copyright 2003 Thomas Paul Diffenbach
44 #include "replaygain.h"
45 #include "rbunicode.h"
47 /** Database of audio formats **/
48 const struct afmt_entry audio_formats
[AFMT_NUM_CODECS
] =
50 /* Unknown file format */
52 AFMT_ENTRY("???", NULL
, NULL
, NULL
),
54 /* MPEG Audio layer 1 */
56 AFMT_ENTRY("MP1", "mpa", NULL
, "mp1\0" ),
57 /* MPEG Audio layer 2 */
59 AFMT_ENTRY("MP2", "mpa", NULL
, "mpa\0mp2\0" ),
60 /* MPEG Audio layer 3 */
62 AFMT_ENTRY("MP3", "mpa", "mp3_enc", "mp3\0" ),
64 #if CONFIG_CODEC == SWCODEC
65 /* Audio Interchange File Format */
67 AFMT_ENTRY("AIFF", "aiff", "aiff_enc", "aiff\0aif\0"),
68 /* Uncompressed PCM in a WAV file */
70 AFMT_ENTRY("WAV", "wav", "wav_enc", "wav\0" ),
73 AFMT_ENTRY("Ogg", "vorbis", NULL
, "ogg\0" ),
76 AFMT_ENTRY("FLAC", "flac", NULL
, "flac\0" ),
79 AFMT_ENTRY("MPC", "mpc", NULL
, "mpc\0" ),
80 /* A/52 (aka AC3) audio */
82 AFMT_ENTRY("AC3", "a52", NULL
, "a52\0ac3\0" ),
85 AFMT_ENTRY("WV", "wavpack", "wavpack_enc", "wv\0" ),
86 /* Apple Lossless Audio Codec */
88 AFMT_ENTRY("ALAC", "alac", NULL
, "m4a\0m4b\0" ),
89 /* Advanced Audio Coding in M4A container */
91 AFMT_ENTRY("AAC", "aac", NULL
, "mp4\0" ),
94 AFMT_ENTRY("SHN", "shorten", NULL
, "shn\0" ),
97 AFMT_ENTRY("SID", "sid", NULL
, "sid\0" ),
100 AFMT_ENTRY("ADX", "adx", NULL
, "adx\0" ),
101 /* NESM (NES Sound Format) */
103 AFMT_ENTRY("NSF", "nsf", NULL
, "nsf\0nsfe\0" ),
104 /* Speex File Format */
106 AFMT_ENTRY("Speex","speex", NULL
, "spx\0" ),
107 /* SPC700 Save State */
109 AFMT_ENTRY("SPC", "spc", NULL
, "spc\0" ),
110 /* APE (Monkey's Audio) */
112 AFMT_ENTRY("APE", "ape", NULL
, "ape\0mac\0" ),
113 /* WMA (WMAV1/V2 in ASF) */
115 AFMT_ENTRY("WMA", "wma", NULL
, "wma\0wmv\0asf\0" ),
119 #if CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING)
120 /* get REC_FORMAT_* corresponding AFMT_* */
121 const int rec_format_afmt
[REC_NUM_FORMATS
] =
123 /* give AFMT_UNKNOWN by default */
124 [0 ... REC_NUM_FORMATS
-1] = AFMT_UNKNOWN
,
125 /* add new entries below this line */
126 [REC_FORMAT_AIFF
] = AFMT_AIFF
,
127 [REC_FORMAT_MPA_L3
] = AFMT_MPA_L3
,
128 [REC_FORMAT_WAVPACK
] = AFMT_WAVPACK
,
129 [REC_FORMAT_PCM_WAV
] = AFMT_PCM_WAV
,
132 /* get AFMT_* corresponding REC_FORMAT_* */
133 const int afmt_rec_format
[AFMT_NUM_CODECS
] =
135 /* give -1 by default */
136 [0 ... AFMT_NUM_CODECS
-1] = -1,
137 /* add new entries below this line */
138 [AFMT_AIFF
] = REC_FORMAT_AIFF
,
139 [AFMT_MPA_L3
] = REC_FORMAT_MPA_L3
,
140 [AFMT_WAVPACK
] = REC_FORMAT_WAVPACK
,
141 [AFMT_PCM_WAV
] = REC_FORMAT_PCM_WAV
,
143 #endif /* CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING) */
146 unsigned long unsync(unsigned long b0
,
151 return (((long)(b0
& 0x7F) << (3*7)) |
152 ((long)(b1
& 0x7F) << (2*7)) |
153 ((long)(b2
& 0x7F) << (1*7)) |
154 ((long)(b3
& 0x7F) << (0*7)));
157 static const char* const genres
[] = {
158 "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
159 "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
160 "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
161 "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
162 "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
163 "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
164 "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
165 "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
166 "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
167 "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
168 "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
169 "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
170 "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
172 /* winamp extensions */
173 "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
174 "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
175 "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
176 "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
177 "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
178 "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
179 "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
180 "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
181 "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
182 "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
183 "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
184 "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
188 char* id3_get_num_genre(unsigned int genre_num
)
190 if (genre_num
< sizeof(genres
)/sizeof(char*))
191 return (char*)genres
[genre_num
];
195 /* True if the string is from the "genres" array */
196 static bool id3_is_genre_string(const char *string
)
198 return ( string
>= genres
[0] &&
199 string
<= genres
[sizeof(genres
)/sizeof(char*) - 1] );
202 char* id3_get_codec(const struct mp3entry
* id3
)
204 if (id3
->codectype
< AFMT_NUM_CODECS
) {
205 return (char*)audio_formats
[id3
->codectype
].label
;
212 HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
213 Code and comments by Thomas Paul Diffenbach
215 To add another ID3v2 Tag, do the following:
216 1. add a char* named for the tag to struct mp3entry in id3.h,
217 (I (tpd) prefer to use char* rather than ints, even for what seems like
218 numerical values, for cases where a number won't do, e.g.,
219 YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
220 TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
221 Text is more flexible, and as the main use of id3 data is to
222 display it, converting it to an int just means reconverting to
223 display it, at a runtime cost.)
225 2. If any special processing beyond copying the tag value from the Id3
226 block to the struct mp3entry is rrequired (such as converting to an
227 int), write a function to perform this special processing.
229 This function's prototype must match that of
230 typedef tagPostProcessFunc, that is it must be:
231 int func( struct mp3entry*, char* tag, int bufferpos )
232 the first argument is a pointer to the current mp3entry structure the
233 second argument is a pointer to the null terminated string value of the
234 tag found the third argument is the offset of the next free byte in the
235 mp3entry's buffer your function should return the corrected offset; if
236 you don't lengthen or shorten the tag string, you can return the third
239 Unless you have a good reason no to, make the function static.
240 TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
242 3. add one or more entries to the tagList array, using the format:
243 char* ID3 Tag symbolic name -- see the ID3 specification for these,
244 sizeof() that name minus 1,
245 offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
246 pointer to your special processing function or NULL
247 if you need no special processing
248 flag indicating if this tag is binary or textual
249 Many ID3 symbolic names come in more than one form. You can add both
250 forms, each referencing the same variable in struct mp3entry.
251 If both forms are present, the last found will be used.
252 Note that the offset can be zero, in which case no entry will be set
253 in the mp3entry struct; the frame is still read into the buffer and
254 the special processing function is called (several times, if there
255 are several frames with the same name).
257 4. Alternately, use the TAG_LIST_ENTRY macro with
258 ID3 tag symbolic name,
259 variable in struct mp3entry,
260 special processing function address
262 5. Add code to wps-display.c function get_tag to assign a printf-like
263 format specifier for the tag */
265 /* Structure for ID3 Tag extraction information */
266 struct tag_resolver
{
270 int (*ppFunc
)(struct mp3entry
*, char* tag
, int bufferpos
);
274 static bool global_ff_found
;
276 static int unsynchronize(char* tag
, int len
, bool *ff_found
)
280 unsigned char *rp
, *wp
;
282 wp
= rp
= (unsigned char *)tag
;
284 rp
= (unsigned char *)tag
;
285 for(i
= 0;i
< len
;i
++) {
286 /* Read the next byte and write it back, but don't increment the
291 /* Increment the write pointer if it isn't an unsynch pattern */
301 return (long)wp
- (long)tag
;
304 static int unsynchronize_frame(char* tag
, int len
)
306 bool ff_found
= false;
308 return unsynchronize(tag
, len
, &ff_found
);
311 static int read_unsynched(int fd
, void *buf
, int len
)
323 rc
= read(fd
, rp
, remaining
);
327 i
= unsynchronize(wp
, remaining
, &global_ff_found
);
335 static int skip_unsynched(int fd
, int len
)
343 rlen
= MIN(sizeof(buf
), (unsigned int)remaining
);
344 rc
= read(fd
, buf
, rlen
);
348 remaining
-= unsynchronize(buf
, rlen
, &global_ff_found
);
354 /* parse numeric value from string */
355 static int parsetracknum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
357 entry
->tracknum
= atoi( tag
);
361 /* parse numeric value from string */
362 static int parsediscnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
364 entry
->discnum
= atoi( tag
);
368 /* parse numeric value from string */
369 static int parseyearnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
371 entry
->year
= atoi( tag
);
375 /* parse numeric genre from string, version 2.2 and 2.3 */
376 static int parsegenre( struct mp3entry
* entry
, char* tag
, int bufferpos
)
378 if(entry
->id3version
>= ID3_VER_2_4
) {
379 /* In version 2.4 and up, there are no parentheses, and the genre frame
380 is a list of strings, either numbers or text. */
382 /* Is it a number? */
383 if(isdigit(tag
[0])) {
384 entry
->genre_string
= id3_get_num_genre(atoi( tag
));
385 return tag
- entry
->id3v2buf
;
387 entry
->genre_string
= tag
;
391 if( tag
[0] == '(' && tag
[1] != '(' ) {
392 entry
->genre_string
= id3_get_num_genre(atoi( tag
+ 1 ));
393 return tag
- entry
->id3v2buf
;
396 entry
->genre_string
= tag
;
402 #if CONFIG_CODEC == SWCODEC
403 /* parse user defined text, looking for replaygain information. */
404 static int parseuser( struct mp3entry
* entry
, char* tag
, int bufferpos
)
407 int desc_len
= strlen(tag
);
410 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
411 /* At least part of the value was read, so we can safely try to
414 value
= tag
+ desc_len
+ 1;
415 value_len
= parse_replaygain(tag
, value
, entry
, tag
,
416 bufferpos
- (tag
- entry
->id3v2buf
));
419 return tag
- entry
->id3v2buf
+ value_len
;
422 /* parse RVA2 binary data and convert to replaygain information. */
423 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
425 int desc_len
= strlen(tag
);
426 int start_pos
= tag
- entry
->id3v2buf
;
427 int end_pos
= start_pos
+ desc_len
+ 5;
429 unsigned char* value
= tag
+ desc_len
+ 1;
431 /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
432 * type is master volume.
434 if (entry
->id3version
== ID3_VER_2_4
&& end_pos
< bufferpos
442 /* The RVA2 specification is unclear on some things (id string and
443 * peak volume), but this matches how Quod Libet use them.
446 gain
= (int16_t) ((value
[0] << 8) | value
[1]);
449 peakbytes
= (peakbits
+ 7) / 8;
451 /* Only use the topmost 24 bits for peak volume */
456 /* Make sure the peak bits were read */
457 if (end_pos
+ peakbytes
< bufferpos
) {
458 long shift
= ((8 - (peakbits
& 7)) & 7) + (3 - peakbytes
) * 8;
460 for ( ; peakbytes
; peakbytes
--) {
468 peak
+= *value
>> (8 - shift
);
472 if (strcasecmp(tag
, "album") == 0) {
474 } else if (strcasecmp(tag
, "track") != 0) {
475 /* Only accept non-track values if we don't have any previous
478 if (entry
->track_gain
!= 0) {
483 value_len
= parse_replaygain_int(album
, gain
, peak
* 2, entry
,
484 tag
, sizeof(entry
->id3v2buf
) - start_pos
);
487 return start_pos
+ value_len
;
491 static const struct tag_resolver taglist
[] = {
492 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
493 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
494 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
495 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
496 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
497 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
498 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
499 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
500 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
501 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
502 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
503 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
504 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
505 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
506 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
507 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
508 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
509 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
510 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
511 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
512 #if CONFIG_CODEC == SWCODEC
513 { "TXXX", 4, 0, &parseuser
, false },
514 { "RVA2", 4, 0, &parserva2
, true },
518 #define TAGLIST_SIZE ((int)(sizeof(taglist) / sizeof(taglist[0])))
520 /* Get the length of an ID3 string in the given encoding. Returns the length
521 * in bytes, including end nil, or -1 if the encoding is unknown.
523 static int unicode_len(char encoding
, const void* string
)
527 if (encoding
== 0x01 || encoding
== 0x02) {
529 const char *s
= string
;
530 /* string might be unaligned, so using short* can crash on ARM and SH1 */
533 } while ((first
| *s
++) != 0);
535 len
= s
- (const char*) string
;
537 len
= strlen((char*) string
) + 1;
543 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
544 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
545 we convert from the default codepage */
546 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
550 unsigned char *str
= (unsigned char *)string
;
552 unsigned char* utf8
= (unsigned char *)utf8buf
;
555 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
558 utf8
= iso_decode(str
, utf8
, -1, *len
);
560 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
563 case 0x01: /* Unicode with or without BOM */
568 /* Handle frames with more than one string
569 (needed for TXXX frames).*/
571 tmp
= bytes2int(0, 0, str
[0], str
[1]);
573 /* Now check if there is a BOM
574 (zero-width non-breaking space, 0xfeff)
575 and if it is in little or big endian format */
576 if(tmp
== 0xfffe) { /* Little endian? */
580 } else if(tmp
== 0xfeff) { /* Big endian? */
584 /* If there is no BOM (which is a specification violation),
585 let's try to guess it. If one of the bytes is 0x00, it is
586 probably the most significant one. */
592 utf8
= utf16LEdecode(str
, utf8
, 1);
594 utf8
= utf16BEdecode(str
, utf8
, 1);
598 } while((str
[0] || str
[1]) && (i
< *len
));
600 *utf8
++ = 0; /* Terminate the string */
601 templen
+= (strlen(&utf8buf
[templen
]) + 1);
608 case 0x03: /* UTF-8 encoded string */
609 for(i
=0; i
< *len
; i
++)
614 default: /* Plain old string */
615 utf8
= iso_decode(str
, utf8
, -1, *len
);
617 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
624 * Sets the title of an MP3 entry based on its ID3v1 tag.
626 * Arguments: file - the MP3 file to scen for a ID3v1 tag
627 * entry - the entry to set the title in
629 * Returns: true if a title was found and created, else false
631 static bool setid3v1title(int fd
, struct mp3entry
*entry
)
633 unsigned char buffer
[128];
634 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
638 if (-1 == lseek(fd
, -128, SEEK_END
))
641 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
644 if (strncmp((char *)buffer
, "TAG", 3))
647 entry
->id3v1len
= 128;
648 entry
->id3version
= ID3_VER_1_0
;
650 for (i
=0; i
< (int)sizeof offsets
; i
++) {
651 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
657 /* kill trailing space in strings */
658 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
660 /* convert string to utf8 */
661 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
662 utf8
= iso_decode(ptr
, utf8
, -1, 30);
663 /* make sure string is terminated */
668 /* kill trailing space in strings */
669 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
671 /* convert string to utf8 */
672 utf8
= (unsigned char *)entry
->id3v1buf
[3];
673 utf8
= iso_decode(ptr
, utf8
, -1, 28);
674 /* make sure string is terminated */
680 entry
->year
= atoi((char *)ptr
);
684 /* id3v1.1 uses last two bytes of comment field for track
685 number: first must be 0 and second is track num */
686 if (!ptr
[0] && ptr
[1]) {
687 entry
->tracknum
= ptr
[1];
688 entry
->id3version
= ID3_VER_1_1
;
694 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
699 entry
->title
= entry
->id3v1buf
[0];
700 entry
->artist
= entry
->id3v1buf
[1];
701 entry
->album
= entry
->id3v1buf
[2];
702 entry
->comment
= entry
->id3v1buf
[3];
709 * Sets the title of an MP3 entry based on its ID3v2 tag.
711 * Arguments: file - the MP3 file to scan for a ID3v2 tag
712 * entry - the entry to set the title in
714 * Returns: true if a title was found and created, else false
716 static void setid3v2title(int fd
, struct mp3entry
*entry
)
720 long bufferpos
= 0, totframelen
, framelen
;
723 unsigned char version
;
724 char *buffer
= entry
->id3v2buf
;
726 int buffersize
= sizeof(entry
->id3v2buf
);
727 unsigned char global_flags
;
730 bool global_unsynch
= false;
731 bool unsynch
= false;
736 global_ff_found
= false;
738 /* Bail out if the tag is shorter than 10 bytes */
739 if(entry
->id3v2len
< 10)
742 /* Read the ID3 tag version from the header */
743 lseek(fd
, 0, SEEK_SET
);
744 if(10 != read(fd
, header
, 10))
747 /* Get the total ID3 tag size */
748 size
= entry
->id3v2len
- 10;
753 version
= ID3_VER_2_2
;
758 version
= ID3_VER_2_3
;
763 version
= ID3_VER_2_4
;
768 /* unsupported id3 version */
771 entry
->id3version
= version
;
772 entry
->tracknum
= entry
->year
= entry
->discnum
= 0;
773 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
775 global_flags
= header
[5];
777 /* Skip the extended header if it is present */
778 if(global_flags
& 0x40) {
779 if(version
== ID3_VER_2_3
) {
780 if(10 != read(fd
, header
, 10))
782 /* The 2.3 extended header size doesn't include the header size
783 field itself. Also, it is not unsynched. */
785 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
787 /* Skip the rest of the header */
788 lseek(fd
, framelen
- 10, SEEK_CUR
);
791 if(version
>= ID3_VER_2_4
) {
792 if(4 != read(fd
, header
, 4))
795 /* The 2.4 extended header size does include the entire header,
796 so here we can just skip it. This header is unsynched. */
797 framelen
= unsync(header
[0], header
[1],
798 header
[2], header
[3]);
800 lseek(fd
, framelen
- 4, SEEK_CUR
);
804 /* Is unsynchronization applied? */
805 if(global_flags
& 0x80) {
806 global_unsynch
= true;
810 * We must have at least minframesize bytes left for the
811 * remaining frames to be interesting
813 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
816 /* Read frame header and check length */
817 if(version
>= ID3_VER_2_3
) {
818 if(global_unsynch
&& version
<= ID3_VER_2_3
)
819 rc
= read_unsynched(fd
, header
, 10);
821 rc
= read(fd
, header
, 10);
824 /* Adjust for the 10 bytes we read */
827 flags
= bytes2int(0, 0, header
[8], header
[9]);
829 if (version
>= ID3_VER_2_4
) {
830 framelen
= unsync(header
[4], header
[5],
831 header
[6], header
[7]);
833 /* version .3 files don't use synchsafe ints for
835 framelen
= bytes2int(header
[4], header
[5],
836 header
[6], header
[7]);
839 if(6 != read(fd
, header
, 6))
841 /* Adjust for the 6 bytes we read */
844 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
847 logf("framelen = %ld", framelen
);
849 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
862 if (version
>= ID3_VER_2_4
) {
863 if(flags
& 0x0040) { /* Grouping identity */
864 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
868 if(flags
& 0x0020) { /* Grouping identity */
869 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
874 if(flags
& 0x000c) /* Compression or encryption */
878 lseek(fd
, framelen
, SEEK_CUR
);
882 if(flags
& 0x0002) /* Unsynchronization */
885 if (version
>= ID3_VER_2_4
) {
886 if(flags
& 0x0001) { /* Data length indicator */
887 if(4 != read(fd
, tmp
, 4))
890 data_length_ind
= unsync(tmp
[0], tmp
[1], tmp
[2], tmp
[3]);
896 /* Keep track of the remaining frame size */
897 totframelen
= framelen
;
899 /* If the frame is larger than the remaining buffer space we try
900 to read as much as would fit in the buffer */
901 if(framelen
>= buffersize
- bufferpos
)
902 framelen
= buffersize
- bufferpos
- 1;
904 logf("id3v2 frame: %.4s", header
);
906 /* Check for certain frame headers
908 'size' is the amount of frame bytes remaining. We decrement it by
909 the amount of bytes we read. If we fail to read as many bytes as
910 we expect, we assume that we can't read from this file, and bail
913 For each frame. we will iterate over the list of supported tags,
914 and read the tag into entry's buffer. All tags will be kept as
915 strings, for cases where a number won't do, e.g., YEAR: "circa
916 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
917 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
918 flexible, and as the main use of id3 data is to display it,
919 converting it to an int just means reconverting to display it, at a
922 For tags that the current code does convert to ints, a post
923 processing function will be called via a pointer to function. */
925 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
926 const struct tag_resolver
* tr
= &taglist
[i
];
927 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
931 /* Only ID3_VER_2_2 uses frames with three-character names. */
932 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
933 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
937 /* Note that parser functions sometimes set *ptag to NULL, so
938 * the "!*ptag" check here doesn't always have the desired
939 * effect. Should the parser functions (parsegenre in
940 * particular) be updated to handle the case of being called
941 * multiple times, or should the "*ptag" check be removed?
943 if( (!ptag
|| !*ptag
) && !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
945 /* found a tag matching one in tagList, and not yet filled */
946 tag
= buffer
+ bufferpos
;
948 if(global_unsynch
&& version
<= ID3_VER_2_3
)
949 bytesread
= read_unsynched(fd
, tag
, framelen
);
951 bytesread
= read(fd
, tag
, framelen
);
953 if( bytesread
!= framelen
)
958 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
959 bytesread
= unsynchronize_frame(tag
, bytesread
);
961 /* the COMM frame has a 3 char field to hold an ISO-639-1
962 * language string and an optional short description;
963 * remove them so unicode_munge can work correctly
966 if(!memcmp( header
, "COMM", 4 )) {
968 /* ignore comments with iTunes 7 soundcheck/gapless data */
969 if(!strncmp(tag
+4, "iTun", 4))
971 offset
= 3 + unicode_len(*tag
, tag
+ 4);
972 if(bytesread
> offset
) {
974 memmove(tag
+ 1, tag
+ 1 + offset
, bytesread
- 1);
978 /* Attempt to parse Unicode string only if the tag contents
981 /* UTF-8 could potentially be 3 times larger */
982 /* so we need to create a new buffer */
983 char utf8buf
[(3 * bytesread
) + 1];
985 unicode_munge( tag
, utf8buf
, &bytesread
);
987 if(bytesread
>= buffersize
- bufferpos
)
988 bytesread
= buffersize
- bufferpos
- 1;
990 for (j
= 0; j
< bytesread
; j
++)
993 /* remove trailing spaces */
994 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
999 bufferpos
+= bytesread
+ 1;
1005 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
1007 /* Seek to the next frame */
1008 if(framelen
< totframelen
)
1009 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
1014 if( i
== TAGLIST_SIZE
) {
1015 /* no tag in tagList was found, or it was a repeat.
1016 skip it using the total size */
1018 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
1019 size
-= skip_unsynched(fd
, totframelen
);
1022 totframelen
= data_length_ind
;
1024 size
-= totframelen
;
1025 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
1033 * Calculates the size of the ID3v2 tag.
1035 * Arguments: file - the file to search for a tag.
1037 * Returns: the size of the tag or 0 if none was found
1039 int getid3v2len(int fd
)
1044 /* Make sure file has a ID3 tag */
1045 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
1046 (read(fd
, buf
, 6) != 6) ||
1047 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
1050 /* Now check what the ID3v2 size field says */
1052 if(read(fd
, buf
, 4) != 4)
1055 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
1057 logf("ID3V2 Length: 0x%x", offset
);
1062 * Calculates the length (in milliseconds) of an MP3 file.
1064 * Modified to only use integers.
1066 * Arguments: file - the file to calculate the length upon
1067 * entry - the entry to update with the length
1069 * Returns: the song length in milliseconds,
1070 * 0 means that it couldn't be calculated
1072 static int getsonglength(int fd
, struct mp3entry
*entry
)
1074 unsigned long filetime
= 0;
1075 struct mp3info info
;
1078 /* Start searching after ID3v2 header */
1079 if(-1 == lseek(fd
, entry
->id3v2len
, SEEK_SET
))
1082 bytecount
= get_mp3file_info(fd
, &info
);
1084 logf("Space between ID3V2 tag and first audio frame: 0x%lx bytes",
1090 bytecount
+= entry
->id3v2len
;
1092 /* Validate byte count, in case the file has been edited without
1093 * updating the header.
1095 if (info
.byte_count
)
1097 const unsigned long expected
= entry
->filesize
- entry
->id3v1len
1099 const unsigned long diff
= MAX(10240, info
.byte_count
/ 20);
1101 if ((info
.byte_count
> expected
+ diff
)
1102 || (info
.byte_count
< expected
- diff
))
1104 logf("Note: info.byte_count differs from expected value by "
1105 "%ld bytes", labs((long) (expected
- info
.byte_count
)));
1106 info
.byte_count
= 0;
1107 info
.frame_count
= 0;
1109 info
.enc_padding
= 0;
1111 /* Even if the bitrate was based on "known bad" values, it
1112 * should still be better for VBR files than using the bitrate
1113 * of the first audio frame.
1118 entry
->bitrate
= info
.bitrate
;
1119 entry
->frequency
= info
.frequency
;
1120 entry
->version
= info
.version
;
1121 entry
->layer
= info
.layer
;
1122 switch(entry
->layer
) {
1123 #if CONFIG_CODEC==SWCODEC
1125 entry
->codectype
=AFMT_MPA_L1
;
1129 entry
->codectype
=AFMT_MPA_L2
;
1132 entry
->codectype
=AFMT_MPA_L3
;
1136 /* If the file time hasn't been established, this may be a fixed
1137 rate MP3, so just use the default formula */
1139 filetime
= info
.file_time
;
1143 /* Prevent a division by zero */
1144 if (info
.bitrate
< 8)
1147 filetime
= (entry
->filesize
- bytecount
) / (info
.bitrate
/ 8);
1148 /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
1149 * instead of filesize * 8 is exact, because mpeg audio bitrates are
1150 * always multiples of 8, and it avoids overflows. */
1153 entry
->frame_count
= info
.frame_count
;
1155 entry
->vbr
= info
.is_vbr
;
1156 entry
->has_toc
= info
.has_toc
;
1158 #if CONFIG_CODEC==SWCODEC
1159 entry
->lead_trim
= info
.enc_delay
;
1160 entry
->tail_trim
= info
.enc_padding
;
1163 memcpy(entry
->toc
, info
.toc
, sizeof(info
.toc
));
1165 entry
->vbr_header_pos
= info
.vbr_header_pos
;
1167 /* Update the seek point for the first playable frame */
1168 entry
->first_frame_offset
= bytecount
;
1169 logf("First frame is at %lx", entry
->first_frame_offset
);
1175 * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
1176 * about an MP3 file and updates it's entry accordingly.
1178 Note, that this returns true for successful, false for error! */
1179 bool get_mp3_metadata(int fd
, struct mp3entry
*entry
, const char *filename
)
1181 #if CONFIG_CODEC != SWCODEC
1182 memset(entry
, 0, sizeof(struct mp3entry
));
1185 strncpy(entry
->path
, filename
, sizeof(entry
->path
));
1187 entry
->title
= NULL
;
1188 entry
->filesize
= filesize(fd
);
1189 entry
->id3v2len
= getid3v2len(fd
);
1190 entry
->tracknum
= 0;
1193 if (entry
->id3v2len
)
1194 setid3v2title(fd
, entry
);
1195 int len
= getsonglength(fd
, entry
);
1198 entry
->length
= len
;
1200 /* Subtract the meta information from the file size to get
1201 the true size of the MP3 stream */
1202 entry
->filesize
-= entry
->first_frame_offset
;
1204 /* only seek to end of file if no id3v2 tags were found */
1205 if (!entry
->id3v2len
) {
1206 setid3v1title(fd
, entry
);
1209 if(!entry
->length
|| (entry
->filesize
< 8 ))
1210 /* no song length or less than 8 bytes is hereby considered to be an
1211 invalid mp3 and won't be played by us! */
1217 /* Note, that this returns false for successful, true for error! */
1218 bool mp3info(struct mp3entry
*entry
, const char *filename
)
1223 fd
= open(filename
, O_RDONLY
);
1227 result
= !get_mp3_metadata(fd
, entry
, filename
);
1234 void adjust_mp3entry(struct mp3entry
*entry
, void *dest
, const void *orig
)
1238 offset
= - ((size_t)orig
- (size_t)dest
);
1240 offset
= (size_t)dest
- (size_t)orig
;
1243 entry
->title
+= offset
;
1245 entry
->artist
+= offset
;
1247 entry
->album
+= offset
;
1248 if (entry
->genre_string
&& !id3_is_genre_string(entry
->genre_string
))
1249 /* Don't adjust that if it points to an entry of the "genres" array */
1250 entry
->genre_string
+= offset
;
1251 if (entry
->track_string
)
1252 entry
->track_string
+= offset
;
1253 if (entry
->disc_string
)
1254 entry
->disc_string
+= offset
;
1255 if (entry
->year_string
)
1256 entry
->year_string
+= offset
;
1257 if (entry
->composer
)
1258 entry
->composer
+= offset
;
1260 entry
->comment
+= offset
;
1261 if (entry
->albumartist
)
1262 entry
->albumartist
+= offset
;
1263 if (entry
->grouping
)
1264 entry
->grouping
+= offset
;
1265 #if CONFIG_CODEC == SWCODEC
1266 if (entry
->track_gain_string
)
1267 entry
->track_gain_string
+= offset
;
1268 if (entry
->album_gain_string
)
1269 entry
->album_gain_string
+= offset
;
1273 void copy_mp3entry(struct mp3entry
*dest
, const struct mp3entry
*orig
)
1275 memcpy(dest
, orig
, sizeof(struct mp3entry
));
1276 adjust_mp3entry(dest
, dest
, orig
);
1279 #ifdef DEBUG_STANDALONE
1281 char *secs2str(int ms
)
1283 static char buffer
[32];
1286 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1290 int main(int argc
, char **argv
)
1293 for(i
=1; i
<argc
; i
++) {
1294 struct mp3entry mp3
;
1295 mp3
.album
= "Bogus";
1296 if(mp3info(&mp3
, argv
[i
], false)) {
1297 printf("Failed to get %s\n", argv
[i
]);
1301 printf("****** File: %s\n"
1305 " Genre: %s (%d) \n"
1309 " Length: %s / %d s\n"
1313 mp3
.title
?mp3
.title
:"<blank>",
1314 mp3
.artist
?mp3
.artist
:"<blank>",
1315 mp3
.album
?mp3
.album
:"<blank>",
1316 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1318 mp3
.composer
?mp3
.composer
:"<blank>",
1319 mp3
.year_string
?mp3
.year_string
:"<blank>",
1321 mp3
.track_string
?mp3
.track_string
:"<blank>",
1323 secs2str(mp3
.length
),