apps/metadata/id3tags.c

   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 "string-extra.h"
  39 #include "config.h"
  40 #include "file.h"
  41 #include "logf.h"
  42 #include "system.h"
  43 #include "replaygain.h"
  44 #include "rbunicode.h"
  45
  46 #include "metadata.h"
  47 #include "mp3data.h"
  48 #if CONFIG_CODEC == SWCODEC
  49 #include "metadata_common.h"
  50 #endif
  51 #include "metadata_parsers.h"
  52
  53 static unsigned long unsync(unsigned long b0,
  54                             unsigned long b1,
  55                             unsigned long b2,
  56                             unsigned long b3)
  57 {
  58    return (((long)(b0 & 0x7F) << (3*7)) |
  59            ((long)(b1 & 0x7F) << (2*7)) |
  60            ((long)(b2 & 0x7F) << (1*7)) |
  61            ((long)(b3 & 0x7F) << (0*7)));
  62 }
  63
  64 static const char* const genres[] = {
  65     "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
  66     "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
  67     "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
  68     "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
  69     "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
  70     "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
  71     "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
  72     "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
  73     "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
  74     "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
  75     "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
  76     "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
  77     "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
  78
  79     /* winamp extensions */
  80     "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
  81     "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
  82     "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
  83     "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
  84     "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
  85     "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
  86     "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
  87     "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
  88     "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
  89     "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
  90     "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
  91     "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
  92     "Synthpop"
  93 };
  94
  95 char* id3_get_num_genre(unsigned int genre_num)
  96 {
  97     if (genre_num < ARRAYLEN(genres))
  98         return (char*)genres[genre_num];
  99     return NULL;
 100 }
 101
 102 /*
 103     HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
 104     Code and comments by Thomas Paul Diffenbach
 105
 106     To add another ID3v2 Tag, do the following:
 107     1.  add a char* named for the tag to struct mp3entry in id3.h,
 108         (I (tpd) prefer to use char* rather than ints, even for what seems like
 109         numerical values, for cases where a number won't do, e.g.,
 110         YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
 111         TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
 112         Text is more flexible, and as the main use of id3 data is to
 113         display it, converting it to an int just means reconverting to
 114         display it, at a runtime cost.)
 115
 116     2. If any special processing beyond copying the tag value from the Id3
 117        block to the struct mp3entry is rrequired (such as converting to an
 118        int), write a function to perform this special processing.
 119
 120        This function's prototype must match that of
 121        typedef tagPostProcessFunc, that is it must be:
 122          int func( struct mp3entry*, char* tag, int bufferpos )
 123        the first argument is a pointer to the current mp3entry structure the
 124        second argument is a pointer to the null terminated string value of the
 125        tag found the third argument is the offset of the next free byte in the
 126        mp3entry's buffer your function should return the corrected offset; if
 127        you don't lengthen or shorten the tag string, you can return the third
 128        argument unchanged.
 129
 130        Unless you have a good reason no to, make the function static.
 131        TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
 132
 133     3. add one or more entries to the tagList array, using the format:
 134             char* ID3 Tag symbolic name -- see the ID3 specification for these,
 135             sizeof() that name minus 1,
 136             offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
 137             pointer to your special processing function or NULL
 138                 if you need no special processing
 139             flag indicating if this tag is binary or textual
 140         Many ID3 symbolic names come in more than one form. You can add both
 141         forms, each referencing the same variable in struct mp3entry.
 142         If both forms are present, the last found will be used.
 143         Note that the offset can be zero, in which case no entry will be set
 144         in the mp3entry struct; the frame is still read into the buffer and
 145         the special processing function is called (several times, if there
 146         are several frames with the same name).
 147
 148     4. Alternately, use the TAG_LIST_ENTRY macro with
 149          ID3 tag symbolic name,
 150          variable in struct mp3entry,
 151          special processing function address
 152
 153     5.  Add code to wps-display.c function get_tag to assign a printf-like
 154         format specifier for the tag */
 155
 156 /* Structure for ID3 Tag extraction information */
 157 struct tag_resolver {
 158     const char* tag;
 159     int tag_length;
 160     size_t offset;
 161     int (*ppFunc)(struct mp3entry*, char* tag, int bufferpos);
 162     bool binary;
 163 };
 164
 165 static bool global_ff_found;
 166
 167 static int unsynchronize(char* tag, int len, bool *ff_found)
 168 {
 169     int i;
 170     unsigned char c;
 171     unsigned char *rp, *wp;
 172
 173     wp = rp = (unsigned char *)tag;
 174
 175     rp = (unsigned char *)tag;
 176     for(i = 0;i < len;i++) {
 177         /* Read the next byte and write it back, but don't increment the
 178            write pointer */
 179         c = *rp++;
 180         *wp = c;
 181         if(*ff_found) {
 182             /* Increment the write pointer if it isn't an unsynch pattern */
 183             if(c != 0)
 184                 wp++;
 185             *ff_found = false;
 186         } else {
 187             if(c == 0xff)
 188                 *ff_found = true;
 189             wp++;
 190         }
 191     }
 192     return (long)wp - (long)tag;
 193 }
 194
 195 static int unsynchronize_frame(char* tag, int len)
 196 {
 197     bool ff_found = false;
 198
 199     return unsynchronize(tag, len, &ff_found);
 200 }
 201
 202 static int read_unsynched(int fd, void *buf, int len)
 203 {
 204     int i;
 205     int rc;
 206     int remaining = len;
 207     char *wp;
 208     char *rp;
 209
 210     wp = buf;
 211
 212     while(remaining) {
 213         rp = wp;
 214         rc = read(fd, rp, remaining);
 215         if(rc <= 0)
 216             return rc;
 217
 218         i = unsynchronize(wp, remaining, &global_ff_found);
 219         remaining -= i;
 220         wp += i;
 221     }
 222
 223     return len;
 224 }
 225
 226 static int skip_unsynched(int fd, int len)
 227 {
 228     int rc;
 229     int remaining = len;
 230     int rlen;
 231     char buf[32];
 232
 233     while(remaining) {
 234         rlen = MIN(sizeof(buf), (unsigned int)remaining);
 235         rc = read(fd, buf, rlen);
 236         if(rc <= 0)
 237             return rc;
 238
 239         remaining -= unsynchronize(buf, rlen, &global_ff_found);
 240     }
 241
 242     return len;
 243 }
 244
 245 /* parse numeric value from string */
 246 static int parsetracknum( struct mp3entry* entry, char* tag, int bufferpos )
 247 {
 248     entry->tracknum = atoi( tag );
 249     return bufferpos;
 250 }
 251
 252 /* parse numeric value from string */
 253 static int parsediscnum( struct mp3entry* entry, char* tag, int bufferpos )
 254 {
 255     entry->discnum = atoi( tag );
 256     return bufferpos;
 257 }
 258
 259 /* parse numeric value from string */
 260 static int parseyearnum( struct mp3entry* entry, char* tag, int bufferpos )
 261 {
 262     entry->year = atoi( tag );
 263     return bufferpos;
 264 }
 265
 266 /* parse numeric genre from string, version 2.2 and 2.3 */
 267 static int parsegenre( struct mp3entry* entry, char* tag, int bufferpos )
 268 {
 269     if(entry->id3version >= ID3_VER_2_4) {
 270         /* In version 2.4 and up, there are no parentheses, and the genre frame
 271            is a list of strings, either numbers or text. */
 272
 273         /* Is it a number? */
 274         if(isdigit(tag[0])) {
 275             entry->genre_string = id3_get_num_genre(atoi( tag ));
 276             return tag - entry->id3v2buf;
 277         } else {
 278             entry->genre_string = tag;
 279             return bufferpos;
 280         }
 281     } else {
 282         if( tag[0] == '(' && tag[1] != '(' ) {
 283             entry->genre_string = id3_get_num_genre(atoi( tag + 1 ));
 284             return tag - entry->id3v2buf;
 285         }
 286         else {
 287             entry->genre_string = tag;
 288             return bufferpos;
 289         }
 290     }
 291 }
 292
 293 /* parse user defined text, looking for album artist and replaygain
 294  * information.
 295  */
 296 static int parseuser( struct mp3entry* entry, char* tag, int bufferpos )
 297 {
 298     char* value = NULL;
 299     int desc_len = strlen(tag);
 300     int value_len = 0;
 301
 302     if ((tag - entry->id3v2buf + desc_len + 2) < bufferpos) {
 303         /* At least part of the value was read, so we can safely try to
 304          * parse it
 305          */
 306         value = tag + desc_len + 1;
 307         value_len = bufferpos - (tag - entry->id3v2buf);
 308
 309         if (!strcasecmp(tag, "ALBUM ARTIST")) {
 310             strlcpy(tag, value, value_len);
 311             entry->albumartist = tag;
 312 #if CONFIG_CODEC == SWCODEC
 313         } else {
 314             value_len = parse_replaygain(tag, value, entry, tag,
 315                 value_len);
 316 #endif
 317         }
 318     }
 319
 320     return tag - entry->id3v2buf + value_len;
 321 }
 322
 323 #if CONFIG_CODEC == SWCODEC
 324 /* parse RVA2 binary data and convert to replaygain information. */
 325 static int parserva2( struct mp3entry* entry, char* tag, int bufferpos )
 326 {
 327     int desc_len = strlen(tag);
 328     int start_pos = tag - entry->id3v2buf;
 329     int end_pos = start_pos + desc_len + 5;
 330     int value_len = 0;
 331     unsigned char* value = tag + desc_len + 1;
 332
 333     /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
 334      * type is master volume.
 335      */
 336     if (entry->id3version == ID3_VER_2_4 && end_pos < bufferpos
 337             && *value++ == 1) {
 338         long gain = 0;
 339         long peak = 0;
 340         long peakbits;
 341         long peakbytes;
 342         bool album = false;
 343
 344         /* The RVA2 specification is unclear on some things (id string and
 345          * peak volume), but this matches how Quod Libet use them.
 346          */
 347
 348         gain = (int16_t) ((value[0] << 8) | value[1]);
 349         value += 2;
 350         peakbits = *value++;
 351         peakbytes = (peakbits + 7) / 8;
 352
 353         /* Only use the topmost 24 bits for peak volume */
 354         if (peakbytes > 3) {
 355             peakbytes = 3;
 356         }
 357
 358         /* Make sure the peak bits were read */
 359         if (end_pos + peakbytes < bufferpos) {
 360             long shift = ((8 - (peakbits & 7)) & 7) + (3 - peakbytes) * 8;
 361
 362             for ( ; peakbytes; peakbytes--) {
 363                 peak <<= 8;
 364                 peak += *value++;
 365             }
 366
 367             peak <<= shift;
 368
 369             if (peakbits > 24) {
 370                 peak += *value >> (8 - shift);
 371             }
 372         }
 373
 374         if (strcasecmp(tag, "album") == 0) {
 375             album = true;
 376         } else if (strcasecmp(tag, "track") != 0) {
 377             /* Only accept non-track values if we don't have any previous
 378              * value.
 379              */
 380             if (entry->track_gain != 0) {
 381                 return start_pos;
 382             }
 383         }
 384
 385         value_len = parse_replaygain_int(album, gain, peak * 2, entry,
 386             tag, sizeof(entry->id3v2buf) - start_pos);
 387     }
 388
 389     return start_pos + value_len;
 390 }
 391 #endif
 392
 393 static int parsembtid( struct mp3entry* entry, char* tag, int bufferpos )
 394 {
 395     char* value = NULL;
 396     int desc_len = strlen(tag);
 397     /*DEBUGF("MBID len: %d\n", desc_len);*/
 398     /* Musicbrainz track IDs are always 36 chars long */
 399     const size_t mbtid_len = 36;
 400
 401     if ((tag - entry->id3v2buf + desc_len + 2) < bufferpos)
 402     {
 403         value = tag + desc_len + 1;
 404
 405         if (strcasecmp(tag, "http://musicbrainz.org") == 0)
 406         {
 407             if (mbtid_len == strlen(value))
 408             {
 409                 entry->mb_track_id = value;
 410                 return bufferpos + mbtid_len + 1;
 411             }
 412         }
 413     }
 414
 415     return bufferpos;
 416 }
 417
 418 static const struct tag_resolver taglist[] = {
 419     { "TPE1", 4, offsetof(struct mp3entry, artist), NULL, false },
 420     { "TP1",  3, offsetof(struct mp3entry, artist), NULL, false },
 421     { "TIT2", 4, offsetof(struct mp3entry, title), NULL, false },
 422     { "TT2",  3, offsetof(struct mp3entry, title), NULL, false },
 423     { "TALB", 4, offsetof(struct mp3entry, album), NULL, false },
 424     { "TAL",  3, offsetof(struct mp3entry, album), NULL, false },
 425     { "TRK",  3, offsetof(struct mp3entry, track_string), &parsetracknum, false },
 426     { "TPOS", 4, offsetof(struct mp3entry, disc_string), &parsediscnum, false },
 427     { "TPA",  3, offsetof(struct mp3entry, disc_string), &parsediscnum, false },
 428     { "TRCK", 4, offsetof(struct mp3entry, track_string), &parsetracknum, false },
 429     { "TDRC", 4, offsetof(struct mp3entry, year_string), &parseyearnum, false },
 430     { "TYER", 4, offsetof(struct mp3entry, year_string), &parseyearnum, false },
 431     { "TYE",  3, offsetof(struct mp3entry, year_string), &parseyearnum, false },
 432     { "TCOM", 4, offsetof(struct mp3entry, composer), NULL, false },
 433     { "TCM",  3, offsetof(struct mp3entry, composer), NULL, false },
 434     { "TPE2", 4, offsetof(struct mp3entry, albumartist), NULL, false },
 435     { "TP2",  3, offsetof(struct mp3entry, albumartist), NULL, false },
 436     { "TIT1", 4, offsetof(struct mp3entry, grouping), NULL, false },
 437     { "TT1",  3, offsetof(struct mp3entry, grouping), NULL, false },
 438     { "COMM", 4, offsetof(struct mp3entry, comment), NULL, false },
 439     { "COM",  3, offsetof(struct mp3entry, comment), NULL, false },
 440     { "TCON", 4, offsetof(struct mp3entry, genre_string), &parsegenre, false },
 441     { "TCO",  3, offsetof(struct mp3entry, genre_string), &parsegenre, false },
 442     { "TXXX", 4, 0, &parseuser, false },
 443 #if CONFIG_CODEC == SWCODEC
 444     { "RVA2", 4, 0, &parserva2, true },
 445 #endif
 446     { "UFID", 4, 0, &parsembtid, false },
 447 };
 448
 449 #define TAGLIST_SIZE ((int)ARRAYLEN(taglist))
 450
 451 /* Get the length of an ID3 string in the given encoding. Returns the length
 452  * in bytes, including end nil, or -1 if the encoding is unknown.
 453  */
 454 static int unicode_len(char encoding, const void* string)
 455 {
 456     int len = 0;
 457
 458     if (encoding == 0x01 || encoding == 0x02) {
 459         char first;
 460         const char *s = string;
 461         /* string might be unaligned, so using short* can crash on ARM and SH1 */
 462         do {
 463             first = *s++;
 464         } while ((first | *s++) != 0);
 465
 466         len = s - (const char*) string;
 467     } else {
 468         len = strlen((char*) string) + 1;
 469     }
 470
 471     return len;
 472 }
 473
 474 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
 475    string.  If it is, we convert it to a UTF-8 string.  If it's not unicode,
 476    we convert from the default codepage */
 477 static int unicode_munge(char* string, char* utf8buf, int *len) {
 478     long tmp;
 479     bool le = false;
 480     int i = 0;
 481     unsigned char *str = (unsigned char *)string;
 482     int templen = 0;
 483     unsigned char* utf8 = (unsigned char *)utf8buf;
 484
 485     switch (str[0]) {
 486         case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
 487             str++;
 488             (*len)--;
 489             utf8 = iso_decode(str, utf8, -1, *len);
 490             *utf8 = 0;
 491             *len = (unsigned long)utf8 - (unsigned long)utf8buf;
 492             break;
 493
 494         case 0x01: /* Unicode with or without BOM */
 495         case 0x02:
 496             (*len)--;
 497             str++;
 498
 499             /* Handle frames with more than one string
 500                (needed for TXXX frames).*/
 501             do {
 502                 tmp = bytes2int(0, 0, str[0], str[1]);
 503
 504                 /* Now check if there is a BOM
 505                    (zero-width non-breaking space, 0xfeff)
 506                    and if it is in little or big endian format */
 507                 if(tmp == 0xfffe) { /* Little endian? */
 508                     le = true;
 509                     str += 2;
 510                     (*len)-=2;
 511                 } else if(tmp == 0xfeff) { /* Big endian? */
 512                     str += 2;
 513                     (*len)-=2;
 514                 } else
 515                 /* If there is no BOM (which is a specification violation),
 516                    let's try to guess it. If one of the bytes is 0x00, it is
 517                    probably the most significant one. */
 518                     if(str[1] == 0)
 519                         le = true;
 520
 521                 do {
 522                     if(le)
 523                         utf8 = utf16LEdecode(str, utf8, 1);
 524                     else
 525                         utf8 = utf16BEdecode(str, utf8, 1);
 526
 527                     str+=2;
 528                     i += 2;
 529                 } while((str[0] || str[1]) && (i < *len));
 530
 531                 *utf8++ = 0; /* Terminate the string */
 532                 templen += (strlen(&utf8buf[templen]) + 1);
 533                 str += 2;
 534                 i+=2;
 535             } while(i < *len);
 536             *len = templen - 1;
 537             break;
 538
 539         case 0x03: /* UTF-8 encoded string */
 540             for(i=0; i < *len; i++)
 541                 utf8[i] = str[i+1];
 542             (*len)--;
 543             break;
 544
 545         default: /* Plain old string */
 546             utf8 = iso_decode(str, utf8, -1, *len);
 547             *utf8 = 0;
 548             *len = (unsigned long)utf8 - (unsigned long)utf8buf;
 549             break;
 550     }
 551     return 0;
 552 }
 553
 554 /*
 555  * Sets the title of an MP3 entry based on its ID3v1 tag.
 556  *
 557  * Arguments: file - the MP3 file to scen for a ID3v1 tag
 558  *            entry - the entry to set the title in
 559  *
 560  * Returns: true if a title was found and created, else false
 561  */
 562 bool setid3v1title(int fd, struct mp3entry *entry)
 563 {
 564     unsigned char buffer[128];
 565     static const char offsets[] = {3, 33, 63, 97, 93, 125, 127};
 566     int i, j;
 567     unsigned char* utf8;
 568
 569     if (-1 == lseek(fd, -128, SEEK_END))
 570         return false;
 571
 572     if (read(fd, buffer, sizeof buffer) != sizeof buffer)
 573         return false;
 574
 575     if (strncmp((char *)buffer, "TAG", 3))
 576         return false;
 577
 578     entry->id3v1len = 128;
 579     entry->id3version = ID3_VER_1_0;
 580
 581     for (i=0; i < (int)sizeof offsets; i++) {
 582         unsigned char* ptr = (unsigned char *)buffer + offsets[i];
 583
 584         switch(i) {
 585             case 0:
 586             case 1:
 587             case 2:
 588                 /* kill trailing space in strings */
 589                 for (j=29; j && (ptr[j]==0 || ptr[j]==' '); j--)
 590                     ptr[j] = 0;
 591                 /* convert string to utf8 */
 592                 utf8 = (unsigned char *)entry->id3v1buf[i];
 593                 utf8 = iso_decode(ptr, utf8, -1, 30);
 594                 /* make sure string is terminated */
 595                 *utf8 = 0;
 596                 break;
 597
 598             case 3:
 599                 /* kill trailing space in strings */
 600                 for (j=27; j && (ptr[j]==0 || ptr[j]==' '); j--)
 601                     ptr[j] = 0;
 602                 /* convert string to utf8 */
 603                 utf8 = (unsigned char *)entry->id3v1buf[3];
 604                 utf8 = iso_decode(ptr, utf8, -1, 28);
 605                 /* make sure string is terminated */
 606                 *utf8 = 0;
 607                 break;
 608
 609             case 4:
 610                 ptr[4] = 0;
 611                 entry->year = atoi((char *)ptr);
 612                 break;
 613
 614             case 5:
 615                 /* id3v1.1 uses last two bytes of comment field for track
 616                    number: first must be 0 and second is track num */
 617                 if (!ptr[0] && ptr[1]) {
 618                     entry->tracknum = ptr[1];
 619                     entry->id3version = ID3_VER_1_1;
 620                 }
 621                 break;
 622
 623             case 6:
 624                 /* genre */
 625                 entry->genre_string = id3_get_num_genre(ptr[0]);
 626                 break;
 627         }
 628     }
 629
 630     entry->title = entry->id3v1buf[0];
 631     entry->artist = entry->id3v1buf[1];
 632     entry->album = entry->id3v1buf[2];
 633     entry->comment = entry->id3v1buf[3];
 634
 635     return true;
 636 }
 637
 638
 639 /*
 640  * Sets the title of an MP3 entry based on its ID3v2 tag.
 641  *
 642  * Arguments: file - the MP3 file to scan for a ID3v2 tag
 643  *            entry - the entry to set the title in
 644  *
 645  * Returns: true if a title was found and created, else false
 646  */
 647 void setid3v2title(int fd, struct mp3entry *entry)
 648 {
 649     int minframesize;
 650     int size;
 651     long bufferpos = 0, totframelen, framelen;
 652     char header[10];
 653     char tmp[4];
 654     unsigned char version;
 655     char *buffer = entry->id3v2buf;
 656     int bytesread = 0;
 657     int buffersize = sizeof(entry->id3v2buf);
 658     unsigned char global_flags;
 659     int flags;
 660     bool global_unsynch = false;
 661     bool unsynch = false;
 662     int i, j;
 663     int rc;
 664 #if CONFIG_CODEC == SWCODEC
 665     bool itunes_gapless = false;
 666 #endif
 667
 668     global_ff_found = false;
 669
 670     /* Bail out if the tag is shorter than 10 bytes */
 671     if(entry->id3v2len < 10)
 672         return;
 673
 674     /* Read the ID3 tag version from the header */
 675     lseek(fd, 0, SEEK_SET);
 676     if(10 != read(fd, header, 10))
 677         return;
 678
 679     /* Get the total ID3 tag size */
 680     size = entry->id3v2len - 10;
 681
 682     version = header[3];
 683     switch ( version ) {
 684         case 2:
 685             version = ID3_VER_2_2;
 686             minframesize = 8;
 687             break;
 688
 689         case 3:
 690             version = ID3_VER_2_3;
 691             minframesize = 12;
 692             break;
 693
 694         case 4:
 695             version = ID3_VER_2_4;
 696             minframesize = 12;
 697             break;
 698
 699         default:
 700             /* unsupported id3 version */
 701             return;
 702     }
 703     entry->id3version = version;
 704     entry->tracknum = entry->year = entry->discnum = 0;
 705     entry->title = entry->artist = entry->album = NULL; /* FIXME incomplete */
 706
 707     global_flags = header[5];
 708
 709     /* Skip the extended header if it is present */
 710     if(global_flags & 0x40) {
 711         if(version == ID3_VER_2_3) {
 712             if(10 != read(fd, header, 10))
 713                 return;
 714             /* The 2.3 extended header size doesn't include the header size
 715                field itself. Also, it is not unsynched. */
 716             framelen =
 717                 bytes2int(header[0], header[1], header[2], header[3]) + 4;
 718
 719             /* Skip the rest of the header */
 720             lseek(fd, framelen - 10, SEEK_CUR);
 721         }
 722
 723         if(version >= ID3_VER_2_4) {
 724             if(4 != read(fd, header, 4))
 725                 return;
 726
 727             /* The 2.4 extended header size does include the entire header,
 728                so here we can just skip it. This header is unsynched. */
 729             framelen = unsync(header[0], header[1],
 730                               header[2], header[3]);
 731
 732             lseek(fd, framelen - 4, SEEK_CUR);
 733         }
 734     }
 735
 736     /* Is unsynchronization applied? */
 737     if(global_flags & 0x80) {
 738         global_unsynch = true;
 739     }
 740
 741     /*
 742      * We must have at least minframesize bytes left for the
 743      * remaining frames to be interesting
 744      */
 745     while (size >= minframesize && bufferpos < buffersize - 1) {
 746         flags = 0;
 747
 748         /* Read frame header and check length */
 749         if(version >= ID3_VER_2_3) {
 750             if(global_unsynch && version <= ID3_VER_2_3)
 751                 rc = read_unsynched(fd, header, 10);
 752             else
 753                 rc = read(fd, header, 10);
 754             if(rc != 10)
 755                 return;
 756             /* Adjust for the 10 bytes we read */
 757             size -= 10;
 758
 759             flags = bytes2int(0, 0, header[8], header[9]);
 760
 761             if (version >= ID3_VER_2_4) {
 762                 framelen = unsync(header[4], header[5],
 763                                   header[6], header[7]);
 764             } else {
 765                 /* version .3 files don't use synchsafe ints for
 766                  * size */
 767                 framelen = bytes2int(header[4], header[5],
 768                                      header[6], header[7]);
 769             }
 770         } else {
 771             if(6 != read(fd, header, 6))
 772                 return;
 773             /* Adjust for the 6 bytes we read */
 774             size -= 6;
 775
 776             framelen = bytes2int(0, header[3], header[4], header[5]);
 777         }
 778
 779         logf("framelen = %ld, flags = 0x%04x", framelen, flags);
 780         if(framelen == 0){
 781             if (header[0] == 0 && header[1] == 0 && header[2] == 0)
 782                 return;
 783             else
 784                 continue;
 785         }
 786
 787         unsynch = false;
 788
 789         if(flags)
 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