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