apps/metadata/metadata_common.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 "metadata.h"
  29 #include "metadata_common.h"
  30 #include "metadata_parsers.h"
  31 #include "replaygain.h"
  32 #include "misc.h"
  33
  34 /* Skip an ID3v2 tag if it can be found. We assume the tag is located at the
  35  * start of the file, which should be true in all cases where we need to skip it.
  36  * Returns true if successfully skipped or not skipped, and false if
  37  * something went wrong while skipping.
  38  */
  39 bool skip_id3v2(int fd, struct mp3entry *id3)
  40 {
  41     char buf[4];
  42
  43     read(fd, buf, 4);
  44     if (memcmp(buf, "ID3", 3) == 0)
  45     {
  46         /* We have found an ID3v2 tag at the start of the file - find its
  47            length and then skip it. */
  48         if ((id3->first_frame_offset = getid3v2len(fd)) == 0)
  49             return false;
  50
  51         if ((lseek(fd, id3->first_frame_offset, SEEK_SET) < 0))
  52             return false;
  53
  54         return true;
  55     } else {
  56         lseek(fd, 0, SEEK_SET);
  57         id3->first_frame_offset = 0;
  58         return true;
  59     }
  60 }
  61
  62
  63 /* Read a string from the file. Read up to size bytes, or, if eos != -1,
  64  * until the eos character is found (eos is not stored in buf, unless it is
  65  * nil). Writes up to buf_size chars to buf, always terminating with a nil.
  66  * Returns number of chars read or -1 on read error.
  67  */
  68 long read_string(int fd, char* buf, long buf_size, int eos, long size)
  69 {
  70     long read_bytes = 0;
  71     char c;
  72
  73     while (size != 0)
  74     {
  75         if (read(fd, &c, 1) != 1)
  76         {
  77             read_bytes = -1;
  78             break;
  79         }
  80
  81         read_bytes++;
  82         size--;
  83
  84         if ((eos != -1) && (eos == (unsigned char) c))
  85         {
  86             break;
  87         }
  88
  89         if (buf_size > 1)
  90         {
  91             *buf++ = c;
  92             buf_size--;
  93         }
  94     }
  95
  96     *buf = 0;
  97     return read_bytes;
  98 }
  99 /* Read an unsigned 8-bit integer from a file. */
 100 int read_uint8(int fd, uint8_t* buf)
 101 {
 102   size_t n;
 103
 104   n = read(fd, (char*) buf, 1);
 105   return n;
 106 }
 107
 108 #ifdef ROCKBOX_LITTLE_ENDIAN
 109 /* Read an unsigned 16-bit integer from a big-endian file. */
 110 int read_uint16be(int fd, uint16_t* buf)
 111 {
 112   size_t n;
 113
 114   n = read(fd, (char*) buf, 2);
 115   *buf = betoh16(*buf);
 116   return n;
 117 }
 118 /* Read an unsigned 32-bit integer from a big-endian file. */
 119 int read_uint32be(int fd, uint32_t* buf)
 120 {
 121   size_t n;
 122
 123   n = read(fd, (char*) buf, 4);
 124   *buf = betoh32(*buf);
 125   return n;
 126 }
 127 /* Read an unsigned 64-bit integer from a big-endian file. */
 128 int read_uint64be(int fd, uint64_t* buf)
 129 {
 130   size_t n;
 131   uint8_t data[8];
 132   int i;
 133
 134   n = read(fd, data, 8);
 135
 136   for (i=0, *buf=0; i<=7; i++) {
 137        *buf <<= 8;
 138        *buf |= data[i];
 139   }
 140   return n;
 141 }
 142 #else
 143 /* Read unsigned integers from a little-endian file. */
 144 int read_uint16le(int fd, uint16_t* buf)
 145 {
 146   size_t n;
 147
 148   n = read(fd, (char*) buf, 2);
 149   *buf = letoh16(*buf);
 150   return n;
 151 }
 152 int read_uint32le(int fd, uint32_t* buf)
 153 {
 154   size_t n;
 155
 156   n = read(fd, (char*) buf, 4);
 157   *buf = letoh32(*buf);
 158   return n;
 159 }
 160 int read_uint64le(int fd, uint64_t* buf)
 161 {
 162   size_t n;
 163   uint8_t data[8];
 164   int i;
 165
 166   n = read(fd, data, 8);
 167
 168   for (i=7, *buf=0; i>=0; i--) {
 169        *buf <<= 8;
 170        *buf |= data[i];
 171   }
 172
 173   return n;
 174 }
 175 #endif
 176
 177 /* Read an unaligned 32-bit little endian long from buffer. */
 178 unsigned long get_long_le(void* buf)
 179 {
 180     unsigned char* p = (unsigned char*) buf;
 181
 182     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
 183 }
 184
 185 /* Read an unaligned 16-bit little endian short from buffer. */
 186 unsigned short get_short_le(void* buf)
 187 {
 188     unsigned char* p = (unsigned char*) buf;
 189
 190     return p[0] | (p[1] << 8);
 191 }
 192
 193 /* Read an unaligned 32-bit big endian long from buffer. */
 194 unsigned long get_long_be(void* buf)
 195 {
 196     unsigned char* p = (unsigned char*) buf;
 197
 198     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 199 }
 200
 201 /* Read an unaligned 32-bit little endian long from buffer. */
 202 long get_slong(void* buf)
 203 {
 204     unsigned char* p = (unsigned char*) buf;
 205
 206     return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
 207 }
 208
 209 unsigned long get_itunes_int32(char* value, int count)
 210 {
 211     static const char hexdigits[] = "0123456789ABCDEF";
 212     const char* c;
 213     int r = 0;
 214
 215     while (count-- > 0)
 216     {
 217         value = skip_whitespace(value);
 218
 219         while (*value && !isspace(*value))
 220         {
 221             value++;
 222         }
 223     }
 224
 225     value = skip_whitespace(value);
 226
 227     while (*value && ((c = strchr(hexdigits, toupper(*value))) != NULL))
 228     {
 229         r = (r << 4) | (c - hexdigits);
 230         value++;
 231     }
 232
 233     return r;
 234 }
 235
 236 /* Parse the tag (the name-value pair) and fill id3 and buffer accordingly.
 237  * String values to keep are written to buf. Returns number of bytes written
 238  * to buf (including end nil).
 239  */
 240 long parse_tag(const char* name, char* value, struct mp3entry* id3,
 241     char* buf, long buf_remaining, enum tagtype type)
 242 {
 243     long len = 0;
 244     char** p;
 245
 246     if ((((strcasecmp(name, "track") == 0) && (type == TAGTYPE_APE)))
 247         || ((strcasecmp(name, "tracknumber") == 0) && (type == TAGTYPE_VORBIS)))
 248     {
 249         id3->tracknum = atoi(value);
 250         p = &(id3->track_string);
 251     }
 252     else if (strcasecmp(name, "discnumber") == 0 || strcasecmp(name, "disc") == 0)
 253     {
 254         id3->discnum = atoi(value);
 255         p = &(id3->disc_string);
 256     }
 257     else if (((strcasecmp(name, "year") == 0) && (type == TAGTYPE_APE))
 258         || ((strcasecmp(name, "date") == 0) && (type == TAGTYPE_VORBIS)))
 259     {
 260         /* Date's can be in any format in Vorbis. However most of them
 261          * are in ISO8601 format so if we try and parse the first part
 262          * of the tag as a number, we should get the year. If we get crap,
 263          * then act like we never parsed it.
 264          */
 265         id3->year = atoi(value);
 266         if (id3->year < 1900)
 267         { /* yeah, not likely */
 268             id3->year = 0;
 269         }
 270         p = &(id3->year_string);
 271     }
 272     else if (strcasecmp(name, "title") == 0)
 273     {
 274         p = &(id3->title);
 275     }
 276     else if (strcasecmp(name, "artist") == 0)
 277     {
 278         p = &(id3->artist);
 279     }
 280     else if (strcasecmp(name, "album") == 0)
 281     {
 282         p = &(id3->album);
 283     }
 284     else if (strcasecmp(name, "genre") == 0)
 285     {
 286         p = &(id3->genre_string);
 287     }
 288     else if (strcasecmp(name, "composer") == 0)
 289     {
 290         p = &(id3->composer);
 291     }
 292     else if (strcasecmp(name, "comment") == 0)
 293     {
 294         p = &(id3->comment);
 295     }
 296     else if (strcasecmp(name, "albumartist") == 0)
 297     {
 298         p = &(id3->albumartist);
 299     }
 300     else if (strcasecmp(name, "album artist") == 0)
 301     {
 302         p = &(id3->albumartist);
 303     }
 304     else if (strcasecmp(name, "ensemble") == 0)
 305     {
 306         p = &(id3->albumartist);
 307     }
 308     else if (strcasecmp(name, "grouping") == 0)
 309     {
 310         p = &(id3->grouping);
 311     }
 312     else if (strcasecmp(name, "content group") == 0)
 313     {
 314         p = &(id3->grouping);
 315     }
 316     else if (strcasecmp(name, "contentgroup") == 0)
 317     {
 318         p = &(id3->grouping);
 319     }
 320     else if (strcasecmp(name, "musicbrainz_trackid") == 0
 321         || strcasecmp(name, "http://musicbrainz.org") == 0 )
 322     {
 323         p = &(id3->mb_track_id);
 324     }
 325     else
 326     {
 327         len = parse_replaygain(name, value, id3, buf, buf_remaining);
 328         p = NULL;
 329     }
 330
 331     if (p)
 332     {
 333         len = strlen(value);
 334         len = MIN(len, buf_remaining - 1);
 335
 336         if (len > 0)
 337         {
 338             len++;
 339             strlcpy(buf, value, len);
 340             *p = buf;
 341         }
 342         else
 343         {
 344             len = 0;
 345         }
 346     }
 347
 348     return len;
 349 }
 350