apps/metadata.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 Dave Chapman
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <stdlib.h>
  22 #include <ctype.h>
  23 #include <inttypes.h>
  24
  25 #include "errno.h"
  26 #include "metadata.h"
  27 #include "mp3_playback.h"
  28 #include "logf.h"
  29 #include "rbunicode.h"
  30 #include "atoi.h"
  31 #include "replaygain.h"
  32 #include "debug.h"
  33 #include "system.h"
  34 #include "cuesheet.h"
  35 #include "structec.h"
  36
  37 enum tagtype { TAGTYPE_APE = 1, TAGTYPE_VORBIS };
  38
  39 #ifdef ROCKBOX_BIG_ENDIAN
  40 #define IS_BIG_ENDIAN 1
  41 #else
  42 #define IS_BIG_ENDIAN 0
  43 #endif
  44
  45 #define APETAG_HEADER_LENGTH        32
  46 #define APETAG_HEADER_FORMAT        "8llll8"
  47 #define APETAG_ITEM_HEADER_FORMAT   "ll"
  48 #define APETAG_ITEM_TYPE_MASK       3
  49
  50 #define TAG_NAME_LENGTH             32
  51 #define TAG_VALUE_LENGTH            128
  52
  53 #define MP4_ID(a, b, c, d)  (((a) << 24) | ((b) << 16) | ((c) << 8) | (d))
  54
  55 #define MP4_3gp6 MP4_ID('3', 'g', 'p', '6')
  56 #define MP4_alac MP4_ID('a', 'l', 'a', 'c')
  57 #define MP4_calb MP4_ID(0xa9, 'a', 'l', 'b')
  58 #define MP4_cART MP4_ID(0xa9, 'A', 'R', 'T')
  59 #define MP4_cnam MP4_ID(0xa9, 'n', 'a', 'm')
  60 #define MP4_cwrt MP4_ID(0xa9, 'w', 'r', 't')
  61 #define MP4_esds MP4_ID('e', 's', 'd', 's')
  62 #define MP4_ftyp MP4_ID('f', 't', 'y', 'p')
  63 #define MP4_gnre MP4_ID('g', 'n', 'r', 'e')
  64 #define MP4_hdlr MP4_ID('h', 'd', 'l', 'r')
  65 #define MP4_ilst MP4_ID('i', 'l', 's', 't')
  66 #define MP4_M4A  MP4_ID('M', '4', 'A', ' ')
  67 #define MP4_M4B  MP4_ID('M', '4', 'B', ' ')
  68 #define MP4_mdat MP4_ID('m', 'd', 'a', 't')
  69 #define MP4_mdia MP4_ID('m', 'd', 'i', 'a')
  70 #define MP4_mdir MP4_ID('m', 'd', 'i', 'r')
  71 #define MP4_meta MP4_ID('m', 'e', 't', 'a')
  72 #define MP4_minf MP4_ID('m', 'i', 'n', 'f')
  73 #define MP4_moov MP4_ID('m', 'o', 'o', 'v')
  74 #define MP4_mp4a MP4_ID('m', 'p', '4', 'a')
  75 #define MP4_mp42 MP4_ID('m', 'p', '4', '2')
  76 #define MP4_qt   MP4_ID('q', 't', ' ', ' ')
  77 #define MP4_soun MP4_ID('s', 'o', 'u', 'n')
  78 #define MP4_stbl MP4_ID('s', 't', 'b', 'l')
  79 #define MP4_stsd MP4_ID('s', 't', 's', 'd')
  80 #define MP4_stts MP4_ID('s', 't', 't', 's')
  81 #define MP4_trak MP4_ID('t', 'r', 'a', 'k')
  82 #define MP4_trkn MP4_ID('t', 'r', 'k', 'n')
  83 #define MP4_udta MP4_ID('u', 'd', 't', 'a')
  84 #define MP4_extra MP4_ID('-', '-', '-', '-')
  85
  86 struct apetag_header
  87 {
  88     char id[8];
  89     long version;
  90     long length;
  91     long item_count;
  92     long flags;
  93     char reserved[8];
  94 };
  95
  96 struct apetag_item_header
  97 {
  98     long length;
  99     long flags;
 100 };
 101
 102 #if CONFIG_CODEC == SWCODEC
 103 static const unsigned short a52_bitrates[] =
 104 {
 105      32,  40,  48,  56,  64,  80,  96, 112, 128, 160,
 106     192, 224, 256, 320, 384, 448, 512, 576, 640
 107 };
 108
 109 /* Only store frame sizes for 44.1KHz - others are simply multiples
 110    of the bitrate */
 111 static const unsigned short a52_441framesizes[] =
 112 {
 113       69 * 2,   70 * 2,   87 * 2,   88 * 2,  104 * 2,  105 * 2,  121 * 2,
 114      122 * 2,  139 * 2,  140 * 2,  174 * 2,  175 * 2,  208 * 2,  209 * 2,
 115      243 * 2,  244 * 2,  278 * 2,  279 * 2,  348 * 2,  349 * 2,  417 * 2,
 116      418 * 2,  487 * 2,  488 * 2,  557 * 2,  558 * 2,  696 * 2,  697 * 2,
 117      835 * 2,  836 * 2,  975 * 2,  976 * 2, 1114 * 2, 1115 * 2, 1253 * 2,
 118     1254 * 2, 1393 * 2, 1394 * 2
 119 };
 120
 121 static const long wavpack_sample_rates [] =
 122 {
 123      6000,  8000,  9600, 11025, 12000, 16000,  22050, 24000,
 124     32000, 44100, 48000, 64000, 88200, 96000, 192000
 125 };
 126
 127 /* Read a string from the file. Read up to size bytes, or, if eos != -1,
 128  * until the eos character is found (eos is not stored in buf, unless it is
 129  * nil). Writes up to buf_size chars to buf, always terminating with a nil.
 130  * Returns number of chars read or -1 on read error.
 131  */
 132 static long read_string(int fd, char* buf, long buf_size, int eos, long size)
 133 {
 134     long read_bytes = 0;
 135     char c;
 136
 137     while (size != 0)
 138     {
 139         if (read(fd, &c, 1) != 1)
 140         {
 141             read_bytes = -1;
 142             break;
 143         }
 144
 145         read_bytes++;
 146         size--;
 147
 148         if ((eos != -1) && (eos == (unsigned char) c))
 149         {
 150             break;
 151         }
 152
 153         if (buf_size > 1)
 154         {
 155             *buf++ = c;
 156             buf_size--;
 157         }
 158     }
 159
 160     *buf = 0;
 161     return read_bytes;
 162 }
 163
 164 /* Read an unsigned 32-bit integer from a big-endian file. */
 165 #ifdef ROCKBOX_BIG_ENDIAN
 166 #define read_uint32be(fd,buf) read((fd), (buf), 4)
 167 #else
 168 static int read_uint32be(int fd, unsigned int* buf)
 169 {
 170   size_t n;
 171
 172   n = read(fd, (char*) buf, 4);
 173   *buf = betoh32(*buf);
 174   return n;
 175 }
 176 #endif
 177
 178 /* Read an unaligned 32-bit little endian long from buffer. */
 179 static unsigned long get_long_le(void* buf)
 180 {
 181     unsigned char* p = (unsigned char*) buf;
 182
 183     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
 184 }
 185
 186 /* Read an unaligned 32-bit big endian long from buffer. */
 187 static unsigned long get_long_be(void* buf)
 188 {
 189     unsigned char* p = (unsigned char*) buf;
 190
 191     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 192 }
 193
 194 /* Read an unaligned 32-bit little endian long from buffer. */
 195 static long get_slong(void* buf)
 196 {
 197     unsigned char* p = (unsigned char*) buf;
 198
 199     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
 200 }
 201
 202 /* Parse the tag (the name-value pair) and fill id3 and buffer accordingly.
 203  * String values to keep are written to buf. Returns number of bytes written
 204  * to buf (including end nil).
 205  */
 206 static long parse_tag(const char* name, char* value, struct mp3entry* id3,
 207     char* buf, long buf_remaining, enum tagtype type)
 208 {
 209     long len = 0;
 210     char** p;
 211
 212     if ((((strcasecmp(name, "track") == 0) && (type == TAGTYPE_APE)))
 213         || ((strcasecmp(name, "tracknumber") == 0) && (type == TAGTYPE_VORBIS)))
 214     {
 215         id3->tracknum = atoi(value);
 216         p = &(id3->track_string);
 217     }
 218     else if (((strcasecmp(name, "year") == 0) && (type == TAGTYPE_APE))
 219         || ((strcasecmp(name, "date") == 0) && (type == TAGTYPE_VORBIS)))
 220     {
 221         /* Date's can be in any format in Vorbis. However most of them
 222          * are in ISO8601 format so if we try and parse the first part
 223          * of the tag as a number, we should get the year. If we get crap,
 224          * then act like we never parsed it.
 225          */
 226         id3->year = atoi(value);
 227         if (id3->year < 1900)
 228         { /* yeah, not likely */
 229             id3->year = 0;
 230         }
 231         p = &(id3->year_string);
 232     }
 233     else if (strcasecmp(name, "title") == 0)
 234     {
 235         p = &(id3->title);
 236     }
 237     else if (strcasecmp(name, "artist") == 0)
 238     {
 239         p = &(id3->artist);
 240     }
 241     else if (strcasecmp(name, "album") == 0)
 242     {
 243         p = &(id3->album);
 244     }
 245     else if (strcasecmp(name, "genre") == 0)
 246     {
 247         p = &(id3->genre_string);
 248     }
 249     else if (strcasecmp(name, "composer") == 0)
 250     {
 251         p = &(id3->composer);
 252     }
 253     else if (strcasecmp(name, "comment") == 0)
 254     {
 255         p = &(id3->comment);
 256     }
 257     else if (strcasecmp(name, "albumartist") == 0)
 258     {
 259         p = &(id3->albumartist);
 260     }
 261     else if (strcasecmp(name, "album artist") == 0)
 262     {
 263         p = &(id3->albumartist);
 264     }
 265     else if (strcasecmp(name, "ensemble") == 0)
 266     {
 267         p = &(id3->albumartist);
 268     }
 269     else
 270     {
 271         len = parse_replaygain(name, value, id3, buf, buf_remaining);
 272         p = NULL;
 273     }
 274
 275     if (p)
 276     {
 277         len = strlen(value);
 278         len = MIN(len, buf_remaining - 1);
 279
 280         if (len > 0)
 281         {
 282             strncpy(buf, value, len);
 283             buf[len] = 0;
 284             *p = buf;
 285             len++;
 286         }
 287         else
 288         {
 289             len = 0;
 290         }
 291     }
 292
 293     return len;
 294 }
 295
 296 /* Read the items in an APEV2 tag. Only looks for a tag at the end of a
 297  * file. Returns true if a tag was found and fully read, false otherwise.
 298  */
 299 static bool read_ape_tags(int fd, struct mp3entry* id3)
 300 {
 301     struct apetag_header header;
 302
 303     if ((lseek(fd, -APETAG_HEADER_LENGTH, SEEK_END) < 0)
 304         || (ecread(fd, &header, 1, APETAG_HEADER_FORMAT, IS_BIG_ENDIAN) != APETAG_HEADER_LENGTH)
 305         || (memcmp(header.id, "APETAGEX", sizeof(header.id))))
 306     {
 307         return false;
 308     }
 309
 310     if ((header.version == 2000) && (header.item_count > 0)
 311         && (header.length > APETAG_HEADER_LENGTH))
 312     {
 313         char *buf = id3->id3v2buf;
 314         unsigned int buf_remaining = sizeof(id3->id3v2buf)
 315             + sizeof(id3->id3v1buf);
 316         unsigned int tag_remaining = header.length - APETAG_HEADER_LENGTH;
 317         int i;
 318
 319         if (lseek(fd, -header.length, SEEK_END) < 0)
 320         {
 321             return false;
 322         }
 323
 324         for (i = 0; i < header.item_count; i++)
 325         {
 326             struct apetag_item_header item;
 327             char name[TAG_NAME_LENGTH];
 328             char value[TAG_VALUE_LENGTH];
 329             long r;
 330
 331             if (tag_remaining < sizeof(item))
 332             {
 333                 break;
 334             }
 335
 336             if (ecread(fd, &item, 1, APETAG_ITEM_HEADER_FORMAT, IS_BIG_ENDIAN) < (long) sizeof(item))
 337             {
 338                 return false;
 339             }
 340
 341             tag_remaining -= sizeof(item);
 342             r = read_string(fd, name, sizeof(name), 0, tag_remaining);
 343
 344             if (r == -1)
 345             {
 346                 return false;
 347             }
 348
 349             tag_remaining -= r + item.length;
 350
 351             if ((item.flags & APETAG_ITEM_TYPE_MASK) == 0)
 352             {
 353                 long len;
 354
 355                 if (read_string(fd, value, sizeof(value), -1, item.length)
 356                     != item.length)
 357                 {
 358                     return false;
 359                 }
 360
 361                 len = parse_tag(name, value, id3, buf, buf_remaining,
 362                     TAGTYPE_APE);
 363                 buf += len;
 364                 buf_remaining -= len;
 365             }
 366             else
 367             {
 368                 if (lseek(fd, item.length, SEEK_CUR) < 0)
 369                 {
 370                     return false;
 371                 }
 372             }
 373         }
 374     }
 375
 376     return true;
 377 }
 378
 379 /* Read the items in a Vorbis comment packet. Returns true the items were
 380  * fully read, false otherwise.
 381  */
 382 static bool read_vorbis_tags(int fd, struct mp3entry *id3,
 383     long tag_remaining)
 384 {
 385     char *buf = id3->id3v2buf;
 386     long comment_count;
 387     long len;
 388     int buf_remaining = sizeof(id3->id3v2buf) + sizeof(id3->id3v1buf);
 389     int i;
 390
 391     if (ecread(fd, &len, 1, "l", IS_BIG_ENDIAN) < (long) sizeof(len))
 392     {
 393         return false;
 394     }
 395
 396     if ((lseek(fd, len, SEEK_CUR) < 0)
 397         || (ecread(fd, &comment_count, 1, "l", IS_BIG_ENDIAN)
 398             < (long) sizeof(comment_count)))
 399     {
 400         return false;
 401     }
 402
 403     tag_remaining -= len + sizeof(len) + sizeof(comment_count);
 404
 405     if (tag_remaining <= 0)
 406     {
 407         return true;
 408     }
 409
 410     for (i = 0; i < comment_count; i++)
 411     {
 412         char name[TAG_NAME_LENGTH];
 413         char value[TAG_VALUE_LENGTH];
 414         long read_len;
 415
 416         if (tag_remaining < 4)
 417         {
 418             break;
 419         }
 420
 421         if (ecread(fd, &len, 1, "l", IS_BIG_ENDIAN) < (long) sizeof(len))
 422         {
 423             return false;
 424         }
 425
 426         tag_remaining -= 4;
 427
 428         /* Quit if we've passed the end of the page */
 429         if (tag_remaining < len)
 430         {
 431             break;
 432         }
 433
 434         tag_remaining -= len;
 435         read_len = read_string(fd, name, sizeof(name), '=', len);
 436
 437         if (read_len < 0)
 438         {
 439             return false;
 440         }
 441
 442         len -= read_len;
 443
 444         if (read_string(fd, value, sizeof(value), -1, len) < 0)
 445         {
 446             return false;
 447         }
 448
 449         len = parse_tag(name, value, id3, buf, buf_remaining,
 450             TAGTYPE_VORBIS);
 451         buf += len;
 452         buf_remaining -= len;
 453     }
 454
 455     /* Skip to the end of the block */
 456     if (tag_remaining)
 457     {
 458         if (lseek(fd, tag_remaining, SEEK_CUR) < 0)
 459         {
 460             return false;
 461         }
 462     }
 463
 464     return true;
 465 }
 466
 467 /* Skip an ID3v2 tag if it can be found. We assume the tag is located at the
 468  * start of the file, which should be true in all cases where we need to skip it.
 469  * Returns true if successfully skipped or not skipped, and false if
 470  * something went wrong while skipping.
 471  */
 472 static bool skip_id3v2(int fd, struct mp3entry *id3)
 473 {
 474     char buf[4];
 475
 476     read(fd, buf, 4);
 477     if (memcmp(buf, "ID3", 3) == 0)
 478     {
 479         /* We have found an ID3v2 tag at the start of the file - find its
 480            length and then skip it. */
 481         if ((id3->first_frame_offset = getid3v2len(fd)) == 0)
 482             return false;
 483
 484         if ((lseek(fd, id3->first_frame_offset, SEEK_SET) < 0))
 485             return false;
 486
 487         return true;
 488     } else {
 489         lseek(fd, 0, SEEK_SET);
 490         id3->first_frame_offset = 0;
 491         return true;
 492     }
 493 }
 494
 495 /* A simple parser to read vital metadata from an Ogg Speex file. Returns
 496  * false if metadata needed by the Speex codec couldn't be read.
 497  */
 498
 499 static bool get_speex_metadata(int fd, struct mp3entry* id3)
 500 {
 501     /* An Ogg File is split into pages, each starting with the string
 502      * "OggS". Each page has a timestamp (in PCM samples) referred to as
 503      * the "granule position".
 504      *
 505      * An Ogg Speex has the following structure:
 506      * 1) Identification header (containing samplerate, numchannels, etc)
 507           Described in this page: (http://www.speex.org/manual2/node7.html)
 508      * 2) Comment header - containing the Vorbis Comments
 509      * 3) Many audio packets...
 510      */
 511
 512     /* Use the path name of the id3 structure as a temporary buffer. */
 513     unsigned char* buf = (unsigned char*)id3->path;
 514     long comment_size;
 515     long remaining = 0;
 516     long last_serial = 0;
 517     long serial, r;
 518     int segments;
 519     int i;
 520     bool eof = false;
 521
 522     if ((lseek(fd, 0, SEEK_SET) < 0) || (read(fd, buf, 58) < 33))
 523     {
 524         return false;
 525     }
 526
 527     if ((memcmp(buf, "OggS", 4) != 0) || (memcmp(&buf[28], "Speex", 5) != 0))
 528     {
 529         return false;
 530     }
 531
 532     /* We need to ensure the serial number from this page is the same as the
 533      * one from the last page (since we only support a single bitstream).
 534      */
 535     serial = get_long_le(&buf[14]);
 536     if ((lseek(fd, 33, SEEK_SET) < 0)||(read(fd, buf, 58) < 4))
 537     {
 538     return false;
 539     }
 540
 541     id3->frequency = get_slong(&buf[31]);
 542     last_serial = get_long_le(&buf[27]);/*temporary, header size*/
 543     id3->bitrate = get_long_le(&buf[47]);
 544     id3->vbr = get_long_le(&buf[55]);
 545     id3->filesize = filesize(fd);
 546     /* Comments are in second Ogg page */
 547     if (lseek(fd, 28+last_serial/*(temporary for header size)*/, SEEK_SET) < 0)
 548     {
 549     return false;
 550     }
 551
 552     /* Minimum header length for Ogg pages is 27. */
 553     if (read(fd, buf, 27) < 27)
 554     {
 555     return false;
 556     }
 557
 558     if (memcmp(buf, "OggS", 4) !=0 )
 559     {
 560     return false;
 561     }
 562
 563     segments = buf[26];
 564     /* read in segment table */
 565     if (read(fd, buf, segments) < segments)
 566     {
 567     return false;
 568     }
 569
 570     /* The second packet in a vorbis stream is the comment packet. It *may*
 571      * extend beyond the second page, but usually does not. Here we find the
 572      * length of the comment packet (or the rest of the page if the comment
 573      * packet extends to the third page).
 574      */
 575     for (i = 0; i < segments; i++)
 576     {
 577         remaining += buf[i];
 578         /* The last segment of a packet is always < 255 bytes */
 579         if (buf[i] < 255)
 580         {
 581               break;
 582         }
 583     }
 584
 585     comment_size = remaining;
 586
 587     /* Failure to read the tags isn't fatal. */
 588     read_vorbis_tags(fd, id3, remaining);
 589
 590     /* We now need to search for the last page in the file - identified by
 591      * by ('O','g','g','S',0) and retrieve totalsamples.
 592      */
 593
 594     /* A page is always < 64 kB */
 595     if (lseek(fd, -(MIN(64 * 1024, id3->filesize)), SEEK_END) < 0)
 596     {
 597     return false;
 598     }
 599
 600     remaining = 0;
 601
 602     while (!eof)
 603     {
 604         r = read(fd, &buf[remaining], MAX_PATH - remaining);
 605
 606         if (r <= 0)
 607         {
 608             eof = true;
 609         }
 610         else
 611         {
 612             remaining += r;
 613         }
 614
 615         /* Inefficient (but simple) search */
 616         i = 0;
 617
 618         while (i < (remaining - 3))
 619         {
 620             if ((buf[i] == 'O') && (memcmp(&buf[i], "OggS", 4) == 0))
 621             {
 622                 if (i < (remaining - 17))
 623                 {
 624                     /* Note that this only reads the low 32 bits of a
 625                      * 64 bit value.
 626                      */
 627                      id3->samples = get_long_le(&buf[i + 6]);
 628                      last_serial = get_long_le(&buf[i + 14]);
 629
 630                     /* If this page is very small the beginning of the next
 631                      * header could be in buffer. Jump near end of this header
 632                      * and continue */
 633                     i += 27;
 634                 }
 635                 else
 636                 {
 637                     break;
 638                 }
 639             }
 640             else
 641             {
 642                 i++;
 643             }
 644         }
 645
 646         if (i < remaining)
 647         {
 648             /* Move the remaining bytes to start of buffer.
 649              * Reuse var 'segments' as it is no longer needed */
 650             segments = 0;
 651             while (i < remaining)
 652             {
 653                 buf[segments++] = buf[i++];
 654             }
 655             remaining = segments;
 656         }
 657         else
 658         {
 659             /* Discard the rest of the buffer */
 660             remaining = 0;
 661         }
 662     }
 663
 664     /* This file has mutiple vorbis bitstreams (or is corrupt). */
 665     /* FIXME we should display an error here. */
 666     if (serial != last_serial)
 667     {
 668         logf("serialno mismatch");
 669         logf("%ld", serial);
 670         logf("%ld", last_serial);
 671     return false;
 672     }
 673
 674     id3->length = (id3->samples / id3->frequency) * 1000;
 675     id3->bitrate = (((int64_t) id3->filesize - comment_size) * 8) / id3->length;
 676     return true;
 677 }
 678
 679
 680 /* A simple parser to read vital metadata from an Ogg Vorbis file.
 681  * Calls get_speex_metadata if a speex file is identified. Returns
 682  * false if metadata needed by the Vorbis codec couldn't be read.
 683  */
 684 static bool get_vorbis_metadata(int fd, struct mp3entry* id3)
 685 {
 686     /* An Ogg File is split into pages, each starting with the string
 687      * "OggS". Each page has a timestamp (in PCM samples) referred to as
 688      * the "granule position".
 689      *
 690      * An Ogg Vorbis has the following structure:
 691      * 1) Identification header (containing samplerate, numchannels, etc)
 692      * 2) Comment header - containing the Vorbis Comments
 693      * 3) Setup header - containing codec setup information
 694      * 4) Many audio packets...
 695      */
 696
 697     /* Use the path name of the id3 structure as a temporary buffer. */
 698     unsigned char* buf = (unsigned char *)id3->path;
 699     long comment_size;
 700     long remaining = 0;
 701     long last_serial = 0;
 702     long serial, r;
 703     int segments;
 704     int i;
 705     bool eof = false;
 706
 707     if ((lseek(fd, 0, SEEK_SET) < 0) || (read(fd, buf, 58) < 4))
 708     {
 709         return false;
 710     }
 711
 712     if ((memcmp(buf, "OggS", 4) != 0) || (memcmp(&buf[29], "vorbis", 6) != 0))
 713     {
 714         if ((memcmp(buf, "OggS", 4) != 0) || (memcmp(&buf[28], "Speex", 5) != 0))
 715         {
 716             return false;
 717         }
 718         else
 719         {
 720             id3->codectype = AFMT_SPEEX;
 721             return get_speex_metadata(fd, id3);
 722         }
 723     }
 724
 725     /* We need to ensure the serial number from this page is the same as the
 726      * one from the last page (since we only support a single bitstream).
 727      */
 728     serial = get_long_le(&buf[14]);
 729     id3->frequency = get_long_le(&buf[40]);
 730     id3->filesize = filesize(fd);
 731
 732     /* Comments are in second Ogg page */
 733     if (lseek(fd, 58, SEEK_SET) < 0)
 734     {
 735         return false;
 736     }
 737
 738     /* Minimum header length for Ogg pages is 27. */
 739     if (read(fd, buf, 27) < 27)
 740     {
 741         return false;
 742     }
 743
 744     if (memcmp(buf, "OggS", 4) !=0 )
 745     {
 746         return false;
 747     }
 748
 749     segments = buf[26];
 750
 751     /* read in segment table */
 752     if (read(fd, buf, segments) < segments)
 753     {
 754         return false;
 755     }
 756
 757     /* The second packet in a vorbis stream is the comment packet. It *may*
 758      * extend beyond the second page, but usually does not. Here we find the
 759      * length of the comment packet (or the rest of the page if the comment
 760      * packet extends to the third page).
 761      */
 762     for (i = 0; i < segments; i++)
 763     {
 764         remaining += buf[i];
 765
 766         /* The last segment of a packet is always < 255 bytes */
 767         if (buf[i] < 255)
 768         {
 769               break;
 770         }
 771     }
 772
 773     /* Now read in packet header (type and id string) */
 774     if (read(fd, buf, 7) < 7)
 775     {
 776         return false;
 777     }
 778
 779     comment_size = remaining;
 780     remaining -= 7;
 781
 782     /* The first byte of a packet is the packet type; comment packets are
 783      * type 3.
 784      */
 785     if ((buf[0] != 3) || (memcmp(buf + 1, "vorbis", 6) !=0))
 786     {
 787         return false;
 788     }
 789
 790     /* Failure to read the tags isn't fatal. */
 791     read_vorbis_tags(fd, id3, remaining);
 792
 793     /* We now need to search for the last page in the file - identified by
 794      * by ('O','g','g','S',0) and retrieve totalsamples.
 795      */
 796
 797     /* A page is always < 64 kB */
 798     if (lseek(fd, -(MIN(64 * 1024, id3->filesize)), SEEK_END) < 0)
 799     {
 800         return false;
 801     }
 802
 803     remaining = 0;
 804
 805     while (!eof)
 806     {
 807         r = read(fd, &buf[remaining], MAX_PATH - remaining);
 808
 809         if (r <= 0)
 810         {
 811             eof = true;
 812         }
 813         else
 814         {
 815             remaining += r;
 816         }
 817
 818         /* Inefficient (but simple) search */
 819         i = 0;
 820
 821         while (i < (remaining - 3))
 822         {
 823             if ((buf[i] == 'O') && (memcmp(&buf[i], "OggS", 4) == 0))
 824             {
 825                 if (i < (remaining - 17))
 826                 {
 827                     /* Note that this only reads the low 32 bits of a
 828                      * 64 bit value.
 829                      */
 830                      id3->samples = get_long_le(&buf[i + 6]);
 831                      last_serial = get_long_le(&buf[i + 14]);
 832
 833                     /* If this page is very small the beginning of the next
 834                      * header could be in buffer. Jump near end of this header
 835                      * and continue */
 836                     i += 27;
 837                 }
 838                 else
 839                 {
 840                     break;
 841                 }
 842             }
 843             else
 844             {
 845                 i++;
 846             }
 847         }
 848
 849         if (i < remaining)
 850         {
 851             /* Move the remaining bytes to start of buffer.
 852              * Reuse var 'segments' as it is no longer needed */
 853             segments = 0;
 854             while (i < remaining)
 855             {
 856                 buf[segments++] = buf[i++];
 857             }
 858             remaining = segments;
 859         }
 860         else
 861         {
 862             /* Discard the rest of the buffer */
 863             remaining = 0;
 864         }
 865     }
 866
 867     /* This file has mutiple vorbis bitstreams (or is corrupt). */
 868     /* FIXME we should display an error here. */
 869     if (serial != last_serial)
 870     {
 871         logf("serialno mismatch");
 872         logf("%ld", serial);
 873         logf("%ld", last_serial);
 874         return false;
 875     }
 876
 877     id3->length = ((int64_t) id3->samples * 1000) / id3->frequency;
 878
 879     if (id3->length <= 0)
 880     {
 881         logf("ogg length invalid!");
 882         return false;
 883     }
 884
 885     id3->bitrate = (((int64_t) id3->filesize - comment_size) * 8) / id3->length;
 886     id3->vbr = true;
 887
 888     return true;
 889 }
 890
 891 static bool get_flac_metadata(int fd, struct mp3entry* id3)
 892 {
 893     /* A simple parser to read vital metadata from a FLAC file - length,
 894      * frequency, bitrate etc. This code should either be moved to a
 895      * seperate file, or discarded in favour of the libFLAC code.
 896      * The FLAC stream specification can be found at
 897      * http://flac.sourceforge.net/format.html#stream
 898      */
 899
 900     /* Use the trackname part of the id3 structure as a temporary buffer */
 901     unsigned char* buf = (unsigned char *)id3->path;
 902     bool rc = false;
 903
 904     if (!skip_id3v2(fd, id3) || (read(fd, buf, 4) < 4))
 905     {
 906         return rc;
 907     }
 908
 909     if (memcmp(buf, "fLaC", 4) != 0)
 910     {
 911         return rc;
 912     }
 913
 914     while (true)
 915     {
 916         long i;
 917
 918         if (read(fd, buf, 4) < 0)
 919         {
 920             return rc;
 921         }
 922
 923         /* The length of the block */
 924         i = (buf[1] << 16) | (buf[2] << 8) | buf[3];
 925
 926         if ((buf[0] & 0x7f) == 0)       /* 0 is the STREAMINFO block */
 927         {
 928             unsigned long totalsamples;
 929
 930             /* FIXME: Don't trust the value of i */
 931             if (read(fd, buf, i) < 0)
 932             {
 933                 return rc;
 934             }
 935
 936             id3->vbr = true;   /* All FLAC files are VBR */
 937             id3->filesize = filesize(fd);
 938             id3->frequency = (buf[10] << 12) | (buf[11] << 4)
 939                 | ((buf[12] & 0xf0) >> 4);
 940             rc = true;  /* Got vital metadata */
 941
 942             /* totalsamples is a 36-bit field, but we assume <= 32 bits are used */
 943             totalsamples = get_long_be(&buf[14]);
 944
 945             /* Calculate track length (in ms) and estimate the bitrate (in kbit/s) */
 946             id3->length = ((int64_t) totalsamples * 1000) / id3->frequency;
 947
 948             if (id3->length <= 0)
 949             {
 950                 logf("flac length invalid!");
 951                 return false;
 952             }
 953
 954             id3->bitrate = (id3->filesize * 8) / id3->length;
 955         }
 956         else if ((buf[0] & 0x7f) == 4)  /* 4 is the VORBIS_COMMENT block */
 957         {
 958             /* The next i bytes of the file contain the VORBIS COMMENTS. */
 959             if (!read_vorbis_tags(fd, id3, i))
 960             {
 961                 return rc;
 962             }
 963         }
 964         else
 965         {
 966             if (buf[0] & 0x80)
 967             {
 968                 /* If we have reached the last metadata block, abort. */
 969                 break;
 970             }
 971             else
 972             {
 973                 /* Skip to next metadata block */
 974                 if (lseek(fd, i, SEEK_CUR) < 0)
 975                 {
 976                     return rc;
 977                 }
 978             }
 979         }
 980     }
 981
 982     return true;
 983 }
 984
 985 static bool get_wave_metadata(int fd, struct mp3entry* id3)
 986 {
 987     /* Use the trackname part of the id3 structure as a temporary buffer */
 988     unsigned char* buf = (unsigned char *)id3->path;
 989     unsigned long totalsamples = 0;
 990     unsigned long channels = 0;
 991     unsigned long bitspersample = 0;
 992     unsigned long numbytes = 0;
 993     int read_bytes;
 994     int i;
 995
 996     /* get RIFF chunk header */
 997     if ((lseek(fd, 0, SEEK_SET) < 0)
 998         || ((read_bytes = read(fd, buf, 12)) < 12))
 999     {
1000         return false;
1001     }
1002
1003     if ((memcmp(buf, "RIFF",4) != 0)
1004         || (memcmp(&buf[8], "WAVE", 4) !=0 ))
1005     {
1006         return false;
1007     }
1008
1009     /* iterate over WAVE chunks until 'data' chunk */
1010     while (true)
1011     {
1012         /* get chunk header */
1013         if ((read_bytes = read(fd, buf, 8)) < 8)
1014             return false;
1015
1016         /* chunkSize */
1017         i = get_long_le(&buf[4]);
1018
1019         if (memcmp(buf, "fmt ", 4) == 0)
1020         {
1021             /* get rest of chunk */
1022             if ((read_bytes = read(fd, buf, 16)) < 16)
1023                 return false;
1024
1025             i -= 16;
1026
1027             /* skipping wFormatTag */
1028             /* wChannels */
1029             channels = buf[2] | (buf[3] << 8);
1030             /* dwSamplesPerSec */
1031             id3->frequency = get_long_le(&buf[4]);
1032             /* dwAvgBytesPerSec */
1033             id3->bitrate = (get_long_le(&buf[8]) * 8) / 1000;
1034             /* skipping wBlockAlign */
1035             /* wBitsPerSample */
1036             bitspersample = buf[14] | (buf[15] << 8);
1037         }
1038         else if (memcmp(buf, "data", 4) == 0)
1039         {
1040             numbytes = i;
1041             break;
1042         }
1043         else if (memcmp(buf, "fact", 4) == 0)
1044         {
1045             /* dwSampleLength */
1046             if (i >= 4)
1047             {
1048                 /* get rest of chunk */
1049                 if ((read_bytes = read(fd, buf, 2)) < 2)
1050                     return false;
1051
1052                 i -= 2;
1053                 totalsamples = get_long_le(buf);
1054             }
1055         }
1056
1057         /* seek to next chunk (even chunk sizes must be padded) */
1058         if (i & 0x01)
1059             i++;
1060
1061         if(lseek(fd, i, SEEK_CUR) < 0)
1062             return false;
1063     }
1064
1065     if ((numbytes == 0) || (channels == 0))
1066     {
1067         return false;
1068     }
1069
1070     if (totalsamples == 0)
1071     {
1072         /* for PCM only */
1073         totalsamples = numbytes
1074             / ((((bitspersample - 1) / 8) + 1) * channels);
1075     }
1076
1077     id3->vbr = false;   /* All WAV files are CBR */
1078     id3->filesize = filesize(fd);
1079
1080     /* Calculate track length (in ms) and estimate the bitrate (in kbit/s) */
1081     id3->length = ((int64_t) totalsamples * 1000) / id3->frequency;
1082
1083     return true;
1084 }
1085
1086 /* Read the tag data from an MP4 file, storing up to buffer_size bytes in
1087  * buffer.
1088  */
1089 static unsigned long read_mp4_tag(int fd, unsigned int size_left, char* buffer,
1090                                   unsigned int buffer_left)
1091 {
1092     unsigned int bytes_read = 0;
1093
1094     if (buffer_left == 0)
1095     {
1096         lseek(fd, size_left, SEEK_CUR);     /* Skip everything */
1097     }
1098     else
1099     {
1100         /* Skip the data tag header - maybe we should parse it properly? */
1101         lseek(fd, 16, SEEK_CUR);
1102         size_left -= 16;
1103
1104         if (size_left > buffer_left)
1105         {
1106             read(fd, buffer, buffer_left);
1107             lseek(fd, size_left - buffer_left, SEEK_CUR);
1108             bytes_read = buffer_left;
1109         }
1110         else
1111         {
1112             read(fd, buffer, size_left);
1113             bytes_read = size_left;
1114         }
1115     }
1116
1117     return bytes_read;
1118 }
1119
1120 /* Read a string tag from an MP4 file */
1121 static unsigned int read_mp4_tag_string(int fd, int size_left, char** buffer,
1122                                         unsigned int* buffer_left, char** dest)
1123 {
1124     unsigned int bytes_read = read_mp4_tag(fd, size_left, *buffer,
1125         *buffer_left - 1);
1126     unsigned int length = 0;
1127
1128     if (bytes_read)
1129     {
1130         (*buffer)[bytes_read] = 0;
1131         *dest = *buffer;
1132         length = strlen(*buffer) + 1;
1133         *buffer_left -= length;
1134         *buffer += length;
1135     }
1136     else
1137     {
1138         *dest = NULL;
1139     }
1140
1141     return length;
1142 }
1143
1144 static unsigned int read_mp4_atom(int fd, unsigned int* size,
1145                                   unsigned int* type, unsigned int size_left)
1146 {
1147     read_uint32be(fd, size);
1148     read_uint32be(fd, type);
1149
1150     if (*size == 1)
1151     {
1152         /* FAT32 doesn't support files this big, so something seems to
1153          * be wrong. (64-bit sizes should only be used when required.)
1154          */
1155         errno = EFBIG;
1156         *type = 0;
1157         return 0;
1158     }
1159
1160     if (*size > 0)
1161     {
1162         if (*size > size_left)
1163         {
1164             size_left = 0;
1165         }
1166         else
1167         {
1168             size_left -= *size;
1169         }
1170
1171         *size -= 8;
1172     }
1173     else
1174     {
1175         *size = size_left;
1176         size_left = 0;
1177     }
1178
1179     return size_left;
1180 }
1181
1182 static unsigned int read_mp4_length(int fd, unsigned int* size)
1183 {
1184     unsigned int length = 0;
1185     int bytes = 0;
1186     unsigned char c;
1187
1188     do
1189     {
1190         read(fd, &c, 1);
1191         bytes++;
1192         (*size)--;
1193         length = (length << 7) | (c & 0x7F);
1194     }
1195     while ((c & 0x80) && (bytes < 4) && (*size > 0));
1196
1197     return length;
1198 }
1199
1200 static bool read_mp4_esds(int fd, struct mp3entry* id3,
1201     unsigned int* size)
1202 {
1203     unsigned char buf[8];
1204     bool sbr = false;
1205
1206     lseek(fd, 4, SEEK_CUR);     /* Version and flags. */
1207     read(fd, buf, 1);           /* Verify ES_DescrTag. */
1208     *size -= 5;
1209
1210     if (*buf == 3)
1211     {
1212         /* read length */
1213         if (read_mp4_length(fd, size) < 20)
1214         {
1215             return sbr;
1216         }
1217
1218         lseek(fd, 3, SEEK_CUR);
1219         *size -= 3;
1220     }
1221     else
1222     {
1223         lseek(fd, 2, SEEK_CUR);
1224         *size -= 2;
1225     }
1226
1227     read(fd, buf, 1);           /* Verify DecoderConfigDescrTab. */
1228     *size -= 1;
1229
1230     if (*buf != 4)
1231     {
1232         return sbr;
1233     }
1234
1235     if (read_mp4_length(fd, size) < 13)
1236     {
1237         return sbr;
1238     }
1239
1240     lseek(fd, 13, SEEK_CUR);    /* Skip audio type, bit rates, etc. */
1241     read(fd, buf, 1);
1242     *size -= 14;
1243
1244     if (*buf != 5)              /* Verify DecSpecificInfoTag. */
1245     {
1246         return sbr;
1247     }
1248
1249     {
1250         static const int sample_rates[] =
1251         {
1252             96000, 88200, 64000, 48000, 44100, 32000,
1253             24000, 22050, 16000, 12000, 11025, 8000
1254         };
1255         unsigned long bits;
1256         unsigned int length;
1257         unsigned int index;
1258         int type;
1259
1260         /* Read the (leading part of the) decoder config. */
1261         length = read_mp4_length(fd, size);
1262         length = MIN(length, *size);
1263         length = MIN(length, sizeof(buf));
1264         read(fd, buf, length);
1265         *size -= length;
1266
1267         /* Decoder config format:
1268          * Object type           - 5 bits
1269          * Frequency index       - 4 bits
1270          * Channel configuration - 4 bits
1271          */
1272         bits = get_long_be(buf);
1273         type = bits >> 27;
1274         index = (bits >> 23) & 0xf;
1275
1276         if (index < (sizeof(sample_rates) / sizeof(*sample_rates)))
1277         {
1278             id3->frequency = sample_rates[index];
1279         }
1280
1281         if (type == 5)
1282         {
1283             sbr = true;
1284             /* Extended frequency index - 4 bits */
1285             index = (bits >> 15) & 0xf;
1286
1287             if (index == 15)
1288             {
1289                 /* 17 bits read so far... */
1290                 bits = get_long_be(&buf[2]);
1291                 id3->frequency = (bits >> 7) & 0x00FFFFFF;
1292             }
1293             else if (index < (sizeof(sample_rates) / sizeof(*sample_rates)))
1294             {
1295                 id3->frequency = sample_rates[index];
1296             }
1297         }
1298         else if (id3->frequency < 24000)
1299         {
1300             /* SBR not indicated, but the file might still contain SBR.
1301              * MPEG specification says that one should assume SBR if
1302              * samplerate <= 24000 Hz.
1303              */
1304             id3->frequency *= 2;
1305             sbr = true;
1306         }
1307     }
1308
1309     return sbr;
1310 }
1311
1312 static bool read_mp4_tags(int fd, struct mp3entry* id3,
1313                           unsigned int size_left)
1314 {
1315     unsigned int size;
1316     unsigned int type;
1317     unsigned int buffer_left = sizeof(id3->id3v2buf) + sizeof(id3->id3v1buf);
1318     char* buffer = id3->id3v2buf;
1319     bool cwrt = false;
1320
1321     do
1322     {
1323         size_left = read_mp4_atom(fd, &size, &type, size_left);
1324
1325         /* DEBUGF("Tag atom: '%c%c%c%c' (%d bytes left)\n", type >> 24 & 0xff,
1326             type >> 16 & 0xff, type >> 8 & 0xff, type & 0xff, size); */
1327
1328         switch (type)
1329         {
1330         case MP4_cnam:
1331             read_mp4_tag_string(fd, size, &buffer, &buffer_left,
1332                 &id3->title);
1333             break;
1334
1335         case MP4_cART:
1336             read_mp4_tag_string(fd, size, &buffer, &buffer_left,
1337                 &id3->artist);
1338             break;
1339
1340         case MP4_calb:
1341             read_mp4_tag_string(fd, size, &buffer, &buffer_left,
1342                 &id3->album);
1343             break;
1344
1345         case MP4_cwrt:
1346             read_mp4_tag_string(fd, size, &buffer, &buffer_left,
1347                 &id3->composer);
1348             cwrt = false;
1349             break;
1350
1351         case MP4_gnre:
1352             {
1353                 unsigned short genre;
1354
1355                 read_mp4_tag(fd, size, (char*) &genre, sizeof(genre));
1356                 id3->genre_string = id3_get_num_genre(betoh16(genre) - 1);
1357             }
1358             break;
1359
1360         case MP4_trkn:
1361             {
1362                 unsigned short n[2];
1363
1364                 read_mp4_tag(fd, size, (char*) &n, sizeof(n));
1365                 id3->tracknum = betoh16(n[1]);
1366             }
1367             break;
1368
1369         case MP4_extra:
1370             {
1371                 char tag_name[TAG_NAME_LENGTH];
1372                 unsigned int sub_size;
1373
1374                 /* "mean" atom */
1375                 read_uint32be(fd, &sub_size);
1376                 size -= sub_size;
1377                 lseek(fd, sub_size - 4, SEEK_CUR);
1378                 /* "name" atom */
1379                 read_uint32be(fd, &sub_size);
1380                 size -= sub_size;
1381                 lseek(fd, 8, SEEK_CUR);
1382                 sub_size -= 12;
1383
1384                 if (sub_size > sizeof(tag_name) - 1)
1385                 {
1386                     read(fd, tag_name, sizeof(tag_name) - 1);
1387                     lseek(fd, sub_size - sizeof(tag_name) - 1, SEEK_CUR);
1388                     tag_name[sizeof(tag_name) - 1] = 0;
1389                 }
1390                 else
1391                 {
1392                     read(fd, tag_name, sub_size);
1393                     tag_name[sub_size] = 0;
1394                 }
1395
1396                 if ((strcasecmp(tag_name, "composer") == 0) && !cwrt)
1397                 {
1398                     read_mp4_tag_string(fd, size, &buffer, &buffer_left,
1399                         &id3->composer);
1400                 }
1401                 else
1402                 {
1403                     char* any;
1404                     unsigned int length = read_mp4_tag_string(fd, size,
1405                         &buffer, &buffer_left, &any);
1406
1407                     if (length > 0)
1408                     {
1409                         /* Re-use the read buffer as the dest buffer... */
1410                         buffer -= length;
1411                         buffer_left += length;
1412
1413                         if (parse_replaygain(tag_name, buffer, id3,
1414                             buffer, buffer_left) > 0)
1415                         {
1416                             /* Data used, keep it. */
1417                             buffer += length;
1418                             buffer_left -= length;
1419                         }
1420                     }
1421                 }
1422             }
1423             break;
1424
1425         default:
1426             lseek(fd, size, SEEK_CUR);
1427             break;
1428         }
1429     }
1430     while ((size_left > 0) && (errno == 0));
1431
1432     return true;
1433 }
1434
1435 static bool read_mp4_container(int fd, struct mp3entry* id3,
1436                                unsigned int size_left)
1437 {
1438     unsigned int size;
1439     unsigned int type;
1440     unsigned int handler = 0;
1441     bool rc = true;
1442
1443     do
1444     {
1445         size_left = read_mp4_atom(fd, &size, &type, size_left);
1446
1447         /* DEBUGF("Atom: '%c%c%c%c' (0x%08x, %d bytes left)\n",
1448             (type >> 24) & 0xff, (type >> 16) & 0xff, (type >> 8) & 0xff,
1449             type & 0xff, type, size); */
1450
1451         switch (type)
1452         {
1453         case MP4_ftyp:
1454             {
1455                 unsigned int id;
1456
1457                 read_uint32be(fd, &id);
1458                 size -= 4;
1459
1460                 if ((id != MP4_M4A) && (id != MP4_M4B) && (id != MP4_mp42)
1461                     && (id != MP4_qt) && (id != MP4_3gp6))
1462                 {
1463                     DEBUGF("Unknown MP4 file type: '%c%c%c%c'\n",
1464                         id >> 24 & 0xff, id >> 16 & 0xff, id >> 8 & 0xff,
1465                         id & 0xff);
1466                     return false;
1467                 }
1468             }
1469             break;
1470
1471         case MP4_meta:
1472             lseek(fd, 4, SEEK_CUR);  /* Skip version */
1473             size -= 4;
1474             /* Fall through */
1475
1476         case MP4_moov:
1477         case MP4_udta:
1478         case MP4_mdia:
1479         case MP4_stbl:
1480         case MP4_trak:
1481             rc = read_mp4_container(fd, id3, size);
1482             size = 0;
1483             break;
1484
1485         case MP4_ilst:
1486             if (handler == MP4_mdir)
1487             {
1488                 rc = read_mp4_tags(fd, id3, size);
1489                 size = 0;
1490             }
1491             break;
1492
1493         case MP4_minf:
1494             if (handler == MP4_soun)
1495             {
1496                 rc = read_mp4_container(fd, id3, size);
1497                 size = 0;
1498             }
1499             break;
1500
1501         case MP4_stsd:
1502             lseek(fd, 8, SEEK_CUR);
1503             size -= 8;
1504             rc = read_mp4_container(fd, id3, size);
1505             size = 0;
1506             break;
1507
1508         case MP4_hdlr:
1509             lseek(fd, 8, SEEK_CUR);
1510             read_uint32be(fd, &handler);
1511             size -= 12;
1512             /* DEBUGF("    Handler '%c%c%c%c'\n", handler >> 24 & 0xff,
1513                 handler >> 16 & 0xff, handler >> 8 & 0xff,handler & 0xff); */
1514             break;
1515
1516         case MP4_stts:
1517             {
1518                 unsigned int entries;
1519                 unsigned int i;
1520
1521                 lseek(fd, 4, SEEK_CUR);
1522                 read_uint32be(fd, &entries);
1523                 id3->samples = 0;
1524
1525                 for (i = 0; i < entries; i++)
1526                 {
1527                     unsigned int n;
1528                     unsigned int l;
1529
1530                     read_uint32be(fd, &n);
1531                     read_uint32be(fd, &l);
1532                     id3->samples += n * l;
1533                 }
1534
1535                 size = 0;
1536             }
1537             break;
1538
1539         case MP4_mp4a:
1540         case MP4_alac:
1541             {
1542                 unsigned int frequency;
1543
1544                 id3->codectype = (type == MP4_mp4a) ? AFMT_AAC : AFMT_ALAC;
1545                 lseek(fd, 22, SEEK_CUR);
1546                 read_uint32be(fd, &frequency);
1547                 size -= 26;
1548                 id3->frequency = frequency;
1549
1550                 if (type == MP4_mp4a)
1551                 {
1552                     unsigned int subsize;
1553                     unsigned int subtype;
1554
1555                     /* Get frequency from the decoder info tag, if possible. */
1556                     lseek(fd, 2, SEEK_CUR);
1557                     /* The esds atom is a part of the mp4a atom, so ignore
1558                      * the returned size (it's already accounted for).
1559                      */
1560                     read_mp4_atom(fd, &subsize, &subtype, size);
1561                     size -= 10;
1562
1563                     if (subtype == MP4_esds)
1564                     {
1565                         read_mp4_esds(fd, id3, &size);
1566                     }
1567                 }
1568             }
1569             break;
1570
1571         case MP4_mdat:
1572             id3->filesize = size;
1573             break;
1574
1575         default:
1576             break;
1577         }
1578
1579         lseek(fd, size, SEEK_CUR);
1580     }
1581     while (rc && (size_left > 0) && (errno == 0) && (id3->filesize == 0));
1582     /* Break on non-zero filesize, since Rockbox currently doesn't support
1583      * metadata after the mdat atom (which sets the filesize field).
1584      */
1585
1586     return rc;
1587 }
1588
1589 static bool get_mp4_metadata(int fd, struct mp3entry* id3)
1590 {
1591     id3->codectype = AFMT_UNKNOWN;
1592     id3->filesize = 0;
1593     errno = 0;
1594
1595     if (read_mp4_container(fd, id3, filesize(fd)) && (errno == 0)
1596         && (id3->samples > 0) && (id3->frequency > 0)
1597         && (id3->filesize > 0))
1598     {
1599         if (id3->codectype == AFMT_UNKNOWN)
1600         {
1601             logf("Not an ALAC or AAC file");
1602             return false;
1603         }
1604
1605         id3->length = ((int64_t) id3->samples * 1000) / id3->frequency;
1606
1607         if (id3->length <= 0)
1608         {
1609             logf("mp4 length invalid!");
1610             return false;
1611         }
1612
1613         id3->bitrate = ((int64_t) id3->filesize * 8) / id3->length;
1614         DEBUGF("MP4 bitrate %d, frequency %ld Hz, length %ld ms\n",
1615             id3->bitrate, id3->frequency, id3->length);
1616     }
1617     else
1618     {
1619         logf("MP4 metadata error");
1620         DEBUGF("MP4 metadata error. errno %d, length %ld, frequency %ld, filesize %ld\n",
1621             errno, id3->length, id3->frequency, id3->filesize);
1622         return false;
1623     }
1624
1625     return true;
1626 }
1627
1628 static bool get_musepack_metadata(int fd, struct mp3entry *id3)
1629 {
1630     const int32_t sfreqs_sv7[4] = { 44100, 48000, 37800, 32000 };
1631     uint32_t header[8];
1632     uint64_t samples = 0;
1633     int i;
1634
1635     if (!skip_id3v2(fd, id3))
1636         return false;
1637     if (read(fd, header, 4*8) != 4*8) return false;
1638     /* Musepack files are little endian, might need swapping */
1639     for (i = 1; i < 8; i++)
1640        header[i] = letoh32(header[i]);
1641     if (!memcmp(header, "MP+", 3)) { /* Compare to sig "MP+" */
1642         unsigned int streamversion;
1643
1644         header[0] = letoh32(header[0]);
1645         streamversion = (header[0] >> 24) & 15;
1646         if (streamversion >= 8) {
1647             return false; /* SV8 or higher don't exist yet, so no support */
1648         } else if (streamversion == 7) {
1649             unsigned int gapless = (header[5] >> 31) & 0x0001;
1650             unsigned int last_frame_samples = (header[5] >> 20) & 0x07ff;
1651             int track_gain, album_gain;
1652             unsigned int bufused;
1653
1654             id3->frequency = sfreqs_sv7[(header[2] >> 16) & 0x0003];
1655             samples = (uint64_t)header[1]*1152; /* 1152 is mpc frame size */
1656             if (gapless)
1657                 samples -= 1152 - last_frame_samples;
1658             else
1659                 samples -= 481; /* Musepack subband synth filter delay */
1660
1661             /* Extract ReplayGain data from header */
1662             track_gain = (int16_t)((header[3] >> 16) & 0xffff);
1663             id3->track_gain = get_replaygain_int(track_gain);
1664             id3->track_peak = ((uint16_t)(header[3] & 0xffff)) << 9;
1665
1666             album_gain = (int16_t)((header[4] >> 16) & 0xffff);
1667             id3->album_gain = get_replaygain_int(album_gain);
1668             id3->album_peak = ((uint16_t)(header[4] & 0xffff)) << 9;
1669
1670             /* Write replaygain values to strings for use in id3 screen. We use
1671                the XING header as buffer space since Musepack files shouldn't
1672                need to use it in any other way */
1673             id3->track_gain_string = (char *)id3->toc;
1674             bufused = snprintf(id3->track_gain_string, 45,
1675                                "%d.%d dB", track_gain/100, abs(track_gain)%100);
1676             id3->album_gain_string = (char *)id3->toc + bufused + 1;
1677             bufused = snprintf(id3->album_gain_string, 45,
1678                                "%d.%d dB", album_gain/100, abs(album_gain)%100);
1679         }
1680     } else {
1681         header[0] = letoh32(header[0]);
1682         unsigned int streamversion = (header[0] >> 11) & 0x03FF;
1683         if (streamversion != 4 && streamversion != 5 && streamversion != 6)
1684             return false;
1685         id3->frequency = 44100;
1686         id3->track_gain = 0;
1687         id3->track_peak = 0;
1688         id3->album_gain = 0;
1689         id3->album_peak = 0;
1690
1691         if (streamversion >= 5)
1692             samples = (uint64_t)header[1]*1152; // 32 bit
1693         else
1694             samples = (uint64_t)(header[1] >> 16)*1152; // 16 bit
1695
1696         samples -= 576;
1697         if (streamversion < 6)
1698             samples -= 1152;
1699     }
1700
1701     id3->vbr = true;
1702     /* Estimate bitrate, we should probably subtract the various header sizes
1703        here for super-accurate results */
1704     id3->length = ((int64_t) samples * 1000) / id3->frequency;
1705
1706     if (id3->length <= 0)
1707     {
1708         logf("mpc length invalid!");
1709         return false;
1710     }
1711
1712     id3->filesize = filesize(fd);
1713     id3->bitrate = id3->filesize * 8 / id3->length;
1714     return true;
1715 }
1716
1717 /* PSID metadata info is available here:
1718    http://www.unusedino.de/ec64/technical/formats/sidplay.html */
1719 static bool get_sid_metadata(int fd, struct mp3entry* id3)
1720 {
1721     /* Use the trackname part of the id3 structure as a temporary buffer */
1722     unsigned char* buf = (unsigned char *)id3->path;
1723     int read_bytes;
1724     char *p;
1725
1726
1727     if ((lseek(fd, 0, SEEK_SET) < 0)
1728          || ((read_bytes = read(fd, buf, 0x80)) < 0x80))
1729     {
1730         return false;
1731     }
1732
1733     if ((memcmp(buf, "PSID",4) != 0))
1734     {
1735         return false;
1736     }
1737
1738     p = id3->id3v2buf;
1739
1740     /* Copy Title (assumed max 0x1f letters + 1 zero byte) */
1741     id3->title = p;
1742     buf[0x16+0x1f] = 0;
1743     p = iso_decode(&buf[0x16], p, 0, strlen(&buf[0x16])+1);
1744
1745     /* Copy Artist (assumed max 0x1f letters + 1 zero byte) */
1746     id3->artist = p;
1747     buf[0x36+0x1f] = 0;
1748     p = iso_decode(&buf[0x36], p, 0, strlen(&buf[0x36])+1);
1749
1750     /* Copy Year (assumed max 4 letters + 1 zero byte) */
1751     buf[0x56+0x4] = 0;
1752     id3->year = atoi(&buf[0x56]);
1753
1754     /* Copy Album (assumed max 0x1f-0x05 letters + 1 zero byte) */
1755     id3->album = p;
1756     buf[0x56+0x1f] = 0;
1757     p = iso_decode(&buf[0x5b], p, 0, strlen(&buf[0x5b])+1);
1758
1759     id3->bitrate = 706;
1760     id3->frequency = 44100;
1761     /* New idea as posted by Marco Alanen (ravon):
1762      * Set the songlength in seconds to the number of subsongs
1763      * so every second represents a subsong.
1764      * Users can then skip the current subsong by seeking
1765      *
1766      * Note: the number of songs is a 16bit value at 0xE, so this code only
1767      * uses the lower 8 bits of the counter.
1768     */
1769     id3->length = (buf[0xf]-1)*1000;
1770     id3->vbr = false;
1771     id3->filesize = filesize(fd);
1772
1773     return true;
1774 }
1775
1776 static bool get_adx_metadata(int fd, struct mp3entry* id3)
1777 {
1778     /* Use the trackname part of the id3 structure as a temporary buffer */
1779     unsigned char * buf = (unsigned char *)id3->path;
1780     int chanstart, channels, read_bytes;
1781     int looping = 0, start_adr = 0, end_adr = 0;
1782
1783     /* try to get the basic header */
1784     if ((lseek(fd, 0, SEEK_SET) < 0)
1785         || ((read_bytes = read(fd, buf, 0x38)) < 0x38))
1786     {
1787         DEBUGF("lseek or read failed\n");
1788         return false;
1789     }
1790
1791     /* ADX starts with 0x80 */
1792     if (buf[0] != 0x80) {
1793         DEBUGF("get_adx_metadata: wrong first byte %c\n",buf[0]);
1794         return false;
1795     }
1796
1797     /* check for a reasonable offset */
1798     chanstart = ((buf[2] << 8) | buf[3]) + 4;
1799     if (chanstart > 4096) {
1800         DEBUGF("get_adx_metadata: bad chanstart %i\n", chanstart);
1801         return false;
1802     }
1803
1804     /* check for a workable number of channels */
1805     channels = buf[7];
1806     if (channels != 1 && channels != 2) {
1807         DEBUGF("get_adx_metadata: bad channel count %i\n",channels);
1808         return false;
1809     }
1810
1811     id3->frequency = get_long_be(&buf[8]);
1812     /* 32 samples per 18 bytes */
1813     id3->bitrate = id3->frequency * channels * 18 * 8 / 32 / 1000;
1814     id3->length = get_long_be(&buf[12]) / id3->frequency * 1000;
1815     id3->vbr = false;
1816     id3->filesize = filesize(fd);
1817
1818     /* get loop info */
1819     if (!memcmp(buf+0x10,"\x01\xF4\x03\x00",4)) {
1820         /* Soul Calibur 2 style (type 03) */
1821         DEBUGF("get_adx_metadata: type 03 found\n");
1822         /* check if header is too small for loop data */
1823         if (chanstart-6 < 0x2c) looping=0;
1824         else {
1825             looping = get_long_be(&buf[0x18]);
1826             end_adr = get_long_be(&buf[0x28]);
1827             start_adr = get_long_be(&buf[0x1c])/32*channels*18+chanstart;
1828         }
1829     } else if (!memcmp(buf+0x10,"\x01\xF4\x04\x00",4)) {
1830         /* Standard (type 04) */
1831         DEBUGF("get_adx_metadata: type 04 found\n");
1832         /* check if header is too small for loop data */
1833         if (chanstart-6 < 0x38) looping=0;
1834         else {
1835             looping = get_long_be(&buf[0x24]);
1836             end_adr = get_long_be(&buf[0x34]);
1837             start_adr = get_long_be(&buf[0x28])/32*channels*18+chanstart;
1838         }
1839     } else {
1840         DEBUGF("get_adx_metadata: error, couldn't determine ADX type\n");
1841         return false;
1842     }
1843
1844     if (looping) {
1845         /* 2 loops, 10 second fade */
1846         id3->length = (start_adr-chanstart + 2*(end_adr-start_adr))
1847                       *8 / id3->bitrate + 10000;
1848     }
1849
1850     /* try to get the channel header */
1851     if ((lseek(fd, chanstart-6, SEEK_SET) < 0)
1852         || ((read_bytes = read(fd, buf, 6)) < 6))
1853     {
1854         return false;
1855     }
1856
1857     /* check channel header */
1858     if (memcmp(buf, "(c)CRI", 6) != 0) return false;
1859
1860     return true;
1861 }
1862
1863 static bool get_spc_metadata(int fd, struct mp3entry* id3)
1864 {
1865     /* Use the trackname part of the id3 structure as a temporary buffer */
1866     unsigned char * buf = (unsigned char *)id3->path;
1867     int read_bytes;
1868     char * p;
1869
1870     unsigned long length;
1871     unsigned long fade;
1872     bool isbinary = true;
1873     int i;
1874
1875     /* try to get the ID666 tag */
1876     if ((lseek(fd, 0x2e, SEEK_SET) < 0)
1877         || ((read_bytes = read(fd, buf, 0xD2)) < 0xD2))
1878     {
1879         DEBUGF("lseek or read failed\n");
1880         return false;
1881     }
1882
1883     p = id3->id3v2buf;
1884
1885     id3->title = p;
1886     buf[31] = 0;
1887     p = iso_decode(buf, p, 0, 32);
1888     buf += 32;
1889
1890     id3->album = p;
1891     buf[31] = 0;
1892     p = iso_decode(buf, p, 0, 32);
1893     buf += 48;
1894
1895     id3->comment = p;
1896     buf[31] = 0;
1897     p = iso_decode(buf, p, 0, 32);
1898     buf += 32;
1899
1900     /* Date check */
1901     if(buf[2] == '/' && buf[5] == '/')
1902         isbinary = false;
1903
1904     /* Reserved bytes check */
1905     if(buf[0xD2 - 0x2E - 112] >= '0' &&
1906        buf[0xD2 - 0x2E - 112] <= '9' &&
1907        buf[0xD3 - 0x2E - 112] == 0x00)
1908         isbinary = false;
1909
1910     /* is length & fade only digits? */
1911     for (i=0;i<8 && (
1912         (buf[0xA9 - 0x2E - 112+i]>='0'&&buf[0xA9 - 0x2E - 112+i]<='9') ||
1913         buf[0xA9 - 0x2E - 112+i]=='\0');
1914         i++);
1915     if (i==8) isbinary = false;
1916
1917     if(isbinary) {
1918         id3->year = buf[0] | (buf[1]<<8);
1919         buf += 11;
1920
1921         length = (buf[0] | (buf[1]<<8) | (buf[2]<<16)) * 1000;
1922         buf += 3;
1923
1924         fade = (buf[0] | (buf[1]<<8) | (buf[2]<<16) | (buf[3]<<24));
1925         buf += 4;
1926     } else {
1927         char tbuf[6];
1928
1929         buf += 6;
1930         buf[4] = 0;
1931         id3->year = atoi(buf);
1932         buf += 5;
1933
1934         memcpy(tbuf, buf, 3);
1935         tbuf[3] = 0;
1936         length = atoi(tbuf) * 1000;
1937         buf += 3;
1938
1939         memcpy(tbuf, buf, 5);
1940         tbuf[5] = 0;
1941         fade = atoi(tbuf);
1942         buf += 5;
1943     }
1944
1945     id3->artist = p;
1946     buf[31] = 0;
1947     p = iso_decode(buf, p, 0, 32);
1948
1949     if (length==0) {
1950         length=3*60*1000; /* 3 minutes */
1951         fade=5*1000; /* 5 seconds */
1952     }
1953
1954     id3->length = length+fade;
1955
1956     return true;
1957 }
1958
1959 static bool get_aiff_metadata(int fd, struct mp3entry* id3)
1960 {
1961     /* Use the trackname part of the id3 structure as a temporary buffer */
1962     unsigned char* buf = (unsigned char *)id3->path;
1963     unsigned long numChannels = 0;
1964     unsigned long numSampleFrames = 0;
1965     unsigned long sampleSize = 0;
1966     unsigned long sampleRate = 0;
1967     unsigned long numbytes = 0;
1968     int read_bytes;
1969     int i;
1970
1971     if ((lseek(fd, 0, SEEK_SET) < 0)
1972         || ((read_bytes = read(fd, buf, sizeof(id3->path))) < 54))
1973     {
1974         return false;
1975     }
1976
1977     if ((memcmp(buf, "FORM",4) != 0)
1978         || (memcmp(&buf[8], "AIFF", 4) !=0 ))
1979     {
1980         return false;
1981     }
1982
1983     buf += 12;
1984     read_bytes -= 12;
1985
1986     while ((numbytes == 0) && (read_bytes >= 8))
1987     {
1988         /* chunkSize */
1989         i = get_long_be(&buf[4]);
1990
1991         if (memcmp(buf, "COMM", 4) == 0)
1992         {
1993             /* numChannels */
1994             numChannels = ((buf[8]<<8)|buf[9]);
1995             /* numSampleFrames */
1996             numSampleFrames = get_long_be(&buf[10]);
1997             /* sampleSize */
1998             sampleSize = ((buf[14]<<8)|buf[15]);
1999             /* sampleRate */
2000             sampleRate = get_long_be(&buf[18]);
2001             sampleRate = sampleRate >> (16+14-buf[17]);
2002             /* save format infos */
2003             id3->bitrate = (sampleSize * numChannels * sampleRate) / 1000;
2004             id3->frequency = sampleRate;
2005             id3->length = ((int64_t) numSampleFrames * 1000) / id3->frequency;
2006
2007             id3->vbr = false;   /* AIFF files are CBR */
2008             id3->filesize = filesize(fd);
2009         }
2010         else if (memcmp(buf, "SSND", 4) == 0)
2011         {
2012             numbytes = i - 8;
2013         }
2014
2015         if (i & 0x01)
2016         {
2017             i++;  /* odd chunk sizes must be padded */
2018         }
2019         buf += i + 8;
2020         read_bytes -= i + 8;
2021     }
2022
2023     if ((numbytes == 0) || (numChannels == 0))
2024     {
2025         return false;
2026     }
2027     return true;
2028 }
2029 #endif /* CONFIG_CODEC == SWCODEC */
2030
2031
2032 /* Simple file type probing by looking at the filename extension. */
2033 unsigned int probe_file_format(const char *filename)
2034 {
2035     char *suffix;
2036     unsigned int i;
2037
2038     suffix = strrchr(filename, '.');
2039
2040     if (suffix == NULL)
2041     {
2042         return AFMT_UNKNOWN;
2043     }
2044
2045     /* skip '.' */
2046     suffix++;
2047
2048     for (i = 1; i < AFMT_NUM_CODECS; i++)
2049     {
2050         /* search extension list for type */
2051         const char *ext = audio_formats[i].ext_list;
2052
2053         do
2054         {
2055             if (strcasecmp(suffix, ext) == 0)
2056             {
2057                 return i;
2058             }
2059
2060             ext += strlen(ext) + 1;
2061         }
2062         while (*ext != '\0');
2063     }
2064
2065     return AFMT_UNKNOWN;
2066 }
2067
2068 /* Get metadata for track - return false if parsing showed problems with the
2069  * file that would prevent playback.
2070  */
2071 bool get_metadata(struct track_info* track, int fd, const char* trackname,
2072                   bool v1first)
2073 {
2074 #if CONFIG_CODEC == SWCODEC
2075     unsigned char* buf;
2076     unsigned long totalsamples;
2077     int i;
2078 #endif
2079
2080     /* Take our best guess at the codec type based on file extension */
2081     track->id3.codectype = probe_file_format(trackname);
2082
2083     /* Load codec specific track tag information and confirm the codec type. */
2084     switch (track->id3.codectype)
2085     {
2086     case AFMT_MPA_L1:
2087     case AFMT_MPA_L2:
2088     case AFMT_MPA_L3:
2089         if (!get_mp3_metadata(fd, &track->id3, trackname, v1first))
2090         {
2091             return false;
2092         }
2093
2094         break;
2095
2096 #if CONFIG_CODEC == SWCODEC
2097     case AFMT_FLAC:
2098         if (!get_flac_metadata(fd, &(track->id3)))
2099         {
2100             return false;
2101         }
2102
2103         break;
2104
2105     case AFMT_MPC:
2106         if (!get_musepack_metadata(fd, &(track->id3)))
2107             return false;
2108         read_ape_tags(fd, &(track->id3));
2109         break;
2110
2111     case AFMT_OGG_VORBIS:
2112         if (!get_vorbis_metadata(fd, &(track->id3)))/*detects and handles Ogg/Speex files*/
2113         {
2114             return false;
2115         }
2116
2117         break;
2118
2119     case AFMT_SPEEX:
2120         if (!get_speex_metadata(fd, &(track->id3)))
2121         {
2122             return false;
2123         }
2124
2125         break;
2126
2127     case AFMT_PCM_WAV:
2128         if (!get_wave_metadata(fd, &(track->id3)))
2129         {
2130             return false;
2131         }
2132
2133         break;
2134
2135     case AFMT_WAVPACK:
2136         /* A simple parser to read basic information from a WavPack file. This
2137          * now works with self-extrating WavPack files. This no longer fails on
2138          * WavPack files containing floating-point audio data because these are
2139          * now converted to standard Rockbox format in the decoder.
2140          */
2141
2142         /* Use the trackname part of the id3 structure as a temporary buffer */
2143         buf = (unsigned char *)track->id3.path;
2144
2145         for (i = 0; i < 256; ++i) {
2146
2147             /* at every 256 bytes into file, try to read a WavPack header */
2148
2149             if ((lseek(fd, i * 256, SEEK_SET) < 0) || (read(fd, buf, 32) < 32))
2150             {
2151                 return false;
2152             }
2153
2154             /* if valid WavPack 4 header version & not floating data, break */
2155
2156             if (memcmp (buf, "wvpk", 4) == 0 && buf [9] == 4 &&
2157                 (buf [8] >= 2 && buf [8] <= 0x10))
2158             {
2159                 break;
2160             }
2161         }
2162
2163         if (i == 256) {
2164             logf ("%s is not a WavPack file\n", trackname);
2165             return false;
2166         }
2167
2168         track->id3.vbr = true;   /* All WavPack files are VBR */
2169         track->id3.filesize = filesize (fd);
2170
2171         if ((buf [20] | buf [21] | buf [22] | buf [23]) &&
2172             (buf [12] & buf [13] & buf [14] & buf [15]) != 0xff)
2173         {
2174             int srindx = ((buf [26] >> 7) & 1) + ((buf [27] << 1) & 14);
2175
2176             if (srindx == 15)
2177             {
2178                 track->id3.frequency = 44100;
2179             }
2180             else
2181             {
2182                 track->id3.frequency = wavpack_sample_rates[srindx];
2183             }
2184
2185             totalsamples = get_long_le(&buf[12]);
2186             track->id3.length = totalsamples / (track->id3.frequency / 100) * 10;
2187             track->id3.bitrate = filesize (fd) / (track->id3.length / 8);
2188         }
2189
2190         read_ape_tags(fd, &track->id3);     /* use any apetag info we find */
2191         break;
2192
2193     case AFMT_A52:
2194         /* Use the trackname part of the id3 structure as a temporary buffer */
2195         buf = (unsigned char *)track->id3.path;
2196
2197         if ((lseek(fd, 0, SEEK_SET) < 0) || (read(fd, buf, 5) < 5))
2198         {
2199             return false;
2200         }
2201
2202         if ((buf[0] != 0x0b) || (buf[1] != 0x77))
2203         {
2204             logf("%s is not an A52/AC3 file\n",trackname);
2205             return false;
2206         }
2207
2208         i = buf[4] & 0x3e;
2209
2210         if (i > 36)
2211         {
2212             logf("A52: Invalid frmsizecod: %d\n",i);
2213             return false;
2214         }
2215
2216         track->id3.bitrate = a52_bitrates[i >> 1];
2217         track->id3.vbr = false;
2218         track->id3.filesize = filesize(fd);
2219
2220         switch (buf[4] & 0xc0)
2221         {
2222         case 0x00:
2223             track->id3.frequency = 48000;
2224             track->id3.bytesperframe=track->id3.bitrate * 2 * 2;
2225             break;
2226
2227         case 0x40:
2228             track->id3.frequency = 44100;
2229             track->id3.bytesperframe = a52_441framesizes[i];
2230             break;
2231
2232         case 0x80:
2233             track->id3.frequency = 32000;
2234             track->id3.bytesperframe = track->id3.bitrate * 3 * 2;
2235             break;
2236
2237         default:
2238             logf("A52: Invalid samplerate code: 0x%02x\n", buf[4] & 0xc0);
2239             return false;
2240             break;
2241         }
2242
2243         /* One A52 frame contains 6 blocks, each containing 256 samples */
2244         totalsamples = track->id3.filesize / track->id3.bytesperframe * 6 * 256;
2245         track->id3.length = totalsamples / track->id3.frequency * 1000;
2246         break;
2247
2248     case AFMT_ALAC:
2249     case AFMT_AAC:
2250         if (!get_mp4_metadata(fd, &(track->id3)))
2251         {
2252             return false;
2253         }
2254
2255         break;
2256
2257     case AFMT_SHN:
2258         track->id3.vbr = true;
2259         track->id3.filesize = filesize(fd);
2260         if (!skip_id3v2(fd, &(track->id3)))
2261         {
2262             return false;
2263         }
2264         /* TODO: read the id3v2 header if it exists */
2265         break;
2266
2267     case AFMT_SID:
2268         if (!get_sid_metadata(fd, &(track->id3)))
2269         {
2270             return false;
2271         }
2272         break;
2273     case AFMT_SPC:
2274         if(!get_spc_metadata(fd, &(track->id3)))
2275         {
2276             DEBUGF("get_spc_metadata error\n");
2277         }
2278
2279         track->id3.filesize = filesize(fd);
2280         track->id3.genre_string = id3_get_num_genre(36);
2281         break;
2282     case AFMT_ADX:
2283         if (!get_adx_metadata(fd, &(track->id3)))
2284         {
2285             DEBUGF("get_adx_metadata error\n");
2286             return false;
2287         }
2288
2289         break;
2290     case AFMT_NSF:
2291         buf = (unsigned char *)track->id3.path;
2292         if ((lseek(fd, 0, SEEK_SET) < 0) || ((read(fd, buf, 8)) < 8))
2293         {
2294             DEBUGF("lseek or read failed\n");
2295             return false;
2296         }
2297         track->id3.vbr = false;
2298         track->id3.filesize = filesize(fd);
2299         if (memcmp(buf,"NESM",4) && memcmp(buf,"NSFE",4)) return false;
2300         break;
2301
2302     case AFMT_AIFF:
2303         if (!get_aiff_metadata(fd, &(track->id3)))
2304         {
2305             return false;
2306         }
2307
2308         break;
2309
2310 #endif /* CONFIG_CODEC == SWCODEC */
2311
2312     default:
2313         /* If we don't know how to read the metadata, assume we can't play
2314            the file */
2315         return false;
2316         break;
2317     }
2318
2319     /* We have successfully read the metadata from the file */
2320
2321 #ifndef __PCTOOL__
2322     if (cuesheet_is_enabled() && look_for_cuesheet_file(trackname))
2323     {
2324         track->id3.cuesheet_type = 1;
2325     }
2326 #endif
2327
2328     lseek(fd, 0, SEEK_SET);
2329     strncpy(track->id3.path, trackname, sizeof(track->id3.path));
2330     track->taginfo_ready = true;
2331
2332     return true;
2333 }
2334