Added code to handle APEv2 tags for WavPack files, although this should be

applicable to Musepack files (and even MP3 files sometimes). Perhaps this
should be integrated with the ID3 tag stuff at some point?


git-svn-id: svn://svn.rockbox.org/rockbox/trunk@6769 a1c6a512-1295-4272-9138-f99709370657

1 files changed, 292 insertions, 0 deletions

diff --git a/apps/metadata.c b/apps/metadata.c
index 2e39ab1685..540e62c4aa 100644
--- a/apps/metadata.c
+++ b/apps/metadata.c
@@ -25,6 +25,7 @@
 #include "mp3_playback.h"
 #include "mp3data.h"
 #include "logf.h"
+#include "atoi.h"
 
 /* Simple file type probing by looking filename extension. */
 int probe_file_format(const char *filename)
@@ -85,6 +86,8 @@ unsigned short a52_441framesizes[]=
 /* Get metadata for track - return false if parsing showed problems with the
    file that would prevent playback. */
 
+static bool get_apetag_info (struct mp3entry *entry, int fd);
+
 bool get_metadata(struct track_info* track, int fd, const char* trackname,
                   bool v1first) {
   unsigned long totalsamples,bytespersample,channels,bitspersample,numbytes;
@@ -341,6 +344,7 @@ bool get_metadata(struct track_info* track, int fd, const char* trackname,
                   (track->id3.length / 8);
       }
 
+      get_apetag_info (&track->id3, fd);    /* use any apetag info we find */
       lseek (fd, 0, SEEK_SET);
       strncpy (track->id3.path, trackname, sizeof (track->id3.path));
       track->taginfo_ready = true;
@@ -411,3 +415,291 @@ bool get_metadata(struct track_info* track, int fd, const char* trackname,
 
   return true;
 }
+
+/************************* APE TAG HANDLING CODE ****************************/
+
+/*
+ * This is a first pass at APEv2 tag handling. I'm not sure if this should
+ * reside here, but I wanted to modify as little as possible since I don't
+ * have a feel for the complete system. It may be that APEv2 tags should be
+ * added to the ID3 handling code in the firmware directory. APEv2 tags are
+ * used in WavPack files and Musepack files by default, however they are
+ * also used in MP3 files sometimes (by Foobar2000). Also, WavPack files can
+ * also use ID3v1 tags (but not ID3v2), so it seems like some universal tag
+ * handler might be a reasonable approach.
+ *
+ * This code does not currently handle APEv1 tags, but I believe that this
+ * is not a problem because they were only used in Monkey's Audio files which
+ * will probably never be playable in RockBox (and certainly not by this CPU).
+ */
+
+#define APETAG_HEADER_FORMAT "8LLLL"
+#define APETAG_HEADER_LENGTH 32
+#define APETAG_DATA_LIMIT 4096
+
+struct apetag_header {
+    char id [8];
+    long version, length, item_count, flags;
+    char res [8];
+};
+
+static struct apetag {
+    struct apetag_header header;
+    char data [APETAG_DATA_LIMIT];
+} temp_apetag;
+
+static int get_apetag_item (struct apetag *tag,
+                            const char *item,
+                            char *value,
+                            int size);
+
+static int load_apetag (int fd, struct apetag *tag);
+static void UTF8ToAnsi (unsigned char *pUTF8);
+
+/*
+ * This function searches the specified file for an APEv2 tag and uses any
+ * information found there to populate the appropriate fields in the specified
+ * mp3entry structure. A temporary buffer is used to hold the tag during this
+ * operation. For now, the actual string data that needs to be held during the
+ * life of the track entry is stored in the "id3v2buf" field (which should not
+ * be used for any file that has an APEv2 tag). This limits the total space
+ * for the artist, title, album, composer and genre strings to 300 characters.
+ */
+
+static bool get_apetag_info (struct mp3entry *entry, int fd)
+{
+    int rem_space = sizeof (entry->id3v2buf), str_space;
+    char *temp_buffer = entry->id3v2buf;
+
+    if (rem_space <= 1 || !load_apetag (fd, &temp_apetag))
+        return false;
+
+    if (get_apetag_item (&temp_apetag, "year", temp_buffer, rem_space))
+        entry->year = atoi (temp_buffer);
+
+    if (get_apetag_item (&temp_apetag, "track", temp_buffer, rem_space))
+        entry->tracknum = atoi (temp_buffer);
+
+    if (get_apetag_item (&temp_apetag, "artist", temp_buffer, rem_space)) {
+        UTF8ToAnsi (entry->artist = temp_buffer);
+        str_space = strlen (temp_buffer) + 1;
+        temp_buffer += str_space;
+        rem_space -= str_space;
+    }
+
+    if (rem_space > 1 &&
+        get_apetag_item (&temp_apetag, "title", temp_buffer, rem_space)) {
+            UTF8ToAnsi (entry->title = temp_buffer);
+            str_space = strlen (temp_buffer) + 1;
+            temp_buffer += str_space;
+            rem_space -= str_space;
+    }
+
+    if (rem_space > 1 &&
+        get_apetag_item (&temp_apetag, "album", temp_buffer, rem_space)) {
+            UTF8ToAnsi (entry->album = temp_buffer);
+            str_space = strlen (temp_buffer) + 1;
+            temp_buffer += str_space;
+            rem_space -= str_space;
+    }
+
+    if (rem_space > 1 &&
+        get_apetag_item (&temp_apetag, "genre", temp_buffer, rem_space)) {
+            UTF8ToAnsi (entry->genre_string = temp_buffer);
+            str_space = strlen (temp_buffer) + 1;
+            temp_buffer += str_space;
+            rem_space -= str_space;
+    }
+
+    if (rem_space > 1 &&
+        get_apetag_item (&temp_apetag, "composer", temp_buffer, rem_space))
+            UTF8ToAnsi (entry->composer = temp_buffer);
+
+    return true;
+}
+
+/*
+ * Helper function to convert little-endian structures to easily usable native
+ * format using a format string (this does nothing on a little-endian machine).
+ */ 
+
+static void little_endian_to_native (void *data, char *format)
+{
+    unsigned char *cp = (unsigned char *) data;
+    long temp;
+
+    while (*format) {
+        switch (*format) {
+            case 'L':
+                temp = cp [0] + ((long) cp [1] << 8) + ((long) cp [2] << 16) + ((long) cp [3] << 24);
+                * (long *) cp = temp;
+                cp += 4;
+                break;
+
+            case 'S':
+                temp = cp [0] + (cp [1] << 8);
+                * (short *) cp = (short) temp;
+                cp += 2;
+                break;
+
+            default:
+                if (*format >= '0' && *format <= '9')
+                    cp += *format - '0';
+
+                break;
+        }
+
+        format++;
+    }
+}
+
+/*
+ * Attempt to obtain the named string-type item from the specified APEv2 tag.
+ * The tag value will be copied to "value" (including an appended terminating
+ * NULL) and the length of the string (including the NULL) will be returned.
+ * If the data will not fit in the specified "size" then it will be truncated
+ * early (but still terminated). If the specified item is not found then 0 is
+ * returned and written to the first character of "value". If "value" is
+ * passed in as NULL, then the specified size is ignored and the actual size
+ * required to store the value is returned.
+ *
+ * Note that this function does not work on binary tag data; only UTF-8
+ * encoded strings. However, numeric data (like ReplayGain) is usually stored
+ * as strings.
+ *
+ * Also, APEv2 tags may have multiple values for a given item and these will
+ * all be copied to "value" with NULL separators (this is why the total data
+ * size is returned). Of course, it is possible to ignore any additional
+ * values by simply using up to the first NULL.
+ */
+
+static int get_apetag_item (struct apetag *tag,
+                            const char *item,
+                            char *value,
+                            int size)
+{
+    if (value && size)
+        *value = 0;
+
+    if (tag->header.id [0] == 'A') {
+        char *p = tag->data;
+        char *q = p + tag->header.length - APETAG_HEADER_LENGTH;
+        int i;
+
+        for (i = 0; i < tag->header.item_count; ++i) {
+            int vsize, flags, isize;
+
+            vsize = * (long *) p; p += 4;
+            flags = * (long *) p; p += 4;
+            isize = strlen (p);
+
+            little_endian_to_native (&vsize, "L");
+            little_endian_to_native (&flags, "L");
+
+            if (p + isize + vsize + 1 > q)
+                break;
+
+            if (isize && vsize && !stricmp (item, p) && !(flags & 6)) {
+
+                if (value) {
+                    if (vsize + 1 > size)
+                        vsize = size - 1;
+
+                    memcpy (value, p + isize + 1, vsize);
+                    value [vsize] = 0;
+                }
+
+                return vsize + 1;
+            }
+            else
+                p += isize + vsize + 1;
+        }
+    }
+
+    return 0;
+}
+
+/*
+ * Attempt to load an APEv2 tag from the specified file into the specified
+ * structure. If the APEv2 tag will not fit into the predefined data size,
+ * then the tag is not loaded. A return value of TRUE indicates success.
+ */
+
+static int load_apetag (int fd, struct apetag *tag)
+{
+    if (lseek (fd, -APETAG_HEADER_LENGTH, SEEK_END) == -1 ||
+        read (fd, &tag->header, APETAG_HEADER_LENGTH) != APETAG_HEADER_LENGTH ||
+        strncmp (tag->header.id, "APETAGEX", 8)) {
+            tag->header.id [0] = 0;
+            return false;
+    }
+
+    little_endian_to_native (&tag->header, APETAG_HEADER_FORMAT);
+
+    if (tag->header.version == 2000 && tag->header.item_count &&
+        tag->header.length > APETAG_HEADER_LENGTH &&
+        tag->header.length < APETAG_DATA_LIMIT) {
+
+            int data_size = tag->header.length - APETAG_HEADER_LENGTH;
+
+            if (lseek (fd, -tag->header.length, SEEK_END) == -1 ||
+                read (fd, tag->data, data_size) != data_size) {
+                    tag->header.id [0] = 0;
+                    return false;
+            }
+            else
+                return true;
+    }
+
+    tag->header.id [0] = 0;
+    return false;
+}
+
+/*
+ * This is a *VERY* boneheaded attempt to convert UTF-8 unicode character
+ * strings to ANSI. It simply maps the 16-bit Unicode characters that are
+ * less than 0x100 directly to an 8-bit value, and turns all the rest into
+ * question marks. This can be done "in-place" because the resulting string
+ * can only get smaller.
+ */
+
+static void UTF8ToAnsi (unsigned char *pUTF8)
+{
+    unsigned char *pAnsi = pUTF8;
+    unsigned short widechar = 0;
+    int trail_bytes = 0;
+
+    while (*pUTF8) {
+        if (*pUTF8 & 0x80) {
+            if (*pUTF8 & 0x40) {
+                if (trail_bytes) {
+                    trail_bytes = 0;
+                    *pAnsi++ = widechar < 0x100 ? widechar : '?';
+                }
+                else {
+                    char temp = *pUTF8;
+
+                    while (temp & 0x80) {
+                        trail_bytes++;
+                        temp <<= 1;
+                    }
+
+                    widechar = temp >> trail_bytes--;
+                }
+            }
+            else if (trail_bytes) {
+                widechar = (widechar << 6) | (*pUTF8 & 0x3f);
+
+                if (!--trail_bytes)
+                    *pAnsi++ = widechar < 0x100 ? widechar : '?';
+            }
+        }
+        else
+            *pAnsi++ = *pUTF8;
+
+        pUTF8++;
+    }
+
+    *pAnsi = 0;
+}
+