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  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include <ctype.h>
  25 #include <inttypes.h>
  26
  27 #include "playback.h"
  28 #include "debug.h"
  29 #include "logf.h"
  30 #include "cuesheet.h"
  31 #include "metadata.h"
  32
  33 #include "metadata/metadata_parsers.h"
  34
  35 #if CONFIG_CODEC == SWCODEC
  36
  37 /* For trailing tag stripping */
  38 #include "buffering.h"
  39
  40 #include "metadata/metadata_common.h"
  41
  42 #endif /* CONFIG_CODEC == SWCODEC */
  43
  44 const struct afmt_entry audio_formats[AFMT_NUM_CODECS] =
  45 {
  46     /* Unknown file format */
  47     [AFMT_UNKNOWN] =
  48         AFMT_ENTRY("???", NULL,       NULL,          NULL         ),
  49
  50     /* MPEG Audio layer 1 */
  51     [AFMT_MPA_L1] =
  52         AFMT_ENTRY("MP1", "mpa",      NULL,          "mp1\0"      ),
  53     /* MPEG Audio layer 2 */
  54     [AFMT_MPA_L2] =
  55         AFMT_ENTRY("MP2", "mpa",      NULL,          "mpa\0mp2\0" ),
  56     /* MPEG Audio layer 3 */
  57     [AFMT_MPA_L3] =
  58         AFMT_ENTRY("MP3", "mpa",      "mp3_enc",     "mp3\0"      ),
  59
  60 #if CONFIG_CODEC == SWCODEC
  61     /* Audio Interchange File Format */
  62     [AFMT_AIFF] =
  63         AFMT_ENTRY("AIFF", "aiff",    "aiff_enc",    "aiff\0aif\0"),
  64     /* Uncompressed PCM in a WAV file */
  65     [AFMT_PCM_WAV] =
  66         AFMT_ENTRY("WAV",  "wav",     "wav_enc",     "wav\0"      ),
  67     /* Ogg Vorbis */
  68     [AFMT_OGG_VORBIS] =
  69         AFMT_ENTRY("Ogg",  "vorbis",  NULL,          "ogg\0oga\0" ),
  70     /* FLAC */
  71     [AFMT_FLAC] =
  72         AFMT_ENTRY("FLAC", "flac",    NULL,          "flac\0"     ),
  73     /* Musepack */
  74     [AFMT_MPC] =
  75         AFMT_ENTRY("MPC",  "mpc",     NULL,          "mpc\0"      ),
  76     /* A/52 (aka AC3) audio */
  77     [AFMT_A52] =
  78         AFMT_ENTRY("AC3",  "a52",     NULL,          "a52\0ac3\0" ),
  79     /* WavPack */
  80     [AFMT_WAVPACK] =
  81         AFMT_ENTRY("WV",   "wavpack", "wavpack_enc", "wv\0"       ),
  82     /* Apple Lossless Audio Codec */
  83     [AFMT_MP4_ALAC] =
  84         AFMT_ENTRY("ALAC", "alac",    NULL,          "m4a\0m4b\0" ),
  85     /* Advanced Audio Coding in M4A container */
  86     [AFMT_MP4_AAC] =
  87         AFMT_ENTRY("AAC",  "aac",     NULL,          "mp4\0"      ),
  88     /* Shorten */
  89     [AFMT_SHN] =
  90         AFMT_ENTRY("SHN",  "shorten", NULL,          "shn\0"      ),
  91     /* SID File Format */
  92     [AFMT_SID] =
  93         AFMT_ENTRY("SID",  "sid",     NULL,          "sid\0"      ),
  94     /* ADX File Format */
  95     [AFMT_ADX] =
  96         AFMT_ENTRY("ADX",  "adx",     NULL,          "adx\0"      ),
  97     /* NESM (NES Sound Format) */
  98     [AFMT_NSF] =
  99         AFMT_ENTRY("NSF",  "nsf",     NULL,          "nsf\0nsfe\0"      ),
 100     /* Speex File Format */
 101     [AFMT_SPEEX] =
 102         AFMT_ENTRY("Speex","speex",   NULL,          "spx\0"      ),
 103     /* SPC700 Save State */
 104     [AFMT_SPC] =
 105         AFMT_ENTRY("SPC",  "spc",     NULL,          "spc\0"      ),
 106     /* APE (Monkey's Audio) */
 107     [AFMT_APE] =
 108         AFMT_ENTRY("APE",  "ape",     NULL,          "ape\0mac\0"      ),
 109     /* WMA (WMAV1/V2 in ASF) */
 110     [AFMT_WMA] =
 111         AFMT_ENTRY("WMA",  "wma",     NULL,          "wma\0wmv\0asf\0"   ),
 112     /* Amiga MOD File */
 113     [AFMT_MOD] =
 114         AFMT_ENTRY("MOD",  "mod",     NULL,          "mod\0"      ),
 115     /* Amiga SAP File */
 116     [AFMT_SAP] =
 117         AFMT_ENTRY("SAP",  "asap",     NULL,          "sap\0"      ),
 118     /* Cook in RM/RA */
 119     [AFMT_RM_COOK] =
 120         AFMT_ENTRY("Cook",  "cook",   NULL,          "rm\0ra\0rmvb\0"      ),
 121     /* AAC in RM/RA */
 122     [AFMT_RM_AAC] =
 123         AFMT_ENTRY("RAAC",  "raac",     NULL,        "rm\0ra\0rmvb\0"      ),
 124     /* AC3 in RM/RA */
 125     [AFMT_RM_AC3] =
 126         AFMT_ENTRY("AC3",   "a52_rm",     NULL,        "rm\0ra\0rmvb\0"      ),
 127     /* ATRAC3 in RM/RA */
 128     [AFMT_RM_ATRAC3] =
 129         AFMT_ENTRY("ATRAC3","atrac3_rm",  NULL,        "rm\0ra\0rmvb\0"      ),
 130 #endif
 131 };
 132
 133 #if CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING)
 134 /* get REC_FORMAT_* corresponding AFMT_* */
 135 const int rec_format_afmt[REC_NUM_FORMATS] =
 136 {
 137     /* give AFMT_UNKNOWN by default */
 138     [0 ... REC_NUM_FORMATS-1] = AFMT_UNKNOWN,
 139     /* add new entries below this line */
 140     [REC_FORMAT_AIFF]    = AFMT_AIFF,
 141     [REC_FORMAT_MPA_L3]  = AFMT_MPA_L3,
 142     [REC_FORMAT_WAVPACK] = AFMT_WAVPACK,
 143     [REC_FORMAT_PCM_WAV] = AFMT_PCM_WAV,
 144 };
 145
 146 /* get AFMT_* corresponding REC_FORMAT_* */
 147 const int afmt_rec_format[AFMT_NUM_CODECS] =
 148 {
 149     /* give -1 by default */
 150     [0 ... AFMT_NUM_CODECS-1] = -1,
 151     /* add new entries below this line */
 152     [AFMT_AIFF]    = REC_FORMAT_AIFF,
 153     [AFMT_MPA_L3]  = REC_FORMAT_MPA_L3,
 154     [AFMT_WAVPACK] = REC_FORMAT_WAVPACK,
 155     [AFMT_PCM_WAV] = REC_FORMAT_PCM_WAV,
 156 };
 157 #endif /* CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING) */
 158
 159
 160 /* Simple file type probing by looking at the filename extension. */
 161 unsigned int probe_file_format(const char *filename)
 162 {
 163     char *suffix;
 164     unsigned int i;
 165
 166     suffix = strrchr(filename, '.');
 167
 168     if (suffix == NULL)
 169     {
 170         return AFMT_UNKNOWN;
 171     }
 172
 173     /* skip '.' */
 174     suffix++;
 175
 176     for (i = 1; i < AFMT_NUM_CODECS; i++)
 177     {
 178         /* search extension list for type */
 179         const char *ext = audio_formats[i].ext_list;
 180
 181         do
 182         {
 183             if (strcasecmp(suffix, ext) == 0)
 184             {
 185                 return i;
 186             }
 187
 188             ext += strlen(ext) + 1;
 189         }
 190         while (*ext != '\0');
 191     }
 192
 193     return AFMT_UNKNOWN;
 194 }
 195
 196 /* Note, that this returns false for successful, true for error! */
 197 bool mp3info(struct mp3entry *entry, const char *filename)
 198 {
 199     int fd;
 200     bool result;
 201
 202     fd = open(filename, O_RDONLY);
 203     if (fd < 0)
 204         return true;
 205
 206     result = !get_mp3_metadata(fd, entry, filename);
 207
 208     close(fd);
 209
 210     return result;
 211 }
 212
 213 /* Get metadata for track - return false if parsing showed problems with the
 214  * file that would prevent playback.
 215  */
 216 bool get_metadata(struct mp3entry* id3, int fd, const char* trackname)
 217 {
 218 #if CONFIG_CODEC == SWCODEC
 219     unsigned char* buf;
 220 #endif
 221
 222     /* Clear the mp3entry to avoid having bogus pointers appear */
 223     memset(id3, 0, sizeof(struct mp3entry));
 224
 225     /* Take our best guess at the codec type based on file extension */
 226     id3->codectype = probe_file_format(trackname);
 227
 228     /* Load codec specific track tag information and confirm the codec type. */
 229     switch (id3->codectype)
 230     {
 231     case AFMT_MPA_L1:
 232     case AFMT_MPA_L2:
 233     case AFMT_MPA_L3:
 234         if (!get_mp3_metadata(fd, id3, trackname))
 235         {
 236             return false;
 237         }
 238
 239         break;
 240
 241 #if CONFIG_CODEC == SWCODEC
 242     case AFMT_FLAC:
 243         if (!get_flac_metadata(fd, id3))
 244         {
 245             return false;
 246         }
 247
 248         break;
 249
 250     case AFMT_WMA:
 251         if (!get_asf_metadata(fd, id3))
 252         {
 253             return false;
 254         }
 255         break;
 256
 257     case AFMT_APE:
 258         if (!get_monkeys_metadata(fd, id3))
 259         {
 260             return false;
 261         }
 262         read_ape_tags(fd, id3);
 263         break;
 264
 265     case AFMT_MPC:
 266         if (!get_musepack_metadata(fd, id3))
 267             return false;
 268         read_ape_tags(fd, id3);
 269         break;
 270
 271     case AFMT_OGG_VORBIS:
 272     case AFMT_SPEEX:
 273         if (!get_ogg_metadata(fd, id3))/*detects and handles Ogg/Speex files*/
 274         {
 275             return false;
 276         }
 277
 278         break;
 279
 280     case AFMT_PCM_WAV:
 281         if (!get_wave_metadata(fd, id3))
 282         {
 283             return false;
 284         }
 285
 286         break;
 287
 288     case AFMT_WAVPACK:
 289         if (!get_wavpack_metadata(fd, id3))
 290         {
 291             return false;
 292         }
 293
 294         read_ape_tags(fd, id3);     /* use any apetag info we find */
 295         break;
 296
 297     case AFMT_A52:
 298         if (!get_a52_metadata(fd, id3))
 299         {
 300             return false;
 301         }
 302
 303         break;
 304
 305     case AFMT_MP4_ALAC:
 306     case AFMT_MP4_AAC:
 307         if (!get_mp4_metadata(fd, id3))
 308         {
 309             return false;
 310         }
 311
 312         break;
 313
 314     case AFMT_MOD:
 315         if (!get_mod_metadata(fd, id3))
 316         {
 317             return false;
 318         }
 319
 320         break;
 321
 322     case AFMT_SHN:
 323         id3->vbr = true;
 324         id3->filesize = filesize(fd);
 325         if (!skip_id3v2(fd, id3))
 326         {
 327             return false;
 328         }
 329         /* TODO: read the id3v2 header if it exists */
 330         break;
 331
 332     case AFMT_SID:
 333         if (!get_sid_metadata(fd, id3))
 334         {
 335             return false;
 336         }
 337         break;
 338
 339     case AFMT_SPC:
 340         if (!get_spc_metadata(fd, id3))
 341         {
 342             DEBUGF("get_spc_metadata error\n");
 343             return false;
 344         }
 345         id3->filesize = filesize(fd);
 346         id3->genre_string = id3_get_num_genre(36);
 347         break;
 348
 349     case AFMT_ADX:
 350         if (!get_adx_metadata(fd, id3))
 351         {
 352             DEBUGF("get_adx_metadata error\n");
 353             return false;
 354         }
 355
 356         break;
 357
 358     case AFMT_NSF:
 359         buf = (unsigned char *)id3->path;
 360         if ((lseek(fd, 0, SEEK_SET) < 0) || ((read(fd, buf, 8)) < 8))
 361         {
 362             DEBUGF("lseek or read failed\n");
 363             return false;
 364         }
 365         id3->vbr = false;
 366         id3->filesize = filesize(fd);
 367         if (memcmp(buf,"NESM",4) && memcmp(buf,"NSFE",4)) return false;
 368         break;
 369
 370     case AFMT_AIFF:
 371         if (!get_aiff_metadata(fd, id3))
 372         {
 373             return false;
 374         }
 375
 376         break;
 377
 378     case AFMT_SAP:
 379         if (!get_asap_metadata(fd, id3))
 380         {
 381             DEBUGF("get_sap_metadata error\n");
 382             return false;
 383         }
 384         id3->filesize = filesize(fd);
 385         id3->genre_string = id3_get_num_genre(36);
 386         break;
 387
 388     case AFMT_RM_COOK:
 389         if (!get_rm_metadata(fd, id3))
 390         {
 391             DEBUGF("get_rm_metadata error\n");
 392             return false;
 393         }
 394         break;
 395
 396 #endif /* CONFIG_CODEC == SWCODEC */
 397
 398     default:
 399         /* If we don't know how to read the metadata, assume we can't play
 400            the file */
 401         return false;
 402         break;
 403     }
 404
 405     /* We have successfully read the metadata from the file */
 406
 407     lseek(fd, 0, SEEK_SET);
 408     strlcpy(id3->path, trackname, sizeof(id3->path));
 409
 410     return true;
 411 }
 412
 413 #ifndef __PCTOOL__
 414 #if CONFIG_CODEC == SWCODEC
 415 void strip_tags(int handle_id)
 416 {
 417     static const unsigned char tag[] = "TAG";
 418     static const unsigned char apetag[] = "APETAGEX";
 419     size_t len, version;
 420     void *tail;
 421
 422     if (bufgettail(handle_id, 128, &tail) != 128)
 423         return;
 424
 425     if (memcmp(tail, tag, 3) == 0)
 426     {
 427         /* Skip id3v1 tag */
 428         logf("Cutting off ID3v1 tag");
 429         bufcuttail(handle_id, 128);
 430     }
 431
 432     /* Get a new tail, as the old one may have been cut */
 433     if (bufgettail(handle_id, 32, &tail) != 32)
 434         return;
 435
 436     /* Check for APE tag (look for the APE tag footer) */
 437     if (memcmp(tail, apetag, 8) != 0)
 438         return;
 439
 440     /* Read the version and length from the footer */
 441     version = get_long_le(&((unsigned char *)tail)[8]);
 442     len = get_long_le(&((unsigned char *)tail)[12]);
 443     if (version == 2000)
 444         len += 32; /* APEv2 has a 32 byte header */
 445
 446     /* Skip APE tag */
 447     logf("Cutting off APE tag (%ldB)", len);
 448     bufcuttail(handle_id, len);
 449 }
 450 #endif /* CONFIG_CODEC == SWCODEC */
 451 #endif /* ! __PCTOOL__ */
 452
 453 void adjust_mp3entry(struct mp3entry *entry, void *dest, const void *orig)
 454 {
 455     long offset;
 456     if (orig > dest)
 457         offset = - ((size_t)orig - (size_t)dest);
 458     else
 459         offset = (size_t)dest - (size_t)orig;
 460
 461     if (entry->title)
 462         entry->title += offset;
 463     if (entry->artist)
 464         entry->artist += offset;
 465     if (entry->album)
 466         entry->album += offset;
 467     if (entry->genre_string > (char*)orig
 468          && entry->genre_string < (char*)orig + sizeof(struct mp3entry))
 469         /* Don't adjust that if it points to an entry of the "genres" array */
 470         entry->genre_string += offset;
 471     if (entry->track_string)
 472         entry->track_string += offset;
 473     if (entry->disc_string)
 474         entry->disc_string += offset;
 475     if (entry->year_string)
 476         entry->year_string += offset;
 477     if (entry->composer)
 478         entry->composer += offset;
 479     if (entry->comment)
 480         entry->comment += offset;
 481     if (entry->albumartist)
 482         entry->albumartist += offset;
 483     if (entry->grouping)
 484         entry->grouping += offset;
 485 #if CONFIG_CODEC == SWCODEC
 486     if (entry->track_gain_string)
 487         entry->track_gain_string += offset;
 488     if (entry->album_gain_string)
 489         entry->album_gain_string += offset;
 490 #endif
 491     if (entry->mb_track_id)
 492         entry->mb_track_id += offset;
 493 }
 494
 495 void copy_mp3entry(struct mp3entry *dest, const struct mp3entry *orig)
 496 {
 497     memcpy(dest, orig, sizeof(struct mp3entry));
 498     adjust_mp3entry(dest, dest, orig);
 499 }