1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by Daniel Stenberg
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
22 * Parts of this code has been stolen from the Ample project and was written
23 * by David H�deman. It has since been extended and enhanced pretty much by
24 * all sorts of friendly Rockbox people.
28 /* tagResolver and associated code copyright 2003 Thomas Paul Diffenbach
38 #include "string-extra.h"
43 #include "replaygain.h"
44 #include "rbunicode.h"
48 #if CONFIG_CODEC == SWCODEC
49 #include "metadata_common.h"
51 #include "metadata_parsers.h"
53 static unsigned long unsync(unsigned long b0
,
58 return (((long)(b0
& 0x7F) << (3*7)) |
59 ((long)(b1
& 0x7F) << (2*7)) |
60 ((long)(b2
& 0x7F) << (1*7)) |
61 ((long)(b3
& 0x7F) << (0*7)));
64 static const char* const genres
[] = {
65 "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
66 "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
67 "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
68 "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
69 "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
70 "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
71 "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
72 "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
73 "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
74 "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
75 "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
76 "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
77 "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
79 /* winamp extensions */
80 "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
81 "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
82 "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
83 "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
84 "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
85 "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
86 "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
87 "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
88 "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
89 "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
90 "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
91 "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
95 char* id3_get_num_genre(unsigned int genre_num
)
97 if (genre_num
< ARRAYLEN(genres
))
98 return (char*)genres
[genre_num
];
103 HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
104 Code and comments by Thomas Paul Diffenbach
106 To add another ID3v2 Tag, do the following:
107 1. add a char* named for the tag to struct mp3entry in id3.h,
108 (I (tpd) prefer to use char* rather than ints, even for what seems like
109 numerical values, for cases where a number won't do, e.g.,
110 YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
111 TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
112 Text is more flexible, and as the main use of id3 data is to
113 display it, converting it to an int just means reconverting to
114 display it, at a runtime cost.)
116 2. If any special processing beyond copying the tag value from the Id3
117 block to the struct mp3entry is rrequired (such as converting to an
118 int), write a function to perform this special processing.
120 This function's prototype must match that of
121 typedef tagPostProcessFunc, that is it must be:
122 int func( struct mp3entry*, char* tag, int bufferpos )
123 the first argument is a pointer to the current mp3entry structure the
124 second argument is a pointer to the null terminated string value of the
125 tag found the third argument is the offset of the next free byte in the
126 mp3entry's buffer your function should return the corrected offset; if
127 you don't lengthen or shorten the tag string, you can return the third
130 Unless you have a good reason no to, make the function static.
131 TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
133 3. add one or more entries to the tagList array, using the format:
134 char* ID3 Tag symbolic name -- see the ID3 specification for these,
135 sizeof() that name minus 1,
136 offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
137 pointer to your special processing function or NULL
138 if you need no special processing
139 flag indicating if this tag is binary or textual
140 Many ID3 symbolic names come in more than one form. You can add both
141 forms, each referencing the same variable in struct mp3entry.
142 If both forms are present, the last found will be used.
143 Note that the offset can be zero, in which case no entry will be set
144 in the mp3entry struct; the frame is still read into the buffer and
145 the special processing function is called (several times, if there
146 are several frames with the same name).
148 4. Alternately, use the TAG_LIST_ENTRY macro with
149 ID3 tag symbolic name,
150 variable in struct mp3entry,
151 special processing function address
153 5. Add code to wps-display.c function get_tag to assign a printf-like
154 format specifier for the tag */
156 /* Structure for ID3 Tag extraction information */
157 struct tag_resolver
{
161 int (*ppFunc
)(struct mp3entry
*, char* tag
, int bufferpos
);
165 static bool global_ff_found
;
167 static int unsynchronize(char* tag
, int len
, bool *ff_found
)
171 unsigned char *rp
, *wp
;
173 wp
= rp
= (unsigned char *)tag
;
175 rp
= (unsigned char *)tag
;
176 for(i
= 0;i
< len
;i
++) {
177 /* Read the next byte and write it back, but don't increment the
182 /* Increment the write pointer if it isn't an unsynch pattern */
192 return (long)wp
- (long)tag
;
195 static int unsynchronize_frame(char* tag
, int len
)
197 bool ff_found
= false;
199 return unsynchronize(tag
, len
, &ff_found
);
202 static int read_unsynched(int fd
, void *buf
, int len
)
214 rc
= read(fd
, rp
, remaining
);
218 i
= unsynchronize(wp
, remaining
, &global_ff_found
);
226 static int skip_unsynched(int fd
, int len
)
234 rlen
= MIN(sizeof(buf
), (unsigned int)remaining
);
235 rc
= read(fd
, buf
, rlen
);
239 remaining
-= unsynchronize(buf
, rlen
, &global_ff_found
);
245 /* parse numeric value from string */
246 static int parsetracknum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
248 entry
->tracknum
= atoi( tag
);
252 /* parse numeric value from string */
253 static int parsediscnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
255 entry
->discnum
= atoi( tag
);
259 /* parse numeric value from string */
260 static int parseyearnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
262 entry
->year
= atoi( tag
);
266 /* parse numeric genre from string, version 2.2 and 2.3 */
267 static int parsegenre( struct mp3entry
* entry
, char* tag
, int bufferpos
)
269 /* Use bufferpos to hold current position in entry->id3v2buf. */
270 bufferpos
= tag
- entry
->id3v2buf
;
272 if(entry
->id3version
>= ID3_VER_2_4
) {
273 /* In version 2.4 and up, there are no parentheses, and the genre frame
274 is a list of strings, either numbers or text. */
276 /* Is it a number? */
277 if(isdigit(tag
[0])) {
278 entry
->genre_string
= id3_get_num_genre(atoi( tag
));
281 entry
->genre_string
= tag
;
282 return bufferpos
+ strlen(tag
) + 1;
285 if( tag
[0] == '(' && tag
[1] != '(' ) {
286 entry
->genre_string
= id3_get_num_genre(atoi( tag
+ 1 ));
290 entry
->genre_string
= tag
;
291 return bufferpos
+ strlen(tag
) + 1;
297 /* parse embed albumart */
298 static int parsealbumart( struct mp3entry
* entry
, char* tag
, int bufferpos
)
300 entry
->embed_albumart
= false;
302 /* we currently don't support unsynchronizing albumart */
303 if (entry
->albumart
.type
== AA_TYPE_UNSYNC
)
306 entry
->albumart
.type
= AA_TYPE_UNKNOWN
;
309 /* skip text encoding */
312 if (memcmp(tag
, "image/", 6) == 0)
316 if (strcmp(tag
, "jpeg") == 0)
318 entry
->albumart
.type
= AA_TYPE_JPG
;
321 else if (strcmp(tag
, "png") == 0)
323 entry
->albumart
.type
= AA_TYPE_PNG
;
330 if (memcmp(tag
, "JPG", 3) == 0)
331 entry
->albumart
.type
= AA_TYPE_JPG
;
332 else if (memcmp(tag
, "PNG", 3) == 0)
333 entry
->albumart
.type
= AA_TYPE_PNG
;
337 if (entry
->albumart
.type
!= AA_TYPE_UNKNOWN
)
339 /* skip picture type */
341 /* skip description */
342 tag
= strchr(tag
, '\0') + 1;
343 /* fixup offset&size for image data */
344 entry
->albumart
.pos
+= tag
- start
;
345 entry
->albumart
.size
-= tag
- start
;
346 entry
->embed_albumart
= true;
348 /* return bufferpos as we didn't store anything in id3v2buf */
353 /* parse user defined text, looking for album artist and replaygain
356 static int parseuser( struct mp3entry
* entry
, char* tag
, int bufferpos
)
359 int desc_len
= strlen(tag
);
362 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
363 /* At least part of the value was read, so we can safely try to
365 value
= tag
+ desc_len
+ 1;
367 if (!strcasecmp(tag
, "ALBUM ARTIST")) {
368 length
= strlen(value
) + 1;
369 strlcpy(tag
, value
, length
);
370 entry
->albumartist
= tag
;
371 #if CONFIG_CODEC == SWCODEC
373 /* Call parse_replaygain(). */
374 parse_replaygain(tag
, value
, entry
);
379 return tag
- entry
->id3v2buf
+ length
;
382 #if CONFIG_CODEC == SWCODEC
383 /* parse RVA2 binary data and convert to replaygain information. */
384 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
386 int desc_len
= strlen(tag
);
387 int start_pos
= tag
- entry
->id3v2buf
;
388 int end_pos
= start_pos
+ desc_len
+ 5;
389 unsigned char* value
= tag
+ desc_len
+ 1;
391 /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
392 * type is master volume.
394 if (entry
->id3version
== ID3_VER_2_4
&& end_pos
< bufferpos
402 /* The RVA2 specification is unclear on some things (id string and
403 * peak volume), but this matches how Quod Libet use them.
406 gain
= (int16_t) ((value
[0] << 8) | value
[1]);
409 peakbytes
= (peakbits
+ 7) / 8;
411 /* Only use the topmost 24 bits for peak volume */
416 /* Make sure the peak bits were read */
417 if (end_pos
+ peakbytes
< bufferpos
) {
418 long shift
= ((8 - (peakbits
& 7)) & 7) + (3 - peakbytes
) * 8;
420 for ( ; peakbytes
; peakbytes
--) {
428 peak
+= *value
>> (8 - shift
);
432 if (strcasecmp(tag
, "album") == 0) {
434 } else if (strcasecmp(tag
, "track") != 0) {
435 /* Only accept non-track values if we don't have any previous
438 if (entry
->track_gain
!= 0) {
443 parse_replaygain_int(album
, gain
, peak
* 2, entry
);
450 static int parsembtid( struct mp3entry
* entry
, char* tag
, int bufferpos
)
453 int desc_len
= strlen(tag
);
454 /*DEBUGF("MBID len: %d\n", desc_len);*/
455 /* Musicbrainz track IDs are always 36 chars long */
456 const size_t mbtid_len
= 36;
458 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
)
460 value
= tag
+ desc_len
+ 1;
462 if (strcasecmp(tag
, "http://musicbrainz.org") == 0)
464 if (mbtid_len
== strlen(value
))
466 entry
->mb_track_id
= value
;
467 return bufferpos
+ mbtid_len
+ 1;
475 static const struct tag_resolver taglist
[] = {
476 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
477 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
478 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
479 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
480 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
481 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
482 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
483 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
484 { "TPA", 3, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
485 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
486 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
487 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
488 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
489 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
490 { "TCM", 3, offsetof(struct mp3entry
, composer
), NULL
, false },
491 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
492 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
493 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
494 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
495 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
496 { "COM", 3, offsetof(struct mp3entry
, comment
), NULL
, false },
497 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
498 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
500 { "APIC", 4, 0, &parsealbumart
, true },
501 { "PIC", 3, 0, &parsealbumart
, true },
503 { "TXXX", 4, 0, &parseuser
, false },
504 #if CONFIG_CODEC == SWCODEC
505 { "RVA2", 4, 0, &parserva2
, true },
507 { "UFID", 4, 0, &parsembtid
, false },
510 #define TAGLIST_SIZE ((int)ARRAYLEN(taglist))
512 /* Get the length of an ID3 string in the given encoding. Returns the length
513 * in bytes, including end nil, or -1 if the encoding is unknown.
515 static int unicode_len(char encoding
, const void* string
)
519 if (encoding
== 0x01 || encoding
== 0x02) {
521 const char *s
= string
;
522 /* string might be unaligned, so using short* can crash on ARM and SH1 */
525 } while ((first
| *s
++) != 0);
527 len
= s
- (const char*) string
;
529 len
= strlen((char*) string
) + 1;
535 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
536 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
537 we convert from the default codepage */
538 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
542 unsigned char *str
= (unsigned char *)string
;
544 unsigned char* utf8
= (unsigned char *)utf8buf
;
547 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
550 utf8
= iso_decode(str
, utf8
, -1, *len
);
552 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
555 case 0x01: /* Unicode with or without BOM */
560 /* Handle frames with more than one string
561 (needed for TXXX frames).*/
563 tmp
= bytes2int(0, 0, str
[0], str
[1]);
565 /* Now check if there is a BOM
566 (zero-width non-breaking space, 0xfeff)
567 and if it is in little or big endian format */
568 if(tmp
== 0xfffe) { /* Little endian? */
572 } else if(tmp
== 0xfeff) { /* Big endian? */
576 /* If there is no BOM (which is a specification violation),
577 let's try to guess it. If one of the bytes is 0x00, it is
578 probably the most significant one. */
584 utf8
= utf16LEdecode(str
, utf8
, 1);
586 utf8
= utf16BEdecode(str
, utf8
, 1);
590 } while((str
[0] || str
[1]) && (i
< *len
));
592 *utf8
++ = 0; /* Terminate the string */
593 templen
+= (strlen(&utf8buf
[templen
]) + 1);
600 case 0x03: /* UTF-8 encoded string */
601 for(i
=0; i
< *len
; i
++)
606 default: /* Plain old string */
607 utf8
= iso_decode(str
, utf8
, -1, *len
);
609 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
616 * Sets the title of an MP3 entry based on its ID3v1 tag.
618 * Arguments: file - the MP3 file to scen for a ID3v1 tag
619 * entry - the entry to set the title in
621 * Returns: true if a title was found and created, else false
623 bool setid3v1title(int fd
, struct mp3entry
*entry
)
625 unsigned char buffer
[128];
626 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
630 if (-1 == lseek(fd
, -128, SEEK_END
))
633 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
636 if (strncmp((char *)buffer
, "TAG", 3))
639 entry
->id3v1len
= 128;
640 entry
->id3version
= ID3_VER_1_0
;
642 for (i
=0; i
< (int)sizeof offsets
; i
++) {
643 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
649 /* kill trailing space in strings */
650 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
652 /* convert string to utf8 */
653 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
654 utf8
= iso_decode(ptr
, utf8
, -1, 30);
655 /* make sure string is terminated */
660 /* kill trailing space in strings */
661 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
663 /* convert string to utf8 */
664 utf8
= (unsigned char *)entry
->id3v1buf
[3];
665 utf8
= iso_decode(ptr
, utf8
, -1, 28);
666 /* make sure string is terminated */
672 entry
->year
= atoi((char *)ptr
);
676 /* id3v1.1 uses last two bytes of comment field for track
677 number: first must be 0 and second is track num */
678 if (!ptr
[0] && ptr
[1]) {
679 entry
->tracknum
= ptr
[1];
680 entry
->id3version
= ID3_VER_1_1
;
686 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
691 entry
->title
= entry
->id3v1buf
[0];
692 entry
->artist
= entry
->id3v1buf
[1];
693 entry
->album
= entry
->id3v1buf
[2];
694 entry
->comment
= entry
->id3v1buf
[3];
701 * Sets the title of an MP3 entry based on its ID3v2 tag.
703 * Arguments: file - the MP3 file to scan for a ID3v2 tag
704 * entry - the entry to set the title in
706 * Returns: true if a title was found and created, else false
708 void setid3v2title(int fd
, struct mp3entry
*entry
)
712 long bufferpos
= 0, totframelen
, framelen
;
715 unsigned char version
;
716 char *buffer
= entry
->id3v2buf
;
718 int buffersize
= sizeof(entry
->id3v2buf
);
719 unsigned char global_flags
;
721 bool global_unsynch
= false;
722 bool unsynch
= false;
725 #if CONFIG_CODEC == SWCODEC
726 bool itunes_gapless
= 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, flags = 0x%04x", framelen
, flags
);
842 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 /* We don't need the data length */
892 /* Keep track of the remaining frame size */
893 totframelen
= framelen
;
895 /* If the frame is larger than the remaining buffer space we try
896 to read as much as would fit in the buffer */
897 if(framelen
>= buffersize
- bufferpos
)
898 framelen
= buffersize
- bufferpos
- 1;
900 /* Limit the maximum length of an id3 data item to ID3V2_MAX_ITEM_SIZE
901 bytes. This reduces the chance that the available buffer is filled
902 by single metadata items like large comments. */
903 if (ID3V2_MAX_ITEM_SIZE
< framelen
)
904 framelen
= ID3V2_MAX_ITEM_SIZE
;
906 logf("id3v2 frame: %.4s", header
);
908 /* Check for certain frame headers
910 'size' is the amount of frame bytes remaining. We decrement it by
911 the amount of bytes we read. If we fail to read as many bytes as
912 we expect, we assume that we can't read from this file, and bail
915 For each frame. we will iterate over the list of supported tags,
916 and read the tag into entry's buffer. All tags will be kept as
917 strings, for cases where a number won't do, e.g., YEAR: "circa
918 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
919 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
920 flexible, and as the main use of id3 data is to display it,
921 converting it to an int just means reconverting to display it, at a
924 For tags that the current code does convert to ints, a post
925 processing function will be called via a pointer to function. */
927 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
928 const struct tag_resolver
* tr
= &taglist
[i
];
929 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
933 /* Only ID3_VER_2_2 uses frames with three-character names. */
934 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
935 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
939 if( !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
941 /* found a tag matching one in tagList, and not yet filled */
942 tag
= buffer
+ bufferpos
;
944 if(global_unsynch
&& version
<= ID3_VER_2_3
)
945 bytesread
= read_unsynched(fd
, tag
, framelen
);
947 bytesread
= read(fd
, tag
, framelen
);
949 if( bytesread
!= framelen
)
954 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
955 bytesread
= unsynchronize_frame(tag
, bytesread
);
957 /* the COMM frame has a 3 char field to hold an ISO-639-1
958 * language string and an optional short description;
959 * remove them so unicode_munge can work correctly
962 if((tr
->tag_length
== 4 && !memcmp( header
, "COMM", 4)) ||
963 (tr
->tag_length
== 3 && !memcmp( header
, "COM", 3))) {
965 if(!strncmp(tag
+4, "iTun", 4)) {
966 #if CONFIG_CODEC == SWCODEC
967 /* check for iTunes gapless information */
968 if(!strncmp(tag
+4, "iTunSMPB", 8))
969 itunes_gapless
= true;
972 /* ignore other with iTunes tags */
976 offset
= 3 + unicode_len(*tag
, tag
+ 4);
977 if(bytesread
> offset
) {
979 memmove(tag
+ 1, tag
+ 1 + offset
, bytesread
- 1);
983 /* Attempt to parse Unicode string only if the tag contents
986 /* UTF-8 could potentially be 3 times larger */
987 /* so we need to create a new buffer */
988 char utf8buf
[(3 * bytesread
) + 1];
990 unicode_munge( tag
, utf8buf
, &bytesread
);
992 if(bytesread
>= buffersize
- bufferpos
)
993 bytesread
= buffersize
- bufferpos
- 1;
995 for (j
= 0; j
< bytesread
; j
++)
998 /* remove trailing spaces */
999 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
1004 bufferpos
+= bytesread
+ 1;
1006 #if CONFIG_CODEC == SWCODEC
1007 /* parse the tag if it contains iTunes gapless info */
1010 itunes_gapless
= false;
1011 entry
->lead_trim
= get_itunes_int32(tag
, 1);
1012 entry
->tail_trim
= get_itunes_int32(tag
, 2);
1016 /* Note that parser functions sometimes set *ptag to NULL, so
1017 * the "!*ptag" check here doesn't always have the desired
1018 * effect. Should the parser functions (parsegenre in
1019 * particular) be updated to handle the case of being called
1020 * multiple times, or should the "*ptag" check be removed?
1025 #ifdef HAVE_ALBUMART
1027 if ((!entry
->embed_albumart
) &&
1028 ((tr
->tag_length
== 4 && !memcmp( header
, "APIC", 4)) ||
1029 (tr
->tag_length
== 3 && !memcmp( header
, "PIC" , 3))))
1031 if (unsynch
|| (global_unsynch
&& version
<= ID3_VER_2_3
))
1032 entry
->albumart
.type
= AA_TYPE_UNSYNC
;
1035 entry
->albumart
.pos
= lseek(fd
, 0, SEEK_CUR
) - framelen
;
1036 entry
->albumart
.size
= totframelen
;
1037 entry
->albumart
.type
= AA_TYPE_UNKNOWN
;
1042 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
1044 /* Seek to the next frame */
1045 if(framelen
< totframelen
)
1046 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
1051 if( i
== TAGLIST_SIZE
) {
1052 /* no tag in tagList was found, or it was a repeat.
1053 skip it using the total size */
1055 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
1056 size
-= skip_unsynched(fd
, totframelen
);
1058 size
-= totframelen
;
1059 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
1067 * Calculates the size of the ID3v2 tag.
1069 * Arguments: file - the file to search for a tag.
1071 * Returns: the size of the tag or 0 if none was found
1073 int getid3v2len(int fd
)
1078 /* Make sure file has a ID3 tag */
1079 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
1080 (read(fd
, buf
, 6) != 6) ||
1081 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
1084 /* Now check what the ID3v2 size field says */
1086 if(read(fd
, buf
, 4) != 4)
1089 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
1091 logf("ID3V2 Length: 0x%x", offset
);
1095 #ifdef DEBUG_STANDALONE
1097 char *secs2str(int ms
)
1099 static char buffer
[32];
1102 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1106 int main(int argc
, char **argv
)
1109 for(i
=1; i
<argc
; i
++) {
1110 struct mp3entry mp3
;
1111 mp3
.album
= "Bogus";
1112 if(mp3info(&mp3
, argv
[i
], false)) {
1113 printf("Failed to get %s\n", argv
[i
]);
1117 printf("****** File: %s\n"
1121 " Genre: %s (%d) \n"
1125 " Length: %s / %d s\n"
1129 mp3
.title
?mp3
.title
:"<blank>",
1130 mp3
.artist
?mp3
.artist
:"<blank>",
1131 mp3
.album
?mp3
.album
:"<blank>",
1132 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1134 mp3
.composer
?mp3
.composer
:"<blank>",
1135 mp3
.year_string
?mp3
.year_string
:"<blank>",
1137 mp3
.track_string
?mp3
.track_string
:"<blank>",
1139 secs2str(mp3
.length
),