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