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     int32_t comment_count;
 387     int32_t 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         int32_t 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         unsigned 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         memset(buf, 0, sizeof(buf));
1265         read(fd, buf, length);
1266         *size -= length;
1267
1268         /* Maybe time to write a simple read_bits function... */
1269
1270         /* Decoder config format:
1271          * Object type           - 5 bits
1272          * Frequency index       - 4 bits
1273          * Channel configuration - 4 bits
1274          */
1275         bits = get_long_be(buf);
1276         type = bits >> 27;              /* Object type - 5 bits */
1277         index = (bits >> 23) & 0xf;     /* Frequency index - 4 bits */
1278
1279         if (index < (sizeof(sample_rates) / sizeof(*sample_rates)))
1280         {
1281             id3->frequency = sample_rates[index];
1282         }
1283
1284         if (type == 5)
1285         {
1286             DEBUGF("MP4: SBR\n");
1287             unsigned int old_index = index;
1288
1289             sbr = true;
1290             index = (bits >> 15) & 0xf; /* Frequency index - 4 bits */
1291
1292             if (index == 15)
1293             {
1294                 /* 17 bits read so far... */
1295                 bits = get_long_be(&buf[2]);
1296                 id3->frequency = (bits >> 7) & 0x00ffffff;
1297             }
1298             else if (index < (sizeof(sample_rates) / sizeof(*sample_rates)))
1299             {
1300                 id3->frequency = sample_rates[index];
1301             }
1302
1303             if (old_index == index)
1304             {
1305                 /* Downsampled SBR */
1306                 id3->frequency *= 2;
1307             }
1308         }
1309         /* Skip 13 bits from above, plus 3 bits, then read 11 bits */
1310         else if ((length >= 4) && (((bits >> 5) & 0x7ff) == 0x2b7))
1311         {
1312             /* extensionAudioObjectType */
1313             DEBUGF("MP4: extensionAudioType\n");
1314             type = bits & 0x1f;         /* Object type - 5 bits*/
1315             bits = get_long_be(&buf[4]);
1316
1317             if (type == 5)
1318             {
1319                 sbr = bits >> 31;
1320
1321                 if (sbr)
1322                 {
1323                     unsigned int old_index = index;
1324
1325                     /* 1 bit read so far */
1326                     index = (bits >> 27) & 0xf; /* Frequency index - 4 bits */
1327
1328                     if (index == 15)
1329                     {
1330                         /* 5 bits read so far */
1331                         id3->frequency = (bits >> 3) & 0x00ffffff;
1332                     }
1333                     else if (index < (sizeof(sample_rates) / sizeof(*sample_rates)))
1334                     {
1335                         id3->frequency = sample_rates[index];
1336                     }
1337
1338                     if (old_index == index)
1339                     {
1340                         /* Downsampled SBR */
1341                         id3->frequency *= 2;
1342                     }
1343                 }
1344             }
1345         }
1346
1347         if (!sbr && (id3->frequency <= 24000) && (length <= 2))
1348         {
1349             /* Double the frequency for low-frequency files without a "long"
1350              * DecSpecificConfig header. The file may or may not contain SBR,
1351              * but here we guess it does if the header is short. This can
1352              * fail on some files, but it's the best we can do, short of
1353              * decoding (parts of) the file.
1354              */
1355             id3->frequency *= 2;
1356         }
1357     }
1358
1359     return sbr;
1360 }
1361
1362 static bool read_mp4_tags(int fd, struct mp3entry* id3,
1363                           unsigned int size_left)
1364 {
1365     unsigned int size;
1366     unsigned int type;
1367     unsigned int buffer_left = sizeof(id3->id3v2buf) + sizeof(id3->id3v1buf);
1368     char* buffer = id3->id3v2buf;
1369     bool cwrt = false;
1370
1371     do
1372     {
1373         size_left = read_mp4_atom(fd, &size, &type, size_left);
1374
1375         /* DEBUGF("Tag atom: '%c%c%c%c' (%d bytes left)\n", type >> 24 & 0xff,
1376             type >> 16 & 0xff, type >> 8 & 0xff, type & 0xff, size); */
1377
1378         switch (type)
1379         {
1380         case MP4_cnam:
1381             read_mp4_tag_string(fd, size, &buffer, &buffer_left,
1382                 &id3->title);
1383             break;
1384
1385         case MP4_cART:
1386             read_mp4_tag_string(fd, size, &buffer, &buffer_left,
1387                 &id3->artist);
1388             break;
1389
1390         case MP4_calb:
1391             read_mp4_tag_string(fd, size, &buffer, &buffer_left,
1392                 &id3->album);
1393             break;
1394
1395         case MP4_cwrt:
1396             read_mp4_tag_string(fd, size, &buffer, &buffer_left,
1397                 &id3->composer);
1398             cwrt = false;
1399             break;
1400
1401         case MP4_gnre:
1402             {
1403                 unsigned short genre;
1404
1405                 read_mp4_tag(fd, size, (char*) &genre, sizeof(genre));
1406                 id3->genre_string = id3_get_num_genre(betoh16(genre) - 1);
1407             }
1408             break;
1409
1410         case MP4_trkn:
1411             {
1412                 unsigned short n[2];
1413
1414                 read_mp4_tag(fd, size, (char*) &n, sizeof(n));
1415                 id3->tracknum = betoh16(n[1]);
1416             }
1417             break;
1418
1419         case MP4_extra:
1420             {
1421                 char tag_name[TAG_NAME_LENGTH];
1422                 unsigned int sub_size;
1423
1424                 /* "mean" atom */
1425                 read_uint32be(fd, &sub_size);
1426                 size -= sub_size;
1427                 lseek(fd, sub_size - 4, SEEK_CUR);
1428                 /* "name" atom */
1429                 read_uint32be(fd, &sub_size);
1430                 size -= sub_size;
1431                 lseek(fd, 8, SEEK_CUR);
1432                 sub_size -= 12;
1433
1434                 if (sub_size > sizeof(tag_name) - 1)
1435                 {
1436                     read(fd, tag_name, sizeof(tag_name) - 1);
1437                     lseek(fd, sub_size - sizeof(tag_name) - 1, SEEK_CUR);
1438                     tag_name[sizeof(tag_name) - 1] = 0;
1439                 }
1440                 else
1441                 {
1442                     read(fd, tag_name, sub_size);
1443                     tag_name[sub_size] = 0;
1444                 }
1445
1446                 if ((strcasecmp(tag_name, "composer") == 0) && !cwrt)
1447                 {
1448                     read_mp4_tag_string(fd, size, &buffer, &buffer_left,
1449                         &id3->composer);
1450                 }
1451                 else
1452                 {
1453                     char* any;
1454                     unsigned int length = read_mp4_tag_string(fd, size,
1455                         &buffer, &buffer_left, &any);
1456
1457                     if (length > 0)
1458                     {
1459                         /* Re-use the read buffer as the dest buffer... */
1460                         buffer -= length;
1461                         buffer_left += length;
1462
1463                         if (parse_replaygain(tag_name, buffer, id3,
1464                             buffer, buffer_left) > 0)
1465                         {
1466                             /* Data used, keep it. */
1467                             buffer += length;
1468                             buffer_left -= length;
1469                         }
1470                     }
1471                 }
1472             }
1473             break;
1474
1475         default:
1476             lseek(fd, size, SEEK_CUR);
1477             break;
1478         }
1479     }
1480     while ((size_left > 0) && (errno == 0));
1481
1482     return true;
1483 }
1484
1485 static bool read_mp4_container(int fd, struct mp3entry* id3,
1486                                unsigned int size_left)
1487 {
1488     unsigned int size;
1489     unsigned int type;
1490     unsigned int handler = 0;
1491     bool rc = true;
1492
1493     do
1494     {
1495         size_left = read_mp4_atom(fd, &size, &type, size_left);
1496
1497         /* DEBUGF("Atom: '%c%c%c%c' (0x%08x, %d bytes left)\n",
1498             (type >> 24) & 0xff, (type >> 16) & 0xff, (type >> 8) & 0xff,
1499             type & 0xff, type, size); */
1500
1501         switch (type)
1502         {
1503         case MP4_ftyp:
1504             {
1505                 unsigned int id;
1506
1507                 read_uint32be(fd, &id);
1508                 size -= 4;
1509
1510                 if ((id != MP4_M4A) && (id != MP4_M4B) && (id != MP4_mp42)
1511                     && (id != MP4_qt) && (id != MP4_3gp6))
1512                 {
1513                     DEBUGF("Unknown MP4 file type: '%c%c%c%c'\n",
1514                         id >> 24 & 0xff, id >> 16 & 0xff, id >> 8 & 0xff,
1515                         id & 0xff);
1516                     return false;
1517                 }
1518             }
1519             break;
1520
1521         case MP4_meta:
1522             lseek(fd, 4, SEEK_CUR);  /* Skip version */
1523             size -= 4;
1524             /* Fall through */
1525
1526         case MP4_moov:
1527         case MP4_udta:
1528         case MP4_mdia:
1529         case MP4_stbl:
1530         case MP4_trak:
1531             rc = read_mp4_container(fd, id3, size);
1532             size = 0;
1533             break;
1534
1535         case MP4_ilst:
1536             if (handler == MP4_mdir)
1537             {
1538                 rc = read_mp4_tags(fd, id3, size);
1539                 size = 0;
1540             }
1541             break;
1542
1543         case MP4_minf:
1544             if (handler == MP4_soun)
1545             {
1546                 rc = read_mp4_container(fd, id3, size);
1547                 size = 0;
1548             }
1549             break;
1550
1551         case MP4_stsd:
1552             lseek(fd, 8, SEEK_CUR);
1553             size -= 8;
1554             rc = read_mp4_container(fd, id3, size);
1555             size = 0;
1556             break;
1557
1558         case MP4_hdlr:
1559             lseek(fd, 8, SEEK_CUR);
1560             read_uint32be(fd, &handler);
1561             size -= 12;
1562             /* DEBUGF("    Handler '%c%c%c%c'\n", handler >> 24 & 0xff,
1563                 handler >> 16 & 0xff, handler >> 8 & 0xff,handler & 0xff); */
1564             break;
1565
1566         case MP4_stts:
1567             {
1568                 unsigned int entries;
1569                 unsigned int i;
1570
1571                 lseek(fd, 4, SEEK_CUR);
1572                 read_uint32be(fd, &entries);
1573                 id3->samples = 0;
1574
1575                 for (i = 0; i < entries; i++)
1576                 {
1577                     unsigned int n;
1578                     unsigned int l;
1579
1580                     read_uint32be(fd, &n);
1581                     read_uint32be(fd, &l);
1582                     id3->samples += n * l;
1583                 }
1584
1585                 size = 0;
1586             }
1587             break;
1588
1589         case MP4_mp4a:
1590         case MP4_alac:
1591             {
1592                 unsigned int frequency;
1593
1594                 id3->codectype = (type == MP4_mp4a) ? AFMT_AAC : AFMT_ALAC;
1595                 lseek(fd, 22, SEEK_CUR);
1596                 read_uint32be(fd, &frequency);
1597                 size -= 26;
1598                 id3->frequency = frequency;
1599
1600                 if (type == MP4_mp4a)
1601                 {
1602                     unsigned int subsize;
1603                     unsigned int subtype;
1604
1605                     /* Get frequency from the decoder info tag, if possible. */
1606                     lseek(fd, 2, SEEK_CUR);
1607                     /* The esds atom is a part of the mp4a atom, so ignore
1608                      * the returned size (it's already accounted for).
1609                      */
1610                     read_mp4_atom(fd, &subsize, &subtype, size);
1611                     size -= 10;
1612
1613                     if (subtype == MP4_esds)
1614                     {
1615                         read_mp4_esds(fd, id3, &size);
1616                     }
1617                 }
1618             }
1619             break;
1620
1621         case MP4_mdat:
1622             id3->filesize = size;
1623             break;
1624
1625         default:
1626             break;
1627         }
1628
1629         lseek(fd, size, SEEK_CUR);
1630     }
1631     while (rc && (size_left > 0) && (errno == 0) && (id3->filesize == 0));
1632     /* Break on non-zero filesize, since Rockbox currently doesn't support
1633      * metadata after the mdat atom (which sets the filesize field).
1634      */
1635
1636     return rc;
1637 }
1638
1639 static bool get_mp4_metadata(int fd, struct mp3entry* id3)
1640 {
1641     id3->codectype = AFMT_UNKNOWN;
1642     id3->filesize = 0;
1643     errno = 0;
1644
1645     if (read_mp4_container(fd, id3, filesize(fd)) && (errno == 0)
1646         && (id3->samples > 0) && (id3->frequency > 0)
1647         && (id3->filesize > 0))
1648     {
1649         if (id3->codectype == AFMT_UNKNOWN)
1650         {
1651             logf("Not an ALAC or AAC file");
1652             return false;
1653         }
1654
1655         id3->length = ((int64_t) id3->samples * 1000) / id3->frequency;
1656
1657         if (id3->length <= 0)
1658         {
1659             logf("mp4 length invalid!");
1660             return false;
1661         }
1662
1663         id3->bitrate = ((int64_t) id3->filesize * 8) / id3->length;
1664         DEBUGF("MP4 bitrate %d, frequency %ld Hz, length %ld ms\n",
1665             id3->bitrate, id3->frequency, id3->length);
1666     }
1667     else
1668     {
1669         logf("MP4 metadata error");
1670         DEBUGF("MP4 metadata error. errno %d, length %ld, frequency %ld, filesize %ld\n",
1671             errno, id3->length, id3->frequency, id3->filesize);
1672         return false;
1673     }
1674
1675     return true;
1676 }
1677
1678 static bool get_musepack_metadata(int fd, struct mp3entry *id3)
1679 {
1680     const int32_t sfreqs_sv7[4] = { 44100, 48000, 37800, 32000 };
1681     uint32_t header[8];
1682     uint64_t samples = 0;
1683     int i;
1684
1685     if (!skip_id3v2(fd, id3))
1686         return false;
1687     if (read(fd, header, 4*8) != 4*8) return false;
1688     /* Musepack files are little endian, might need swapping */
1689     for (i = 1; i < 8; i++)
1690        header[i] = letoh32(header[i]);
1691     if (!memcmp(header, "MP+", 3)) { /* Compare to sig "MP+" */
1692         unsigned int streamversion;
1693
1694         header[0] = letoh32(header[0]);
1695         streamversion = (header[0] >> 24) & 15;
1696         if (streamversion >= 8) {
1697             return false; /* SV8 or higher don't exist yet, so no support */
1698         } else if (streamversion == 7) {
1699             unsigned int gapless = (header[5] >> 31) & 0x0001;
1700             unsigned int last_frame_samples = (header[5] >> 20) & 0x07ff;
1701             int track_gain, album_gain;
1702             unsigned int bufused;
1703
1704             id3->frequency = sfreqs_sv7[(header[2] >> 16) & 0x0003];
1705             samples = (uint64_t)header[1]*1152; /* 1152 is mpc frame size */
1706             if (gapless)
1707                 samples -= 1152 - last_frame_samples;
1708             else
1709                 samples -= 481; /* Musepack subband synth filter delay */
1710
1711             /* Extract ReplayGain data from header */
1712             track_gain = (int16_t)((header[3] >> 16) & 0xffff);
1713             id3->track_gain = get_replaygain_int(track_gain);
1714             id3->track_peak = ((uint16_t)(header[3] & 0xffff)) << 9;
1715
1716             album_gain = (int16_t)((header[4] >> 16) & 0xffff);
1717             id3->album_gain = get_replaygain_int(album_gain);
1718             id3->album_peak = ((uint16_t)(header[4] & 0xffff)) << 9;
1719
1720             /* Write replaygain values to strings for use in id3 screen. We use
1721                the XING header as buffer space since Musepack files shouldn't
1722                need to use it in any other way */
1723             id3->track_gain_string = (char *)id3->toc;
1724             bufused = snprintf(id3->track_gain_string, 45,
1725                                "%d.%d dB", track_gain/100, abs(track_gain)%100);
1726             id3->album_gain_string = (char *)id3->toc + bufused + 1;
1727             bufused = snprintf(id3->album_gain_string, 45,
1728                                "%d.%d dB", album_gain/100, abs(album_gain)%100);
1729         }
1730     } else {
1731         header[0] = letoh32(header[0]);
1732         unsigned int streamversion = (header[0] >> 11) & 0x03FF;
1733         if (streamversion != 4 && streamversion != 5 && streamversion != 6)
1734             return false;
1735         id3->frequency = 44100;
1736         id3->track_gain = 0;
1737         id3->track_peak = 0;
1738         id3->album_gain = 0;
1739         id3->album_peak = 0;
1740
1741         if (streamversion >= 5)
1742             samples = (uint64_t)header[1]*1152; // 32 bit
1743         else
1744             samples = (uint64_t)(header[1] >> 16)*1152; // 16 bit
1745
1746         samples -= 576;
1747         if (streamversion < 6)
1748             samples -= 1152;
1749     }
1750
1751     id3->vbr = true;
1752     /* Estimate bitrate, we should probably subtract the various header sizes
1753        here for super-accurate results */
1754     id3->length = ((int64_t) samples * 1000) / id3->frequency;
1755
1756     if (id3->length <= 0)
1757     {
1758         logf("mpc length invalid!");
1759         return false;
1760     }
1761
1762     id3->filesize = filesize(fd);
1763     id3->bitrate = id3->filesize * 8 / id3->length;
1764     return true;
1765 }
1766
1767 /* PSID metadata info is available here:
1768    http://www.unusedino.de/ec64/technical/formats/sidplay.html */
1769 static bool get_sid_metadata(int fd, struct mp3entry* id3)
1770 {
1771     /* Use the trackname part of the id3 structure as a temporary buffer */
1772     unsigned char* buf = (unsigned char *)id3->path;
1773     int read_bytes;
1774     char *p;
1775
1776
1777     if ((lseek(fd, 0, SEEK_SET) < 0)
1778          || ((read_bytes = read(fd, buf, 0x80)) < 0x80))
1779     {
1780         return false;
1781     }
1782
1783     if ((memcmp(buf, "PSID",4) != 0))
1784     {
1785         return false;
1786     }
1787
1788     p = id3->id3v2buf;
1789
1790     /* Copy Title (assumed max 0x1f letters + 1 zero byte) */
1791     id3->title = p;
1792     buf[0x16+0x1f] = 0;
1793     p = iso_decode(&buf[0x16], p, 0, strlen(&buf[0x16])+1);
1794
1795     /* Copy Artist (assumed max 0x1f letters + 1 zero byte) */
1796     id3->artist = p;
1797     buf[0x36+0x1f] = 0;
1798     p = iso_decode(&buf[0x36], p, 0, strlen(&buf[0x36])+1);
1799
1800     /* Copy Year (assumed max 4 letters + 1 zero byte) */
1801     buf[0x56+0x4] = 0;
1802     id3->year = atoi(&buf[0x56]);
1803
1804     /* Copy Album (assumed max 0x1f-0x05 letters + 1 zero byte) */
1805     id3->album = p;
1806     buf[0x56+0x1f] = 0;
1807     p = iso_decode(&buf[0x5b], p, 0, strlen(&buf[0x5b])+1);
1808
1809     id3->bitrate = 706;
1810     id3->frequency = 44100;
1811     /* New idea as posted by Marco Alanen (ravon):
1812      * Set the songlength in seconds to the number of subsongs
1813      * so every second represents a subsong.
1814      * Users can then skip the current subsong by seeking
1815      *
1816      * Note: the number of songs is a 16bit value at 0xE, so this code only
1817      * uses the lower 8 bits of the counter.
1818     */
1819     id3->length = (buf[0xf]-1)*1000;
1820     id3->vbr = false;
1821     id3->filesize = filesize(fd);
1822
1823     return true;
1824 }
1825
1826 static bool get_adx_metadata(int fd, struct mp3entry* id3)
1827 {
1828     /* Use the trackname part of the id3 structure as a temporary buffer */
1829     unsigned char * buf = (unsigned char *)id3->path;
1830     int chanstart, channels, read_bytes;
1831     int looping = 0, start_adr = 0, end_adr = 0;
1832
1833     /* try to get the basic header */
1834     if ((lseek(fd, 0, SEEK_SET) < 0)
1835         || ((read_bytes = read(fd, buf, 0x38)) < 0x38))
1836     {
1837         DEBUGF("lseek or read failed\n");
1838         return false;
1839     }
1840
1841     /* ADX starts with 0x80 */
1842     if (buf[0] != 0x80) {
1843         DEBUGF("get_adx_metadata: wrong first byte %c\n",buf[0]);
1844         return false;
1845     }
1846
1847     /* check for a reasonable offset */
1848     chanstart = ((buf[2] << 8) | buf[3]) + 4;
1849     if (chanstart > 4096) {
1850         DEBUGF("get_adx_metadata: bad chanstart %i\n", chanstart);
1851         return false;
1852     }
1853
1854     /* check for a workable number of channels */
1855     channels = buf[7];
1856     if (channels != 1 && channels != 2) {
1857         DEBUGF("get_adx_metadata: bad channel count %i\n",channels);
1858         return false;
1859     }
1860
1861     id3->frequency = get_long_be(&buf[8]);
1862     /* 32 samples per 18 bytes */
1863     id3->bitrate = id3->frequency * channels * 18 * 8 / 32 / 1000;
1864     id3->length = get_long_be(&buf[12]) / id3->frequency * 1000;
1865     id3->vbr = false;
1866     id3->filesize = filesize(fd);
1867
1868     /* get loop info */
1869     if (!memcmp(buf+0x10,"\x01\xF4\x03\x00",4)) {
1870         /* Soul Calibur 2 style (type 03) */
1871         DEBUGF("get_adx_metadata: type 03 found\n");
1872         /* check if header is too small for loop data */
1873         if (chanstart-6 < 0x2c) looping=0;
1874         else {
1875             looping = get_long_be(&buf[0x18]);
1876             end_adr = get_long_be(&buf[0x28]);
1877             start_adr = get_long_be(&buf[0x1c])/32*channels*18+chanstart;
1878         }
1879     } else if (!memcmp(buf+0x10,"\x01\xF4\x04\x00",4)) {
1880         /* Standard (type 04) */
1881         DEBUGF("get_adx_metadata: type 04 found\n");
1882         /* check if header is too small for loop data */
1883         if (chanstart-6 < 0x38) looping=0;
1884         else {
1885             looping = get_long_be(&buf[0x24]);
1886             end_adr = get_long_be(&buf[0x34]);
1887             start_adr = get_long_be(&buf[0x28])/32*channels*18+chanstart;
1888         }
1889     } else {
1890         DEBUGF("get_adx_metadata: error, couldn't determine ADX type\n");
1891         return false;
1892     }
1893
1894     if (looping) {
1895         /* 2 loops, 10 second fade */
1896         id3->length = (start_adr-chanstart + 2*(end_adr-start_adr))
1897                       *8 / id3->bitrate + 10000;
1898     }
1899
1900     /* try to get the channel header */
1901     if ((lseek(fd, chanstart-6, SEEK_SET) < 0)
1902         || ((read_bytes = read(fd, buf, 6)) < 6))
1903     {
1904         return false;
1905     }
1906
1907     /* check channel header */
1908     if (memcmp(buf, "(c)CRI", 6) != 0) return false;
1909
1910     return true;
1911 }
1912
1913 static bool get_spc_metadata(int fd, struct mp3entry* id3)
1914 {
1915     /* Use the trackname part of the id3 structure as a temporary buffer */
1916     unsigned char * buf = (unsigned char *)id3->path;
1917     int read_bytes;
1918     char * p;
1919
1920     unsigned long length;
1921     unsigned long fade;
1922     bool isbinary = true;
1923     int i;
1924
1925     /* try to get the ID666 tag */
1926     if ((lseek(fd, 0x2e, SEEK_SET) < 0)
1927         || ((read_bytes = read(fd, buf, 0xD2)) < 0xD2))
1928     {
1929         DEBUGF("lseek or read failed\n");
1930         return false;
1931     }
1932
1933     p = id3->id3v2buf;
1934
1935     id3->title = p;
1936     buf[31] = 0;
1937     p = iso_decode(buf, p, 0, 32);
1938     buf += 32;
1939
1940     id3->album = p;
1941     buf[31] = 0;
1942     p = iso_decode(buf, p, 0, 32);
1943     buf += 48;
1944
1945     id3->comment = p;
1946     buf[31] = 0;
1947     p = iso_decode(buf, p, 0, 32);
1948     buf += 32;
1949
1950     /* Date check */
1951     if(buf[2] == '/' && buf[5] == '/')
1952         isbinary = false;
1953
1954     /* Reserved bytes check */
1955     if(buf[0xD2 - 0x2E - 112] >= '0' &&
1956        buf[0xD2 - 0x2E - 112] <= '9' &&
1957        buf[0xD3 - 0x2E - 112] == 0x00)
1958         isbinary = false;
1959
1960     /* is length & fade only digits? */
1961     for (i=0;i<8 && (
1962         (buf[0xA9 - 0x2E - 112+i]>='0'&&buf[0xA9 - 0x2E - 112+i]<='9') ||
1963         buf[0xA9 - 0x2E - 112+i]=='\0');
1964         i++);
1965     if (i==8) isbinary = false;
1966
1967     if(isbinary) {
1968         id3->year = buf[0] | (buf[1]<<8);
1969         buf += 11;
1970
1971         length = (buf[0] | (buf[1]<<8) | (buf[2]<<16)) * 1000;
1972         buf += 3;
1973
1974         fade = (buf[0] | (buf[1]<<8) | (buf[2]<<16) | (buf[3]<<24));
1975         buf += 4;
1976     } else {
1977         char tbuf[6];
1978
1979         buf += 6;
1980         buf[4] = 0;
1981         id3->year = atoi(buf);
1982         buf += 5;
1983
1984         memcpy(tbuf, buf, 3);
1985         tbuf[3] = 0;
1986         length = atoi(tbuf) * 1000;
1987         buf += 3;
1988
1989         memcpy(tbuf, buf, 5);
1990         tbuf[5] = 0;
1991         fade = atoi(tbuf);
1992         buf += 5;
1993     }
1994
1995     id3->artist = p;
1996     buf[31] = 0;
1997     p = iso_decode(buf, p, 0, 32);
1998
1999     if (length==0) {
2000         length=3*60*1000; /* 3 minutes */
2001         fade=5*1000; /* 5 seconds */
2002     }
2003
2004     id3->length = length+fade;
2005
2006     return true;
2007 }
2008
2009 static bool get_aiff_metadata(int fd, struct mp3entry* id3)
2010 {
2011     /* Use the trackname part of the id3 structure as a temporary buffer */
2012     unsigned char* buf = (unsigned char *)id3->path;
2013     unsigned long numChannels = 0;
2014     unsigned long numSampleFrames = 0;
2015     unsigned long sampleSize = 0;
2016     unsigned long sampleRate = 0;
2017     unsigned long numbytes = 0;
2018     int read_bytes;
2019     int i;
2020
2021     if ((lseek(fd, 0, SEEK_SET) < 0)
2022         || ((read_bytes = read(fd, buf, sizeof(id3->path))) < 54))
2023     {
2024         return false;
2025     }
2026
2027     if ((memcmp(buf, "FORM",4) != 0)
2028         || (memcmp(&buf[8], "AIFF", 4) !=0 ))
2029     {
2030         return false;
2031     }
2032
2033     buf += 12;
2034     read_bytes -= 12;
2035
2036     while ((numbytes == 0) && (read_bytes >= 8))
2037     {
2038         /* chunkSize */
2039         i = get_long_be(&buf[4]);
2040
2041         if (memcmp(buf, "COMM", 4) == 0)
2042         {
2043             /* numChannels */
2044             numChannels = ((buf[8]<<8)|buf[9]);
2045             /* numSampleFrames */
2046             numSampleFrames = get_long_be(&buf[10]);
2047             /* sampleSize */
2048             sampleSize = ((buf[14]<<8)|buf[15]);
2049             /* sampleRate */
2050             sampleRate = get_long_be(&buf[18]);
2051             sampleRate = sampleRate >> (16+14-buf[17]);
2052             /* save format infos */
2053             id3->bitrate = (sampleSize * numChannels * sampleRate) / 1000;
2054             id3->frequency = sampleRate;
2055             id3->length = ((int64_t) numSampleFrames * 1000) / id3->frequency;
2056
2057             id3->vbr = false;   /* AIFF files are CBR */
2058             id3->filesize = filesize(fd);
2059         }
2060         else if (memcmp(buf, "SSND", 4) == 0)
2061         {
2062             numbytes = i - 8;
2063         }
2064
2065         if (i & 0x01)
2066         {
2067             i++;  /* odd chunk sizes must be padded */
2068         }
2069         buf += i + 8;
2070         read_bytes -= i + 8;
2071     }
2072
2073     if ((numbytes == 0) || (numChannels == 0))
2074     {
2075         return false;
2076     }
2077     return true;
2078 }
2079 #endif /* CONFIG_CODEC == SWCODEC */
2080
2081
2082 /* Simple file type probing by looking at the filename extension. */
2083 unsigned int probe_file_format(const char *filename)
2084 {
2085     char *suffix;
2086     unsigned int i;
2087
2088     suffix = strrchr(filename, '.');
2089
2090     if (suffix == NULL)
2091     {
2092         return AFMT_UNKNOWN;
2093     }
2094
2095     /* skip '.' */
2096     suffix++;
2097
2098     for (i = 1; i < AFMT_NUM_CODECS; i++)
2099     {
2100         /* search extension list for type */
2101         const char *ext = audio_formats[i].ext_list;
2102
2103         do
2104         {
2105             if (strcasecmp(suffix, ext) == 0)
2106             {
2107                 return i;
2108             }
2109
2110             ext += strlen(ext) + 1;
2111         }
2112         while (*ext != '\0');
2113     }
2114
2115     return AFMT_UNKNOWN;
2116 }
2117
2118 /* Get metadata for track - return false if parsing showed problems with the
2119  * file that would prevent playback.
2120  */
2121 bool get_metadata(struct track_info* track, int fd, const char* trackname,
2122                   bool v1first)
2123 {
2124 #if CONFIG_CODEC == SWCODEC
2125     unsigned char* buf;
2126     unsigned long totalsamples;
2127     int i;
2128 #endif
2129
2130     /* Take our best guess at the codec type based on file extension */
2131     track->id3.codectype = probe_file_format(trackname);
2132
2133     /* Load codec specific track tag information and confirm the codec type. */
2134     switch (track->id3.codectype)
2135     {
2136     case AFMT_MPA_L1:
2137     case AFMT_MPA_L2:
2138     case AFMT_MPA_L3:
2139         if (!get_mp3_metadata(fd, &track->id3, trackname, v1first))
2140         {
2141             return false;
2142         }
2143
2144         break;
2145
2146 #if CONFIG_CODEC == SWCODEC
2147     case AFMT_FLAC:
2148         if (!get_flac_metadata(fd, &(track->id3)))
2149         {
2150             return false;
2151         }
2152
2153         break;
2154
2155     case AFMT_MPC:
2156         if (!get_musepack_metadata(fd, &(track->id3)))
2157             return false;
2158         read_ape_tags(fd, &(track->id3));
2159         break;
2160
2161     case AFMT_OGG_VORBIS:
2162         if (!get_vorbis_metadata(fd, &(track->id3)))/*detects and handles Ogg/Speex files*/
2163         {
2164             return false;
2165         }
2166
2167         break;
2168
2169     case AFMT_SPEEX:
2170         if (!get_speex_metadata(fd, &(track->id3)))
2171         {
2172             return false;
2173         }
2174
2175         break;
2176
2177     case AFMT_PCM_WAV:
2178         if (!get_wave_metadata(fd, &(track->id3)))
2179         {
2180             return false;
2181         }
2182
2183         break;
2184
2185     case AFMT_WAVPACK:
2186         /* A simple parser to read basic information from a WavPack file. This
2187          * now works with self-extrating WavPack files. This no longer fails on
2188          * WavPack files containing floating-point audio data because these are
2189          * now converted to standard Rockbox format in the decoder.
2190          */
2191
2192         /* Use the trackname part of the id3 structure as a temporary buffer */
2193         buf = (unsigned char *)track->id3.path;
2194
2195         for (i = 0; i < 256; ++i) {
2196
2197             /* at every 256 bytes into file, try to read a WavPack header */
2198
2199             if ((lseek(fd, i * 256, SEEK_SET) < 0) || (read(fd, buf, 32) < 32))
2200             {
2201                 return false;
2202             }
2203
2204             /* if valid WavPack 4 header version & not floating data, break */
2205
2206             if (memcmp (buf, "wvpk", 4) == 0 && buf [9] == 4 &&
2207                 (buf [8] >= 2 && buf [8] <= 0x10))
2208             {
2209                 break;
2210             }
2211         }
2212
2213         if (i == 256) {
2214             logf ("%s is not a WavPack file\n", trackname);
2215             return false;
2216         }
2217
2218         track->id3.vbr = true;   /* All WavPack files are VBR */
2219         track->id3.filesize = filesize (fd);
2220
2221         if ((buf [20] | buf [21] | buf [22] | buf [23]) &&
2222             (buf [12] & buf [13] & buf [14] & buf [15]) != 0xff)
2223         {
2224             int srindx = ((buf [26] >> 7) & 1) + ((buf [27] << 1) & 14);
2225
2226             if (srindx == 15)
2227             {
2228                 track->id3.frequency = 44100;
2229             }
2230             else
2231             {
2232                 track->id3.frequency = wavpack_sample_rates[srindx];
2233             }
2234
2235             totalsamples = get_long_le(&buf[12]);
2236             track->id3.length = totalsamples / (track->id3.frequency / 100) * 10;
2237             track->id3.bitrate = filesize (fd) / (track->id3.length / 8);
2238         }
2239
2240         read_ape_tags(fd, &track->id3);     /* use any apetag info we find */
2241         break;
2242
2243     case AFMT_A52:
2244         /* Use the trackname part of the id3 structure as a temporary buffer */
2245         buf = (unsigned char *)track->id3.path;
2246
2247         if ((lseek(fd, 0, SEEK_SET) < 0) || (read(fd, buf, 5) < 5))
2248         {
2249             return false;
2250         }
2251
2252         if ((buf[0] != 0x0b) || (buf[1] != 0x77))
2253         {
2254             logf("%s is not an A52/AC3 file\n",trackname);
2255             return false;
2256         }
2257
2258         i = buf[4] & 0x3e;
2259
2260         if (i > 36)
2261         {
2262             logf("A52: Invalid frmsizecod: %d\n",i);
2263             return false;
2264         }
2265
2266         track->id3.bitrate = a52_bitrates[i >> 1];
2267         track->id3.vbr = false;
2268         track->id3.filesize = filesize(fd);
2269
2270         switch (buf[4] & 0xc0)
2271         {
2272         case 0x00:
2273             track->id3.frequency = 48000;
2274             track->id3.bytesperframe=track->id3.bitrate * 2 * 2;
2275             break;
2276
2277         case 0x40:
2278             track->id3.frequency = 44100;
2279             track->id3.bytesperframe = a52_441framesizes[i];
2280             break;
2281
2282         case 0x80:
2283             track->id3.frequency = 32000;
2284             track->id3.bytesperframe = track->id3.bitrate * 3 * 2;
2285             break;
2286
2287         default:
2288             logf("A52: Invalid samplerate code: 0x%02x\n", buf[4] & 0xc0);
2289             return false;
2290             break;
2291         }
2292
2293         /* One A52 frame contains 6 blocks, each containing 256 samples */
2294         totalsamples = track->id3.filesize / track->id3.bytesperframe * 6 * 256;
2295         track->id3.length = totalsamples / track->id3.frequency * 1000;
2296         break;
2297
2298     case AFMT_ALAC:
2299     case AFMT_AAC:
2300         if (!get_mp4_metadata(fd, &(track->id3)))
2301         {
2302             return false;
2303         }
2304
2305         break;
2306
2307     case AFMT_SHN:
2308         track->id3.vbr = true;
2309         track->id3.filesize = filesize(fd);
2310         if (!skip_id3v2(fd, &(track->id3)))
2311         {
2312             return false;
2313         }
2314         /* TODO: read the id3v2 header if it exists */
2315         break;
2316
2317     case AFMT_SID:
2318         if (!get_sid_metadata(fd, &(track->id3)))
2319         {
2320             return false;
2321         }
2322         break;
2323     case AFMT_SPC:
2324         if(!get_spc_metadata(fd, &(track->id3)))
2325         {
2326             DEBUGF("get_spc_metadata error\n");
2327         }
2328
2329         track->id3.filesize = filesize(fd);
2330         track->id3.genre_string = id3_get_num_genre(36);
2331         break;
2332     case AFMT_ADX:
2333         if (!get_adx_metadata(fd, &(track->id3)))
2334         {
2335             DEBUGF("get_adx_metadata error\n");
2336             return false;
2337         }
2338
2339         break;
2340     case AFMT_NSF:
2341         buf = (unsigned char *)track->id3.path;
2342         if ((lseek(fd, 0, SEEK_SET) < 0) || ((read(fd, buf, 8)) < 8))
2343         {
2344             DEBUGF("lseek or read failed\n");
2345             return false;
2346         }
2347         track->id3.vbr = false;
2348         track->id3.filesize = filesize(fd);
2349         if (memcmp(buf,"NESM",4) && memcmp(buf,"NSFE",4)) return false;
2350         break;
2351
2352     case AFMT_AIFF:
2353         if (!get_aiff_metadata(fd, &(track->id3)))
2354         {
2355             return false;
2356         }
2357
2358         break;
2359
2360 #endif /* CONFIG_CODEC == SWCODEC */
2361
2362     default:
2363         /* If we don't know how to read the metadata, assume we can't play
2364            the file */
2365         return false;
2366         break;
2367     }
2368
2369     /* We have successfully read the metadata from the file */
2370
2371 #ifndef __PCTOOL__
2372     if (cuesheet_is_enabled() && look_for_cuesheet_file(trackname))
2373     {
2374         track->id3.cuesheet_type = 1;
2375     }
2376 #endif
2377
2378     lseek(fd, 0, SEEK_SET);
2379     strncpy(track->id3.path, trackname, sizeof(track->id3.path));
2380     track->taginfo_ready = true;
2381
2382     return true;
2383 }
2384