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