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