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