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
  31 #if CONFIG_CODEC == SWCODEC
  32
  33 #include "metadata/metadata_common.h"
  34 #include "metadata/metadata_parsers.h"
  35
  36 static const unsigned short a52_bitrates[] =
  37 {
  38      32,  40,  48,  56,  64,  80,  96, 112, 128, 160,
  39     192, 224, 256, 320, 384, 448, 512, 576, 640
  40 };
  41
  42 /* Only store frame sizes for 44.1KHz - others are simply multiples
  43    of the bitrate */
  44 static const unsigned short a52_441framesizes[] =
  45 {
  46       69 * 2,   70 * 2,   87 * 2,   88 * 2,  104 * 2,  105 * 2,  121 * 2,
  47      122 * 2,  139 * 2,  140 * 2,  174 * 2,  175 * 2,  208 * 2,  209 * 2,
  48      243 * 2,  244 * 2,  278 * 2,  279 * 2,  348 * 2,  349 * 2,  417 * 2,
  49      418 * 2,  487 * 2,  488 * 2,  557 * 2,  558 * 2,  696 * 2,  697 * 2,
  50      835 * 2,  836 * 2,  975 * 2,  976 * 2, 1114 * 2, 1115 * 2, 1253 * 2,
  51     1254 * 2, 1393 * 2, 1394 * 2
  52 };
  53
  54 #endif /* CONFIG_CODEC == SWCODEC */
  55
  56
  57 /* Simple file type probing by looking at the filename extension. */
  58 unsigned int probe_file_format(const char *filename)
  59 {
  60     char *suffix;
  61     unsigned int i;
  62
  63     suffix = strrchr(filename, '.');
  64
  65     if (suffix == NULL)
  66     {
  67         return AFMT_UNKNOWN;
  68     }
  69
  70     /* skip '.' */
  71     suffix++;
  72
  73     for (i = 1; i < AFMT_NUM_CODECS; i++)
  74     {
  75         /* search extension list for type */
  76         const char *ext = audio_formats[i].ext_list;
  77
  78         do
  79         {
  80             if (strcasecmp(suffix, ext) == 0)
  81             {
  82                 return i;
  83             }
  84
  85             ext += strlen(ext) + 1;
  86         }
  87         while (*ext != '\0');
  88     }
  89
  90     return AFMT_UNKNOWN;
  91 }
  92
  93 /* Get metadata for track - return false if parsing showed problems with the
  94  * file that would prevent playback.
  95  */
  96 bool get_metadata(struct mp3entry* id3, int fd, const char* trackname)
  97 {
  98 #if CONFIG_CODEC == SWCODEC
  99     unsigned char* buf;
 100     unsigned long totalsamples;
 101     int i;
 102 #endif
 103
 104     /* Take our best guess at the codec type based on file extension */
 105     id3->codectype = probe_file_format(trackname);
 106
 107     /* Load codec specific track tag information and confirm the codec type. */
 108     switch (id3->codectype)
 109     {
 110     case AFMT_MPA_L1:
 111     case AFMT_MPA_L2:
 112     case AFMT_MPA_L3:
 113         if (!get_mp3_metadata(fd, id3, trackname))
 114         {
 115             return false;
 116         }
 117
 118         break;
 119
 120 #if CONFIG_CODEC == SWCODEC
 121     case AFMT_FLAC:
 122         if (!get_flac_metadata(fd, id3))
 123         {
 124             return false;
 125         }
 126
 127         break;
 128
 129     case AFMT_WMA:
 130         if (!get_asf_metadata(fd, id3))
 131         {
 132             return false;
 133         }
 134         break;
 135
 136     case AFMT_APE:
 137         if (!get_monkeys_metadata(fd, id3))
 138         {
 139             return false;
 140         }
 141         read_ape_tags(fd, id3);
 142         break;
 143
 144     case AFMT_MPC:
 145         if (!get_musepack_metadata(fd, id3))
 146             return false;
 147         read_ape_tags(fd, id3);
 148         break;
 149
 150     case AFMT_OGG_VORBIS:
 151         if (!get_vorbis_metadata(fd, id3))/*detects and handles Ogg/Speex files*/
 152         {
 153             return false;
 154         }
 155
 156         break;
 157
 158     case AFMT_SPEEX:
 159         if (!get_speex_metadata(fd, id3))
 160         {
 161             return false;
 162         }
 163
 164         break;
 165
 166     case AFMT_PCM_WAV:
 167         if (!get_wave_metadata(fd, id3))
 168         {
 169             return false;
 170         }
 171
 172         break;
 173
 174     case AFMT_WAVPACK:
 175         if (!get_wavpack_metadata(fd, id3))
 176             return false;
 177
 178         read_ape_tags(fd, id3);     /* use any apetag info we find */
 179         break;
 180
 181     case AFMT_A52:
 182         /* Use the trackname part of the id3 structure as a temporary buffer */
 183         buf = (unsigned char *)id3->path;
 184
 185         if ((lseek(fd, 0, SEEK_SET) < 0) || (read(fd, buf, 5) < 5))
 186         {
 187             return false;
 188         }
 189
 190         if ((buf[0] != 0x0b) || (buf[1] != 0x77))
 191         {
 192             logf("%s is not an A52/AC3 file\n",trackname);
 193             return false;
 194         }
 195
 196         i = buf[4] & 0x3e;
 197
 198         if (i > 36)
 199         {
 200             logf("A52: Invalid frmsizecod: %d\n",i);
 201             return false;
 202         }
 203
 204         id3->bitrate = a52_bitrates[i >> 1];
 205         id3->vbr = false;
 206         id3->filesize = filesize(fd);
 207
 208         switch (buf[4] & 0xc0)
 209         {
 210         case 0x00:
 211             id3->frequency = 48000;
 212             id3->bytesperframe=id3->bitrate * 2 * 2;
 213             break;
 214
 215         case 0x40:
 216             id3->frequency = 44100;
 217             id3->bytesperframe = a52_441framesizes[i];
 218             break;
 219
 220         case 0x80:
 221             id3->frequency = 32000;
 222             id3->bytesperframe = id3->bitrate * 3 * 2;
 223             break;
 224
 225         default:
 226             logf("A52: Invalid samplerate code: 0x%02x\n", buf[4] & 0xc0);
 227             return false;
 228             break;
 229         }
 230
 231         /* One A52 frame contains 6 blocks, each containing 256 samples */
 232         totalsamples = id3->filesize / id3->bytesperframe * 6 * 256;
 233         id3->length = totalsamples / id3->frequency * 1000;
 234         break;
 235
 236     case AFMT_ALAC:
 237     case AFMT_AAC:
 238         if (!get_mp4_metadata(fd, id3))
 239         {
 240             return false;
 241         }
 242
 243         break;
 244
 245     case AFMT_SHN:
 246         id3->vbr = true;
 247         id3->filesize = filesize(fd);
 248         if (!skip_id3v2(fd, id3))
 249         {
 250             return false;
 251         }
 252         /* TODO: read the id3v2 header if it exists */
 253         break;
 254
 255     case AFMT_SID:
 256         if (!get_sid_metadata(fd, id3))
 257         {
 258             return false;
 259         }
 260         break;
 261     case AFMT_SPC:
 262         if(!get_spc_metadata(fd, id3))
 263         {
 264             DEBUGF("get_spc_metadata error\n");
 265         }
 266
 267         id3->filesize = filesize(fd);
 268         id3->genre_string = id3_get_num_genre(36);
 269         break;
 270     case AFMT_ADX:
 271         if (!get_adx_metadata(fd, id3))
 272         {
 273             DEBUGF("get_adx_metadata error\n");
 274             return false;
 275         }
 276
 277         break;
 278     case AFMT_NSF:
 279         buf = (unsigned char *)id3->path;
 280         if ((lseek(fd, 0, SEEK_SET) < 0) || ((read(fd, buf, 8)) < 8))
 281         {
 282             DEBUGF("lseek or read failed\n");
 283             return false;
 284         }
 285         id3->vbr = false;
 286         id3->filesize = filesize(fd);
 287         if (memcmp(buf,"NESM",4) && memcmp(buf,"NSFE",4)) return false;
 288         break;
 289
 290     case AFMT_AIFF:
 291         if (!get_aiff_metadata(fd, id3))
 292         {
 293             return false;
 294         }
 295
 296         break;
 297
 298 #endif /* CONFIG_CODEC == SWCODEC */
 299
 300     default:
 301         /* If we don't know how to read the metadata, assume we can't play
 302            the file */
 303         return false;
 304         break;
 305     }
 306
 307     /* We have successfully read the metadata from the file */
 308
 309 #ifndef __PCTOOL__
 310     if (cuesheet_is_enabled() && look_for_cuesheet_file(trackname, NULL))
 311     {
 312         id3->cuesheet_type = 1;
 313     }
 314 #endif
 315
 316     lseek(fd, 0, SEEK_SET);
 317     strncpy(id3->path, trackname, sizeof(id3->path));
 318
 319     return true;
 320 }
 321