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 if(entry
->id3version
>= ID3_VER_2_4
) {
270 /* In version 2.4 and up, there are no parentheses, and the genre frame
271 is a list of strings, either numbers or text. */
273 /* Is it a number? */
274 if(isdigit(tag
[0])) {
275 entry
->genre_string
= id3_get_num_genre(atoi( tag
));
276 return tag
- entry
->id3v2buf
;
278 entry
->genre_string
= tag
;
282 if( tag
[0] == '(' && tag
[1] != '(' ) {
283 entry
->genre_string
= id3_get_num_genre(atoi( tag
+ 1 ));
284 return tag
- entry
->id3v2buf
;
287 entry
->genre_string
= tag
;
293 /* parse user defined text, looking for album artist and replaygain
296 static int parseuser( struct mp3entry
* entry
, char* tag
, int bufferpos
)
299 int desc_len
= strlen(tag
);
302 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
303 /* At least part of the value was read, so we can safely try to
306 value
= tag
+ desc_len
+ 1;
307 value_len
= bufferpos
- (tag
- entry
->id3v2buf
);
309 if (!strcasecmp(tag
, "ALBUM ARTIST")) {
310 strlcpy(tag
, value
, value_len
);
311 entry
->albumartist
= tag
;
312 #if CONFIG_CODEC == SWCODEC
314 value_len
= parse_replaygain(tag
, value
, entry
, tag
,
320 return tag
- entry
->id3v2buf
+ value_len
;
323 #if CONFIG_CODEC == SWCODEC
324 /* parse RVA2 binary data and convert to replaygain information. */
325 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
327 int desc_len
= strlen(tag
);
328 int start_pos
= tag
- entry
->id3v2buf
;
329 int end_pos
= start_pos
+ desc_len
+ 5;
331 unsigned char* value
= tag
+ desc_len
+ 1;
333 /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
334 * type is master volume.
336 if (entry
->id3version
== ID3_VER_2_4
&& end_pos
< bufferpos
344 /* The RVA2 specification is unclear on some things (id string and
345 * peak volume), but this matches how Quod Libet use them.
348 gain
= (int16_t) ((value
[0] << 8) | value
[1]);
351 peakbytes
= (peakbits
+ 7) / 8;
353 /* Only use the topmost 24 bits for peak volume */
358 /* Make sure the peak bits were read */
359 if (end_pos
+ peakbytes
< bufferpos
) {
360 long shift
= ((8 - (peakbits
& 7)) & 7) + (3 - peakbytes
) * 8;
362 for ( ; peakbytes
; peakbytes
--) {
370 peak
+= *value
>> (8 - shift
);
374 if (strcasecmp(tag
, "album") == 0) {
376 } else if (strcasecmp(tag
, "track") != 0) {
377 /* Only accept non-track values if we don't have any previous
380 if (entry
->track_gain
!= 0) {
385 value_len
= parse_replaygain_int(album
, gain
, peak
* 2, entry
,
386 tag
, sizeof(entry
->id3v2buf
) - start_pos
);
389 return start_pos
+ value_len
;
393 static int parsembtid( struct mp3entry
* entry
, char* tag
, int bufferpos
)
396 int desc_len
= strlen(tag
);
397 /*DEBUGF("MBID len: %d\n", desc_len);*/
398 /* Musicbrainz track IDs are always 36 chars long */
399 const size_t mbtid_len
= 36;
401 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
)
403 value
= tag
+ desc_len
+ 1;
405 if (strcasecmp(tag
, "http://musicbrainz.org") == 0)
407 if (mbtid_len
== strlen(value
))
409 entry
->mb_track_id
= value
;
410 return bufferpos
+ mbtid_len
+ 1;
418 static const struct tag_resolver taglist
[] = {
419 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
420 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
421 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
422 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
423 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
424 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
425 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
426 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
427 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
428 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
429 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
430 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
431 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
432 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
433 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
434 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
435 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
436 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
437 { "COM", 3, offsetof(struct mp3entry
, comment
), NULL
, false },
438 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
439 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
440 { "TXXX", 4, 0, &parseuser
, false },
441 #if CONFIG_CODEC == SWCODEC
442 { "RVA2", 4, 0, &parserva2
, true },
444 { "UFID", 4, 0, &parsembtid
, false },
447 #define TAGLIST_SIZE ((int)ARRAYLEN(taglist))
449 /* Get the length of an ID3 string in the given encoding. Returns the length
450 * in bytes, including end nil, or -1 if the encoding is unknown.
452 static int unicode_len(char encoding
, const void* string
)
456 if (encoding
== 0x01 || encoding
== 0x02) {
458 const char *s
= string
;
459 /* string might be unaligned, so using short* can crash on ARM and SH1 */
462 } while ((first
| *s
++) != 0);
464 len
= s
- (const char*) string
;
466 len
= strlen((char*) string
) + 1;
472 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
473 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
474 we convert from the default codepage */
475 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
479 unsigned char *str
= (unsigned char *)string
;
481 unsigned char* utf8
= (unsigned char *)utf8buf
;
484 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
487 utf8
= iso_decode(str
, utf8
, -1, *len
);
489 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
492 case 0x01: /* Unicode with or without BOM */
497 /* Handle frames with more than one string
498 (needed for TXXX frames).*/
500 tmp
= bytes2int(0, 0, str
[0], str
[1]);
502 /* Now check if there is a BOM
503 (zero-width non-breaking space, 0xfeff)
504 and if it is in little or big endian format */
505 if(tmp
== 0xfffe) { /* Little endian? */
509 } else if(tmp
== 0xfeff) { /* Big endian? */
513 /* If there is no BOM (which is a specification violation),
514 let's try to guess it. If one of the bytes is 0x00, it is
515 probably the most significant one. */
521 utf8
= utf16LEdecode(str
, utf8
, 1);
523 utf8
= utf16BEdecode(str
, utf8
, 1);
527 } while((str
[0] || str
[1]) && (i
< *len
));
529 *utf8
++ = 0; /* Terminate the string */
530 templen
+= (strlen(&utf8buf
[templen
]) + 1);
537 case 0x03: /* UTF-8 encoded string */
538 for(i
=0; i
< *len
; i
++)
543 default: /* Plain old string */
544 utf8
= iso_decode(str
, utf8
, -1, *len
);
546 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
553 * Sets the title of an MP3 entry based on its ID3v1 tag.
555 * Arguments: file - the MP3 file to scen for a ID3v1 tag
556 * entry - the entry to set the title in
558 * Returns: true if a title was found and created, else false
560 bool setid3v1title(int fd
, struct mp3entry
*entry
)
562 unsigned char buffer
[128];
563 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
567 if (-1 == lseek(fd
, -128, SEEK_END
))
570 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
573 if (strncmp((char *)buffer
, "TAG", 3))
576 entry
->id3v1len
= 128;
577 entry
->id3version
= ID3_VER_1_0
;
579 for (i
=0; i
< (int)sizeof offsets
; i
++) {
580 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
586 /* kill trailing space in strings */
587 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
589 /* convert string to utf8 */
590 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
591 utf8
= iso_decode(ptr
, utf8
, -1, 30);
592 /* make sure string is terminated */
597 /* kill trailing space in strings */
598 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
600 /* convert string to utf8 */
601 utf8
= (unsigned char *)entry
->id3v1buf
[3];
602 utf8
= iso_decode(ptr
, utf8
, -1, 28);
603 /* make sure string is terminated */
609 entry
->year
= atoi((char *)ptr
);
613 /* id3v1.1 uses last two bytes of comment field for track
614 number: first must be 0 and second is track num */
615 if (!ptr
[0] && ptr
[1]) {
616 entry
->tracknum
= ptr
[1];
617 entry
->id3version
= ID3_VER_1_1
;
623 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
628 entry
->title
= entry
->id3v1buf
[0];
629 entry
->artist
= entry
->id3v1buf
[1];
630 entry
->album
= entry
->id3v1buf
[2];
631 entry
->comment
= entry
->id3v1buf
[3];
638 * Sets the title of an MP3 entry based on its ID3v2 tag.
640 * Arguments: file - the MP3 file to scan for a ID3v2 tag
641 * entry - the entry to set the title in
643 * Returns: true if a title was found and created, else false
645 void setid3v2title(int fd
, struct mp3entry
*entry
)
649 long bufferpos
= 0, totframelen
, framelen
;
652 unsigned char version
;
653 char *buffer
= entry
->id3v2buf
;
655 int buffersize
= sizeof(entry
->id3v2buf
);
656 unsigned char global_flags
;
659 bool global_unsynch
= false;
660 bool unsynch
= false;
663 #if CONFIG_CODEC == SWCODEC
664 bool itunes_gapless
= false;
667 global_ff_found
= false;
669 /* Bail out if the tag is shorter than 10 bytes */
670 if(entry
->id3v2len
< 10)
673 /* Read the ID3 tag version from the header */
674 lseek(fd
, 0, SEEK_SET
);
675 if(10 != read(fd
, header
, 10))
678 /* Get the total ID3 tag size */
679 size
= entry
->id3v2len
- 10;
684 version
= ID3_VER_2_2
;
689 version
= ID3_VER_2_3
;
694 version
= ID3_VER_2_4
;
699 /* unsupported id3 version */
702 entry
->id3version
= version
;
703 entry
->tracknum
= entry
->year
= entry
->discnum
= 0;
704 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
706 global_flags
= header
[5];
708 /* Skip the extended header if it is present */
709 if(global_flags
& 0x40) {
710 if(version
== ID3_VER_2_3
) {
711 if(10 != read(fd
, header
, 10))
713 /* The 2.3 extended header size doesn't include the header size
714 field itself. Also, it is not unsynched. */
716 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
718 /* Skip the rest of the header */
719 lseek(fd
, framelen
- 10, SEEK_CUR
);
722 if(version
>= ID3_VER_2_4
) {
723 if(4 != read(fd
, header
, 4))
726 /* The 2.4 extended header size does include the entire header,
727 so here we can just skip it. This header is unsynched. */
728 framelen
= unsync(header
[0], header
[1],
729 header
[2], header
[3]);
731 lseek(fd
, framelen
- 4, SEEK_CUR
);
735 /* Is unsynchronization applied? */
736 if(global_flags
& 0x80) {
737 global_unsynch
= true;
741 * We must have at least minframesize bytes left for the
742 * remaining frames to be interesting
744 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
747 /* Read frame header and check length */
748 if(version
>= ID3_VER_2_3
) {
749 if(global_unsynch
&& version
<= ID3_VER_2_3
)
750 rc
= read_unsynched(fd
, header
, 10);
752 rc
= read(fd
, header
, 10);
755 /* Adjust for the 10 bytes we read */
758 flags
= bytes2int(0, 0, header
[8], header
[9]);
760 if (version
>= ID3_VER_2_4
) {
761 framelen
= unsync(header
[4], header
[5],
762 header
[6], header
[7]);
764 /* version .3 files don't use synchsafe ints for
766 framelen
= bytes2int(header
[4], header
[5],
767 header
[6], header
[7]);
770 if(6 != read(fd
, header
, 6))
772 /* Adjust for the 6 bytes we read */
775 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
778 logf("framelen = %ld, flags = 0x%04x", framelen
, flags
);
780 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
792 if (version
>= ID3_VER_2_4
) {
793 if(flags
& 0x0040) { /* Grouping identity */
794 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
798 if(flags
& 0x0020) { /* Grouping identity */
799 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
804 if(flags
& 0x000c) /* Compression or encryption */
808 lseek(fd
, framelen
, SEEK_CUR
);
812 if(flags
& 0x0002) /* Unsynchronization */
815 if (version
>= ID3_VER_2_4
) {
816 if(flags
& 0x0001) { /* Data length indicator */
817 if(4 != read(fd
, tmp
, 4))
820 /* We don't need the data length */
832 /* Keep track of the remaining frame size */
833 totframelen
= framelen
;
835 /* If the frame is larger than the remaining buffer space we try
836 to read as much as would fit in the buffer */
837 if(framelen
>= buffersize
- bufferpos
)
838 framelen
= buffersize
- bufferpos
- 1;
840 logf("id3v2 frame: %.4s", header
);
842 /* Check for certain frame headers
844 'size' is the amount of frame bytes remaining. We decrement it by
845 the amount of bytes we read. If we fail to read as many bytes as
846 we expect, we assume that we can't read from this file, and bail
849 For each frame. we will iterate over the list of supported tags,
850 and read the tag into entry's buffer. All tags will be kept as
851 strings, for cases where a number won't do, e.g., YEAR: "circa
852 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
853 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
854 flexible, and as the main use of id3 data is to display it,
855 converting it to an int just means reconverting to display it, at a
858 For tags that the current code does convert to ints, a post
859 processing function will be called via a pointer to function. */
861 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
862 const struct tag_resolver
* tr
= &taglist
[i
];
863 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
867 /* Only ID3_VER_2_2 uses frames with three-character names. */
868 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
869 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
873 if( !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
875 /* found a tag matching one in tagList, and not yet filled */
876 tag
= buffer
+ bufferpos
;
878 if(global_unsynch
&& version
<= ID3_VER_2_3
)
879 bytesread
= read_unsynched(fd
, tag
, framelen
);
881 bytesread
= read(fd
, tag
, framelen
);
883 if( bytesread
!= framelen
)
888 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
889 bytesread
= unsynchronize_frame(tag
, bytesread
);
891 /* the COMM frame has a 3 char field to hold an ISO-639-1
892 * language string and an optional short description;
893 * remove them so unicode_munge can work correctly
896 if((tr
->tag_length
== 4 && !memcmp( header
, "COMM", 4)) ||
897 (tr
->tag_length
== 3 && !memcmp( header
, "COM", 3))) {
899 if(!strncmp(tag
+4, "iTun", 4)) {
900 #if CONFIG_CODEC == SWCODEC
901 /* check for iTunes gapless information */
902 if(!strncmp(tag
+4, "iTunSMPB", 8))
903 itunes_gapless
= true;
906 /* ignore other with iTunes tags */
910 offset
= 3 + unicode_len(*tag
, tag
+ 4);
911 if(bytesread
> offset
) {
913 memmove(tag
+ 1, tag
+ 1 + offset
, bytesread
- 1);
917 /* Attempt to parse Unicode string only if the tag contents
920 /* UTF-8 could potentially be 3 times larger */
921 /* so we need to create a new buffer */
922 char utf8buf
[(3 * bytesread
) + 1];
924 unicode_munge( tag
, utf8buf
, &bytesread
);
926 if(bytesread
>= buffersize
- bufferpos
)
927 bytesread
= buffersize
- bufferpos
- 1;
929 for (j
= 0; j
< bytesread
; j
++)
932 /* remove trailing spaces */
933 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
938 bufferpos
+= bytesread
+ 1;
940 #if CONFIG_CODEC == SWCODEC
941 /* parse the tag if it contains iTunes gapless info */
944 itunes_gapless
= false;
945 entry
->lead_trim
= get_itunes_int32(tag
, 1);
946 entry
->tail_trim
= get_itunes_int32(tag
, 2);
950 /* Note that parser functions sometimes set *ptag to NULL, so
951 * the "!*ptag" check here doesn't always have the desired
952 * effect. Should the parser functions (parsegenre in
953 * particular) be updated to handle the case of being called
954 * multiple times, or should the "*ptag" check be removed?
960 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
962 /* Seek to the next frame */
963 if(framelen
< totframelen
)
964 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
969 if( i
== TAGLIST_SIZE
) {
970 /* no tag in tagList was found, or it was a repeat.
971 skip it using the total size */
973 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
974 size
-= skip_unsynched(fd
, totframelen
);
977 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
985 * Calculates the size of the ID3v2 tag.
987 * Arguments: file - the file to search for a tag.
989 * Returns: the size of the tag or 0 if none was found
991 int getid3v2len(int fd
)
996 /* Make sure file has a ID3 tag */
997 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
998 (read(fd
, buf
, 6) != 6) ||
999 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
1002 /* Now check what the ID3v2 size field says */
1004 if(read(fd
, buf
, 4) != 4)
1007 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
1009 logf("ID3V2 Length: 0x%x", offset
);
1013 #ifdef DEBUG_STANDALONE
1015 char *secs2str(int ms
)
1017 static char buffer
[32];
1020 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1024 int main(int argc
, char **argv
)
1027 for(i
=1; i
<argc
; i
++) {
1028 struct mp3entry mp3
;
1029 mp3
.album
= "Bogus";
1030 if(mp3info(&mp3
, argv
[i
], false)) {
1031 printf("Failed to get %s\n", argv
[i
]);
1035 printf("****** File: %s\n"
1039 " Genre: %s (%d) \n"
1043 " Length: %s / %d s\n"
1047 mp3
.title
?mp3
.title
:"<blank>",
1048 mp3
.artist
?mp3
.artist
:"<blank>",
1049 mp3
.album
?mp3
.album
:"<blank>",
1050 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1052 mp3
.composer
?mp3
.composer
:"<blank>",
1053 mp3
.year_string
?mp3
.year_string
:"<blank>",
1055 mp3
.track_string
?mp3
.track_string
:"<blank>",
1057 secs2str(mp3
.length
),