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                   bool v1first)
  98 {
  99 #if CONFIG_CODEC == SWCODEC
 100     unsigned char* buf;
 101     unsigned long totalsamples;
 102     int i;
 103 #endif
 104
 105     /* Take our best guess at the codec type based on file extension */
 106     id3->codectype = probe_file_format(trackname);
 107
 108     /* Load codec specific track tag information and confirm the codec type. */
 109     switch (id3->codectype)
 110     {
 111     case AFMT_MPA_L1:
 112     case AFMT_MPA_L2:
 113     case AFMT_MPA_L3:
 114         if (!get_mp3_metadata(fd, id3, trackname, v1first))
 115         {
 116             return false;
 117         }
 118
 119         break;
 120
 121 #if CONFIG_CODEC == SWCODEC
 122     case AFMT_FLAC:
 123         if (!get_flac_metadata(fd, id3))
 124         {
 125             return false;
 126         }
 127
 128         break;
 129
 130     case AFMT_WMA:
 131         if (!get_asf_metadata(fd, id3))
 132         {
 133             return false;
 134         }
 135         break;
 136
 137     case AFMT_APE:
 138         if (!get_monkeys_metadata(fd, id3))
 139         {
 140             return false;
 141         }
 142         read_ape_tags(fd, id3);
 143         break;
 144
 145     case AFMT_MPC:
 146         if (!get_musepack_metadata(fd, id3))
 147             return false;
 148         read_ape_tags(fd, id3);
 149         break;
 150
 151     case AFMT_OGG_VORBIS:
 152         if (!get_vorbis_metadata(fd, id3))/*detects and handles Ogg/Speex files*/
 153         {
 154             return false;
 155         }
 156
 157         break;
 158
 159     case AFMT_SPEEX:
 160         if (!get_speex_metadata(fd, id3))
 161         {
 162             return false;
 163         }
 164
 165         break;
 166
 167     case AFMT_PCM_WAV:
 168         if (!get_wave_metadata(fd, id3))
 169         {
 170             return false;
 171         }
 172
 173         break;
 174
 175     case AFMT_WAVPACK:
 176         if (!get_wavpack_metadata(fd, id3))
 177             return false;
 178
 179         read_ape_tags(fd, id3);     /* use any apetag info we find */
 180         break;
 181
 182     case AFMT_A52:
 183         /* Use the trackname part of the id3 structure as a temporary buffer */
 184         buf = (unsigned char *)id3->path;
 185
 186         if ((lseek(fd, 0, SEEK_SET) < 0) || (read(fd, buf, 5) < 5))
 187         {
 188             return false;
 189         }
 190
 191         if ((buf[0] != 0x0b) || (buf[1] != 0x77))
 192         {
 193             logf("%s is not an A52/AC3 file\n",trackname);
 194             return false;
 195         }
 196
 197         i = buf[4] & 0x3e;
 198
 199         if (i > 36)
 200         {
 201             logf("A52: Invalid frmsizecod: %d\n",i);
 202             return false;
 203         }
 204
 205         id3->bitrate = a52_bitrates[i >> 1];
 206         id3->vbr = false;
 207         id3->filesize = filesize(fd);
 208
 209         switch (buf[4] & 0xc0)
 210         {
 211         case 0x00:
 212             id3->frequency = 48000;
 213             id3->bytesperframe=id3->bitrate * 2 * 2;
 214             break;
 215
 216         case 0x40:
 217             id3->frequency = 44100;
 218             id3->bytesperframe = a52_441framesizes[i];
 219             break;
 220
 221         case 0x80:
 222             id3->frequency = 32000;
 223             id3->bytesperframe = id3->bitrate * 3 * 2;
 224             break;
 225
 226         default:
 227             logf("A52: Invalid samplerate code: 0x%02x\n", buf[4] & 0xc0);
 228             return false;
 229             break;
 230         }
 231
 232         /* One A52 frame contains 6 blocks, each containing 256 samples */
 233         totalsamples = id3->filesize / id3->bytesperframe * 6 * 256;
 234         id3->length = totalsamples / id3->frequency * 1000;
 235         break;
 236
 237     case AFMT_ALAC:
 238     case AFMT_AAC:
 239         if (!get_mp4_metadata(fd, id3))
 240         {
 241             return false;
 242         }
 243
 244         break;
 245
 246     case AFMT_SHN:
 247         id3->vbr = true;
 248         id3->filesize = filesize(fd);
 249         if (!skip_id3v2(fd, id3))
 250         {
 251             return false;
 252         }
 253         /* TODO: read the id3v2 header if it exists */
 254         break;
 255
 256     case AFMT_SID:
 257         if (!get_sid_metadata(fd, id3))
 258         {
 259             return false;
 260         }
 261         break;
 262     case AFMT_SPC:
 263         if(!get_spc_metadata(fd, id3))
 264         {
 265             DEBUGF("get_spc_metadata error\n");
 266         }
 267
 268         id3->filesize = filesize(fd);
 269         id3->genre_string = id3_get_num_genre(36);
 270         break;
 271     case AFMT_ADX:
 272         if (!get_adx_metadata(fd, id3))
 273         {
 274             DEBUGF("get_adx_metadata error\n");
 275             return false;
 276         }
 277
 278         break;
 279     case AFMT_NSF:
 280         buf = (unsigned char *)id3->path;
 281         if ((lseek(fd, 0, SEEK_SET) < 0) || ((read(fd, buf, 8)) < 8))
 282         {
 283             DEBUGF("lseek or read failed\n");
 284             return false;
 285         }
 286         id3->vbr = false;
 287         id3->filesize = filesize(fd);
 288         if (memcmp(buf,"NESM",4) && memcmp(buf,"NSFE",4)) return false;
 289         break;
 290
 291     case AFMT_AIFF:
 292         if (!get_aiff_metadata(fd, id3))
 293         {
 294             return false;
 295         }
 296
 297         break;
 298
 299 #endif /* CONFIG_CODEC == SWCODEC */
 300
 301     default:
 302         /* If we don't know how to read the metadata, assume we can't play
 303            the file */
 304         return false;
 305         break;
 306     }
 307
 308     /* We have successfully read the metadata from the file */
 309
 310 #ifndef __PCTOOL__
 311     if (cuesheet_is_enabled() && look_for_cuesheet_file(trackname, NULL))
 312     {
 313         id3->cuesheet_type = 1;
 314     }
 315 #endif
 316
 317     lseek(fd, 0, SEEK_SET);
 318     strncpy(id3->path, trackname, sizeof(id3->path));
 319
 320     return true;
 321 }
 322