2f736d7b9b168f87363f6f0145d89c0c90b57dc9
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
42 #include "replaygain.h"
43 #include "rbunicode.h"
47 #if CONFIG_CODEC == SWCODEC
48 #include "metadata_common.h"
50 #include "metadata_parsers.h"
52 static unsigned long unsync(unsigned long b0
,
57 return (((long)(b0
& 0x7F) << (3*7)) |
58 ((long)(b1
& 0x7F) << (2*7)) |
59 ((long)(b2
& 0x7F) << (1*7)) |
60 ((long)(b3
& 0x7F) << (0*7)));
63 static const char* const genres
[] = {
64 "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
65 "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
66 "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
67 "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
68 "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
69 "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
70 "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
71 "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
72 "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
73 "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
74 "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
75 "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
76 "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
78 /* winamp extensions */
79 "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
80 "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
81 "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
82 "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
83 "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
84 "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
85 "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
86 "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
87 "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
88 "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
89 "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
90 "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
94 char* id3_get_num_genre(unsigned int genre_num
)
96 if (genre_num
< ARRAYLEN(genres
))
97 return (char*)genres
[genre_num
];
102 HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
103 Code and comments by Thomas Paul Diffenbach
105 To add another ID3v2 Tag, do the following:
106 1. add a char* named for the tag to struct mp3entry in id3.h,
107 (I (tpd) prefer to use char* rather than ints, even for what seems like
108 numerical values, for cases where a number won't do, e.g.,
109 YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
110 TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
111 Text is more flexible, and as the main use of id3 data is to
112 display it, converting it to an int just means reconverting to
113 display it, at a runtime cost.)
115 2. If any special processing beyond copying the tag value from the Id3
116 block to the struct mp3entry is rrequired (such as converting to an
117 int), write a function to perform this special processing.
119 This function's prototype must match that of
120 typedef tagPostProcessFunc, that is it must be:
121 int func( struct mp3entry*, char* tag, int bufferpos )
122 the first argument is a pointer to the current mp3entry structure the
123 second argument is a pointer to the null terminated string value of the
124 tag found the third argument is the offset of the next free byte in the
125 mp3entry's buffer your function should return the corrected offset; if
126 you don't lengthen or shorten the tag string, you can return the third
129 Unless you have a good reason no to, make the function static.
130 TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
132 3. add one or more entries to the tagList array, using the format:
133 char* ID3 Tag symbolic name -- see the ID3 specification for these,
134 sizeof() that name minus 1,
135 offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
136 pointer to your special processing function or NULL
137 if you need no special processing
138 flag indicating if this tag is binary or textual
139 Many ID3 symbolic names come in more than one form. You can add both
140 forms, each referencing the same variable in struct mp3entry.
141 If both forms are present, the last found will be used.
142 Note that the offset can be zero, in which case no entry will be set
143 in the mp3entry struct; the frame is still read into the buffer and
144 the special processing function is called (several times, if there
145 are several frames with the same name).
147 4. Alternately, use the TAG_LIST_ENTRY macro with
148 ID3 tag symbolic name,
149 variable in struct mp3entry,
150 special processing function address
152 5. Add code to wps-display.c function get_tag to assign a printf-like
153 format specifier for the tag */
155 /* Structure for ID3 Tag extraction information */
156 struct tag_resolver
{
160 int (*ppFunc
)(struct mp3entry
*, char* tag
, int bufferpos
);
164 static bool global_ff_found
;
166 static int unsynchronize(char* tag
, int len
, bool *ff_found
)
170 unsigned char *rp
, *wp
;
172 wp
= rp
= (unsigned char *)tag
;
174 rp
= (unsigned char *)tag
;
175 for(i
= 0;i
< len
;i
++) {
176 /* Read the next byte and write it back, but don't increment the
181 /* Increment the write pointer if it isn't an unsynch pattern */
191 return (long)wp
- (long)tag
;
194 static int unsynchronize_frame(char* tag
, int len
)
196 bool ff_found
= false;
198 return unsynchronize(tag
, len
, &ff_found
);
201 static int read_unsynched(int fd
, void *buf
, int len
)
213 rc
= read(fd
, rp
, remaining
);
217 i
= unsynchronize(wp
, remaining
, &global_ff_found
);
225 static int skip_unsynched(int fd
, int len
)
233 rlen
= MIN(sizeof(buf
), (unsigned int)remaining
);
234 rc
= read(fd
, buf
, rlen
);
238 remaining
-= unsynchronize(buf
, rlen
, &global_ff_found
);
244 /* parse numeric value from string */
245 static int parsetracknum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
247 entry
->tracknum
= atoi( tag
);
251 /* parse numeric value from string */
252 static int parsediscnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
254 entry
->discnum
= atoi( tag
);
258 /* parse numeric value from string */
259 static int parseyearnum( struct mp3entry
* entry
, char* tag
, int bufferpos
)
261 entry
->year
= atoi( tag
);
265 /* parse numeric genre from string, version 2.2 and 2.3 */
266 static int parsegenre( struct mp3entry
* entry
, char* tag
, int bufferpos
)
268 if(entry
->id3version
>= ID3_VER_2_4
) {
269 /* In version 2.4 and up, there are no parentheses, and the genre frame
270 is a list of strings, either numbers or text. */
272 /* Is it a number? */
273 if(isdigit(tag
[0])) {
274 entry
->genre_string
= id3_get_num_genre(atoi( tag
));
275 return tag
- entry
->id3v2buf
;
277 entry
->genre_string
= tag
;
281 if( tag
[0] == '(' && tag
[1] != '(' ) {
282 entry
->genre_string
= id3_get_num_genre(atoi( tag
+ 1 ));
283 return tag
- entry
->id3v2buf
;
286 entry
->genre_string
= tag
;
292 /* parse user defined text, looking for album artist and replaygain
295 static int parseuser( struct mp3entry
* entry
, char* tag
, int bufferpos
)
298 int desc_len
= strlen(tag
);
301 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
) {
302 /* At least part of the value was read, so we can safely try to
305 value
= tag
+ desc_len
+ 1;
306 value_len
= bufferpos
- (tag
- entry
->id3v2buf
);
308 if (!strcasecmp(tag
, "ALBUM ARTIST")) {
309 strlcpy(tag
, value
, value_len
);
310 entry
->albumartist
= tag
;
311 #if CONFIG_CODEC == SWCODEC
313 value_len
= parse_replaygain(tag
, value
, entry
, tag
,
319 return tag
- entry
->id3v2buf
+ value_len
;
322 #if CONFIG_CODEC == SWCODEC
323 /* parse RVA2 binary data and convert to replaygain information. */
324 static int parserva2( struct mp3entry
* entry
, char* tag
, int bufferpos
)
326 int desc_len
= strlen(tag
);
327 int start_pos
= tag
- entry
->id3v2buf
;
328 int end_pos
= start_pos
+ desc_len
+ 5;
330 unsigned char* value
= tag
+ desc_len
+ 1;
332 /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
333 * type is master volume.
335 if (entry
->id3version
== ID3_VER_2_4
&& end_pos
< bufferpos
343 /* The RVA2 specification is unclear on some things (id string and
344 * peak volume), but this matches how Quod Libet use them.
347 gain
= (int16_t) ((value
[0] << 8) | value
[1]);
350 peakbytes
= (peakbits
+ 7) / 8;
352 /* Only use the topmost 24 bits for peak volume */
357 /* Make sure the peak bits were read */
358 if (end_pos
+ peakbytes
< bufferpos
) {
359 long shift
= ((8 - (peakbits
& 7)) & 7) + (3 - peakbytes
) * 8;
361 for ( ; peakbytes
; peakbytes
--) {
369 peak
+= *value
>> (8 - shift
);
373 if (strcasecmp(tag
, "album") == 0) {
375 } else if (strcasecmp(tag
, "track") != 0) {
376 /* Only accept non-track values if we don't have any previous
379 if (entry
->track_gain
!= 0) {
384 value_len
= parse_replaygain_int(album
, gain
, peak
* 2, entry
,
385 tag
, sizeof(entry
->id3v2buf
) - start_pos
);
388 return start_pos
+ value_len
;
392 static int parsembtid( struct mp3entry
* entry
, char* tag
, int bufferpos
)
395 int desc_len
= strlen(tag
);
396 /*DEBUGF("MBID len: %d\n", desc_len);*/
397 /* Musicbrainz track IDs are always 36 chars long */
398 const size_t mbtid_len
= 36;
400 if ((tag
- entry
->id3v2buf
+ desc_len
+ 2) < bufferpos
)
402 value
= tag
+ desc_len
+ 1;
404 if (strcasecmp(tag
, "http://musicbrainz.org") == 0)
406 if (mbtid_len
== strlen(value
))
408 entry
->mb_track_id
= value
;
409 return bufferpos
+ mbtid_len
+ 1;
417 static const struct tag_resolver taglist
[] = {
418 { "TPE1", 4, offsetof(struct mp3entry
, artist
), NULL
, false },
419 { "TP1", 3, offsetof(struct mp3entry
, artist
), NULL
, false },
420 { "TIT2", 4, offsetof(struct mp3entry
, title
), NULL
, false },
421 { "TT2", 3, offsetof(struct mp3entry
, title
), NULL
, false },
422 { "TALB", 4, offsetof(struct mp3entry
, album
), NULL
, false },
423 { "TAL", 3, offsetof(struct mp3entry
, album
), NULL
, false },
424 { "TRK", 3, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
425 { "TPOS", 4, offsetof(struct mp3entry
, disc_string
), &parsediscnum
, false },
426 { "TRCK", 4, offsetof(struct mp3entry
, track_string
), &parsetracknum
, false },
427 { "TDRC", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
428 { "TYER", 4, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
429 { "TYE", 3, offsetof(struct mp3entry
, year_string
), &parseyearnum
, false },
430 { "TCOM", 4, offsetof(struct mp3entry
, composer
), NULL
, false },
431 { "TPE2", 4, offsetof(struct mp3entry
, albumartist
), NULL
, false },
432 { "TP2", 3, offsetof(struct mp3entry
, albumartist
), NULL
, false },
433 { "TIT1", 4, offsetof(struct mp3entry
, grouping
), NULL
, false },
434 { "TT1", 3, offsetof(struct mp3entry
, grouping
), NULL
, false },
435 { "COMM", 4, offsetof(struct mp3entry
, comment
), NULL
, false },
436 { "COM", 3, offsetof(struct mp3entry
, comment
), NULL
, false },
437 { "TCON", 4, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
438 { "TCO", 3, offsetof(struct mp3entry
, genre_string
), &parsegenre
, false },
439 { "TXXX", 4, 0, &parseuser
, false },
440 #if CONFIG_CODEC == SWCODEC
441 { "RVA2", 4, 0, &parserva2
, true },
443 { "UFID", 4, 0, &parsembtid
, false },
446 #define TAGLIST_SIZE ((int)ARRAYLEN(taglist))
448 /* Get the length of an ID3 string in the given encoding. Returns the length
449 * in bytes, including end nil, or -1 if the encoding is unknown.
451 static int unicode_len(char encoding
, const void* string
)
455 if (encoding
== 0x01 || encoding
== 0x02) {
457 const char *s
= string
;
458 /* string might be unaligned, so using short* can crash on ARM and SH1 */
461 } while ((first
| *s
++) != 0);
463 len
= s
- (const char*) string
;
465 len
= strlen((char*) string
) + 1;
471 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
472 string. If it is, we convert it to a UTF-8 string. If it's not unicode,
473 we convert from the default codepage */
474 static int unicode_munge(char* string
, char* utf8buf
, int *len
) {
478 unsigned char *str
= (unsigned char *)string
;
480 unsigned char* utf8
= (unsigned char *)utf8buf
;
483 case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
486 utf8
= iso_decode(str
, utf8
, -1, *len
);
488 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
491 case 0x01: /* Unicode with or without BOM */
496 /* Handle frames with more than one string
497 (needed for TXXX frames).*/
499 tmp
= bytes2int(0, 0, str
[0], str
[1]);
501 /* Now check if there is a BOM
502 (zero-width non-breaking space, 0xfeff)
503 and if it is in little or big endian format */
504 if(tmp
== 0xfffe) { /* Little endian? */
508 } else if(tmp
== 0xfeff) { /* Big endian? */
512 /* If there is no BOM (which is a specification violation),
513 let's try to guess it. If one of the bytes is 0x00, it is
514 probably the most significant one. */
520 utf8
= utf16LEdecode(str
, utf8
, 1);
522 utf8
= utf16BEdecode(str
, utf8
, 1);
526 } while((str
[0] || str
[1]) && (i
< *len
));
528 *utf8
++ = 0; /* Terminate the string */
529 templen
+= (strlen(&utf8buf
[templen
]) + 1);
536 case 0x03: /* UTF-8 encoded string */
537 for(i
=0; i
< *len
; i
++)
542 default: /* Plain old string */
543 utf8
= iso_decode(str
, utf8
, -1, *len
);
545 *len
= (unsigned long)utf8
- (unsigned long)utf8buf
;
552 * Sets the title of an MP3 entry based on its ID3v1 tag.
554 * Arguments: file - the MP3 file to scen for a ID3v1 tag
555 * entry - the entry to set the title in
557 * Returns: true if a title was found and created, else false
559 bool setid3v1title(int fd
, struct mp3entry
*entry
)
561 unsigned char buffer
[128];
562 static const char offsets
[] = {3, 33, 63, 97, 93, 125, 127};
566 if (-1 == lseek(fd
, -128, SEEK_END
))
569 if (read(fd
, buffer
, sizeof buffer
) != sizeof buffer
)
572 if (strncmp((char *)buffer
, "TAG", 3))
575 entry
->id3v1len
= 128;
576 entry
->id3version
= ID3_VER_1_0
;
578 for (i
=0; i
< (int)sizeof offsets
; i
++) {
579 unsigned char* ptr
= (unsigned char *)buffer
+ offsets
[i
];
585 /* kill trailing space in strings */
586 for (j
=29; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
588 /* convert string to utf8 */
589 utf8
= (unsigned char *)entry
->id3v1buf
[i
];
590 utf8
= iso_decode(ptr
, utf8
, -1, 30);
591 /* make sure string is terminated */
596 /* kill trailing space in strings */
597 for (j
=27; j
&& (ptr
[j
]==0 || ptr
[j
]==' '); j
--)
599 /* convert string to utf8 */
600 utf8
= (unsigned char *)entry
->id3v1buf
[3];
601 utf8
= iso_decode(ptr
, utf8
, -1, 28);
602 /* make sure string is terminated */
608 entry
->year
= atoi((char *)ptr
);
612 /* id3v1.1 uses last two bytes of comment field for track
613 number: first must be 0 and second is track num */
614 if (!ptr
[0] && ptr
[1]) {
615 entry
->tracknum
= ptr
[1];
616 entry
->id3version
= ID3_VER_1_1
;
622 entry
->genre_string
= id3_get_num_genre(ptr
[0]);
627 entry
->title
= entry
->id3v1buf
[0];
628 entry
->artist
= entry
->id3v1buf
[1];
629 entry
->album
= entry
->id3v1buf
[2];
630 entry
->comment
= entry
->id3v1buf
[3];
637 * Sets the title of an MP3 entry based on its ID3v2 tag.
639 * Arguments: file - the MP3 file to scan for a ID3v2 tag
640 * entry - the entry to set the title in
642 * Returns: true if a title was found and created, else false
644 void setid3v2title(int fd
, struct mp3entry
*entry
)
648 long bufferpos
= 0, totframelen
, framelen
;
651 unsigned char version
;
652 char *buffer
= entry
->id3v2buf
;
654 int buffersize
= sizeof(entry
->id3v2buf
);
655 unsigned char global_flags
;
658 bool global_unsynch
= false;
659 bool unsynch
= false;
662 #if CONFIG_CODEC == SWCODEC
663 bool itunes_gapless
= false;
666 global_ff_found
= false;
668 /* Bail out if the tag is shorter than 10 bytes */
669 if(entry
->id3v2len
< 10)
672 /* Read the ID3 tag version from the header */
673 lseek(fd
, 0, SEEK_SET
);
674 if(10 != read(fd
, header
, 10))
677 /* Get the total ID3 tag size */
678 size
= entry
->id3v2len
- 10;
683 version
= ID3_VER_2_2
;
688 version
= ID3_VER_2_3
;
693 version
= ID3_VER_2_4
;
698 /* unsupported id3 version */
701 entry
->id3version
= version
;
702 entry
->tracknum
= entry
->year
= entry
->discnum
= 0;
703 entry
->title
= entry
->artist
= entry
->album
= NULL
; /* FIXME incomplete */
705 global_flags
= header
[5];
707 /* Skip the extended header if it is present */
708 if(global_flags
& 0x40) {
709 if(version
== ID3_VER_2_3
) {
710 if(10 != read(fd
, header
, 10))
712 /* The 2.3 extended header size doesn't include the header size
713 field itself. Also, it is not unsynched. */
715 bytes2int(header
[0], header
[1], header
[2], header
[3]) + 4;
717 /* Skip the rest of the header */
718 lseek(fd
, framelen
- 10, SEEK_CUR
);
721 if(version
>= ID3_VER_2_4
) {
722 if(4 != read(fd
, header
, 4))
725 /* The 2.4 extended header size does include the entire header,
726 so here we can just skip it. This header is unsynched. */
727 framelen
= unsync(header
[0], header
[1],
728 header
[2], header
[3]);
730 lseek(fd
, framelen
- 4, SEEK_CUR
);
734 /* Is unsynchronization applied? */
735 if(global_flags
& 0x80) {
736 global_unsynch
= true;
740 * We must have at least minframesize bytes left for the
741 * remaining frames to be interesting
743 while (size
>= minframesize
&& bufferpos
< buffersize
- 1) {
746 /* Read frame header and check length */
747 if(version
>= ID3_VER_2_3
) {
748 if(global_unsynch
&& version
<= ID3_VER_2_3
)
749 rc
= read_unsynched(fd
, header
, 10);
751 rc
= read(fd
, header
, 10);
754 /* Adjust for the 10 bytes we read */
757 flags
= bytes2int(0, 0, header
[8], header
[9]);
759 if (version
>= ID3_VER_2_4
) {
760 framelen
= unsync(header
[4], header
[5],
761 header
[6], header
[7]);
763 /* version .3 files don't use synchsafe ints for
765 framelen
= bytes2int(header
[4], header
[5],
766 header
[6], header
[7]);
769 if(6 != read(fd
, header
, 6))
771 /* Adjust for the 6 bytes we read */
774 framelen
= bytes2int(0, header
[3], header
[4], header
[5]);
777 logf("framelen = %ld, flags = 0x%04x", framelen
, flags
);
779 if (header
[0] == 0 && header
[1] == 0 && header
[2] == 0)
791 if (version
>= ID3_VER_2_4
) {
792 if(flags
& 0x0040) { /* Grouping identity */
793 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
797 if(flags
& 0x0020) { /* Grouping identity */
798 lseek(fd
, 1, SEEK_CUR
); /* Skip 1 byte */
803 if(flags
& 0x000c) /* Compression or encryption */
807 lseek(fd
, framelen
, SEEK_CUR
);
811 if(flags
& 0x0002) /* Unsynchronization */
814 if (version
>= ID3_VER_2_4
) {
815 if(flags
& 0x0001) { /* Data length indicator */
816 if(4 != read(fd
, tmp
, 4))
819 /* We don't need the data length */
831 /* Keep track of the remaining frame size */
832 totframelen
= framelen
;
834 /* If the frame is larger than the remaining buffer space we try
835 to read as much as would fit in the buffer */
836 if(framelen
>= buffersize
- bufferpos
)
837 framelen
= buffersize
- bufferpos
- 1;
839 logf("id3v2 frame: %.4s", header
);
841 /* Check for certain frame headers
843 'size' is the amount of frame bytes remaining. We decrement it by
844 the amount of bytes we read. If we fail to read as many bytes as
845 we expect, we assume that we can't read from this file, and bail
848 For each frame. we will iterate over the list of supported tags,
849 and read the tag into entry's buffer. All tags will be kept as
850 strings, for cases where a number won't do, e.g., YEAR: "circa
851 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
852 "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
853 flexible, and as the main use of id3 data is to display it,
854 converting it to an int just means reconverting to display it, at a
857 For tags that the current code does convert to ints, a post
858 processing function will be called via a pointer to function. */
860 for (i
=0; i
<TAGLIST_SIZE
; i
++) {
861 const struct tag_resolver
* tr
= &taglist
[i
];
862 char** ptag
= tr
->offset
? (char**) (((char*)entry
) + tr
->offset
)
866 /* Only ID3_VER_2_2 uses frames with three-character names. */
867 if (((version
== ID3_VER_2_2
) && (tr
->tag_length
!= 3))
868 || ((version
> ID3_VER_2_2
) && (tr
->tag_length
!= 4))) {
872 if( !memcmp( header
, tr
->tag
, tr
->tag_length
) ) {
874 /* found a tag matching one in tagList, and not yet filled */
875 tag
= buffer
+ bufferpos
;
877 if(global_unsynch
&& version
<= ID3_VER_2_3
)
878 bytesread
= read_unsynched(fd
, tag
, framelen
);
880 bytesread
= read(fd
, tag
, framelen
);
882 if( bytesread
!= framelen
)
887 if(unsynch
|| (global_unsynch
&& version
>= ID3_VER_2_4
))
888 bytesread
= unsynchronize_frame(tag
, bytesread
);
890 /* the COMM frame has a 3 char field to hold an ISO-639-1
891 * language string and an optional short description;
892 * remove them so unicode_munge can work correctly
895 if((tr
->tag_length
== 4 && !memcmp( header
, "COMM", 4)) ||
896 (tr
->tag_length
== 3 && !memcmp( header
, "COM", 3))) {
898 if(!strncmp(tag
+4, "iTun", 4)) {
899 #if CONFIG_CODEC == SWCODEC
900 /* check for iTunes gapless information */
901 if(!strncmp(tag
+4, "iTunSMPB", 8))
902 itunes_gapless
= true;
905 /* ignore other with iTunes tags */
909 offset
= 3 + unicode_len(*tag
, tag
+ 4);
910 if(bytesread
> offset
) {
912 memmove(tag
+ 1, tag
+ 1 + offset
, bytesread
- 1);
916 /* Attempt to parse Unicode string only if the tag contents
919 /* UTF-8 could potentially be 3 times larger */
920 /* so we need to create a new buffer */
921 char utf8buf
[(3 * bytesread
) + 1];
923 unicode_munge( tag
, utf8buf
, &bytesread
);
925 if(bytesread
>= buffersize
- bufferpos
)
926 bytesread
= buffersize
- bufferpos
- 1;
928 for (j
= 0; j
< bytesread
; j
++)
931 /* remove trailing spaces */
932 while ( bytesread
> 0 && isspace(tag
[bytesread
-1]))
937 bufferpos
+= bytesread
+ 1;
939 #if CONFIG_CODEC == SWCODEC
940 /* parse the tag if it contains iTunes gapless info */
943 itunes_gapless
= false;
944 entry
->lead_trim
= get_itunes_int32(tag
, 1);
945 entry
->tail_trim
= get_itunes_int32(tag
, 2);
949 /* Note that parser functions sometimes set *ptag to NULL, so
950 * the "!*ptag" check here doesn't always have the desired
951 * effect. Should the parser functions (parsegenre in
952 * particular) be updated to handle the case of being called
953 * multiple times, or should the "*ptag" check be removed?
959 bufferpos
= tr
->ppFunc(entry
, tag
, bufferpos
);
961 /* Seek to the next frame */
962 if(framelen
< totframelen
)
963 lseek(fd
, totframelen
- framelen
, SEEK_CUR
);
968 if( i
== TAGLIST_SIZE
) {
969 /* no tag in tagList was found, or it was a repeat.
970 skip it using the total size */
972 if(global_unsynch
&& version
<= ID3_VER_2_3
) {
973 size
-= skip_unsynched(fd
, totframelen
);
976 if( lseek(fd
, totframelen
, SEEK_CUR
) == -1 )
984 * Calculates the size of the ID3v2 tag.
986 * Arguments: file - the file to search for a tag.
988 * Returns: the size of the tag or 0 if none was found
990 int getid3v2len(int fd
)
995 /* Make sure file has a ID3 tag */
996 if((-1 == lseek(fd
, 0, SEEK_SET
)) ||
997 (read(fd
, buf
, 6) != 6) ||
998 (strncmp(buf
, "ID3", strlen("ID3")) != 0))
1001 /* Now check what the ID3v2 size field says */
1003 if(read(fd
, buf
, 4) != 4)
1006 offset
= unsync(buf
[0], buf
[1], buf
[2], buf
[3]) + 10;
1008 logf("ID3V2 Length: 0x%x", offset
);
1012 #ifdef DEBUG_STANDALONE
1014 char *secs2str(int ms
)
1016 static char buffer
[32];
1019 snprintf(buffer
, sizeof(buffer
), "%d:%02d.%d", secs
/60, secs
%60, ms
/100);
1023 int main(int argc
, char **argv
)
1026 for(i
=1; i
<argc
; i
++) {
1027 struct mp3entry mp3
;
1028 mp3
.album
= "Bogus";
1029 if(mp3info(&mp3
, argv
[i
], false)) {
1030 printf("Failed to get %s\n", argv
[i
]);
1034 printf("****** File: %s\n"
1038 " Genre: %s (%d) \n"
1042 " Length: %s / %d s\n"
1046 mp3
.title
?mp3
.title
:"<blank>",
1047 mp3
.artist
?mp3
.artist
:"<blank>",
1048 mp3
.album
?mp3
.album
:"<blank>",
1049 mp3
.genre_string
?mp3
.genre_string
:"<blank>",
1051 mp3
.composer
?mp3
.composer
:"<blank>",
1052 mp3
.year_string
?mp3
.year_string
:"<blank>",
1054 mp3
.track_string
?mp3
.track_string
:"<blank>",
1056 secs2str(mp3
.length
),