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