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 /* Calculate residual buffer size in bytes which can be used by
374 * parse_replaygain() to save the string representation of
376 length
= sizeof(entry
->id3v2buf
) - (tag
- entry
->id3v2buf
);
378 /* Call parse_replaygain(), returns length in bytes used by the
379 * string representation of replaygain data. */
380 length
= parse_replaygain(tag
, value
, entry
, tag
, length
);
385 return tag
- entry
->id3v2buf
+ length
;
388 #if CONFIG_CODEC == SWCODEC
389 /* parse RVA2 binary data and convert to replaygain information. */
390 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
392 int desc_len
= strlen(tag
);
393 int start_pos
= tag
- entry
->id3v2buf
;
394 int end_pos
= start_pos
+ desc_len
+ 5;
396 unsigned char* value
= tag
+ desc_len
+ 1;
398 /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
399 * type is master volume.
401 if (entry
->id3version
== ID3_VER_2_4
&& end_pos
< bufferpos
409 /* The RVA2 specification is unclear on some things (id string and
410 * peak volume), but this matches how Quod Libet use them.
413 gain
= (int16_t) ((value
[0] << 8) | value
[1]);
416 peakbytes
= (peakbits
+ 7) / 8;
418 /* Only use the topmost 24 bits for peak volume */
423 /* Make sure the peak bits were read */
424 if (end_pos
+ peakbytes
< bufferpos
) {
425 long shift
= ((8 - (peakbits
& 7)) & 7) + (3 - peakbytes
) * 8;
427 for ( ; peakbytes
; peakbytes
--) {
435 peak
+= *value
>> (8 - shift
);
439 if (strcasecmp(tag
, "album") == 0) {
441 } else if (strcasecmp(tag
, "track") != 0) {
442 /* Only accept non-track values if we don't have any previous
445 if (entry
->track_gain
!= 0) {
450 value_len
= parse_replaygain_int(album
, gain
, peak
* 2, entry
,
451 tag
, sizeof(entry
->id3v2buf
) - start_pos
);
454 return start_pos
+ value_len
;
458 static int parsembtid( struct mp3entry
* entry
, char* tag
, int bufferpos
)
461 int desc_len
= strlen(tag
);
462 /*DEBUGF("MBID len: %d\n", desc_len);*/
463 /* Musicbrainz track IDs are always 36 chars long */
464 const size_t mbtid_len
= 36;
466 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
)
468 value
= tag
+ desc_len
+ 1;
470 if (strcasecmp(tag
, "http://musicbrainz.org") == 0)
472 if (mbtid_len
== strlen(value
))
474 entry
->mb_track_id
= value
;
475 return bufferpos
+ mbtid_len
+ 1;
483 static const struct tag_resolver taglist
[] = {
484 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
485 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
486 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
487 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
488 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
489 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
490 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
491 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
492 { "TPA", 3, 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 { "TCM", 3, offsetof(struct mp3entry
, composer
), NULL
, false },
499 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
500 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
501 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
502 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
503 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
504 { "COM", 3, offsetof(struct mp3entry
, comment
), NULL
, false },
505 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
506 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
508 { "APIC", 4, 0, &parsealbumart
, true },
509 { "PIC", 3, 0, &parsealbumart
, true },
511 { "TXXX", 4, 0, &parseuser
, false },
512 #if CONFIG_CODEC == SWCODEC
513 { "RVA2", 4, 0, &parserva2
, true },
515 { "UFID", 4, 0, &parsembtid
, false },
518 #define TAGLIST_SIZE ((int)ARRAYLEN(taglist))
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 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 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
;
729 bool global_unsynch
= false;
730 bool unsynch
= false;
733 #if CONFIG_CODEC == SWCODEC
734 bool itunes_gapless
= false;
737 global_ff_found
= false;
739 /* Bail out if the tag is shorter than 10 bytes */
740 if(entry
->id3v2len
< 10)
743 /* Read the ID3 tag version from the header */
744 lseek(fd
, 0, SEEK_SET
);
745 if(10 != read(fd
, header
, 10))
748 /* Get the total ID3 tag size */
749 size
= entry
->id3v2len
- 10;
754 version
= ID3_VER_2_2
;
759 version
= ID3_VER_2_3
;
764 version
= ID3_VER_2_4
;
769 /* unsupported id3 version */
772 entry
->id3version
= version
;
773 entry
->tracknum
= entry
->year
= entry
->discnum
= 0;
774 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
776 global_flags
= header
[5];
778 /* Skip the extended header if it is present */
779 if(global_flags
& 0x40) {
780 if(version
== ID3_VER_2_3
) {
781 if(10 != read(fd
, header
, 10))
783 /* The 2.3 extended header size doesn't include the header size
784 field itself. Also, it is not unsynched. */
786 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
788 /* Skip the rest of the header */
789 lseek(fd
, framelen
- 10, SEEK_CUR
);
792 if(version
>= ID3_VER_2_4
) {
793 if(4 != read(fd
, header
, 4))
796 /* The 2.4 extended header size does include the entire header,
797 so here we can just skip it. This header is unsynched. */
798 framelen
= unsync(header
[0], header
[1],
799 header
[2], header
[3]);
801 lseek(fd
, framelen
- 4, SEEK_CUR
);
805 /* Is unsynchronization applied? */
806 if(global_flags
& 0x80) {
807 global_unsynch
= true;
811 * We must have at least minframesize bytes left for the
812 * remaining frames to be interesting
814 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
817 /* Read frame header and check length */
818 if(version
>= ID3_VER_2_3
) {
819 if(global_unsynch
&& version
<= ID3_VER_2_3
)
820 rc
= read_unsynched(fd
, header
, 10);
822 rc
= read(fd
, header
, 10);
825 /* Adjust for the 10 bytes we read */
828 flags
= bytes2int(0, 0, header
[8], header
[9]);
830 if (version
>= ID3_VER_2_4
) {
831 framelen
= unsync(header
[4], header
[5],
832 header
[6], header
[7]);
834 /* version .3 files don't use synchsafe ints for
836 framelen
= bytes2int(header
[4], header
[5],
837 header
[6], header
[7]);
840 if(6 != read(fd
, header
, 6))
842 /* Adjust for the 6 bytes we read */
845 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
848 logf("framelen = %ld, flags = 0x%04x", framelen
, flags
);
850 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
860 if (version
>= ID3_VER_2_4
) {
861 if(flags
& 0x0040) { /* Grouping identity */
862 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
866 if(flags
& 0x0020) { /* Grouping identity */
867 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
872 if(flags
& 0x000c) /* Compression or encryption */
876 lseek(fd
, framelen
, SEEK_CUR
);
880 if(flags
& 0x0002) /* Unsynchronization */
883 if (version
>= ID3_VER_2_4
) {
884 if(flags
& 0x0001) { /* Data length indicator */
885 if(4 != read(fd
, tmp
, 4))
888 /* We don't need the data length */
900 /* Keep track of the remaining frame size */
901 totframelen
= framelen
;
903 /* If the frame is larger than the remaining buffer space we try
904 to read as much as would fit in the buffer */
905 if(framelen
>= buffersize
- bufferpos
)
906 framelen
= buffersize
- bufferpos
- 1;
908 /* Limit the maximum length of an id3 data item to ID3V2_MAX_ITEM_SIZE
909 bytes. This reduces the chance that the available buffer is filled
910 by single metadata items like large comments. */
911 if (ID3V2_MAX_ITEM_SIZE
< framelen
)
912 framelen
= ID3V2_MAX_ITEM_SIZE
;
914 logf("id3v2 frame: %.4s", header
);
916 /* Check for certain frame headers
918 'size' is the amount of frame bytes remaining. We decrement it by
919 the amount of bytes we read. If we fail to read as many bytes as
920 we expect, we assume that we can't read from this file, and bail
923 For each frame. we will iterate over the list of supported tags,
924 and read the tag into entry's buffer. All tags will be kept as
925 strings, for cases where a number won't do, e.g., YEAR: "circa
926 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
927 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
928 flexible, and as the main use of id3 data is to display it,
929 converting it to an int just means reconverting to display it, at a
932 For tags that the current code does convert to ints, a post
933 processing function will be called via a pointer to function. */
935 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
936 const struct tag_resolver
* tr
= &taglist
[i
];
937 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
941 /* Only ID3_VER_2_2 uses frames with three-character names. */
942 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
943 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
947 if( !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
949 /* found a tag matching one in tagList, and not yet filled */
950 tag
= buffer
+ bufferpos
;
952 if(global_unsynch
&& version
<= ID3_VER_2_3
)
953 bytesread
= read_unsynched(fd
, tag
, framelen
);
955 bytesread
= read(fd
, tag
, framelen
);
957 if( bytesread
!= framelen
)
962 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
963 bytesread
= unsynchronize_frame(tag
, bytesread
);
965 /* the COMM frame has a 3 char field to hold an ISO-639-1
966 * language string and an optional short description;
967 * remove them so unicode_munge can work correctly
970 if((tr
->tag_length
== 4 && !memcmp( header
, "COMM", 4)) ||
971 (tr
->tag_length
== 3 && !memcmp( header
, "COM", 3))) {
973 if(!strncmp(tag
+4, "iTun", 4)) {
974 #if CONFIG_CODEC == SWCODEC
975 /* check for iTunes gapless information */
976 if(!strncmp(tag
+4, "iTunSMPB", 8))
977 itunes_gapless
= true;
980 /* ignore other with iTunes tags */
984 offset
= 3 + unicode_len(*tag
, tag
+ 4);
985 if(bytesread
> offset
) {
987 memmove(tag
+ 1, tag
+ 1 + offset
, bytesread
- 1);
991 /* Attempt to parse Unicode string only if the tag contents
994 /* UTF-8 could potentially be 3 times larger */
995 /* so we need to create a new buffer */
996 char utf8buf
[(3 * bytesread
) + 1];
998 unicode_munge( tag
, utf8buf
, &bytesread
);
1000 if(bytesread
>= buffersize
- bufferpos
)
1001 bytesread
= buffersize
- bufferpos
- 1;
1003 for (j
= 0; j
< bytesread
; j
++)
1004 tag
[j
] = utf8buf
[j
];
1006 /* remove trailing spaces */
1007 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
1012 bufferpos
+= bytesread
+ 1;
1014 #if CONFIG_CODEC == SWCODEC
1015 /* parse the tag if it contains iTunes gapless info */
1018 itunes_gapless
= false;
1019 entry
->lead_trim
= get_itunes_int32(tag
, 1);
1020 entry
->tail_trim
= get_itunes_int32(tag
, 2);
1024 /* Note that parser functions sometimes set *ptag to NULL, so
1025 * the "!*ptag" check here doesn't always have the desired
1026 * effect. Should the parser functions (parsegenre in
1027 * particular) be updated to handle the case of being called
1028 * multiple times, or should the "*ptag" check be removed?
1033 #ifdef HAVE_ALBUMART
1035 if ((!entry
->embed_albumart
) &&
1036 ((tr
->tag_length
== 4 && !memcmp( header
, "APIC", 4)) ||
1037 (tr
->tag_length
== 3 && !memcmp( header
, "PIC" , 3))))
1039 if (unsynch
|| (global_unsynch
&& version
<= ID3_VER_2_3
))
1040 entry
->albumart
.type
= AA_TYPE_UNSYNC
;
1043 entry
->albumart
.pos
= lseek(fd
, 0, SEEK_CUR
) - framelen
;
1044 entry
->albumart
.size
= totframelen
;
1045 entry
->albumart
.type
= AA_TYPE_UNKNOWN
;
1050 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
1052 /* Seek to the next frame */
1053 if(framelen
< totframelen
)
1054 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
1059 if( i
== TAGLIST_SIZE
) {
1060 /* no tag in tagList was found, or it was a repeat.
1061 skip it using the total size */
1063 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
1064 size
-= skip_unsynched(fd
, totframelen
);
1066 size
-= totframelen
;
1067 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
1075 * Calculates the size of the ID3v2 tag.
1077 * Arguments: file - the file to search for a tag.
1079 * Returns: the size of the tag or 0 if none was found
1081 int getid3v2len(int fd
)
1086 /* Make sure file has a ID3 tag */
1087 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
1088 (read(fd
, buf
, 6) != 6) ||
1089 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
1092 /* Now check what the ID3v2 size field says */
1094 if(read(fd
, buf
, 4) != 4)
1097 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
1099 logf("ID3V2 Length: 0x%x", offset
);
1103 #ifdef DEBUG_STANDALONE
1105 char *secs2str(int ms
)
1107 static char buffer
[32];
1110 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1114 int main(int argc
, char **argv
)
1117 for(i
=1; i
<argc
; i
++) {
1118 struct mp3entry mp3
;
1119 mp3
.album
= "Bogus";
1120 if(mp3info(&mp3
, argv
[i
], false)) {
1121 printf("Failed to get %s\n", argv
[i
]);
1125 printf("****** File: %s\n"
1129 " Genre: %s (%d) \n"
1133 " Length: %s / %d s\n"
1137 mp3
.title
?mp3
.title
:"<blank>",
1138 mp3
.artist
?mp3
.artist
:"<blank>",
1139 mp3
.album
?mp3
.album
:"<blank>",
1140 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1142 mp3
.composer
?mp3
.composer
:"<blank>",
1143 mp3
.year_string
?mp3
.year_string
:"<blank>",
1145 mp3
.track_string
?mp3
.track_string
:"<blank>",
1147 secs2str(mp3
.length
),