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 "system.h"
  28 #include "playback.h"
  29 #include "debug.h"
  30 #include "logf.h"
  31 #include "cuesheet.h"
  32 #include "metadata.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 #include "metadata/metadata_parsers.h"
  41
  42 #endif /* CONFIG_CODEC == SWCODEC */
  43
  44
  45 /* Simple file type probing by looking at the filename extension. */
  46 unsigned int probe_file_format(const char *filename)
  47 {
  48     char *suffix;
  49     unsigned int i;
  50
  51     suffix = strrchr(filename, '.');
  52
  53     if (suffix == NULL)
  54     {
  55         return AFMT_UNKNOWN;
  56     }
  57
  58     /* skip '.' */
  59     suffix++;
  60
  61     for (i = 1; i < AFMT_NUM_CODECS; i++)
  62     {
  63         /* search extension list for type */
  64         const char *ext = audio_formats[i].ext_list;
  65
  66         do
  67         {
  68             if (strcasecmp(suffix, ext) == 0)
  69             {
  70                 return i;
  71             }
  72
  73             ext += strlen(ext) + 1;
  74         }
  75         while (*ext != '\0');
  76     }
  77
  78     return AFMT_UNKNOWN;
  79 }
  80
  81 /* Get metadata for track - return false if parsing showed problems with the
  82  * file that would prevent playback.
  83  */
  84 bool get_metadata(struct mp3entry* id3, int fd, const char* trackname)
  85 {
  86 #if CONFIG_CODEC == SWCODEC
  87     unsigned char* buf;
  88 #endif
  89
  90     /* Clear the mp3entry to avoid having bogus pointers appear */
  91     memset(id3, 0, sizeof(struct mp3entry));
  92
  93     /* Take our best guess at the codec type based on file extension */
  94     id3->codectype = probe_file_format(trackname);
  95
  96     /* Load codec specific track tag information and confirm the codec type. */
  97     switch (id3->codectype)
  98     {
  99     case AFMT_MPA_L1:
 100     case AFMT_MPA_L2:
 101     case AFMT_MPA_L3:
 102         if (!get_mp3_metadata(fd, id3, trackname))
 103         {
 104             return false;
 105         }
 106
 107         break;
 108
 109 #if CONFIG_CODEC == SWCODEC
 110     case AFMT_FLAC:
 111         if (!get_flac_metadata(fd, id3))
 112         {
 113             return false;
 114         }
 115
 116         break;
 117
 118     case AFMT_WMA:
 119         if (!get_asf_metadata(fd, id3))
 120         {
 121             return false;
 122         }
 123         break;
 124
 125     case AFMT_APE:
 126         if (!get_monkeys_metadata(fd, id3))
 127         {
 128             return false;
 129         }
 130         read_ape_tags(fd, id3);
 131         break;
 132
 133     case AFMT_MPC:
 134         if (!get_musepack_metadata(fd, id3))
 135             return false;
 136         read_ape_tags(fd, id3);
 137         break;
 138
 139     case AFMT_OGG_VORBIS:
 140         if (!get_ogg_metadata(fd, id3))/*detects and handles Ogg/Speex files*/
 141         {
 142             return false;
 143         }
 144
 145         break;
 146
 147     case AFMT_SPEEX:
 148         if (!get_ogg_metadata(fd, id3))
 149         {
 150             return false;
 151         }
 152
 153         break;
 154
 155     case AFMT_PCM_WAV:
 156         if (!get_wave_metadata(fd, id3))
 157         {
 158             return false;
 159         }
 160
 161         break;
 162
 163     case AFMT_WAVPACK:
 164         if (!get_wavpack_metadata(fd, id3))
 165         {
 166             return false;
 167         }
 168
 169         read_ape_tags(fd, id3);     /* use any apetag info we find */
 170         break;
 171
 172     case AFMT_A52:
 173         if (!get_a52_metadata(fd, id3))
 174         {
 175             return false;
 176         }
 177
 178         break;
 179
 180     case AFMT_ALAC:
 181     case AFMT_AAC:
 182         if (!get_mp4_metadata(fd, id3))
 183         {
 184             return false;
 185         }
 186
 187         break;
 188
 189     case AFMT_MOD:
 190         if (!get_mod_metadata(fd, id3))
 191         {
 192             return false;
 193         }
 194
 195         break;
 196
 197     case AFMT_SHN:
 198         id3->vbr = true;
 199         id3->filesize = filesize(fd);
 200         if (!skip_id3v2(fd, id3))
 201         {
 202             return false;
 203         }
 204         /* TODO: read the id3v2 header if it exists */
 205         break;
 206
 207     case AFMT_SID:
 208         if (!get_sid_metadata(fd, id3))
 209         {
 210             return false;
 211         }
 212         break;
 213
 214     case AFMT_SPC:
 215         if (!get_spc_metadata(fd, id3))
 216         {
 217             DEBUGF("get_spc_metadata error\n");
 218             return false;
 219         }
 220         id3->filesize = filesize(fd);
 221         id3->genre_string = id3_get_num_genre(36);
 222         break;
 223
 224     case AFMT_ADX:
 225         if (!get_adx_metadata(fd, id3))
 226         {
 227             DEBUGF("get_adx_metadata error\n");
 228             return false;
 229         }
 230
 231         break;
 232
 233     case AFMT_NSF:
 234         buf = (unsigned char *)id3->path;
 235         if ((lseek(fd, 0, SEEK_SET) < 0) || ((read(fd, buf, 8)) < 8))
 236         {
 237             DEBUGF("lseek or read failed\n");
 238             return false;
 239         }
 240         id3->vbr = false;
 241         id3->filesize = filesize(fd);
 242         if (memcmp(buf,"NESM",4) && memcmp(buf,"NSFE",4)) return false;
 243         break;
 244
 245     case AFMT_AIFF:
 246         if (!get_aiff_metadata(fd, id3))
 247         {
 248             return false;
 249         }
 250
 251         break;
 252
 253 #endif /* CONFIG_CODEC == SWCODEC */
 254
 255     default:
 256         /* If we don't know how to read the metadata, assume we can't play
 257            the file */
 258         return false;
 259         break;
 260     }
 261
 262     /* We have successfully read the metadata from the file */
 263
 264 #ifndef __PCTOOL__
 265     if (cuesheet_is_enabled() && look_for_cuesheet_file(trackname, NULL))
 266     {
 267         id3->cuesheet_type = 1;
 268     }
 269 #endif
 270
 271     lseek(fd, 0, SEEK_SET);
 272     strncpy(id3->path, trackname, sizeof(id3->path));
 273
 274     return true;
 275 }
 276
 277 #if CONFIG_CODEC == SWCODEC
 278 void strip_tags(int handle_id)
 279 {
 280     static const unsigned char tag[] = "TAG";
 281     static const unsigned char apetag[] = "APETAGEX";
 282     size_t len, version;
 283     void *tail;
 284
 285     if (bufgettail(handle_id, 128, &tail) != 128)
 286         return;
 287
 288     if (memcmp(tail, tag, 3) == 0)
 289     {
 290         /* Skip id3v1 tag */
 291         logf("Cutting off ID3v1 tag");
 292         bufcuttail(handle_id, 128);
 293     }
 294
 295     /* Get a new tail, as the old one may have been cut */
 296     if (bufgettail(handle_id, 32, &tail) != 32)
 297         return;
 298
 299     /* Check for APE tag (look for the APE tag footer) */
 300     if (memcmp(tail, apetag, 8) != 0)
 301         return;
 302
 303     /* Read the version and length from the footer */
 304     version = get_long_le(&((unsigned char *)tail)[8]);
 305     len = get_long_le(&((unsigned char *)tail)[12]);
 306     if (version == 2000)
 307         len += 32; /* APEv2 has a 32 byte header */
 308
 309     /* Skip APE tag */
 310     logf("Cutting off APE tag (%ldB)", len);
 311     bufcuttail(handle_id, len);
 312 }
 313 #endif /* CONFIG_CODEC == SWCODEC */