diff options
-rw-r--r-- | apps/SOURCES | 1 | ||||
-rw-r--r-- | apps/metadata/id3tags.c | 1065 | ||||
-rw-r--r-- | apps/metadata/mp3.c | 1029 | ||||
-rw-r--r-- | tools/database/SOURCES | 1 |
4 files changed, 1071 insertions, 1025 deletions
diff --git a/apps/SOURCES b/apps/SOURCES index 8151c299b9..c6a9e6a79a 100644 --- a/apps/SOURCES +++ b/apps/SOURCES | |||
@@ -171,6 +171,7 @@ usb_keymaps.c | |||
171 | gui/usb_screen.c | 171 | gui/usb_screen.c |
172 | #endif | 172 | #endif |
173 | metadata.c | 173 | metadata.c |
174 | metadata/id3tags.c | ||
174 | metadata/mp3.c | 175 | metadata/mp3.c |
175 | #if CONFIG_CODEC == SWCODEC | 176 | #if CONFIG_CODEC == SWCODEC |
176 | metadata/metadata_common.c | 177 | metadata/metadata_common.c |
diff --git a/apps/metadata/id3tags.c b/apps/metadata/id3tags.c new file mode 100644 index 0000000000..2f736d7b9b --- /dev/null +++ b/apps/metadata/id3tags.c | |||
@@ -0,0 +1,1065 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2002 by Daniel Stenberg | ||
11 | * | ||
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. | ||
16 | * | ||
17 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
18 | * KIND, either express or implied. | ||
19 | * | ||
20 | ****************************************************************************/ | ||
21 | /* | ||
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. | ||
25 | * | ||
26 | */ | ||
27 | |||
28 | /* tagResolver and associated code copyright 2003 Thomas Paul Diffenbach | ||
29 | */ | ||
30 | |||
31 | #include <stdio.h> | ||
32 | #include <stdlib.h> | ||
33 | #include <string.h> | ||
34 | #include <errno.h> | ||
35 | #include <stdbool.h> | ||
36 | #include <stddef.h> | ||
37 | #include <ctype.h> | ||
38 | #include "config.h" | ||
39 | #include "file.h" | ||
40 | #include "logf.h" | ||
41 | #include "system.h" | ||
42 | #include "replaygain.h" | ||
43 | #include "rbunicode.h" | ||
44 | |||
45 | #include "metadata.h" | ||
46 | #include "mp3data.h" | ||
47 | #if CONFIG_CODEC == SWCODEC | ||
48 | #include "metadata_common.h" | ||
49 | #endif | ||
50 | #include "metadata_parsers.h" | ||
51 | |||
52 | static unsigned long unsync(unsigned long b0, | ||
53 | unsigned long b1, | ||
54 | unsigned long b2, | ||
55 | unsigned long b3) | ||
56 | { | ||
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))); | ||
61 | } | ||
62 | |||
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", | ||
77 | |||
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", | ||
91 | "Synthpop" | ||
92 | }; | ||
93 | |||
94 | char* id3_get_num_genre(unsigned int genre_num) | ||
95 | { | ||
96 | if (genre_num < ARRAYLEN(genres)) | ||
97 | return (char*)genres[genre_num]; | ||
98 | return NULL; | ||
99 | } | ||
100 | |||
101 | /* | ||
102 | HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS | ||
103 | Code and comments by Thomas Paul Diffenbach | ||
104 | |||
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.) | ||
114 | |||
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. | ||
118 | |||
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 | ||
127 | argument unchanged. | ||
128 | |||
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. | ||
131 | |||
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). | ||
146 | |||
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 | ||
151 | |||
152 | 5. Add code to wps-display.c function get_tag to assign a printf-like | ||
153 | format specifier for the tag */ | ||
154 | |||
155 | /* Structure for ID3 Tag extraction information */ | ||
156 | struct tag_resolver { | ||
157 | const char* tag; | ||
158 | int tag_length; | ||
159 | size_t offset; | ||
160 | int (*ppFunc)(struct mp3entry*, char* tag, int bufferpos); | ||
161 | bool binary; | ||
162 | }; | ||
163 | |||
164 | static bool global_ff_found; | ||
165 | |||
166 | static int unsynchronize(char* tag, int len, bool *ff_found) | ||
167 | { | ||
168 | int i; | ||
169 | unsigned char c; | ||
170 | unsigned char *rp, *wp; | ||
171 | |||
172 | wp = rp = (unsigned char *)tag; | ||
173 | |||
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 | ||
177 | write pointer */ | ||
178 | c = *rp++; | ||
179 | *wp = c; | ||
180 | if(*ff_found) { | ||
181 | /* Increment the write pointer if it isn't an unsynch pattern */ | ||
182 | if(c != 0) | ||
183 | wp++; | ||
184 | *ff_found = false; | ||
185 | } else { | ||
186 | if(c == 0xff) | ||
187 | *ff_found = true; | ||
188 | wp++; | ||
189 | } | ||
190 | } | ||
191 | return (long)wp - (long)tag; | ||
192 | } | ||
193 | |||
194 | static int unsynchronize_frame(char* tag, int len) | ||
195 | { | ||
196 | bool ff_found = false; | ||
197 | |||
198 | return unsynchronize(tag, len, &ff_found); | ||
199 | } | ||
200 | |||
201 | static int read_unsynched(int fd, void *buf, int len) | ||
202 | { | ||
203 | int i; | ||
204 | int rc; | ||
205 | int remaining = len; | ||
206 | char *wp; | ||
207 | char *rp; | ||
208 | |||
209 | wp = buf; | ||
210 | |||
211 | while(remaining) { | ||
212 | rp = wp; | ||
213 | rc = read(fd, rp, remaining); | ||
214 | if(rc <= 0) | ||
215 | return rc; | ||
216 | |||
217 | i = unsynchronize(wp, remaining, &global_ff_found); | ||
218 | remaining -= i; | ||
219 | wp += i; | ||
220 | } | ||
221 | |||
222 | return len; | ||
223 | } | ||
224 | |||
225 | static int skip_unsynched(int fd, int len) | ||
226 | { | ||
227 | int rc; | ||
228 | int remaining = len; | ||
229 | int rlen; | ||
230 | char buf[32]; | ||
231 | |||
232 | while(remaining) { | ||
233 | rlen = MIN(sizeof(buf), (unsigned int)remaining); | ||
234 | rc = read(fd, buf, rlen); | ||
235 | if(rc <= 0) | ||
236 | return rc; | ||
237 | |||
238 | remaining -= unsynchronize(buf, rlen, &global_ff_found); | ||
239 | } | ||
240 | |||
241 | return len; | ||
242 | } | ||
243 | |||
244 | /* parse numeric value from string */ | ||
245 | static int parsetracknum( struct mp3entry* entry, char* tag, int bufferpos ) | ||
246 | { | ||
247 | entry->tracknum = atoi( tag ); | ||
248 | return bufferpos; | ||
249 | } | ||
250 | |||
251 | /* parse numeric value from string */ | ||
252 | static int parsediscnum( struct mp3entry* entry, char* tag, int bufferpos ) | ||
253 | { | ||
254 | entry->discnum = atoi( tag ); | ||
255 | return bufferpos; | ||
256 | } | ||
257 | |||
258 | /* parse numeric value from string */ | ||
259 | static int parseyearnum( struct mp3entry* entry, char* tag, int bufferpos ) | ||
260 | { | ||
261 | entry->year = atoi( tag ); | ||
262 | return bufferpos; | ||
263 | } | ||
264 | |||
265 | /* parse numeric genre from string, version 2.2 and 2.3 */ | ||
266 | static int parsegenre( struct mp3entry* entry, char* tag, int bufferpos ) | ||
267 | { | ||
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. */ | ||
271 | |||
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; | ||
276 | } else { | ||
277 | entry->genre_string = tag; | ||
278 | return bufferpos; | ||
279 | } | ||
280 | } else { | ||
281 | if( tag[0] == '(' && tag[1] != '(' ) { | ||
282 | entry->genre_string = id3_get_num_genre(atoi( tag + 1 )); | ||
283 | return tag - entry->id3v2buf; | ||
284 | } | ||
285 | else { | ||
286 | entry->genre_string = tag; | ||
287 | return bufferpos; | ||
288 | } | ||
289 | } | ||
290 | } | ||
291 | |||
292 | /* parse user defined text, looking for album artist and replaygain | ||
293 | * information. | ||
294 | */ | ||
295 | static int parseuser( struct mp3entry* entry, char* tag, int bufferpos ) | ||
296 | { | ||
297 | char* value = NULL; | ||
298 | int desc_len = strlen(tag); | ||
299 | int value_len = 0; | ||
300 | |||
301 | if ((tag - entry->id3v2buf + desc_len + 2) < bufferpos) { | ||
302 | /* At least part of the value was read, so we can safely try to | ||
303 | * parse it | ||
304 | */ | ||
305 | value = tag + desc_len + 1; | ||
306 | value_len = bufferpos - (tag - entry->id3v2buf); | ||
307 | |||
308 | if (!strcasecmp(tag, "ALBUM ARTIST")) { | ||
309 | strlcpy(tag, value, value_len); | ||
310 | entry->albumartist = tag; | ||
311 | #if CONFIG_CODEC == SWCODEC | ||
312 | } else { | ||
313 | value_len = parse_replaygain(tag, value, entry, tag, | ||
314 | value_len); | ||
315 | #endif | ||
316 | } | ||
317 | } | ||
318 | |||
319 | return tag - entry->id3v2buf + value_len; | ||
320 | } | ||
321 | |||
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 ) | ||
325 | { | ||
326 | int desc_len = strlen(tag); | ||
327 | int start_pos = tag - entry->id3v2buf; | ||
328 | int end_pos = start_pos + desc_len + 5; | ||
329 | int value_len = 0; | ||
330 | unsigned char* value = tag + desc_len + 1; | ||
331 | |||
332 | /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel | ||
333 | * type is master volume. | ||
334 | */ | ||
335 | if (entry->id3version == ID3_VER_2_4 && end_pos < bufferpos | ||
336 | && *value++ == 1) { | ||
337 | long gain = 0; | ||
338 | long peak = 0; | ||
339 | long peakbits; | ||
340 | long peakbytes; | ||
341 | bool album = false; | ||
342 | |||
343 | /* The RVA2 specification is unclear on some things (id string and | ||
344 | * peak volume), but this matches how Quod Libet use them. | ||
345 | */ | ||
346 | |||
347 | gain = (int16_t) ((value[0] << 8) | value[1]); | ||
348 | value += 2; | ||
349 | peakbits = *value++; | ||
350 | peakbytes = (peakbits + 7) / 8; | ||
351 | |||
352 | /* Only use the topmost 24 bits for peak volume */ | ||
353 | if (peakbytes > 3) { | ||
354 | peakbytes = 3; | ||
355 | } | ||
356 | |||
357 | /* Make sure the peak bits were read */ | ||
358 | if (end_pos + peakbytes < bufferpos) { | ||
359 | long shift = ((8 - (peakbits & 7)) & 7) + (3 - peakbytes) * 8; | ||
360 | |||
361 | for ( ; peakbytes; peakbytes--) { | ||
362 | peak <<= 8; | ||
363 | peak += *value++; | ||
364 | } | ||
365 | |||
366 | peak <<= shift; | ||
367 | |||
368 | if (peakbits > 24) { | ||
369 | peak += *value >> (8 - shift); | ||
370 | } | ||
371 | } | ||
372 | |||
373 | if (strcasecmp(tag, "album") == 0) { | ||
374 | album = true; | ||
375 | } else if (strcasecmp(tag, "track") != 0) { | ||
376 | /* Only accept non-track values if we don't have any previous | ||
377 | * value. | ||
378 | */ | ||
379 | if (entry->track_gain != 0) { | ||
380 | return start_pos; | ||
381 | } | ||
382 | } | ||
383 | |||
384 | value_len = parse_replaygain_int(album, gain, peak * 2, entry, | ||
385 | tag, sizeof(entry->id3v2buf) - start_pos); | ||
386 | } | ||
387 | |||
388 | return start_pos + value_len; | ||
389 | } | ||
390 | #endif | ||
391 | |||
392 | static int parsembtid( struct mp3entry* entry, char* tag, int bufferpos ) | ||
393 | { | ||
394 | char* value = NULL; | ||
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; | ||
399 | |||
400 | if ((tag - entry->id3v2buf + desc_len + 2) < bufferpos) | ||
401 | { | ||
402 | value = tag + desc_len + 1; | ||
403 | |||
404 | if (strcasecmp(tag, "http://musicbrainz.org") == 0) | ||
405 | { | ||
406 | if (mbtid_len == strlen(value)) | ||
407 | { | ||
408 | entry->mb_track_id = value; | ||
409 | return bufferpos + mbtid_len + 1; | ||
410 | } | ||
411 | } | ||
412 | } | ||
413 | |||
414 | return bufferpos; | ||
415 | } | ||
416 | |||
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 }, | ||
442 | #endif | ||
443 | { "UFID", 4, 0, &parsembtid, false }, | ||
444 | }; | ||
445 | |||
446 | #define TAGLIST_SIZE ((int)ARRAYLEN(taglist)) | ||
447 | |||
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. | ||
450 | */ | ||
451 | static int unicode_len(char encoding, const void* string) | ||
452 | { | ||
453 | int len = 0; | ||
454 | |||
455 | if (encoding == 0x01 || encoding == 0x02) { | ||
456 | char first; | ||
457 | const char *s = string; | ||
458 | /* string might be unaligned, so using short* can crash on ARM and SH1 */ | ||
459 | do { | ||
460 | first = *s++; | ||
461 | } while ((first | *s++) != 0); | ||
462 | |||
463 | len = s - (const char*) string; | ||
464 | } else { | ||
465 | len = strlen((char*) string) + 1; | ||
466 | } | ||
467 | |||
468 | return len; | ||
469 | } | ||
470 | |||
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) { | ||
475 | long tmp; | ||
476 | bool le = false; | ||
477 | int i = 0; | ||
478 | unsigned char *str = (unsigned char *)string; | ||
479 | int templen = 0; | ||
480 | unsigned char* utf8 = (unsigned char *)utf8buf; | ||
481 | |||
482 | switch (str[0]) { | ||
483 | case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */ | ||
484 | str++; | ||
485 | (*len)--; | ||
486 | utf8 = iso_decode(str, utf8, -1, *len); | ||
487 | *utf8 = 0; | ||
488 | *len = (unsigned long)utf8 - (unsigned long)utf8buf; | ||
489 | break; | ||
490 | |||
491 | case 0x01: /* Unicode with or without BOM */ | ||
492 | case 0x02: | ||
493 | (*len)--; | ||
494 | str++; | ||
495 | |||
496 | /* Handle frames with more than one string | ||
497 | (needed for TXXX frames).*/ | ||
498 | do { | ||
499 | tmp = bytes2int(0, 0, str[0], str[1]); | ||
500 | |||
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? */ | ||
505 | le = true; | ||
506 | str += 2; | ||
507 | (*len)-=2; | ||
508 | } else if(tmp == 0xfeff) { /* Big endian? */ | ||
509 | str += 2; | ||
510 | (*len)-=2; | ||
511 | } else | ||
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. */ | ||
515 | if(str[1] == 0) | ||
516 | le = true; | ||
517 | |||
518 | do { | ||
519 | if(le) | ||
520 | utf8 = utf16LEdecode(str, utf8, 1); | ||
521 | else | ||
522 | utf8 = utf16BEdecode(str, utf8, 1); | ||
523 | |||
524 | str+=2; | ||
525 | i += 2; | ||
526 | } while((str[0] || str[1]) && (i < *len)); | ||
527 | |||
528 | *utf8++ = 0; /* Terminate the string */ | ||
529 | templen += (strlen(&utf8buf[templen]) + 1); | ||
530 | str += 2; | ||
531 | i+=2; | ||
532 | } while(i < *len); | ||
533 | *len = templen - 1; | ||
534 | break; | ||
535 | |||
536 | case 0x03: /* UTF-8 encoded string */ | ||
537 | for(i=0; i < *len; i++) | ||
538 | utf8[i] = str[i+1]; | ||
539 | (*len)--; | ||
540 | break; | ||
541 | |||
542 | default: /* Plain old string */ | ||
543 | utf8 = iso_decode(str, utf8, -1, *len); | ||
544 | *utf8 = 0; | ||
545 | *len = (unsigned long)utf8 - (unsigned long)utf8buf; | ||
546 | break; | ||
547 | } | ||
548 | return 0; | ||
549 | } | ||
550 | |||
551 | /* | ||
552 | * Sets the title of an MP3 entry based on its ID3v1 tag. | ||
553 | * | ||
554 | * Arguments: file - the MP3 file to scen for a ID3v1 tag | ||
555 | * entry - the entry to set the title in | ||
556 | * | ||
557 | * Returns: true if a title was found and created, else false | ||
558 | */ | ||
559 | bool setid3v1title(int fd, struct mp3entry *entry) | ||
560 | { | ||
561 | unsigned char buffer[128]; | ||
562 | static const char offsets[] = {3, 33, 63, 97, 93, 125, 127}; | ||
563 | int i, j; | ||
564 | unsigned char* utf8; | ||
565 | |||
566 | if (-1 == lseek(fd, -128, SEEK_END)) | ||
567 | return false; | ||
568 | |||
569 | if (read(fd, buffer, sizeof buffer) != sizeof buffer) | ||
570 | return false; | ||
571 | |||
572 | if (strncmp((char *)buffer, "TAG", 3)) | ||
573 | return false; | ||
574 | |||
575 | entry->id3v1len = 128; | ||
576 | entry->id3version = ID3_VER_1_0; | ||
577 | |||
578 | for (i=0; i < (int)sizeof offsets; i++) { | ||
579 | unsigned char* ptr = (unsigned char *)buffer + offsets[i]; | ||
580 | |||
581 | switch(i) { | ||
582 | case 0: | ||
583 | case 1: | ||
584 | case 2: | ||
585 | /* kill trailing space in strings */ | ||
586 | for (j=29; j && (ptr[j]==0 || ptr[j]==' '); j--) | ||
587 | ptr[j] = 0; | ||
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 */ | ||
592 | *utf8 = 0; | ||
593 | break; | ||
594 | |||
595 | case 3: | ||
596 | /* kill trailing space in strings */ | ||
597 | for (j=27; j && (ptr[j]==0 || ptr[j]==' '); j--) | ||
598 | ptr[j] = 0; | ||
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 */ | ||
603 | *utf8 = 0; | ||
604 | break; | ||
605 | |||
606 | case 4: | ||
607 | ptr[4] = 0; | ||
608 | entry->year = atoi((char *)ptr); | ||
609 | break; | ||
610 | |||
611 | case 5: | ||
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; | ||
617 | } | ||
618 | break; | ||
619 | |||
620 | case 6: | ||
621 | /* genre */ | ||
622 | entry->genre_string = id3_get_num_genre(ptr[0]); | ||
623 | break; | ||
624 | } | ||
625 | } | ||
626 | |||
627 | entry->title = entry->id3v1buf[0]; | ||
628 | entry->artist = entry->id3v1buf[1]; | ||
629 | entry->album = entry->id3v1buf[2]; | ||
630 | entry->comment = entry->id3v1buf[3]; | ||
631 | |||
632 | return true; | ||
633 | } | ||
634 | |||
635 | |||
636 | /* | ||
637 | * Sets the title of an MP3 entry based on its ID3v2 tag. | ||
638 | * | ||
639 | * Arguments: file - the MP3 file to scan for a ID3v2 tag | ||
640 | * entry - the entry to set the title in | ||
641 | * | ||
642 | * Returns: true if a title was found and created, else false | ||
643 | */ | ||
644 | void setid3v2title(int fd, struct mp3entry *entry) | ||
645 | { | ||
646 | int minframesize; | ||
647 | int size; | ||
648 | long bufferpos = 0, totframelen, framelen; | ||
649 | char header[10]; | ||
650 | char tmp[4]; | ||
651 | unsigned char version; | ||
652 | char *buffer = entry->id3v2buf; | ||
653 | int bytesread = 0; | ||
654 | int buffersize = sizeof(entry->id3v2buf); | ||
655 | unsigned char global_flags; | ||
656 | int flags; | ||
657 | int skip; | ||
658 | bool global_unsynch = false; | ||
659 | bool unsynch = false; | ||
660 | int i, j; | ||
661 | int rc; | ||
662 | #if CONFIG_CODEC == SWCODEC | ||
663 | bool itunes_gapless = false; | ||
664 | #endif | ||
665 | |||
666 | global_ff_found = false; | ||
667 | |||
668 | /* Bail out if the tag is shorter than 10 bytes */ | ||
669 | if(entry->id3v2len < 10) | ||
670 | return; | ||
671 | |||
672 | /* Read the ID3 tag version from the header */ | ||
673 | lseek(fd, 0, SEEK_SET); | ||
674 | if(10 != read(fd, header, 10)) | ||
675 | return; | ||
676 | |||
677 | /* Get the total ID3 tag size */ | ||
678 | size = entry->id3v2len - 10; | ||
679 | |||
680 | version = header[3]; | ||
681 | switch ( version ) { | ||
682 | case 2: | ||
683 | version = ID3_VER_2_2; | ||
684 | minframesize = 8; | ||
685 | break; | ||
686 | |||
687 | case 3: | ||
688 | version = ID3_VER_2_3; | ||
689 | minframesize = 12; | ||
690 | break; | ||
691 | |||
692 | case 4: | ||
693 | version = ID3_VER_2_4; | ||
694 | minframesize = 12; | ||
695 | break; | ||
696 | |||
697 | default: | ||
698 | /* unsupported id3 version */ | ||
699 | return; | ||
700 | } | ||
701 | entry->id3version = version; | ||
702 | entry->tracknum = entry->year = entry->discnum = 0; | ||
703 | entry->title = entry->artist = entry->album = NULL; /* FIXME incomplete */ | ||
704 | |||
705 | global_flags = header[5]; | ||
706 | |||
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)) | ||
711 | return; | ||
712 | /* The 2.3 extended header size doesn't include the header size | ||
713 | field itself. Also, it is not unsynched. */ | ||
714 | framelen = | ||
715 | bytes2int(header[0], header[1], header[2], header[3]) + 4; | ||
716 | |||
717 | /* Skip the rest of the header */ | ||
718 | lseek(fd, framelen - 10, SEEK_CUR); | ||
719 | } | ||
720 | |||
721 | if(version >= ID3_VER_2_4) { | ||
722 | if(4 != read(fd, header, 4)) | ||
723 | return; | ||
724 | |||
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]); | ||
729 | |||
730 | lseek(fd, framelen - 4, SEEK_CUR); | ||
731 | } | ||
732 | } | ||
733 | |||
734 | /* Is unsynchronization applied? */ | ||
735 | if(global_flags & 0x80) { | ||
736 | global_unsynch = true; | ||
737 | } | ||
738 | |||
739 | /* | ||
740 | * We must have at least minframesize bytes left for the | ||
741 | * remaining frames to be interesting | ||
742 | */ | ||
743 | while (size >= minframesize && bufferpos < buffersize - 1) { | ||
744 | flags = 0; | ||
745 | |||
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); | ||
750 | else | ||
751 | rc = read(fd, header, 10); | ||
752 | if(rc != 10) | ||
753 | return; | ||
754 | /* Adjust for the 10 bytes we read */ | ||
755 | size -= 10; | ||
756 | |||
757 | flags = bytes2int(0, 0, header[8], header[9]); | ||
758 | |||
759 | if (version >= ID3_VER_2_4) { | ||
760 | framelen = unsync(header[4], header[5], | ||
761 | header[6], header[7]); | ||
762 | } else { | ||
763 | /* version .3 files don't use synchsafe ints for | ||
764 | * size */ | ||
765 | framelen = bytes2int(header[4], header[5], | ||
766 | header[6], header[7]); | ||
767 | } | ||
768 | } else { | ||
769 | if(6 != read(fd, header, 6)) | ||
770 | return; | ||
771 | /* Adjust for the 6 bytes we read */ | ||
772 | size -= 6; | ||
773 | |||
774 | framelen = bytes2int(0, header[3], header[4], header[5]); | ||
775 | } | ||
776 | |||
777 | logf("framelen = %ld, flags = 0x%04x", framelen, flags); | ||
778 | if(framelen == 0){ | ||
779 | if (header[0] == 0 && header[1] == 0 && header[2] == 0) | ||
780 | return; | ||
781 | else | ||
782 | continue; | ||
783 | } | ||
784 | |||
785 | unsynch = false; | ||
786 | |||
787 | if(flags) | ||
788 | { | ||
789 | skip = 0; | ||
790 | |||
791 | if (version >= ID3_VER_2_4) { | ||
792 | if(flags & 0x0040) { /* Grouping identity */ | ||
793 | lseek(fd, 1, SEEK_CUR); /* Skip 1 byte */ | ||
794 | framelen--; | ||
795 | } | ||
796 | } else { | ||
797 | if(flags & 0x0020) { /* Grouping identity */ | ||
798 | lseek(fd, 1, SEEK_CUR); /* Skip 1 byte */ | ||
799 | framelen--; | ||
800 | } | ||
801 | } | ||
802 | |||
803 | if(flags & 0x000c) /* Compression or encryption */ | ||
804 | { | ||
805 | /* Skip it */ | ||
806 | size -= framelen; | ||
807 | lseek(fd, framelen, SEEK_CUR); | ||
808 | continue; | ||
809 | } | ||
810 | |||
811 | if(flags & 0x0002) /* Unsynchronization */ | ||
812 | unsynch = true; | ||
813 | |||
814 | if (version >= ID3_VER_2_4) { | ||
815 | if(flags & 0x0001) { /* Data length indicator */ | ||
816 | if(4 != read(fd, tmp, 4)) | ||
817 | return; | ||
818 | |||
819 | /* We don't need the data length */ | ||
820 | framelen -= 4; | ||
821 | } | ||
822 | } | ||
823 | } | ||
824 | |||
825 | if (framelen == 0) | ||
826 | continue; | ||
827 | |||
828 | if (framelen < 0) | ||
829 | return; | ||
830 | |||
831 | /* Keep track of the remaining frame size */ | ||
832 | totframelen = framelen; | ||
833 | |||
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; | ||
838 | |||
839 | logf("id3v2 frame: %.4s", header); | ||
840 | |||
841 | /* Check for certain frame headers | ||
842 | |||
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 | ||
846 | out. | ||
847 | |||
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 | ||
855 | runtime cost. | ||
856 | |||
857 | For tags that the current code does convert to ints, a post | ||
858 | processing function will be called via a pointer to function. */ | ||
859 | |||
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) | ||
863 | : NULL; | ||
864 | char* tag; | ||
865 | |||
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))) { | ||
869 | continue; | ||
870 | } | ||
871 | |||
872 | if( !memcmp( header, tr->tag, tr->tag_length ) ) { | ||
873 | |||
874 | /* found a tag matching one in tagList, and not yet filled */ | ||
875 | tag = buffer + bufferpos; | ||
876 | |||
877 | if(global_unsynch && version <= ID3_VER_2_3) | ||
878 | bytesread = read_unsynched(fd, tag, framelen); | ||
879 | else | ||
880 | bytesread = read(fd, tag, framelen); | ||
881 | |||
882 | if( bytesread != framelen ) | ||
883 | return; | ||
884 | |||
885 | size -= bytesread; | ||
886 | |||
887 | if(unsynch || (global_unsynch && version >= ID3_VER_2_4)) | ||
888 | bytesread = unsynchronize_frame(tag, bytesread); | ||
889 | |||
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 | ||
893 | */ | ||
894 | |||
895 | if((tr->tag_length == 4 && !memcmp( header, "COMM", 4)) || | ||
896 | (tr->tag_length == 3 && !memcmp( header, "COM", 3))) { | ||
897 | int offset; | ||
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; | ||
903 | else | ||
904 | #endif | ||
905 | /* ignore other with iTunes tags */ | ||
906 | break; | ||
907 | } | ||
908 | |||
909 | offset = 3 + unicode_len(*tag, tag + 4); | ||
910 | if(bytesread > offset) { | ||
911 | bytesread -= offset; | ||
912 | memmove(tag + 1, tag + 1 + offset, bytesread - 1); | ||
913 | } | ||
914 | } | ||
915 | |||
916 | /* Attempt to parse Unicode string only if the tag contents | ||
917 | aren't binary */ | ||
918 | if(!tr->binary) { | ||
919 | /* UTF-8 could potentially be 3 times larger */ | ||
920 | /* so we need to create a new buffer */ | ||
921 | char utf8buf[(3 * bytesread) + 1]; | ||
922 | |||
923 | unicode_munge( tag, utf8buf, &bytesread ); | ||
924 | |||
925 | if(bytesread >= buffersize - bufferpos) | ||
926 | bytesread = buffersize - bufferpos - 1; | ||
927 | |||
928 | for (j = 0; j < bytesread; j++) | ||
929 | tag[j] = utf8buf[j]; | ||
930 | |||
931 | /* remove trailing spaces */ | ||
932 | while ( bytesread > 0 && isspace(tag[bytesread-1])) | ||
933 | bytesread--; | ||
934 | } | ||
935 | |||
936 | tag[bytesread] = 0; | ||
937 | bufferpos += bytesread + 1; | ||
938 | |||
939 | #if CONFIG_CODEC == SWCODEC | ||
940 | /* parse the tag if it contains iTunes gapless info */ | ||
941 | if (itunes_gapless) | ||
942 | { | ||
943 | itunes_gapless = false; | ||
944 | entry->lead_trim = get_itunes_int32(tag, 1); | ||
945 | entry->tail_trim = get_itunes_int32(tag, 2); | ||
946 | } | ||
947 | #endif | ||
948 | |||
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? | ||
954 | */ | ||
955 | if (ptag && !*ptag) | ||
956 | *ptag = tag; | ||
957 | |||
958 | if( tr->ppFunc ) | ||
959 | bufferpos = tr->ppFunc(entry, tag, bufferpos); | ||
960 | |||
961 | /* Seek to the next frame */ | ||
962 | if(framelen < totframelen) | ||
963 | lseek(fd, totframelen - framelen, SEEK_CUR); | ||
964 | break; | ||
965 | } | ||
966 | } | ||
967 | |||
968 | if( i == TAGLIST_SIZE ) { | ||
969 | /* no tag in tagList was found, or it was a repeat. | ||
970 | skip it using the total size */ | ||
971 | |||
972 | if(global_unsynch && version <= ID3_VER_2_3) { | ||
973 | size -= skip_unsynched(fd, totframelen); | ||
974 | } else { | ||
975 | size -= totframelen; | ||
976 | if( lseek(fd, totframelen, SEEK_CUR) == -1 ) | ||
977 | return; | ||
978 | } | ||
979 | } | ||
980 | } | ||
981 | } | ||
982 | |||
983 | /* | ||
984 | * Calculates the size of the ID3v2 tag. | ||
985 | * | ||
986 | * Arguments: file - the file to search for a tag. | ||
987 | * | ||
988 | * Returns: the size of the tag or 0 if none was found | ||
989 | */ | ||
990 | int getid3v2len(int fd) | ||
991 | { | ||
992 | char buf[6]; | ||
993 | int offset; | ||
994 | |||
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)) | ||
999 | offset = 0; | ||
1000 | |||
1001 | /* Now check what the ID3v2 size field says */ | ||
1002 | else | ||
1003 | if(read(fd, buf, 4) != 4) | ||
1004 | offset = 0; | ||
1005 | else | ||
1006 | offset = unsync(buf[0], buf[1], buf[2], buf[3]) + 10; | ||
1007 | |||
1008 | logf("ID3V2 Length: 0x%x", offset); | ||
1009 | return offset; | ||
1010 | } | ||
1011 | |||
1012 | #ifdef DEBUG_STANDALONE | ||
1013 | |||
1014 | char *secs2str(int ms) | ||
1015 | { | ||
1016 | static char buffer[32]; | ||
1017 | int secs = ms/1000; | ||
1018 | ms %= 1000; | ||
1019 | snprintf(buffer, sizeof(buffer), "%d:%02d.%d", secs/60, secs%60, ms/100); | ||
1020 | return buffer; | ||
1021 | } | ||
1022 | |||
1023 | int main(int argc, char **argv) | ||
1024 | { | ||
1025 | int i; | ||
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]); | ||
1031 | return 0; | ||
1032 | } | ||
1033 | |||
1034 | printf("****** File: %s\n" | ||
1035 | " Title: %s\n" | ||
1036 | " Artist: %s\n" | ||
1037 | " Album: %s\n" | ||
1038 | " Genre: %s (%d) \n" | ||
1039 | " Composer: %s\n" | ||
1040 | " Year: %s (%d)\n" | ||
1041 | " Track: %s (%d)\n" | ||
1042 | " Length: %s / %d s\n" | ||
1043 | " Bitrate: %d\n" | ||
1044 | " Frequency: %d\n", | ||
1045 | argv[i], | ||
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>", | ||
1050 | mp3.genre, | ||
1051 | mp3.composer?mp3.composer:"<blank>", | ||
1052 | mp3.year_string?mp3.year_string:"<blank>", | ||
1053 | mp3.year, | ||
1054 | mp3.track_string?mp3.track_string:"<blank>", | ||
1055 | mp3.tracknum, | ||
1056 | secs2str(mp3.length), | ||
1057 | mp3.length/1000, | ||
1058 | mp3.bitrate, | ||
1059 | mp3.frequency); | ||
1060 | } | ||
1061 | |||
1062 | return 0; | ||
1063 | } | ||
1064 | |||
1065 | #endif | ||
diff --git a/apps/metadata/mp3.c b/apps/metadata/mp3.c index 0f786bd52b..15c0a5059b 100644 --- a/apps/metadata/mp3.c +++ b/apps/metadata/mp3.c | |||
@@ -30,983 +30,17 @@ | |||
30 | 30 | ||
31 | #include <stdio.h> | 31 | #include <stdio.h> |
32 | #include <stdlib.h> | 32 | #include <stdlib.h> |
33 | #include <errno.h> | 33 | #include <string.h> |
34 | #include <stdbool.h> | 34 | #include <stdbool.h> |
35 | #include <stddef.h> | ||
36 | #include <ctype.h> | ||
37 | #include "string-extra.h" | ||
38 | #include "config.h" | 35 | #include "config.h" |
39 | #include "file.h" | 36 | #include "file.h" |
40 | #include "logf.h" | 37 | #include "logf.h" |
41 | 38 | ||
42 | #include "mp3data.h" | ||
43 | #include "system.h" | 39 | #include "system.h" |
44 | #include "replaygain.h" | 40 | #include "metadata.h" |
45 | #include "rbunicode.h" | 41 | #include "mp3data.h" |
46 | #include "metadata_parsers.h" | ||
47 | #if CONFIG_CODEC == SWCODEC | ||
48 | #include "metadata_common.h" | 42 | #include "metadata_common.h" |
49 | #endif | 43 | #include "metadata_parsers.h" |
50 | |||
51 | static unsigned long unsync(unsigned long b0, | ||
52 | unsigned long b1, | ||
53 | unsigned long b2, | ||
54 | unsigned long b3) | ||
55 | { | ||
56 | return (((long)(b0 & 0x7F) << (3*7)) | | ||
57 | ((long)(b1 & 0x7F) << (2*7)) | | ||
58 | ((long)(b2 & 0x7F) << (1*7)) | | ||
59 | ((long)(b3 & 0x7F) << (0*7))); | ||
60 | } | ||
61 | |||
62 | static const char* const genres[] = { | ||
63 | "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge", | ||
64 | "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B", | ||
65 | "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska", | ||
66 | "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop", | ||
67 | "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental", | ||
68 | "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock", | ||
69 | "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop", | ||
70 | "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial", | ||
71 | "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy", | ||
72 | "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle", | ||
73 | "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave", | ||
74 | "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz", | ||
75 | "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock", | ||
76 | |||
77 | /* winamp extensions */ | ||
78 | "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob", | ||
79 | "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock", | ||
80 | "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock", | ||
81 | "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech", | ||
82 | "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass", | ||
83 | "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba", | ||
84 | "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle", | ||
85 | "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall", | ||
86 | "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie", | ||
87 | "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap", | ||
88 | "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian", | ||
89 | "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop", | ||
90 | "Synthpop" | ||
91 | }; | ||
92 | |||
93 | char* id3_get_num_genre(unsigned int genre_num) | ||
94 | { | ||
95 | if (genre_num < ARRAYLEN(genres)) | ||
96 | return (char*)genres[genre_num]; | ||
97 | return NULL; | ||
98 | } | ||
99 | |||
100 | /* | ||
101 | HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS | ||
102 | Code and comments by Thomas Paul Diffenbach | ||
103 | |||
104 | To add another ID3v2 Tag, do the following: | ||
105 | 1. add a char* named for the tag to struct mp3entry in id3.h, | ||
106 | (I (tpd) prefer to use char* rather than ints, even for what seems like | ||
107 | numerical values, for cases where a number won't do, e.g., | ||
108 | YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969" | ||
109 | TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name" | ||
110 | Text is more flexible, and as the main use of id3 data is to | ||
111 | display it, converting it to an int just means reconverting to | ||
112 | display it, at a runtime cost.) | ||
113 | |||
114 | 2. If any special processing beyond copying the tag value from the Id3 | ||
115 | block to the struct mp3entry is rrequired (such as converting to an | ||
116 | int), write a function to perform this special processing. | ||
117 | |||
118 | This function's prototype must match that of | ||
119 | typedef tagPostProcessFunc, that is it must be: | ||
120 | int func( struct mp3entry*, char* tag, int bufferpos ) | ||
121 | the first argument is a pointer to the current mp3entry structure the | ||
122 | second argument is a pointer to the null terminated string value of the | ||
123 | tag found the third argument is the offset of the next free byte in the | ||
124 | mp3entry's buffer your function should return the corrected offset; if | ||
125 | you don't lengthen or shorten the tag string, you can return the third | ||
126 | argument unchanged. | ||
127 | |||
128 | Unless you have a good reason no to, make the function static. | ||
129 | TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED. | ||
130 | |||
131 | 3. add one or more entries to the tagList array, using the format: | ||
132 | char* ID3 Tag symbolic name -- see the ID3 specification for these, | ||
133 | sizeof() that name minus 1, | ||
134 | offsetof( struct mp3entry, variable_name_in_struct_mp3entry ), | ||
135 | pointer to your special processing function or NULL | ||
136 | if you need no special processing | ||
137 | flag indicating if this tag is binary or textual | ||
138 | Many ID3 symbolic names come in more than one form. You can add both | ||
139 | forms, each referencing the same variable in struct mp3entry. | ||
140 | If both forms are present, the last found will be used. | ||
141 | Note that the offset can be zero, in which case no entry will be set | ||
142 | in the mp3entry struct; the frame is still read into the buffer and | ||
143 | the special processing function is called (several times, if there | ||
144 | are several frames with the same name). | ||
145 | |||
146 | 4. Alternately, use the TAG_LIST_ENTRY macro with | ||
147 | ID3 tag symbolic name, | ||
148 | variable in struct mp3entry, | ||
149 | special processing function address | ||
150 | |||
151 | 5. Add code to wps-display.c function get_tag to assign a printf-like | ||
152 | format specifier for the tag */ | ||
153 | |||
154 | /* Structure for ID3 Tag extraction information */ | ||
155 | struct tag_resolver { | ||
156 | const char* tag; | ||
157 | int tag_length; | ||
158 | size_t offset; | ||
159 | int (*ppFunc)(struct mp3entry*, char* tag, int bufferpos); | ||
160 | bool binary; | ||
161 | }; | ||
162 | |||
163 | static bool global_ff_found; | ||
164 | |||
165 | static int unsynchronize(char* tag, int len, bool *ff_found) | ||
166 | { | ||
167 | int i; | ||
168 | unsigned char c; | ||
169 | unsigned char *rp, *wp; | ||
170 | |||
171 | wp = rp = (unsigned char *)tag; | ||
172 | |||
173 | rp = (unsigned char *)tag; | ||
174 | for(i = 0;i < len;i++) { | ||
175 | /* Read the next byte and write it back, but don't increment the | ||
176 | write pointer */ | ||
177 | c = *rp++; | ||
178 | *wp = c; | ||
179 | if(*ff_found) { | ||
180 | /* Increment the write pointer if it isn't an unsynch pattern */ | ||
181 | if(c != 0) | ||
182 | wp++; | ||
183 | *ff_found = false; | ||
184 | } else { | ||
185 | if(c == 0xff) | ||
186 | *ff_found = true; | ||
187 | wp++; | ||
188 | } | ||
189 | } | ||
190 | return (long)wp - (long)tag; | ||
191 | } | ||
192 | |||
193 | static int unsynchronize_frame(char* tag, int len) | ||
194 | { | ||
195 | bool ff_found = false; | ||
196 | |||
197 | return unsynchronize(tag, len, &ff_found); | ||
198 | } | ||
199 | |||
200 | static int read_unsynched(int fd, void *buf, int len) | ||
201 | { | ||
202 | int i; | ||
203 | int rc; | ||
204 | int remaining = len; | ||
205 | char *wp; | ||
206 | char *rp; | ||
207 | |||
208 | wp = buf; | ||
209 | |||
210 | while(remaining) { | ||
211 | rp = wp; | ||
212 | rc = read(fd, rp, remaining); | ||
213 | if(rc <= 0) | ||
214 | return rc; | ||
215 | |||
216 | i = unsynchronize(wp, remaining, &global_ff_found); | ||
217 | remaining -= i; | ||
218 | wp += i; | ||
219 | } | ||
220 | |||
221 | return len; | ||
222 | } | ||
223 | |||
224 | static int skip_unsynched(int fd, int len) | ||
225 | { | ||
226 | int rc; | ||
227 | int remaining = len; | ||
228 | int rlen; | ||
229 | char buf[32]; | ||
230 | |||
231 | while(remaining) { | ||
232 | rlen = MIN(sizeof(buf), (unsigned int)remaining); | ||
233 | rc = read(fd, buf, rlen); | ||
234 | if(rc <= 0) | ||
235 | return rc; | ||
236 | |||
237 | remaining -= unsynchronize(buf, rlen, &global_ff_found); | ||
238 | } | ||
239 | |||
240 | return len; | ||
241 | } | ||
242 | |||
243 | /* parse numeric value from string */ | ||
244 | static int parsetracknum( struct mp3entry* entry, char* tag, int bufferpos ) | ||
245 | { | ||
246 | entry->tracknum = atoi( tag ); | ||
247 | return bufferpos; | ||
248 | } | ||
249 | |||
250 | /* parse numeric value from string */ | ||
251 | static int parsediscnum( struct mp3entry* entry, char* tag, int bufferpos ) | ||
252 | { | ||
253 | entry->discnum = atoi( tag ); | ||
254 | return bufferpos; | ||
255 | } | ||
256 | |||
257 | /* parse numeric value from string */ | ||
258 | static int parseyearnum( struct mp3entry* entry, char* tag, int bufferpos ) | ||
259 | { | ||
260 | entry->year = atoi( tag ); | ||
261 | return bufferpos; | ||
262 | } | ||
263 | |||
264 | /* parse numeric genre from string, version 2.2 and 2.3 */ | ||
265 | static int parsegenre( struct mp3entry* entry, char* tag, int bufferpos ) | ||
266 | { | ||
267 | if(entry->id3version >= ID3_VER_2_4) { | ||
268 | /* In version 2.4 and up, there are no parentheses, and the genre frame | ||
269 | is a list of strings, either numbers or text. */ | ||
270 | |||
271 | /* Is it a number? */ | ||
272 | if(isdigit(tag[0])) { | ||
273 | entry->genre_string = id3_get_num_genre(atoi( tag )); | ||
274 | return tag - entry->id3v2buf; | ||
275 | } else { | ||
276 | entry->genre_string = tag; | ||
277 | return bufferpos; | ||
278 | } | ||
279 | } else { | ||
280 | if( tag[0] == '(' && tag[1] != '(' ) { | ||
281 | entry->genre_string = id3_get_num_genre(atoi( tag + 1 )); | ||
282 | return tag - entry->id3v2buf; | ||
283 | } | ||
284 | else { | ||
285 | entry->genre_string = tag; | ||
286 | return bufferpos; | ||
287 | } | ||
288 | } | ||
289 | } | ||
290 | |||
291 | /* parse user defined text, looking for album artist and replaygain | ||
292 | * information. | ||
293 | */ | ||
294 | static int parseuser( struct mp3entry* entry, char* tag, int bufferpos ) | ||
295 | { | ||
296 | char* value = NULL; | ||
297 | int desc_len = strlen(tag); | ||
298 | int value_len = 0; | ||
299 | |||
300 | if ((tag - entry->id3v2buf + desc_len + 2) < bufferpos) { | ||
301 | /* At least part of the value was read, so we can safely try to | ||
302 | * parse it | ||
303 | */ | ||
304 | value = tag + desc_len + 1; | ||
305 | value_len = bufferpos - (tag - entry->id3v2buf); | ||
306 | |||
307 | if (!strcasecmp(tag, "ALBUM ARTIST")) { | ||
308 | strlcpy(tag, value, value_len); | ||
309 | entry->albumartist = tag; | ||
310 | #if CONFIG_CODEC == SWCODEC | ||
311 | } else { | ||
312 | value_len = parse_replaygain(tag, value, entry, tag, | ||
313 | value_len); | ||
314 | #endif | ||
315 | } | ||
316 | } | ||
317 | |||
318 | return tag - entry->id3v2buf + value_len; | ||
319 | } | ||
320 | |||
321 | #if CONFIG_CODEC == SWCODEC | ||
322 | /* parse RVA2 binary data and convert to replaygain information. */ | ||
323 | static int parserva2( struct mp3entry* entry, char* tag, int bufferpos ) | ||
324 | { | ||
325 | int desc_len = strlen(tag); | ||
326 | int start_pos = tag - entry->id3v2buf; | ||
327 | int end_pos = start_pos + desc_len + 5; | ||
328 | int value_len = 0; | ||
329 | unsigned char* value = tag + desc_len + 1; | ||
330 | |||
331 | /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel | ||
332 | * type is master volume. | ||
333 | */ | ||
334 | if (entry->id3version == ID3_VER_2_4 && end_pos < bufferpos | ||
335 | && *value++ == 1) { | ||
336 | long gain = 0; | ||
337 | long peak = 0; | ||
338 | long peakbits; | ||
339 | long peakbytes; | ||
340 | bool album = false; | ||
341 | |||
342 | /* The RVA2 specification is unclear on some things (id string and | ||
343 | * peak volume), but this matches how Quod Libet use them. | ||
344 | */ | ||
345 | |||
346 | gain = (int16_t) ((value[0] << 8) | value[1]); | ||
347 | value += 2; | ||
348 | peakbits = *value++; | ||
349 | peakbytes = (peakbits + 7) / 8; | ||
350 | |||
351 | /* Only use the topmost 24 bits for peak volume */ | ||
352 | if (peakbytes > 3) { | ||
353 | peakbytes = 3; | ||
354 | } | ||
355 | |||
356 | /* Make sure the peak bits were read */ | ||
357 | if (end_pos + peakbytes < bufferpos) { | ||
358 | long shift = ((8 - (peakbits & 7)) & 7) + (3 - peakbytes) * 8; | ||
359 | |||
360 | for ( ; peakbytes; peakbytes--) { | ||
361 | peak <<= 8; | ||
362 | peak += *value++; | ||
363 | } | ||
364 | |||
365 | peak <<= shift; | ||
366 | |||
367 | if (peakbits > 24) { | ||
368 | peak += *value >> (8 - shift); | ||
369 | } | ||
370 | } | ||
371 | |||
372 | if (strcasecmp(tag, "album") == 0) { | ||
373 | album = true; | ||
374 | } else if (strcasecmp(tag, "track") != 0) { | ||
375 | /* Only accept non-track values if we don't have any previous | ||
376 | * value. | ||
377 | */ | ||
378 | if (entry->track_gain != 0) { | ||
379 | return start_pos; | ||
380 | } | ||
381 | } | ||
382 | |||
383 | value_len = parse_replaygain_int(album, gain, peak * 2, entry, | ||
384 | tag, sizeof(entry->id3v2buf) - start_pos); | ||
385 | } | ||
386 | |||
387 | return start_pos + value_len; | ||
388 | } | ||
389 | #endif | ||
390 | |||
391 | static int parsembtid( struct mp3entry* entry, char* tag, int bufferpos ) | ||
392 | { | ||
393 | char* value = NULL; | ||
394 | int desc_len = strlen(tag); | ||
395 | /*DEBUGF("MBID len: %d\n", desc_len);*/ | ||
396 | /* Musicbrainz track IDs are always 36 chars long */ | ||
397 | const size_t mbtid_len = 36; | ||
398 | |||
399 | if ((tag - entry->id3v2buf + desc_len + 2) < bufferpos) | ||
400 | { | ||
401 | value = tag + desc_len + 1; | ||
402 | |||
403 | if (strcasecmp(tag, "http://musicbrainz.org") == 0) | ||
404 | { | ||
405 | if (mbtid_len == strlen(value)) | ||
406 | { | ||
407 | entry->mb_track_id = value; | ||
408 | return bufferpos + mbtid_len + 1; | ||
409 | } | ||
410 | } | ||
411 | } | ||
412 | |||
413 | return bufferpos; | ||
414 | } | ||
415 | |||
416 | static const struct tag_resolver taglist[] = { | ||
417 | { "TPE1", 4, offsetof(struct mp3entry, artist), NULL, false }, | ||
418 | { "TP1", 3, offsetof(struct mp3entry, artist), NULL, false }, | ||
419 | { "TIT2", 4, offsetof(struct mp3entry, title), NULL, false }, | ||
420 | { "TT2", 3, offsetof(struct mp3entry, title), NULL, false }, | ||
421 | { "TALB", 4, offsetof(struct mp3entry, album), NULL, false }, | ||
422 | { "TAL", 3, offsetof(struct mp3entry, album), NULL, false }, | ||
423 | { "TRK", 3, offsetof(struct mp3entry, track_string), &parsetracknum, false }, | ||
424 | { "TPOS", 4, offsetof(struct mp3entry, disc_string), &parsediscnum, false }, | ||
425 | { "TRCK", 4, offsetof(struct mp3entry, track_string), &parsetracknum, false }, | ||
426 | { "TDRC", 4, offsetof(struct mp3entry, year_string), &parseyearnum, false }, | ||
427 | { "TYER", 4, offsetof(struct mp3entry, year_string), &parseyearnum, false }, | ||
428 | { "TYE", 3, offsetof(struct mp3entry, year_string), &parseyearnum, false }, | ||
429 | { "TCOM", 4, offsetof(struct mp3entry, composer), NULL, false }, | ||
430 | { "TPE2", 4, offsetof(struct mp3entry, albumartist), NULL, false }, | ||
431 | { "TP2", 3, offsetof(struct mp3entry, albumartist), NULL, false }, | ||
432 | { "TIT1", 4, offsetof(struct mp3entry, grouping), NULL, false }, | ||
433 | { "TT1", 3, offsetof(struct mp3entry, grouping), NULL, false }, | ||
434 | { "COMM", 4, offsetof(struct mp3entry, comment), NULL, false }, | ||
435 | { "COM", 3, offsetof(struct mp3entry, comment), NULL, false }, | ||
436 | { "TCON", 4, offsetof(struct mp3entry, genre_string), &parsegenre, false }, | ||
437 | { "TCO", 3, offsetof(struct mp3entry, genre_string), &parsegenre, false }, | ||
438 | { "TXXX", 4, 0, &parseuser, false }, | ||
439 | #if CONFIG_CODEC == SWCODEC | ||
440 | { "RVA2", 4, 0, &parserva2, true }, | ||
441 | #endif | ||
442 | { "UFID", 4, 0, &parsembtid, false }, | ||
443 | }; | ||
444 | |||
445 | #define TAGLIST_SIZE ((int)ARRAYLEN(taglist)) | ||
446 | |||
447 | /* Get the length of an ID3 string in the given encoding. Returns the length | ||
448 | * in bytes, including end nil, or -1 if the encoding is unknown. | ||
449 | */ | ||
450 | static int unicode_len(char encoding, const void* string) | ||
451 | { | ||
452 | int len = 0; | ||
453 | |||
454 | if (encoding == 0x01 || encoding == 0x02) { | ||
455 | char first; | ||
456 | const char *s = string; | ||
457 | /* string might be unaligned, so using short* can crash on ARM and SH1 */ | ||
458 | do { | ||
459 | first = *s++; | ||
460 | } while ((first | *s++) != 0); | ||
461 | |||
462 | len = s - (const char*) string; | ||
463 | } else { | ||
464 | len = strlen((char*) string) + 1; | ||
465 | } | ||
466 | |||
467 | return len; | ||
468 | } | ||
469 | |||
470 | /* Checks to see if the passed in string is a 16-bit wide Unicode v2 | ||
471 | string. If it is, we convert it to a UTF-8 string. If it's not unicode, | ||
472 | we convert from the default codepage */ | ||
473 | static int unicode_munge(char* string, char* utf8buf, int *len) { | ||
474 | long tmp; | ||
475 | bool le = false; | ||
476 | int i = 0; | ||
477 | unsigned char *str = (unsigned char *)string; | ||
478 | int templen = 0; | ||
479 | unsigned char* utf8 = (unsigned char *)utf8buf; | ||
480 | |||
481 | switch (str[0]) { | ||
482 | case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */ | ||
483 | str++; | ||
484 | (*len)--; | ||
485 | utf8 = iso_decode(str, utf8, -1, *len); | ||
486 | *utf8 = 0; | ||
487 | *len = (unsigned long)utf8 - (unsigned long)utf8buf; | ||
488 | break; | ||
489 | |||
490 | case 0x01: /* Unicode with or without BOM */ | ||
491 | case 0x02: | ||
492 | (*len)--; | ||
493 | str++; | ||
494 | |||
495 | /* Handle frames with more than one string | ||
496 | (needed for TXXX frames).*/ | ||
497 | do { | ||
498 | tmp = bytes2int(0, 0, str[0], str[1]); | ||
499 | |||
500 | /* Now check if there is a BOM | ||
501 | (zero-width non-breaking space, 0xfeff) | ||
502 | and if it is in little or big endian format */ | ||
503 | if(tmp == 0xfffe) { /* Little endian? */ | ||
504 | le = true; | ||
505 | str += 2; | ||
506 | (*len)-=2; | ||
507 | } else if(tmp == 0xfeff) { /* Big endian? */ | ||
508 | str += 2; | ||
509 | (*len)-=2; | ||
510 | } else | ||
511 | /* If there is no BOM (which is a specification violation), | ||
512 | let's try to guess it. If one of the bytes is 0x00, it is | ||
513 | probably the most significant one. */ | ||
514 | if(str[1] == 0) | ||
515 | le = true; | ||
516 | |||
517 | do { | ||
518 | if(le) | ||
519 | utf8 = utf16LEdecode(str, utf8, 1); | ||
520 | else | ||
521 | utf8 = utf16BEdecode(str, utf8, 1); | ||
522 | |||
523 | str+=2; | ||
524 | i += 2; | ||
525 | } while((str[0] || str[1]) && (i < *len)); | ||
526 | |||
527 | *utf8++ = 0; /* Terminate the string */ | ||
528 | templen += (strlen(&utf8buf[templen]) + 1); | ||
529 | str += 2; | ||
530 | i+=2; | ||
531 | } while(i < *len); | ||
532 | *len = templen - 1; | ||
533 | break; | ||
534 | |||
535 | case 0x03: /* UTF-8 encoded string */ | ||
536 | for(i=0; i < *len; i++) | ||
537 | utf8[i] = str[i+1]; | ||
538 | (*len)--; | ||
539 | break; | ||
540 | |||
541 | default: /* Plain old string */ | ||
542 | utf8 = iso_decode(str, utf8, -1, *len); | ||
543 | *utf8 = 0; | ||
544 | *len = (unsigned long)utf8 - (unsigned long)utf8buf; | ||
545 | break; | ||
546 | } | ||
547 | return 0; | ||
548 | } | ||
549 | |||
550 | /* | ||
551 | * Sets the title of an MP3 entry based on its ID3v1 tag. | ||
552 | * | ||
553 | * Arguments: file - the MP3 file to scen for a ID3v1 tag | ||
554 | * entry - the entry to set the title in | ||
555 | * | ||
556 | * Returns: true if a title was found and created, else false | ||
557 | */ | ||
558 | bool setid3v1title(int fd, struct mp3entry *entry) | ||
559 | { | ||
560 | unsigned char buffer[128]; | ||
561 | static const char offsets[] = {3, 33, 63, 97, 93, 125, 127}; | ||
562 | int i, j; | ||
563 | unsigned char* utf8; | ||
564 | |||
565 | if (-1 == lseek(fd, -128, SEEK_END)) | ||
566 | return false; | ||
567 | |||
568 | if (read(fd, buffer, sizeof buffer) != sizeof buffer) | ||
569 | return false; | ||
570 | |||
571 | if (strncmp((char *)buffer, "TAG", 3)) | ||
572 | return false; | ||
573 | |||
574 | entry->id3v1len = 128; | ||
575 | entry->id3version = ID3_VER_1_0; | ||
576 | |||
577 | for (i=0; i < (int)sizeof offsets; i++) { | ||
578 | unsigned char* ptr = (unsigned char *)buffer + offsets[i]; | ||
579 | |||
580 | switch(i) { | ||
581 | case 0: | ||
582 | case 1: | ||
583 | case 2: | ||
584 | /* kill trailing space in strings */ | ||
585 | for (j=29; j && (ptr[j]==0 || ptr[j]==' '); j--) | ||
586 | ptr[j] = 0; | ||
587 | /* convert string to utf8 */ | ||
588 | utf8 = (unsigned char *)entry->id3v1buf[i]; | ||
589 | utf8 = iso_decode(ptr, utf8, -1, 30); | ||
590 | /* make sure string is terminated */ | ||
591 | *utf8 = 0; | ||
592 | break; | ||
593 | |||
594 | case 3: | ||
595 | /* kill trailing space in strings */ | ||
596 | for (j=27; j && (ptr[j]==0 || ptr[j]==' '); j--) | ||
597 | ptr[j] = 0; | ||
598 | /* convert string to utf8 */ | ||
599 | utf8 = (unsigned char *)entry->id3v1buf[3]; | ||
600 | utf8 = iso_decode(ptr, utf8, -1, 28); | ||
601 | /* make sure string is terminated */ | ||
602 | *utf8 = 0; | ||
603 | break; | ||
604 | |||
605 | case 4: | ||
606 | ptr[4] = 0; | ||
607 | entry->year = atoi((char *)ptr); | ||
608 | break; | ||
609 | |||
610 | case 5: | ||
611 | /* id3v1.1 uses last two bytes of comment field for track | ||
612 | number: first must be 0 and second is track num */ | ||
613 | if (!ptr[0] && ptr[1]) { | ||
614 | entry->tracknum = ptr[1]; | ||
615 | entry->id3version = ID3_VER_1_1; | ||
616 | } | ||
617 | break; | ||
618 | |||
619 | case 6: | ||
620 | /* genre */ | ||
621 | entry->genre_string = id3_get_num_genre(ptr[0]); | ||
622 | break; | ||
623 | } | ||
624 | } | ||
625 | |||
626 | entry->title = entry->id3v1buf[0]; | ||
627 | entry->artist = entry->id3v1buf[1]; | ||
628 | entry->album = entry->id3v1buf[2]; | ||
629 | entry->comment = entry->id3v1buf[3]; | ||
630 | |||
631 | return true; | ||
632 | } | ||
633 | |||
634 | |||
635 | /* | ||
636 | * Sets the title of an MP3 entry based on its ID3v2 tag. | ||
637 | * | ||
638 | * Arguments: file - the MP3 file to scan for a ID3v2 tag | ||
639 | * entry - the entry to set the title in | ||
640 | * | ||
641 | * Returns: true if a title was found and created, else false | ||
642 | */ | ||
643 | void setid3v2title(int fd, struct mp3entry *entry) | ||
644 | { | ||
645 | int minframesize; | ||
646 | int size; | ||
647 | long bufferpos = 0, totframelen, framelen; | ||
648 | char header[10]; | ||
649 | char tmp[4]; | ||
650 | unsigned char version; | ||
651 | char *buffer = entry->id3v2buf; | ||
652 | int bytesread = 0; | ||
653 | int buffersize = sizeof(entry->id3v2buf); | ||
654 | unsigned char global_flags; | ||
655 | int flags; | ||
656 | int skip; | ||
657 | bool global_unsynch = false; | ||
658 | bool unsynch = false; | ||
659 | int i, j; | ||
660 | int rc; | ||
661 | #if CONFIG_CODEC == SWCODEC | ||
662 | bool itunes_gapless = false; | ||
663 | #endif | ||
664 | |||
665 | global_ff_found = false; | ||
666 | |||
667 | /* Bail out if the tag is shorter than 10 bytes */ | ||
668 | if(entry->id3v2len < 10) | ||
669 | return; | ||
670 | |||
671 | /* Read the ID3 tag version from the header */ | ||
672 | lseek(fd, 0, SEEK_SET); | ||
673 | if(10 != read(fd, header, 10)) | ||
674 | return; | ||
675 | |||
676 | /* Get the total ID3 tag size */ | ||
677 | size = entry->id3v2len - 10; | ||
678 | |||
679 | version = header[3]; | ||
680 | switch ( version ) { | ||
681 | case 2: | ||
682 | version = ID3_VER_2_2; | ||
683 | minframesize = 8; | ||
684 | break; | ||
685 | |||
686 | case 3: | ||
687 | version = ID3_VER_2_3; | ||
688 | minframesize = 12; | ||
689 | break; | ||
690 | |||
691 | case 4: | ||
692 | version = ID3_VER_2_4; | ||
693 | minframesize = 12; | ||
694 | break; | ||
695 | |||
696 | default: | ||
697 | /* unsupported id3 version */ | ||
698 | return; | ||
699 | } | ||
700 | entry->id3version = version; | ||
701 | entry->tracknum = entry->year = entry->discnum = 0; | ||
702 | entry->title = entry->artist = entry->album = NULL; /* FIXME incomplete */ | ||
703 | |||
704 | global_flags = header[5]; | ||
705 | |||
706 | /* Skip the extended header if it is present */ | ||
707 | if(global_flags & 0x40) { | ||
708 | if(version == ID3_VER_2_3) { | ||
709 | if(10 != read(fd, header, 10)) | ||
710 | return; | ||
711 | /* The 2.3 extended header size doesn't include the header size | ||
712 | field itself. Also, it is not unsynched. */ | ||
713 | framelen = | ||
714 | bytes2int(header[0], header[1], header[2], header[3]) + 4; | ||
715 | |||
716 | /* Skip the rest of the header */ | ||
717 | lseek(fd, framelen - 10, SEEK_CUR); | ||
718 | } | ||
719 | |||
720 | if(version >= ID3_VER_2_4) { | ||
721 | if(4 != read(fd, header, 4)) | ||
722 | return; | ||
723 | |||
724 | /* The 2.4 extended header size does include the entire header, | ||
725 | so here we can just skip it. This header is unsynched. */ | ||
726 | framelen = unsync(header[0], header[1], | ||
727 | header[2], header[3]); | ||
728 | |||
729 | lseek(fd, framelen - 4, SEEK_CUR); | ||
730 | } | ||
731 | } | ||
732 | |||
733 | /* Is unsynchronization applied? */ | ||
734 | if(global_flags & 0x80) { | ||
735 | global_unsynch = true; | ||
736 | } | ||
737 | |||
738 | /* | ||
739 | * We must have at least minframesize bytes left for the | ||
740 | * remaining frames to be interesting | ||
741 | */ | ||
742 | while (size >= minframesize && bufferpos < buffersize - 1) { | ||
743 | flags = 0; | ||
744 | |||
745 | /* Read frame header and check length */ | ||
746 | if(version >= ID3_VER_2_3) { | ||
747 | if(global_unsynch && version <= ID3_VER_2_3) | ||
748 | rc = read_unsynched(fd, header, 10); | ||
749 | else | ||
750 | rc = read(fd, header, 10); | ||
751 | if(rc != 10) | ||
752 | return; | ||
753 | /* Adjust for the 10 bytes we read */ | ||
754 | size -= 10; | ||
755 | |||
756 | flags = bytes2int(0, 0, header[8], header[9]); | ||
757 | |||
758 | if (version >= ID3_VER_2_4) { | ||
759 | framelen = unsync(header[4], header[5], | ||
760 | header[6], header[7]); | ||
761 | } else { | ||
762 | /* version .3 files don't use synchsafe ints for | ||
763 | * size */ | ||
764 | framelen = bytes2int(header[4], header[5], | ||
765 | header[6], header[7]); | ||
766 | } | ||
767 | } else { | ||
768 | if(6 != read(fd, header, 6)) | ||
769 | return; | ||
770 | /* Adjust for the 6 bytes we read */ | ||
771 | size -= 6; | ||
772 | |||
773 | framelen = bytes2int(0, header[3], header[4], header[5]); | ||
774 | } | ||
775 | |||
776 | logf("framelen = %ld, flags = 0x%04x", framelen, flags); | ||
777 | if(framelen == 0){ | ||
778 | if (header[0] == 0 && header[1] == 0 && header[2] == 0) | ||
779 | return; | ||
780 | else | ||
781 | continue; | ||
782 | } | ||
783 | |||
784 | unsynch = false; | ||
785 | |||
786 | if(flags) | ||
787 | { | ||
788 | skip = 0; | ||
789 | |||
790 | if (version >= ID3_VER_2_4) { | ||
791 | if(flags & 0x0040) { /* Grouping identity */ | ||
792 | lseek(fd, 1, SEEK_CUR); /* Skip 1 byte */ | ||
793 | framelen--; | ||
794 | } | ||
795 | } else { | ||
796 | if(flags & 0x0020) { /* Grouping identity */ | ||
797 | lseek(fd, 1, SEEK_CUR); /* Skip 1 byte */ | ||
798 | framelen--; | ||
799 | } | ||
800 | } | ||
801 | |||
802 | if(flags & 0x000c) /* Compression or encryption */ | ||
803 | { | ||
804 | /* Skip it */ | ||
805 | size -= framelen; | ||
806 | lseek(fd, framelen, SEEK_CUR); | ||
807 | continue; | ||
808 | } | ||
809 | |||
810 | if(flags & 0x0002) /* Unsynchronization */ | ||
811 | unsynch = true; | ||
812 | |||
813 | if (version >= ID3_VER_2_4) { | ||
814 | if(flags & 0x0001) { /* Data length indicator */ | ||
815 | if(4 != read(fd, tmp, 4)) | ||
816 | return; | ||
817 | |||
818 | /* We don't need the data length */ | ||
819 | framelen -= 4; | ||
820 | } | ||
821 | } | ||
822 | } | ||
823 | |||
824 | if (framelen == 0) | ||
825 | continue; | ||
826 | |||
827 | if (framelen < 0) | ||
828 | return; | ||
829 | |||
830 | /* Keep track of the remaining frame size */ | ||
831 | totframelen = framelen; | ||
832 | |||
833 | /* If the frame is larger than the remaining buffer space we try | ||
834 | to read as much as would fit in the buffer */ | ||
835 | if(framelen >= buffersize - bufferpos) | ||
836 | framelen = buffersize - bufferpos - 1; | ||
837 | |||
838 | logf("id3v2 frame: %.4s", header); | ||
839 | |||
840 | /* Check for certain frame headers | ||
841 | |||
842 | 'size' is the amount of frame bytes remaining. We decrement it by | ||
843 | the amount of bytes we read. If we fail to read as many bytes as | ||
844 | we expect, we assume that we can't read from this file, and bail | ||
845 | out. | ||
846 | |||
847 | For each frame. we will iterate over the list of supported tags, | ||
848 | and read the tag into entry's buffer. All tags will be kept as | ||
849 | strings, for cases where a number won't do, e.g., YEAR: "circa | ||
850 | 1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK: | ||
851 | "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more | ||
852 | flexible, and as the main use of id3 data is to display it, | ||
853 | converting it to an int just means reconverting to display it, at a | ||
854 | runtime cost. | ||
855 | |||
856 | For tags that the current code does convert to ints, a post | ||
857 | processing function will be called via a pointer to function. */ | ||
858 | |||
859 | for (i=0; i<TAGLIST_SIZE; i++) { | ||
860 | const struct tag_resolver* tr = &taglist[i]; | ||
861 | char** ptag = tr->offset ? (char**) (((char*)entry) + tr->offset) | ||
862 | : NULL; | ||
863 | char* tag; | ||
864 | |||
865 | /* Only ID3_VER_2_2 uses frames with three-character names. */ | ||
866 | if (((version == ID3_VER_2_2) && (tr->tag_length != 3)) | ||
867 | || ((version > ID3_VER_2_2) && (tr->tag_length != 4))) { | ||
868 | continue; | ||
869 | } | ||
870 | |||
871 | if( !memcmp( header, tr->tag, tr->tag_length ) ) { | ||
872 | |||
873 | /* found a tag matching one in tagList, and not yet filled */ | ||
874 | tag = buffer + bufferpos; | ||
875 | |||
876 | if(global_unsynch && version <= ID3_VER_2_3) | ||
877 | bytesread = read_unsynched(fd, tag, framelen); | ||
878 | else | ||
879 | bytesread = read(fd, tag, framelen); | ||
880 | |||
881 | if( bytesread != framelen ) | ||
882 | return; | ||
883 | |||
884 | size -= bytesread; | ||
885 | |||
886 | if(unsynch || (global_unsynch && version >= ID3_VER_2_4)) | ||
887 | bytesread = unsynchronize_frame(tag, bytesread); | ||
888 | |||
889 | /* the COMM frame has a 3 char field to hold an ISO-639-1 | ||
890 | * language string and an optional short description; | ||
891 | * remove them so unicode_munge can work correctly | ||
892 | */ | ||
893 | |||
894 | if((tr->tag_length == 4 && !memcmp( header, "COMM", 4)) || | ||
895 | (tr->tag_length == 3 && !memcmp( header, "COM", 3))) { | ||
896 | int offset; | ||
897 | if(!strncmp(tag+4, "iTun", 4)) { | ||
898 | #if CONFIG_CODEC == SWCODEC | ||
899 | /* check for iTunes gapless information */ | ||
900 | if(!strncmp(tag+4, "iTunSMPB", 8)) | ||
901 | itunes_gapless = true; | ||
902 | else | ||
903 | #endif | ||
904 | /* ignore other with iTunes tags */ | ||
905 | break; | ||
906 | } | ||
907 | |||
908 | offset = 3 + unicode_len(*tag, tag + 4); | ||
909 | if(bytesread > offset) { | ||
910 | bytesread -= offset; | ||
911 | memmove(tag + 1, tag + 1 + offset, bytesread - 1); | ||
912 | } | ||
913 | } | ||
914 | |||
915 | /* Attempt to parse Unicode string only if the tag contents | ||
916 | aren't binary */ | ||
917 | if(!tr->binary) { | ||
918 | /* UTF-8 could potentially be 3 times larger */ | ||
919 | /* so we need to create a new buffer */ | ||
920 | char utf8buf[(3 * bytesread) + 1]; | ||
921 | |||
922 | unicode_munge( tag, utf8buf, &bytesread ); | ||
923 | |||
924 | if(bytesread >= buffersize - bufferpos) | ||
925 | bytesread = buffersize - bufferpos - 1; | ||
926 | |||
927 | for (j = 0; j < bytesread; j++) | ||
928 | tag[j] = utf8buf[j]; | ||
929 | |||
930 | /* remove trailing spaces */ | ||
931 | while ( bytesread > 0 && isspace(tag[bytesread-1])) | ||
932 | bytesread--; | ||
933 | } | ||
934 | |||
935 | tag[bytesread] = 0; | ||
936 | bufferpos += bytesread + 1; | ||
937 | |||
938 | #if CONFIG_CODEC == SWCODEC | ||
939 | /* parse the tag if it contains iTunes gapless info */ | ||
940 | if (itunes_gapless) | ||
941 | { | ||
942 | itunes_gapless = false; | ||
943 | entry->lead_trim = get_itunes_int32(tag, 1); | ||
944 | entry->tail_trim = get_itunes_int32(tag, 2); | ||
945 | } | ||
946 | #endif | ||
947 | |||
948 | /* Note that parser functions sometimes set *ptag to NULL, so | ||
949 | * the "!*ptag" check here doesn't always have the desired | ||
950 | * effect. Should the parser functions (parsegenre in | ||
951 | * particular) be updated to handle the case of being called | ||
952 | * multiple times, or should the "*ptag" check be removed? | ||
953 | */ | ||
954 | if (ptag && !*ptag) | ||
955 | *ptag = tag; | ||
956 | |||
957 | if( tr->ppFunc ) | ||
958 | bufferpos = tr->ppFunc(entry, tag, bufferpos); | ||
959 | |||
960 | /* Seek to the next frame */ | ||
961 | if(framelen < totframelen) | ||
962 | lseek(fd, totframelen - framelen, SEEK_CUR); | ||
963 | break; | ||
964 | } | ||
965 | } | ||
966 | |||
967 | if( i == TAGLIST_SIZE ) { | ||
968 | /* no tag in tagList was found, or it was a repeat. | ||
969 | skip it using the total size */ | ||
970 | |||
971 | if(global_unsynch && version <= ID3_VER_2_3) { | ||
972 | size -= skip_unsynched(fd, totframelen); | ||
973 | } else { | ||
974 | size -= totframelen; | ||
975 | if( lseek(fd, totframelen, SEEK_CUR) == -1 ) | ||
976 | return; | ||
977 | } | ||
978 | } | ||
979 | } | ||
980 | } | ||
981 | |||
982 | /* | ||
983 | * Calculates the size of the ID3v2 tag. | ||
984 | * | ||
985 | * Arguments: file - the file to search for a tag. | ||
986 | * | ||
987 | * Returns: the size of the tag or 0 if none was found | ||
988 | */ | ||
989 | int getid3v2len(int fd) | ||
990 | { | ||
991 | char buf[6]; | ||
992 | int offset; | ||
993 | |||
994 | /* Make sure file has a ID3 tag */ | ||
995 | if((-1 == lseek(fd, 0, SEEK_SET)) || | ||
996 | (read(fd, buf, 6) != 6) || | ||
997 | (strncmp(buf, "ID3", strlen("ID3")) != 0)) | ||
998 | offset = 0; | ||
999 | |||
1000 | /* Now check what the ID3v2 size field says */ | ||
1001 | else | ||
1002 | if(read(fd, buf, 4) != 4) | ||
1003 | offset = 0; | ||
1004 | else | ||
1005 | offset = unsync(buf[0], buf[1], buf[2], buf[3]) + 10; | ||
1006 | |||
1007 | logf("ID3V2 Length: 0x%x", offset); | ||
1008 | return offset; | ||
1009 | } | ||
1010 | 44 | ||
1011 | /* | 45 | /* |
1012 | * Calculates the length (in milliseconds) of an MP3 file. | 46 | * Calculates the length (in milliseconds) of an MP3 file. |
@@ -1165,58 +199,3 @@ bool get_mp3_metadata(int fd, struct mp3entry *entry, const char *filename) | |||
1165 | 199 | ||
1166 | return true; | 200 | return true; |
1167 | } | 201 | } |
1168 | |||
1169 | #ifdef DEBUG_STANDALONE | ||
1170 | |||
1171 | char *secs2str(int ms) | ||
1172 | { | ||
1173 | static char buffer[32]; | ||
1174 | int secs = ms/1000; | ||
1175 | ms %= 1000; | ||
1176 | snprintf(buffer, sizeof(buffer), "%d:%02d.%d", secs/60, secs%60, ms/100); | ||
1177 | return buffer; | ||
1178 | } | ||
1179 | |||
1180 | int main(int argc, char **argv) | ||
1181 | { | ||
1182 | int i; | ||
1183 | for(i=1; i<argc; i++) { | ||
1184 | struct mp3entry mp3; | ||
1185 | mp3.album = "Bogus"; | ||
1186 | if(mp3info(&mp3, argv[i], false)) { | ||
1187 | printf("Failed to get %s\n", argv[i]); | ||
1188 | return 0; | ||
1189 | } | ||
1190 | |||
1191 | printf("****** File: %s\n" | ||
1192 | " Title: %s\n" | ||
1193 | " Artist: %s\n" | ||
1194 | " Album: %s\n" | ||
1195 | " Genre: %s (%d) \n" | ||
1196 | " Composer: %s\n" | ||
1197 | " Year: %s (%d)\n" | ||
1198 | " Track: %s (%d)\n" | ||
1199 | " Length: %s / %d s\n" | ||
1200 | " Bitrate: %d\n" | ||
1201 | " Frequency: %d\n", | ||
1202 | argv[i], | ||
1203 | mp3.title?mp3.title:"<blank>", | ||
1204 | mp3.artist?mp3.artist:"<blank>", | ||
1205 | mp3.album?mp3.album:"<blank>", | ||
1206 | mp3.genre_string?mp3.genre_string:"<blank>", | ||
1207 | mp3.genre, | ||
1208 | mp3.composer?mp3.composer:"<blank>", | ||
1209 | mp3.year_string?mp3.year_string:"<blank>", | ||
1210 | mp3.year, | ||
1211 | mp3.track_string?mp3.track_string:"<blank>", | ||
1212 | mp3.tracknum, | ||
1213 | secs2str(mp3.length), | ||
1214 | mp3.length/1000, | ||
1215 | mp3.bitrate, | ||
1216 | mp3.frequency); | ||
1217 | } | ||
1218 | |||
1219 | return 0; | ||
1220 | } | ||
1221 | |||
1222 | #endif | ||
diff --git a/tools/database/SOURCES b/tools/database/SOURCES index cef0e96eec..e66ea603e1 100644 --- a/tools/database/SOURCES +++ b/tools/database/SOURCES | |||
@@ -15,6 +15,7 @@ database.c | |||
15 | ../../firmware/logf.c | 15 | ../../firmware/logf.c |
16 | ../../uisimulator/common/io.c | 16 | ../../uisimulator/common/io.c |
17 | #if CONFIG_CODEC != SWCODEC | 17 | #if CONFIG_CODEC != SWCODEC |
18 | ../../apps/metadata/id3tags.c | ||
18 | ../../apps/metadata/mp3.c | 19 | ../../apps/metadata/mp3.c |
19 | #endif | 20 | #endif |
20 | /* Caution. metadata files do not add!! */ | 21 | /* Caution. metadata files do not add!! */ |