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     { "TRCK", 4, offsetof(struct mp3entry, track_string), &parsetracknum, false },
 428     { "TDRC", 4, offsetof(struct mp3entry, year_string), &parseyearnum, false },
 429     { "TYER", 4, offsetof(struct mp3entry, year_string), &parseyearnum, false },
 430     { "TYE",  3, offsetof(struct mp3entry, year_string), &parseyearnum, false },
 431     { "TCOM", 4, offsetof(struct mp3entry, composer), NULL, false },
 432     { "TPE2", 4, offsetof(struct mp3entry, albumartist), NULL, false },
 433     { "TP2",  3, offsetof(struct mp3entry, albumartist), NULL, false },
 434     { "TIT1", 4, offsetof(struct mp3entry, grouping), NULL, false },
 435     { "TT1",  3, offsetof(struct mp3entry, grouping), NULL, false },
 436     { "COMM", 4, offsetof(struct mp3entry, comment), NULL, false },
 437     { "COM",  3, offsetof(struct mp3entry, comment), NULL, false },
 438     { "TCON", 4, offsetof(struct mp3entry, genre_string), &parsegenre, false },
 439     { "TCO",  3, offsetof(struct mp3entry, genre_string), &parsegenre, false },
 440     { "TXXX", 4, 0, &parseuser, false },
 441 #if CONFIG_CODEC == SWCODEC
 442     { "RVA2", 4, 0, &parserva2, true },
 443 #endif
 444     { "UFID", 4, 0, &parsembtid, false },
 445 };
 446
 447 #define TAGLIST_SIZE ((int)ARRAYLEN(taglist))
 448
 449 /* Get the length of an ID3 string in the given encoding. Returns the length
 450  * in bytes, including end nil, or -1 if the encoding is unknown.
 451  */
 452 static int unicode_len(char encoding, const void* string)
 453 {
 454     int len = 0;
 455
 456     if (encoding == 0x01 || encoding == 0x02) {
 457         char first;
 458         const char *s = string;
 459         /* string might be unaligned, so using short* can crash on ARM and SH1 */
 460         do {
 461             first = *s++;
 462         } while ((first | *s++) != 0);
 463
 464         len = s - (const char*) string;
 465     } else {
 466         len = strlen((char*) string) + 1;
 467     }
 468
 469     return len;
 470 }
 471
 472 /* Checks to see if the passed in string is a 16-bit wide Unicode v2
 473    string.  If it is, we convert it to a UTF-8 string.  If it's not unicode,
 474    we convert from the default codepage */
 475 static int unicode_munge(char* string, char* utf8buf, int *len) {
 476     long tmp;
 477     bool le = false;
 478     int i = 0;
 479     unsigned char *str = (unsigned char *)string;
 480     int templen = 0;
 481     unsigned char* utf8 = (unsigned char *)utf8buf;
 482
 483     switch (str[0]) {
 484         case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
 485             str++;
 486             (*len)--;
 487             utf8 = iso_decode(str, utf8, -1, *len);
 488             *utf8 = 0;
 489             *len = (unsigned long)utf8 - (unsigned long)utf8buf;
 490             break;
 491
 492         case 0x01: /* Unicode with or without BOM */
 493         case 0x02:
 494             (*len)--;
 495             str++;
 496
 497             /* Handle frames with more than one string
 498                (needed for TXXX frames).*/
 499             do {
 500                 tmp = bytes2int(0, 0, str[0], str[1]);
 501
 502                 /* Now check if there is a BOM
 503                    (zero-width non-breaking space, 0xfeff)
 504                    and if it is in little or big endian format */
 505                 if(tmp == 0xfffe) { /* Little endian? */
 506                     le = true;
 507                     str += 2;
 508                     (*len)-=2;
 509                 } else if(tmp == 0xfeff) { /* Big endian? */
 510                     str += 2;
 511                     (*len)-=2;
 512                 } else
 513                 /* If there is no BOM (which is a specification violation),
 514                    let's try to guess it. If one of the bytes is 0x00, it is
 515                    probably the most significant one. */
 516                     if(str[1] == 0)
 517                         le = true;
 518
 519                 do {
 520                     if(le)
 521                         utf8 = utf16LEdecode(str, utf8, 1);
 522                     else
 523                         utf8 = utf16BEdecode(str, utf8, 1);
 524
 525                     str+=2;
 526                     i += 2;
 527                 } while((str[0] || str[1]) && (i < *len));
 528
 529                 *utf8++ = 0; /* Terminate the string */
 530                 templen += (strlen(&utf8buf[templen]) + 1);
 531                 str += 2;
 532                 i+=2;
 533             } while(i < *len);
 534             *len = templen - 1;
 535             break;
 536
 537         case 0x03: /* UTF-8 encoded string */
 538             for(i=0; i < *len; i++)
 539                 utf8[i] = str[i+1];
 540             (*len)--;
 541             break;
 542
 543         default: /* Plain old string */
 544             utf8 = iso_decode(str, utf8, -1, *len);
 545             *utf8 = 0;
 546             *len = (unsigned long)utf8 - (unsigned long)utf8buf;
 547             break;
 548     }
 549     return 0;
 550 }
 551
 552 /*
 553  * Sets the title of an MP3 entry based on its ID3v1 tag.
 554  *
 555  * Arguments: file - the MP3 file to scen for a ID3v1 tag
 556  *            entry - the entry to set the title in
 557  *
 558  * Returns: true if a title was found and created, else false
 559  */
 560 bool setid3v1title(int fd, struct mp3entry *entry)
 561 {
 562     unsigned char buffer[128];
 563     static const char offsets[] = {3, 33, 63, 97, 93, 125, 127};
 564     int i, j;
 565     unsigned char* utf8;
 566
 567     if (-1 == lseek(fd, -128, SEEK_END))
 568         return false;
 569
 570     if (read(fd, buffer, sizeof buffer) != sizeof buffer)
 571         return false;
 572
 573     if (strncmp((char *)buffer, "TAG", 3))
 574         return false;
 575
 576     entry->id3v1len = 128;
 577     entry->id3version = ID3_VER_1_0;
 578
 579     for (i=0; i < (int)sizeof offsets; i++) {
 580         unsigned char* ptr = (unsigned char *)buffer + offsets[i];
 581
 582         switch(i) {
 583             case 0:
 584             case 1:
 585             case 2:
 586                 /* kill trailing space in strings */
 587                 for (j=29; j && (ptr[j]==0 || ptr[j]==' '); j--)
 588                     ptr[j] = 0;
 589                 /* convert string to utf8 */
 590                 utf8 = (unsigned char *)entry->id3v1buf[i];
 591                 utf8 = iso_decode(ptr, utf8, -1, 30);
 592                 /* make sure string is terminated */
 593                 *utf8 = 0;
 594                 break;
 595
 596             case 3:
 597                 /* kill trailing space in strings */
 598                 for (j=27; j && (ptr[j]==0 || ptr[j]==' '); j--)
 599                     ptr[j] = 0;
 600                 /* convert string to utf8 */
 601                 utf8 = (unsigned char *)entry->id3v1buf[3];
 602                 utf8 = iso_decode(ptr, utf8, -1, 28);
 603                 /* make sure string is terminated */
 604                 *utf8 = 0;
 605                 break;
 606
 607             case 4:
 608                 ptr[4] = 0;
 609                 entry->year = atoi((char *)ptr);
 610                 break;
 611
 612             case 5:
 613                 /* id3v1.1 uses last two bytes of comment field for track
 614                    number: first must be 0 and second is track num */
 615                 if (!ptr[0] && ptr[1]) {
 616                     entry->tracknum = ptr[1];
 617                     entry->id3version = ID3_VER_1_1;
 618                 }
 619                 break;
 620
 621             case 6:
 622                 /* genre */
 623                 entry->genre_string = id3_get_num_genre(ptr[0]);
 624                 break;
 625         }
 626     }
 627
 628     entry->title = entry->id3v1buf[0];
 629     entry->artist = entry->id3v1buf[1];
 630     entry->album = entry->id3v1buf[2];
 631     entry->comment = entry->id3v1buf[3];
 632
 633     return true;
 634 }
 635
 636
 637 /*
 638  * Sets the title of an MP3 entry based on its ID3v2 tag.
 639  *
 640  * Arguments: file - the MP3 file to scan for a ID3v2 tag
 641  *            entry - the entry to set the title in
 642  *
 643  * Returns: true if a title was found and created, else false
 644  */
 645 void setid3v2title(int fd, struct mp3entry *entry)
 646 {
 647     int minframesize;
 648     int size;
 649     long bufferpos = 0, totframelen, framelen;
 650     char header[10];
 651     char tmp[4];
 652     unsigned char version;
 653     char *buffer = entry->id3v2buf;
 654     int bytesread = 0;
 655     int buffersize = sizeof(entry->id3v2buf);
 656     unsigned char global_flags;
 657     int flags;
 658     int skip;
 659     bool global_unsynch = false;
 660     bool unsynch = false;
 661     int i, j;
 662     int rc;
 663 #if CONFIG_CODEC == SWCODEC
 664     bool itunes_gapless = false;
 665 #endif
 666
 667     global_ff_found = false;
 668
 669     /* Bail out if the tag is shorter than 10 bytes */
 670     if(entry->id3v2len < 10)
 671         return;
 672
 673     /* Read the ID3 tag version from the header */
 674     lseek(fd, 0, SEEK_SET);
 675     if(10 != read(fd, header, 10))
 676         return;
 677
 678     /* Get the total ID3 tag size */
 679     size = entry->id3v2len - 10;
 680
 681     version = header[3];
 682     switch ( version ) {
 683         case 2:
 684             version = ID3_VER_2_2;
 685             minframesize = 8;
 686             break;
 687
 688         case 3:
 689             version = ID3_VER_2_3;
 690             minframesize = 12;
 691             break;
 692
 693         case 4:
 694             version = ID3_VER_2_4;
 695             minframesize = 12;
 696             break;
 697
 698         default:
 699             /* unsupported id3 version */
 700             return;
 701     }
 702     entry->id3version = version;
 703     entry->tracknum = entry->year = entry->discnum = 0;
 704     entry->title = entry->artist = entry->album = NULL; /* FIXME incomplete */
 705
 706     global_flags = header[5];
 707
 708     /* Skip the extended header if it is present */
 709     if(global_flags & 0x40) {
 710         if(version == ID3_VER_2_3) {
 711             if(10 != read(fd, header, 10))
 712                 return;
 713             /* The 2.3 extended header size doesn't include the header size
 714                field itself. Also, it is not unsynched. */
 715             framelen =
 716                 bytes2int(header[0], header[1], header[2], header[3]) + 4;
 717
 718             /* Skip the rest of the header */
 719             lseek(fd, framelen - 10, SEEK_CUR);
 720         }
 721
 722         if(version >= ID3_VER_2_4) {
 723             if(4 != read(fd, header, 4))
 724                 return;
 725
 726             /* The 2.4 extended header size does include the entire header,
 727                so here we can just skip it. This header is unsynched. */
 728             framelen = unsync(header[0], header[1],
 729                               header[2], header[3]);
 730
 731             lseek(fd, framelen - 4, SEEK_CUR);
 732         }
 733     }
 734
 735     /* Is unsynchronization applied? */
 736     if(global_flags & 0x80) {
 737         global_unsynch = true;
 738     }
 739
 740     /*
 741      * We must have at least minframesize bytes left for the
 742      * remaining frames to be interesting
 743      */
 744     while (size >= minframesize && bufferpos < buffersize - 1) {
 745         flags = 0;
 746
 747         /* Read frame header and check length */
 748         if(version >= ID3_VER_2_3) {
 749             if(global_unsynch && version <= ID3_VER_2_3)
 750                 rc = read_unsynched(fd, header, 10);
 751             else
 752                 rc = read(fd, header, 10);
 753             if(rc != 10)
 754                 return;
 755             /* Adjust for the 10 bytes we read */
 756             size -= 10;
 757
 758             flags = bytes2int(0, 0, header[8], header[9]);
 759
 760             if (version >= ID3_VER_2_4) {
 761                 framelen = unsync(header[4], header[5],
 762                                   header[6], header[7]);
 763             } else {
 764                 /* version .3 files don't use synchsafe ints for
 765                  * size */
 766                 framelen = bytes2int(header[4], header[5],
 767                                      header[6], header[7]);
 768             }
 769         } else {
 770             if(6 != read(fd, header, 6))
 771                 return;
 772             /* Adjust for the 6 bytes we read */
 773             size -= 6;
 774
 775             framelen = bytes2int(0, header[3], header[4], header[5]);
 776         }
 777
 778         logf("framelen = %ld, flags = 0x%04x", framelen, flags);
 779         if(framelen == 0){
 780             if (header[0] == 0 && header[1] == 0 && header[2] == 0)
 781                 return;
 782             else
 783                 continue;
 784         }
 785
 786         unsynch = false;
 787
 788         if(flags)
 789         {
 790             skip = 0;
 791
 792             if (version >= ID3_VER_2_4) {
 793                 if(flags & 0x0040) { /* Grouping identity */
 794                     lseek(fd, 1, SEEK_CUR); /* Skip 1 byte */
 795                     framelen--;
 796                 }
 797             } else {
 798                 if(flags & 0x0020) { /* Grouping identity */
 799                     lseek(fd, 1, SEEK_CUR); /* Skip 1 byte */
 800                     framelen--;
 801                 }
 802             }
 803
 804             if(flags & 0x000c) /* Compression or encryption */
 805             {
 806                 /* Skip it */
 807                 size -= framelen;
 808                 lseek(fd, framelen, SEEK_CUR);
 809                 continue;
 810             }
 811
 812             if(flags & 0x0002) /* Unsynchronization */
 813                 unsynch = true;
 814
 815             if (version >= ID3_VER_2_4) {
 816                 if(flags & 0x0001) { /* Data length indicator */
 817                     if(4 != read(fd, tmp, 4))
 818                         return;
 819
 820                     /* We don't need the data length */
 821                     framelen -= 4;
 822                 }
 823             }
 824         }
 825
 826         if (framelen == 0)
 827             continue;
 828
 829         if (framelen < 0)
 830             return;
 831
 832         /* Keep track of the remaining frame size */
 833         totframelen = framelen;
 834
 835         /* If the frame is larger than the remaining buffer space we try
 836            to read as much as would fit in the buffer */
 837         if(framelen >= buffersize - bufferpos)
 838             framelen = buffersize - bufferpos - 1;
 839
 840         logf("id3v2 frame: %.4s", header);
 841
 842         /* Check for certain frame headers
 843
 844            'size' is the amount of frame bytes remaining.  We decrement it by
 845            the amount of bytes we read.  If we fail to read as many bytes as
 846            we expect, we assume that we can't read from this file, and bail
 847            out.
 848
 849            For each frame. we will iterate over the list of supported tags,
 850            and read the tag into entry's buffer. All tags will be kept as
 851            strings, for cases where a number won't do, e.g., YEAR: "circa
 852            1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
 853            "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
 854            flexible, and as the main use of id3 data is to display it,
 855            converting it to an int just means reconverting to display it, at a
 856            runtime cost.
 857
 858            For tags that the current code does convert to ints, a post
 859            processing function will be called via a pointer to function. */
 860
 861         for (i=0; i<TAGLIST_SIZE; i++) {
 862             const struct tag_resolver* tr = &taglist[i];
 863             char** ptag = tr->offset ? (char**) (((char*)entry) + tr->offset)
 864                 : NULL;
 865             char* tag;
 866
 867             /* Only ID3_VER_2_2 uses frames with three-character names. */
 868             if (((version == ID3_VER_2_2) && (tr->tag_length != 3))
 869                 || ((version > ID3_VER_2_2) && (tr->tag_length != 4))) {
 870                 continue;
 871             }
 872
 873             if( !memcmp( header, tr->tag, tr->tag_length ) ) {
 874
 875                 /* found a tag matching one in tagList, and not yet filled */
 876                 tag = buffer + bufferpos;
 877
 878                 if(global_unsynch && version <= ID3_VER_2_3)
 879                     bytesread = read_unsynched(fd, tag, framelen);
 880                 else
 881                     bytesread = read(fd, tag, framelen);
 882
 883                 if( bytesread != framelen )
 884                     return;
 885
 886                 size -= bytesread;
 887
 888                 if(unsynch || (global_unsynch && version >= ID3_VER_2_4))
 889                     bytesread = unsynchronize_frame(tag, bytesread);
 890
 891                 /* the COMM frame has a 3 char field to hold an ISO-639-1
 892                  * language string and an optional short description;
 893                  * remove them so unicode_munge can work correctly
 894                  */
 895
 896                 if((tr->tag_length == 4 && !memcmp( header, "COMM", 4)) ||
 897                    (tr->tag_length == 3 && !memcmp( header, "COM", 3))) {
 898                     int offset;
 899                     if(!strncmp(tag+4, "iTun", 4)) {
 900 #if CONFIG_CODEC == SWCODEC
 901                         /* check for iTunes gapless information */
 902                         if(!strncmp(tag+4, "iTunSMPB", 8))
 903                             itunes_gapless = true;
 904                         else
 905 #endif
 906                         /* ignore other with iTunes tags */
 907                         break;
 908                     }
 909
 910                     offset = 3 + unicode_len(*tag, tag + 4);
 911                     if(bytesread > offset) {
 912                         bytesread -= offset;
 913                         memmove(tag + 1, tag + 1 + offset, bytesread - 1);
 914                     }
 915                 }
 916
 917                 /* Attempt to parse Unicode string only if the tag contents
 918                    aren't binary */
 919                 if(!tr->binary) {
 920                     /* UTF-8 could potentially be 3 times larger */
 921                     /* so we need to create a new buffer         */
 922                     char utf8buf[(3 * bytesread) + 1];
 923
 924                     unicode_munge( tag, utf8buf, &bytesread );
 925
 926                     if(bytesread >= buffersize - bufferpos)
 927                         bytesread = buffersize - bufferpos - 1;
 928
 929                     for (j = 0; j < bytesread; j++)
 930                         tag[j] = utf8buf[j];
 931
 932                     /* remove trailing spaces */
 933                     while ( bytesread > 0 && isspace(tag[bytesread-1]))
 934                         bytesread--;
 935                 }
 936
 937                 tag[bytesread] = 0;
 938                 bufferpos += bytesread + 1;
 939
 940 #if CONFIG_CODEC == SWCODEC
 941                 /* parse the tag if it contains iTunes gapless info */
 942                 if (itunes_gapless)
 943                 {
 944                     itunes_gapless = false;
 945                     entry->lead_trim = get_itunes_int32(tag, 1);
 946                     entry->tail_trim = get_itunes_int32(tag, 2);
 947                 }
 948 #endif
 949
 950                 /* Note that parser functions sometimes set *ptag to NULL, so
 951                  * the "!*ptag" check here doesn't always have the desired
 952                  * effect. Should the parser functions (parsegenre in
 953                  * particular) be updated to handle the case of being called
 954                  * multiple times, or should the "*ptag" check be removed?
 955                  */
 956                 if (ptag && !*ptag)
 957                     *ptag = tag;
 958
 959                 if( tr->ppFunc )
 960                     bufferpos = tr->ppFunc(entry, tag, bufferpos);
 961
 962                 /* Seek to the next frame */
 963                 if(framelen < totframelen)
 964                     lseek(fd, totframelen - framelen, SEEK_CUR);
 965                 break;
 966             }
 967         }
 968
 969         if( i == TAGLIST_SIZE ) {
 970             /* no tag in tagList was found, or it was a repeat.
 971                skip it using the total size */
 972
 973             if(global_unsynch && version <= ID3_VER_2_3) {
 974                 size -= skip_unsynched(fd, totframelen);
 975             } else {
 976                 size -= totframelen;
 977                 if( lseek(fd, totframelen, SEEK_CUR) == -1 )
 978                     return;
 979             }
 980         }
 981     }
 982 }
 983
 984 /*
 985  * Calculates the size of the ID3v2 tag.
 986  *
 987  * Arguments: file - the file to search for a tag.
 988  *
 989  * Returns: the size of the tag or 0 if none was found
 990  */
 991 int getid3v2len(int fd)
 992 {
 993     char buf[6];
 994     int offset;
 995
 996     /* Make sure file has a ID3 tag */
 997     if((-1 == lseek(fd, 0, SEEK_SET)) ||
 998        (read(fd, buf, 6) != 6) ||
 999        (strncmp(buf, "ID3", strlen("ID3")) != 0))
1000         offset = 0;
1001
1002     /* Now check what the ID3v2 size field says */
1003     else
1004         if(read(fd, buf, 4) != 4)
1005             offset = 0;
1006         else
1007             offset = unsync(buf[0], buf[1], buf[2], buf[3]) + 10;
1008
1009     logf("ID3V2 Length: 0x%x", offset);
1010     return offset;
1011 }
1012
1013 #ifdef DEBUG_STANDALONE
1014
1015 char *secs2str(int ms)
1016 {
1017     static char buffer[32];
1018     int secs = ms/1000;
1019     ms %= 1000;
1020     snprintf(buffer, sizeof(buffer), "%d:%02d.%d", secs/60, secs%60, ms/100);
1021     return buffer;
1022 }
1023
1024 int main(int argc, char **argv)
1025 {
1026     int i;
1027     for(i=1; i<argc; i++) {
1028         struct mp3entry mp3;
1029         mp3.album = "Bogus";
1030         if(mp3info(&mp3, argv[i], false)) {
1031             printf("Failed to get %s\n", argv[i]);
1032             return 0;
1033         }
1034
1035         printf("****** File: %s\n"
1036                "      Title: %s\n"
1037                "     Artist: %s\n"
1038                "      Album: %s\n"
1039                "      Genre: %s (%d) \n"
1040                "   Composer: %s\n"
1041                "       Year: %s (%d)\n"
1042                "      Track: %s (%d)\n"
1043                "     Length: %s / %d s\n"
1044                "    Bitrate: %d\n"
1045                "  Frequency: %d\n",
1046                argv[i],
1047                mp3.title?mp3.title:"<blank>",
1048                mp3.artist?mp3.artist:"<blank>",
1049                mp3.album?mp3.album:"<blank>",
1050                mp3.genre_string?mp3.genre_string:"<blank>",
1051                     mp3.genre,
1052                mp3.composer?mp3.composer:"<blank>",
1053                mp3.year_string?mp3.year_string:"<blank>",
1054                     mp3.year,
1055                mp3.track_string?mp3.track_string:"<blank>",
1056                     mp3.tracknum,
1057                secs2str(mp3.length),
1058                mp3.length/1000,
1059                mp3.bitrate,
1060                mp3.frequency);
1061     }
1062
1063     return 0;
1064 }
1065
1066 #endif