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