apps/metadata/mp3.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 "config.h"
  39 #include "file.h"
  40 #include "logf.h"
  41
  42 #include "mp3data.h"
  43 #include "system.h"
  44 #include "replaygain.h"
  45 #include "rbunicode.h"
  46 #include "metadata_parsers.h"
  47
  48 static unsigned long unsync(unsigned long b0,
  49                             unsigned long b1,
  50                             unsigned long b2,
  51                             unsigned long b3)
  52 {
  53    return (((long)(b0 & 0x7F) << (3*7)) |
  54            ((long)(b1 & 0x7F) << (2*7)) |
  55            ((long)(b2 & 0x7F) << (1*7)) |
  56            ((long)(b3 & 0x7F) << (0*7)));
  57 }
  58
  59 static const char* const genres[] = {
  60     "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
  61     "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
  62     "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
  63     "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
  64     "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
  65     "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
  66     "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
  67     "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
  68     "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
  69     "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
  70     "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
  71     "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
  72     "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
  73
  74     /* winamp extensions */
  75     "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
  76     "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
  77     "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
  78     "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
  79     "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
  80     "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
  81     "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
  82     "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
  83     "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
  84     "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
  85     "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
  86     "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
  87     "Synthpop"
  88 };
  89
  90 char* id3_get_num_genre(unsigned int genre_num)
  91 {
  92     if (genre_num < sizeof(genres)/sizeof(char*))
  93         return (char*)genres[genre_num];
  94     return NULL;
  95 }
  96
  97 /* True if the string is from the "genres" array */
  98 bool id3_is_genre_string(const char *string)
  99 {
 100     return ( string >= genres[0] &&
 101              string <= genres[sizeof(genres)/sizeof(char*) - 1] );
 102 }
 103
 104 /*
 105     HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
 106     Code and comments by Thomas Paul Diffenbach
 107
 108     To add another ID3v2 Tag, do the following:
 109     1.  add a char* named for the tag to struct mp3entry in id3.h,
 110         (I (tpd) prefer to use char* rather than ints, even for what seems like
 111         numerical values, for cases where a number won't do, e.g.,
 112         YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
 113         TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
 114         Text is more flexible, and as the main use of id3 data is to
 115         display it, converting it to an int just means reconverting to
 116         display it, at a runtime cost.)
 117
 118     2. If any special processing beyond copying the tag value from the Id3
 119        block to the struct mp3entry is rrequired (such as converting to an
 120        int), write a function to perform this special processing.
 121
 122        This function's prototype must match that of
 123        typedef tagPostProcessFunc, that is it must be:
 124          int func( struct mp3entry*, char* tag, int bufferpos )
 125        the first argument is a pointer to the current mp3entry structure the
 126        second argument is a pointer to the null terminated string value of the
 127        tag found the third argument is the offset of the next free byte in the
 128        mp3entry's buffer your function should return the corrected offset; if
 129        you don't lengthen or shorten the tag string, you can return the third
 130        argument unchanged.
 131
 132        Unless you have a good reason no to, make the function static.
 133        TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
 134
 135     3. add one or more entries to the tagList array, using the format:
 136             char* ID3 Tag symbolic name -- see the ID3 specification for these,
 137             sizeof() that name minus 1,
 138             offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
 139             pointer to your special processing function or NULL
 140                 if you need no special processing
 141             flag indicating if this tag is binary or textual
 142         Many ID3 symbolic names come in more than one form. You can add both
 143         forms, each referencing the same variable in struct mp3entry.
 144         If both forms are present, the last found will be used.
 145         Note that the offset can be zero, in which case no entry will be set
 146         in the mp3entry struct; the frame is still read into the buffer and
 147         the special processing function is called (several times, if there
 148         are several frames with the same name).
 149
 150     4. Alternately, use the TAG_LIST_ENTRY macro with
 151          ID3 tag symbolic name,
 152          variable in struct mp3entry,
 153          special processing function address
 154
 155     5.  Add code to wps-display.c function get_tag to assign a printf-like
 156         format specifier for the tag */
 157
 158 /* Structure for ID3 Tag extraction information */
 159 struct tag_resolver {
 160     const char* tag;
 161     int tag_length;
 162     size_t offset;
 163     int (*ppFunc)(struct mp3entry*, char* tag, int bufferpos);
 164     bool binary;
 165 };
 166
 167 static bool global_ff_found;
 168
 169 static int unsynchronize(char* tag, int len, bool *ff_found)
 170 {
 171     int i;
 172     unsigned char c;
 173     unsigned char *rp, *wp;
 174
 175     wp = rp = (unsigned char *)tag;
 176
 177     rp = (unsigned char *)tag;
 178     for(i = 0;i < len;i++) {
 179         /* Read the next byte and write it back, but don't increment the
 180            write pointer */
 181         c = *rp++;
 182         *wp = c;
 183         if(*ff_found) {
 184             /* Increment the write pointer if it isn't an unsynch pattern */
 185             if(c != 0)
 186                 wp++;
 187             *ff_found = false;
 188         } else {
 189             if(c == 0xff)
 190                 *ff_found = true;
 191             wp++;
 192         }
 193     }
 194     return (long)wp - (long)tag;
 195 }
 196
 197 static int unsynchronize_frame(char* tag, int len)
 198 {
 199     bool ff_found = false;
 200
 201     return unsynchronize(tag, len, &ff_found);
 202 }
 203
 204 static int read_unsynched(int fd, void *buf, int len)
 205 {
 206     int i;
 207     int rc;
 208     int remaining = len;
 209     char *wp;
 210     char *rp;
 211
 212     wp = buf;
 213
 214     while(remaining) {
 215         rp = wp;
 216         rc = read(fd, rp, remaining);
 217         if(rc <= 0)
 218             return rc;
 219
 220         i = unsynchronize(wp, remaining, &global_ff_found);
 221         remaining -= i;
 222         wp += i;
 223     }
 224
 225     return len;
 226 }
 227
 228 static int skip_unsynched(int fd, int len)
 229 {
 230     int rc;
 231     int remaining = len;
 232     int rlen;
 233     char buf[32];
 234
 235     while(remaining) {
 236         rlen = MIN(sizeof(buf), (unsigned int)remaining);
 237         rc = read(fd, buf, rlen);
 238         if(rc <= 0)
 239             return rc;
 240
 241         remaining -= unsynchronize(buf, rlen, &global_ff_found);
 242     }
 243
 244     return len;
 245 }
 246
 247 /* parse numeric value from string */
 248 static int parsetracknum( struct mp3entry* entry, char* tag, int bufferpos )
 249 {
 250     entry->tracknum = atoi( tag );
 251     return bufferpos;
 252 }
 253
 254 /* parse numeric value from string */
 255 static int parsediscnum( struct mp3entry* entry, char* tag, int bufferpos )
 256 {
 257     entry->discnum = atoi( tag );
 258     return bufferpos;
 259 }
 260
 261 /* parse numeric value from string */
 262 static int parseyearnum( struct mp3entry* entry, char* tag, int bufferpos )
 263 {
 264     entry->year = atoi( tag );
 265     return bufferpos;
 266 }
 267
 268 /* parse numeric genre from string, version 2.2 and 2.3 */
 269 static int parsegenre( struct mp3entry* entry, char* tag, int bufferpos )
 270 {
 271     if(entry->id3version >= ID3_VER_2_4) {
 272         /* In version 2.4 and up, there are no parentheses, and the genre frame
 273            is a list of strings, either numbers or text. */
 274
 275         /* Is it a number? */
 276         if(isdigit(tag[0])) {
 277             entry->genre_string = id3_get_num_genre(atoi( tag ));
 278             return tag - entry->id3v2buf;
 279         } else {
 280             entry->genre_string = tag;
 281             return bufferpos;
 282         }
 283     } else {
 284         if( tag[0] == '(' && tag[1] != '(' ) {
 285             entry->genre_string = id3_get_num_genre(atoi( tag + 1 ));
 286             return tag - entry->id3v2buf;
 287         }
 288         else {
 289             entry->genre_string = tag;
 290             return bufferpos;
 291         }
 292     }
 293 }
 294
 295 /* parse user defined text, looking for album artist and replaygain
 296  * information.
 297  */
 298 static int parseuser( struct mp3entry* entry, char* tag, int bufferpos )
 299 {
 300     char* value = NULL;
 301     int desc_len = strlen(tag);
 302     int value_len = 0;
 303
 304     if ((tag - entry->id3v2buf + desc_len + 2) < bufferpos) {
 305         /* At least part of the value was read, so we can safely try to
 306          * parse it
 307          */
 308         value = tag + desc_len + 1;
 309         value_len = bufferpos - (tag - entry->id3v2buf);
 310
 311         if (!strcasecmp(tag, "ALBUM ARTIST")) {
 312             strncpy(tag, value, value_len);
 313             tag[value_len - 1] = 0;
 314             entry->albumartist = tag;
 315 #if CONFIG_CODEC == SWCODEC
 316         } else {
 317             value_len = parse_replaygain(tag, value, entry, tag,
 318                 value_len);
 319 #endif
 320         }
 321     }
 322
 323     return tag - entry->id3v2buf + value_len;
 324 }
 325
 326 #if CONFIG_CODEC == SWCODEC
 327 /* parse RVA2 binary data and convert to replaygain information. */
 328 static int parserva2( struct mp3entry* entry, char* tag, int bufferpos )
 329 {
 330     int desc_len = strlen(tag);
 331     int start_pos = tag - entry->id3v2buf;
 332     int end_pos = start_pos + desc_len + 5;
 333     int value_len = 0;
 334     unsigned char* value = tag + desc_len + 1;
 335
 336     /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
 337      * type is master volume.
 338      */
 339     if (entry->id3version == ID3_VER_2_4 && end_pos < bufferpos
 340             && *value++ == 1) {
 341         long gain = 0;
 342         long peak = 0;
 343         long peakbits;
 344         long peakbytes;
 345         bool album = false;
 346
 347         /* The RVA2 specification is unclear on some things (id string and
 348          * peak volume), but this matches how Quod Libet use them.
 349          */
 350
 351         gain = (int16_t) ((value[0] << 8) | value[1]);
 352         value += 2;
 353         peakbits = *value++;
 354         peakbytes = (peakbits + 7) / 8;
 355
 356         /* Only use the topmost 24 bits for peak volume */
 357         if (peakbytes > 3) {
 358             peakbytes = 3;
 359         }
 360
 361         /* Make sure the peak bits were read */
 362         if (end_pos + peakbytes < bufferpos) {
 363             long shift = ((8 - (peakbits & 7)) & 7) + (3 - peakbytes) * 8;
 364
 365             for ( ; peakbytes; peakbytes--) {
 366                 peak <<= 8;
 367                 peak += *value++;
 368             }
 369
 370             peak <<= shift;
 371
 372             if (peakbits > 24) {
 373                 peak += *value >> (8 - shift);
 374             }
 375         }
 376
 377         if (strcasecmp(tag, "album") == 0) {
 378             album = true;
 379         } else if (strcasecmp(tag, "track") != 0) {
 380             /* Only accept non-track values if we don't have any previous
 381              * value.
 382              */
 383             if (entry->track_gain != 0) {
 384                 return start_pos;
 385             }
 386         }
 387
 388         value_len = parse_replaygain_int(album, gain, peak * 2, entry,
 389             tag, sizeof(entry->id3v2buf) - start_pos);
 390     }
 391
 392     return start_pos + value_len;
 393 }
 394 #endif
 395
 396 static int parsembtid( struct mp3entry* entry, char* tag, int bufferpos )
 397 {
 398     char* value = NULL;
 399     int desc_len = strlen(tag);
 400     /*DEBUGF("MBID len: %d\n", desc_len);*/
 401     /* Musicbrainz track IDs are always 36 chars long */
 402     const size_t mbtid_len = 36;
 403
 404     if ((tag - entry->id3v2buf + desc_len + 2) < bufferpos)
 405     {
 406         value = tag + desc_len + 1;
 407
 408         if (strcasecmp(tag, "http://musicbrainz.org") == 0)
 409         {
 410             if (mbtid_len == strlen(value))
 411             {
 412                 entry->mb_track_id = value;
 413                 return bufferpos + mbtid_len + 1;
 414             }
 415         }
 416     }
 417
 418     return bufferpos;
 419 }
 420
 421 static const struct tag_resolver taglist[] = {
 422     { "TPE1", 4, offsetof(struct mp3entry, artist), NULL, false },
 423     { "TP1",  3, offsetof(struct mp3entry, artist), NULL, false },
 424     { "TIT2", 4, offsetof(struct mp3entry, title), NULL, false },
 425     { "TT2",  3, offsetof(struct mp3entry, title), NULL, false },
 426     { "TALB", 4, offsetof(struct mp3entry, album), NULL, false },
 427     { "TAL",  3, offsetof(struct mp3entry, album), NULL, false },
 428     { "TRK",  3, offsetof(struct mp3entry, track_string), &parsetracknum, false },
 429     { "TPOS", 4, offsetof(struct mp3entry, disc_string), &parsediscnum, false },
 430     { "TRCK", 4, offsetof(struct mp3entry, track_string), &parsetracknum, false },
 431     { "TDRC", 4, offsetof(struct mp3entry, year_string), &parseyearnum, false },
 432     { "TYER", 4, offsetof(struct mp3entry, year_string), &parseyearnum, false },
 433     { "TYE",  3, offsetof(struct mp3entry, year_string), &parseyearnum, false },
 434     { "TCOM", 4, offsetof(struct mp3entry, composer), NULL, false },
 435     { "TPE2", 4, offsetof(struct mp3entry, albumartist), NULL, false },
 436     { "TP2",  3, offsetof(struct mp3entry, albumartist), NULL, false },
 437     { "TIT1", 4, offsetof(struct mp3entry, grouping), NULL, false },
 438     { "TT1",  3, offsetof(struct mp3entry, grouping), NULL, false },
 439     { "COMM", 4, 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)(sizeof(taglist) / sizeof(taglist[0])))
 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 static 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 static 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     int skip;
 661     bool global_unsynch = false;
 662     bool unsynch = false;
 663     int i, j;
 664     int rc;
 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             /* Note that parser functions sometimes set *ptag to NULL, so
 873              * the "!*ptag" check here doesn't always have the desired
 874              * effect. Should the parser functions (parsegenre in
 875              * particular) be updated to handle the case of being called
 876              * multiple times, or should the "*ptag" check be removed?
 877              */
 878             if( (!ptag || !*ptag) && !memcmp( header, tr->tag, tr->tag_length ) ) {
 879
 880                 /* found a tag matching one in tagList, and not yet filled */
 881                 tag = buffer + bufferpos;
 882
 883                 if(global_unsynch && version <= ID3_VER_2_3)
 884                     bytesread = read_unsynched(fd, tag, framelen);
 885                 else
 886                     bytesread = read(fd, tag, framelen);
 887
 888                 if( bytesread != framelen )
 889                     return;
 890
 891                 size -= bytesread;
 892
 893                 if(unsynch || (global_unsynch && version >= ID3_VER_2_4))
 894                     bytesread = unsynchronize_frame(tag, bytesread);
 895
 896                 /* the COMM frame has a 3 char field to hold an ISO-639-1
 897                  * language string and an optional short description;
 898                  * remove them so unicode_munge can work correctly
 899                  */
 900
 901                 if(!memcmp( header, "COMM", 4 )) {
 902                     int offset;
 903                     /* ignore comments with iTunes 7 soundcheck/gapless data */
 904                     if(!strncmp(tag+4, "iTun", 4))
 905                         break;
 906                     offset = 3 + unicode_len(*tag, tag + 4);
 907                     if(bytesread > offset) {
 908                         bytesread -= offset;
 909                         memmove(tag + 1, tag + 1 + offset, bytesread - 1);
 910                     }
 911                 }
 912
 913                 /* Attempt to parse Unicode string only if the tag contents
 914                    aren't binary */
 915                 if(!tr->binary) {
 916                     /* UTF-8 could potentially be 3 times larger */
 917                     /* so we need to create a new buffer         */
 918                     char utf8buf[(3 * bytesread) + 1];
 919
 920                     unicode_munge( tag, utf8buf, &bytesread );
 921
 922                     if(bytesread >= buffersize - bufferpos)
 923                         bytesread = buffersize - bufferpos - 1;
 924
 925                     for (j = 0; j < bytesread; j++)
 926                         tag[j] = utf8buf[j];
 927
 928                     /* remove trailing spaces */
 929                     while ( bytesread > 0 && isspace(tag[bytesread-1]))
 930                         bytesread--;
 931                 }
 932
 933                 tag[bytesread] = 0;
 934                 bufferpos += bytesread + 1;
 935
 936                 if (ptag)
 937                     *ptag = tag;
 938
 939                 if( tr->ppFunc )
 940                     bufferpos = tr->ppFunc(entry, tag, bufferpos);
 941
 942                 /* Seek to the next frame */
 943                 if(framelen < totframelen)
 944                     lseek(fd, totframelen - framelen, SEEK_CUR);
 945                 break;
 946             }
 947         }
 948
 949         if( i == TAGLIST_SIZE ) {
 950             /* no tag in tagList was found, or it was a repeat.
 951                skip it using the total size */
 952
 953             if(global_unsynch && version <= ID3_VER_2_3) {
 954                 size -= skip_unsynched(fd, totframelen);
 955             } else {
 956                 size -= totframelen;
 957                 if( lseek(fd, totframelen, SEEK_CUR) == -1 )
 958                     return;
 959             }
 960         }
 961     }
 962 }
 963
 964 /*
 965  * Calculates the size of the ID3v2 tag.
 966  *
 967  * Arguments: file - the file to search for a tag.
 968  *
 969  * Returns: the size of the tag or 0 if none was found
 970  */
 971 int getid3v2len(int fd)
 972 {
 973     char buf[6];
 974     int offset;
 975
 976     /* Make sure file has a ID3 tag */
 977     if((-1 == lseek(fd, 0, SEEK_SET)) ||
 978        (read(fd, buf, 6) != 6) ||
 979        (strncmp(buf, "ID3", strlen("ID3")) != 0))
 980         offset = 0;
 981
 982     /* Now check what the ID3v2 size field says */
 983     else
 984         if(read(fd, buf, 4) != 4)
 985             offset = 0;
 986         else
 987             offset = unsync(buf[0], buf[1], buf[2], buf[3]) + 10;
 988
 989     logf("ID3V2 Length: 0x%x", offset);
 990     return offset;
 991 }
 992
 993 /*
 994  * Calculates the length (in milliseconds) of an MP3 file.
 995  *
 996  * Modified to only use integers.
 997  *
 998  * Arguments: file - the file to calculate the length upon
 999  *            entry - the entry to update with the length
1000  *
1001  * Returns: the song length in milliseconds,
1002  *          0 means that it couldn't be calculated
1003  */
1004 static int getsonglength(int fd, struct mp3entry *entry)
1005 {
1006     unsigned long filetime = 0;
1007     struct mp3info info;
1008     long bytecount;
1009
1010     /* Start searching after ID3v2 header */
1011     if(-1 == lseek(fd, entry->id3v2len, SEEK_SET))
1012         return 0;
1013
1014     bytecount = get_mp3file_info(fd, &info);
1015
1016     logf("Space between ID3V2 tag and first audio frame: 0x%lx bytes",
1017            bytecount);
1018
1019     if(bytecount < 0)
1020         return -1;
1021
1022     bytecount += entry->id3v2len;
1023
1024     /* Validate byte count, in case the file has been edited without
1025      * updating the header.
1026      */
1027     if (info.byte_count)
1028     {
1029         const unsigned long expected = entry->filesize - entry->id3v1len
1030             - entry->id3v2len;
1031         const unsigned long diff = MAX(10240, info.byte_count / 20);
1032
1033         if ((info.byte_count > expected + diff)
1034             || (info.byte_count < expected - diff))
1035         {
1036             logf("Note: info.byte_count differs from expected value by "
1037                  "%ld bytes", labs((long) (expected - info.byte_count)));
1038             info.byte_count = 0;
1039             info.frame_count = 0;
1040             info.file_time = 0;
1041             info.enc_padding = 0;
1042
1043             /* Even if the bitrate was based on "known bad" values, it
1044              * should still be better for VBR files than using the bitrate
1045              * of the first audio frame.
1046              */
1047         }
1048     }
1049
1050     entry->bitrate = info.bitrate;
1051     entry->frequency = info.frequency;
1052     entry->version = info.version;
1053     entry->layer = info.layer;
1054     switch(entry->layer) {
1055 #if CONFIG_CODEC==SWCODEC
1056         case 0:
1057             entry->codectype=AFMT_MPA_L1;
1058             break;
1059 #endif
1060         case 1:
1061             entry->codectype=AFMT_MPA_L2;
1062             break;
1063         case 2:
1064             entry->codectype=AFMT_MPA_L3;
1065             break;
1066     }
1067
1068     /* If the file time hasn't been established, this may be a fixed
1069        rate MP3, so just use the default formula */
1070
1071     filetime = info.file_time;
1072
1073     if(filetime == 0)
1074     {
1075         /* Prevent a division by zero */
1076         if (info.bitrate < 8)
1077             filetime = 0;
1078         else
1079             filetime = (entry->filesize - bytecount) / (info.bitrate / 8);
1080         /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
1081          * instead of filesize * 8 is exact, because mpeg audio bitrates are
1082          * always multiples of 8, and it avoids overflows. */
1083     }
1084
1085     entry->frame_count = info.frame_count;
1086
1087     entry->vbr = info.is_vbr;
1088     entry->has_toc = info.has_toc;
1089
1090 #if CONFIG_CODEC==SWCODEC
1091     entry->lead_trim = info.enc_delay;
1092     entry->tail_trim = info.enc_padding;
1093 #endif
1094
1095     memcpy(entry->toc, info.toc, sizeof(info.toc));
1096
1097     entry->vbr_header_pos = info.vbr_header_pos;
1098
1099     /* Update the seek point for the first playable frame */
1100     entry->first_frame_offset = bytecount;
1101     logf("First frame is at %lx", entry->first_frame_offset);
1102
1103     return filetime;
1104 }
1105
1106 /*
1107  * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
1108  * about an MP3 file and updates it's entry accordingly.
1109  *
1110   Note, that this returns true for successful, false for error! */
1111 bool get_mp3_metadata(int fd, struct mp3entry *entry, const char *filename)
1112 {
1113 #if CONFIG_CODEC != SWCODEC
1114     memset(entry, 0, sizeof(struct mp3entry));
1115 #endif
1116
1117     strncpy(entry->path, filename, sizeof(entry->path));
1118
1119     entry->title = NULL;
1120     entry->filesize = filesize(fd);
1121     entry->id3v2len = getid3v2len(fd);
1122     entry->tracknum = 0;
1123     entry->discnum = 0;
1124
1125     if (entry->id3v2len)
1126         setid3v2title(fd, entry);
1127     int len = getsonglength(fd, entry);
1128     if (len < 0)
1129         return false;
1130     entry->length = len;
1131
1132     /* Subtract the meta information from the file size to get
1133        the true size of the MP3 stream */
1134     entry->filesize -= entry->first_frame_offset;
1135
1136     /* only seek to end of file if no id3v2 tags were found */
1137     if (!entry->id3v2len) {
1138         setid3v1title(fd, entry);
1139     }
1140
1141     if(!entry->length || (entry->filesize < 8 ))
1142         /* no song length or less than 8 bytes is hereby considered to be an
1143            invalid mp3 and won't be played by us! */
1144         return false;
1145
1146     return true;
1147 }
1148
1149 #ifdef DEBUG_STANDALONE
1150
1151 char *secs2str(int ms)
1152 {
1153     static char buffer[32];
1154     int secs = ms/1000;
1155     ms %= 1000;
1156     snprintf(buffer, sizeof(buffer), "%d:%02d.%d", secs/60, secs%60, ms/100);
1157     return buffer;
1158 }
1159
1160 int main(int argc, char **argv)
1161 {
1162     int i;
1163     for(i=1; i<argc; i++) {
1164         struct mp3entry mp3;
1165         mp3.album = "Bogus";
1166         if(mp3info(&mp3, argv[i], false)) {
1167             printf("Failed to get %s\n", argv[i]);
1168             return 0;
1169         }
1170
1171         printf("****** File: %s\n"
1172                "      Title: %s\n"
1173                "     Artist: %s\n"
1174                "      Album: %s\n"
1175                "      Genre: %s (%d) \n"
1176                "   Composer: %s\n"
1177                "       Year: %s (%d)\n"
1178                "      Track: %s (%d)\n"
1179                "     Length: %s / %d s\n"
1180                "    Bitrate: %d\n"
1181                "  Frequency: %d\n",
1182                argv[i],
1183                mp3.title?mp3.title:"<blank>",
1184                mp3.artist?mp3.artist:"<blank>",
1185                mp3.album?mp3.album:"<blank>",
1186                mp3.genre_string?mp3.genre_string:"<blank>",
1187                     mp3.genre,
1188                mp3.composer?mp3.composer:"<blank>",
1189                mp3.year_string?mp3.year_string:"<blank>",
1190                     mp3.year,
1191                mp3.track_string?mp3.track_string:"<blank>",
1192                     mp3.tracknum,
1193                secs2str(mp3.length),
1194                mp3.length/1000,
1195                mp3.bitrate,
1196                mp3.frequency);
1197     }
1198
1199     return 0;
1200 }
1201
1202 #endif