10 files changed, 591 insertions, 3 deletions

diff --git a/apps/metadata/ay.c b/apps/metadata/ay.c
new file mode 100644
index 0000000000..8b737a7eba
--- /dev/null
+++ b/apps/metadata/ay.c
@@ -0,0 +1,148 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <inttypes.h>
+
+#include "system.h"
+#include "metadata.h"
+#include "metadata_common.h"
+#include "metadata_parsers.h"
+#include "rbunicode.h"
+
+/* Taken from blargg's Game_Music_Emu library */
+
+typedef unsigned char byte;
+
+/* AY file header */
+enum { header_size = 0x14 };
+struct header_t
+{
+    byte tag[8];
+    byte vers;
+    byte player;
+    byte unused[2];
+    byte author[2];
+    byte comment[2];
+    byte max_track;
+    byte first_track;
+    byte track_info[2];
+};
+
+struct file_t {
+        struct header_t const* header;
+        byte const* tracks;
+        byte const* end;    /* end of file data */
+};
+
+static int get_be16( const void *a )
+{
+    return get_short_be( (void*) a );
+}
+
+/* Given pointer to 2-byte offset of data, returns pointer to data, or NULL if
+ * offset is 0 or there is less than min_size bytes of data available. */
+static byte const* get_data( struct file_t const* file, byte const ptr [], int min_size )
+{
+    int offset = (int16_t) get_be16( ptr );
+    int pos  = ptr - (byte const*) file->header;
+    int size = file->end - (byte const*) file->header;
+    int limit = size - min_size;
+    if ( limit < 0 || !offset || (unsigned) (pos + offset) > (unsigned) limit )
+        return NULL;
+    return ptr + offset;
+}
+
+static const char *parse_header( byte const in [], int size, struct file_t* out )
+{
+    if ( size < header_size )
+        return "wrong file type";
+
+    out->header = (struct header_t const*) in;
+    out->end    = in + size;
+    struct header_t const* h = (struct header_t const*) in;
+    if ( memcmp( h->tag, "ZXAYEMUL", 8 ) )
+        return "wrong file type";
+
+    out->tracks = get_data( out, h->track_info, (h->max_track + 1) * 4 );
+    if ( !out->tracks )
+        return "missing track data";
+
+    return 0;
+}
+
+static void copy_ay_fields( struct file_t const* file, struct mp3entry* id3, int track )
+{
+    int track_count = file->header->max_track + 1;
+
+    /* calculate track length based on number of subtracks */
+    if (track_count > 1) {
+        id3->length = file->header->max_track * 1000;
+    } else {
+        byte const* track_info = get_data( file, file->tracks + track * 4 + 2, 6 );
+        if (track_info)
+            id3->length = get_be16( track_info + 4 ) * (1000 / 50); /* frames to msec */
+        else id3->length = 120 * 1000;
+    }
+    
+    if ( id3->length <= 0 )
+        id3->length = 120 * 1000;  /* 2 minutes */ 
+
+    /* If meta info was found in the m3u skip next step */
+    if (id3->title && id3->title[0]) return;
+
+    /* If file has more than one track will
+        use file name as title */
+    char * tmp;
+    if (track_count <= 1) {
+        tmp = (char *) get_data( file, file->tracks + track * 4, 1 );
+        if ( tmp ) id3->title = tmp;
+    }
+
+    /* Author */
+    tmp = (char *) get_data( file, file->header->author, 1 );
+    if (tmp) id3->artist = tmp;
+    
+    /* Comment */
+    tmp = (char *) get_data( file, file->header->comment, 1 );
+    if (tmp) id3->comment = tmp;
+}
+
+bool parse_ay_header(int fd, struct mp3entry *id3)
+{
+    /* Use the trackname part of the id3 structure as a temporary buffer */
+    unsigned char* buf = (unsigned char *)id3->id3v2buf;
+    struct file_t file;
+    int read_bytes;
+
+    lseek(fd, 0, SEEK_SET);
+    if ((read_bytes = read(fd, buf, ID3V2_BUF_SIZE)) < header_size)
+        return false;
+
+    buf [ID3V2_BUF_SIZE] = '\0';
+    if ( parse_header( buf, read_bytes, &file ) ) 
+        return false;
+
+    copy_ay_fields( &file, id3, 0 );
+    return true;
+}
+
+bool get_ay_metadata(int fd, struct mp3entry* id3)
+{
+    char ay_type[8];
+    if ((lseek(fd, 0, SEEK_SET) < 0) ||
+         read(fd, ay_type, 8) < 8)
+        return false;
+
+    id3->vbr = false;
+    id3->filesize = filesize(fd);
+
+    id3->bitrate = 706;
+    id3->frequency = 44100;
+  
+    /* Make sure this is a ZX Ay file */
+    if (memcmp( ay_type, "ZXAYEMUL", 8 ) != 0)
+        return false;
+
+    return parse_ay_header(fd, id3);
+}
diff --git a/apps/metadata/gbs.c b/apps/metadata/gbs.c
new file mode 100644
index 0000000000..796db5932f
--- /dev/null
+++ b/apps/metadata/gbs.c
@@ -0,0 +1,65 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <inttypes.h>
+
+#include "system.h"
+#include "metadata.h"
+#include "metadata_common.h"
+#include "metadata_parsers.h"
+#include "rbunicode.h"
+
+bool parse_gbs_header(int fd, struct mp3entry* id3)
+{
+    /* Use the trackname part of the id3 structure as a temporary buffer */
+    unsigned char* buf = (unsigned char *)id3->path;
+    lseek(fd, 0, SEEK_SET);
+    if (read(fd, buf, 112) < 112)
+        return false;
+
+    /* Calculate track length with number of subtracks */
+    id3->length = buf[4] * 1000;
+
+    /* If meta info was found in the m3u skip next step */
+    if (id3->title && id3->title[0]) return true;
+    
+    char *p = id3->id3v2buf;
+
+    /* Some metadata entries have 32 bytes length */
+    /* Game */
+    memcpy(p, &buf[16], 32); *(p + 33) = '\0';
+    id3->title = p;
+    p += strlen(p)+1;
+
+    /* Artist */
+    memcpy(p, &buf[48], 32); *(p + 33) = '\0';
+    id3->artist = p;
+    p += strlen(p)+1;
+
+    /* Copyright */
+    memcpy(p, &buf[80], 32); *(p + 33) = '\0';
+    id3->album = p;
+
+    return true;
+}
+
+bool get_gbs_metadata(int fd, struct mp3entry* id3)
+{
+    char gbs_type[3];
+    if ((lseek(fd, 0, SEEK_SET) < 0) ||
+         (read(fd, gbs_type, 3) < 3))
+        return false;
+
+    id3->vbr = false;
+    id3->filesize = filesize(fd);
+    /* we only render 16 bits, 44.1KHz, Stereo */
+    id3->bitrate = 706;
+    id3->frequency = 44100;
+
+    /* Check for GBS magic */
+    if (memcmp( gbs_type, "GBS", 3 ) != 0)
+        return false;
+
+    return parse_gbs_header(fd, id3);
+}
diff --git a/apps/metadata/hes.c b/apps/metadata/hes.c
new file mode 100644
index 0000000000..6d99d523cb
--- /dev/null
+++ b/apps/metadata/hes.c
@@ -0,0 +1,39 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <inttypes.h>
+
+#include "system.h"
+#include "metadata.h"
+#include "metadata_common.h"
+#include "metadata_parsers.h"
+#include "rbunicode.h"
+#include "plugin.h"
+
+bool get_hes_metadata(int fd, struct mp3entry* id3)
+{
+    /* Use the id3v2 buffer part of the id3 structure as a temporary buffer */
+    unsigned char* buf = (unsigned char *)id3->id3v2buf;
+    int read_bytes;
+
+    if ((lseek(fd, 0, SEEK_SET) < 0) 
+         || ((read_bytes = read(fd, buf, 4)) < 4))
+        return false;
+
+    /* Verify this is a HES file */
+    if (memcmp(buf,"HESM",4) != 0)
+        return false;
+
+    id3->vbr = false;
+    id3->filesize = filesize(fd);
+    /* we only render 16 bits, 44.1KHz, Stereo */
+    id3->bitrate = 706;
+    id3->frequency = 44100;
+
+    /* Set default track count (length)*/
+    id3->length = 255 * 1000;
+
+    return true;
+}
+
diff --git a/apps/metadata/kss.c b/apps/metadata/kss.c
new file mode 100644
index 0000000000..ecb59b8353
--- /dev/null
+++ b/apps/metadata/kss.c
@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <inttypes.h>
+
+#include "system.h"
+#include "metadata.h"
+#include "metadata_common.h"
+#include "metadata_parsers.h"
+#include "rbunicode.h"
+
+bool parse_kss_header(int fd, struct mp3entry* id3)
+{
+    /* Use the trackname part of the id3 structure as a temporary buffer */
+    unsigned char* buf = (unsigned char *)id3->path;
+
+     lseek(fd, 0, SEEK_SET);
+     if (read(fd, buf, 0x20) < 0x20)
+        return false;
+
+    /* calculate track length with number of tracks */
+    id3->length = 0;
+    if (buf[14] == 0x10) {
+        id3->length = (get_short_le((void *)(buf + 26)) + 1) * 1000;
+    }
+    
+    if (id3->length <= 0)
+        id3->length = 255 * 1000; /* 255 tracks */
+
+    return true;
+}
+
+
+bool get_kss_metadata(int fd, struct mp3entry* id3)
+{
+   uint32_t kss_type;
+    if ((lseek(fd, 0, SEEK_SET) < 0) ||
+         read_uint32be(fd, &kss_type) != (int)sizeof(kss_type))
+        return false;
+
+    id3->vbr = false;
+    id3->filesize = filesize(fd);
+    /* we only render 16 bits, 44.1KHz, Stereo */
+    id3->bitrate = 706;
+    id3->frequency = 44100;
+  
+    /* Make sure this is an SGC file */
+    if (kss_type != FOURCC('K','S','C','C') && kss_type != FOURCC('K','S','S','X'))
+        return false;
+
+    return parse_kss_header(fd, id3);
+}
diff --git a/apps/metadata/metadata_common.c b/apps/metadata/metadata_common.c
index 6c420d921f..1ad89d1b7a 100644
--- a/apps/metadata/metadata_common.c
+++ b/apps/metadata/metadata_common.c
@@ -178,6 +178,14 @@ unsigned long get_long_be(void* buf)
     return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
 }
 
+/* Read an unaligned 16-bit little endian short from buffer. */
+unsigned short get_short_be(void* buf)
+{
+    unsigned char* p = (unsigned char*) buf;
+
+    return (p[0] << 8) | p[1];
+}
+
 /* Read an unaligned 32-bit little endian long from buffer. */
 long get_slong(void* buf)
 {
diff --git a/apps/metadata/metadata_common.h b/apps/metadata/metadata_common.h
index b2c76afb45..a48c2a4e89 100644
--- a/apps/metadata/metadata_common.h
+++ b/apps/metadata/metadata_common.h
@@ -62,6 +62,7 @@ uint64_t get_uint64_le(void* buf);
 unsigned long get_long_le(void* buf);
 unsigned short get_short_le(void* buf);
 unsigned long get_long_be(void* buf);
+unsigned short get_short_be(void* buf);
 long get_slong(void* buf);
 unsigned long get_itunes_int32(char* value, int count);
 long parse_tag(const char* name, char* value, struct mp3entry* id3,
diff --git a/apps/metadata/metadata_parsers.h b/apps/metadata/metadata_parsers.h
index 7797b47094..adb7a82cd5 100644
--- a/apps/metadata/metadata_parsers.h
+++ b/apps/metadata/metadata_parsers.h
@@ -47,3 +47,9 @@ bool get_au_metadata(int fd, struct mp3entry* id3);
 bool get_vox_metadata(int fd, struct mp3entry* id3);
 bool get_wave64_metadata(int fd, struct mp3entry* id3);
 bool get_tta_metadata(int fd, struct mp3entry* id3);
+bool get_ay_metadata(int fd, struct mp3entry* id3);
+bool get_gbs_metadata(int fd, struct mp3entry* id3);
+bool get_hes_metadata(int fd, struct mp3entry* id3);
+bool get_sgc_metadata(int fd, struct mp3entry* id3);
+bool get_vgm_metadata(int fd, struct mp3entry* id3);
+bool get_kss_metadata(int fd, struct mp3entry* id3);
diff --git a/apps/metadata/nsf.c b/apps/metadata/nsf.c
index 29fd8475bb..2fa6f36b12 100644
--- a/apps/metadata/nsf.c
+++ b/apps/metadata/nsf.c
@@ -11,6 +11,9 @@
 #include "rbunicode.h"
 #include "string-extra.h"
 
+/* NOTE: This file was modified to work properly with the new nsf codec based
+    on Game_Music_Emu */
+
 struct NESM_HEADER
 {
     uint32_t        nHeader;
@@ -66,7 +69,7 @@ static bool parse_nsfe(int fd, struct mp3entry *id3)
 
      /* default values */
     info.nTrackCount = 1;
-    id3->length = 2*1000*60;
+    id3->length = 150 * 1000;
     
     /* begin reading chunks */
     while (!(chunks_found & CHUNK_NEND))
@@ -210,6 +213,10 @@ static bool parse_nsfe(int fd, struct mp3entry *id3)
     if (track_count | playlist_count)
         id3->length = MAX(track_count, playlist_count)*1000;
 
+    /* Single subtrack files will be treated differently
+        by gme's nsf codec */
+    if (id3->length <= 1000) id3->length = 150 * 1000;
+
     /*
      * if we exited the while loop without a 'return', we must have hit an NEND
      *  chunk if this is the case, the file was layed out as it was expected.
@@ -230,7 +237,7 @@ static bool parse_nesm(int fd, struct mp3entry *id3)
         return false;
 
     /* Length */
-    id3->length = hdr.nTrackCount*1000;
+    id3->length = (hdr.nTrackCount > 1 ? hdr.nTrackCount : 150) * 1000;
 
     /* Title */
     id3->title = p;
@@ -250,7 +257,6 @@ static bool parse_nesm(int fd, struct mp3entry *id3)
 bool get_nsf_metadata(int fd, struct mp3entry* id3)
 {
     uint32_t nsf_type;
-      
     if (lseek(fd, 0, SEEK_SET) < 0 ||
         read_uint32be(fd, &nsf_type) != (int)sizeof(nsf_type))
         return false;
diff --git a/apps/metadata/sgc.c b/apps/metadata/sgc.c
new file mode 100644
index 0000000000..9e16de2c76
--- /dev/null
+++ b/apps/metadata/sgc.c
@@ -0,0 +1,67 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <inttypes.h>
+
+#include "system.h"
+#include "metadata.h"
+#include "metadata_common.h"
+#include "metadata_parsers.h"
+#include "rbunicode.h"
+
+bool parse_sgc_header(int fd, struct mp3entry* id3)
+{
+    /* Use the trackname part of the id3 structure as a temporary buffer */
+    unsigned char* buf = (unsigned char *)id3->path;
+
+     lseek(fd, 0, SEEK_SET);
+     if (read(fd, buf, 0xA0) < 0xA0)
+        return false;
+
+    /* calculate track length with number of tracks */
+    id3->length = buf[37] * 1000;
+
+    /* If meta info was found in the m3u skip next step */
+    if (id3->title && id3->title[0]) return true;
+
+    char *p = id3->id3v2buf;
+
+    /* Some metadata entries have 32 bytes length */
+    /* Game */
+    memcpy(p, &buf[64], 32); *(p + 33) = '\0';
+    id3->title = p;
+    p += strlen(p)+1;
+
+    /* Artist */
+    memcpy(p, &buf[96], 32); *(p + 33) = '\0';
+    id3->artist = p;
+    p += strlen(p)+1;
+
+    /* Copyright */
+    memcpy(p, &buf[128], 32); *(p + 33) = '\0';
+    id3->album = p;
+    p += strlen(p)+1;
+    return true;
+}
+
+
+bool get_sgc_metadata(int fd, struct mp3entry* id3)
+{
+   uint32_t sgc_type;
+    if ((lseek(fd, 0, SEEK_SET) < 0) ||
+         read_uint32be(fd, &sgc_type) != (int)sizeof(sgc_type))
+        return false;
+
+    id3->vbr = false;
+    id3->filesize = filesize(fd);
+    /* we only render 16 bits, 44.1KHz, Stereo */
+    id3->bitrate = 706;
+    id3->frequency = 44100;
+  
+    /* Make sure this is an SGC file */
+    if (sgc_type != FOURCC('S','G','C',0x1A))
+        return false;
+
+    return parse_sgc_header(fd, id3);
+}
diff --git a/apps/metadata/vgm.c b/apps/metadata/vgm.c
new file mode 100644
index 0000000000..9ea95b3939
--- /dev/null
+++ b/apps/metadata/vgm.c
@@ -0,0 +1,195 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <inttypes.h>
+
+#include "system.h"
+#include "metadata.h"
+#include "metadata_common.h"
+#include "metadata_parsers.h"
+#include "rbunicode.h"
+
+/* Ripped off from Game_Music_Emu 0.5.2. http://www.slack.net/~ant/ */
+
+typedef unsigned char byte;
+
+enum { header_size = 0x40 };
+enum { max_field = 64 };
+
+struct header_t
+{
+    char tag [4]; 
+    byte data_size [4];
+    byte version [4];
+    byte psg_rate [4];
+    byte ym2413_rate [4];
+    byte gd3_offset [4];
+    byte track_duration [4];
+    byte loop_offset [4];
+    byte loop_duration [4];
+    byte frame_rate [4];
+    byte noise_feedback [2];
+    byte noise_width;
+    byte unused1;
+    byte ym2612_rate [4];
+    byte ym2151_rate [4];
+    byte data_offset [4];
+    byte unused2 [8];
+};
+
+static byte const* skip_gd3_str( byte const* in, byte const* end )
+{
+    while ( end - in >= 2 )
+    {
+        in += 2;
+        if ( !(in [-2] | in [-1]) )
+            break;
+    }
+    return in;
+}
+
+static byte const* get_gd3_str( byte const* in, byte const* end, char* field )
+{
+    byte const* mid = skip_gd3_str( in, end );
+    int len = (mid - in) / 2 - 1;
+    if ( field && len > 0 )
+    {
+        len = len < (int) max_field ? len : (int) max_field;
+
+        field [len] = 0;
+        /* Conver to utf8 */
+        utf16LEdecode( in, field, len );
+        
+        /* Copy string back to id3v2buf */
+        strcpy( (char*) in, field );
+    }
+    return mid;
+}
+
+static byte const* get_gd3_pair( byte const* in, byte const* end, char* field )
+{
+    return skip_gd3_str( get_gd3_str( in, end, field ), end );
+}
+
+static void parse_gd3( byte const* in, byte const* end, struct mp3entry* id3 )
+{
+    char* p = id3->path;
+    id3->title = (char *) in;
+    in = get_gd3_pair( in, end, p ); /* Song */
+
+    id3->album = (char *) in;
+    in = get_gd3_pair( in, end, p ); /* Game */
+
+    in = get_gd3_pair( in, end, NULL ); /* System */
+
+    id3->artist = (char *) in;
+    in = get_gd3_pair( in, end, p ); /* Author */
+
+#if MEMORYSIZE > 2
+    in = get_gd3_str ( in, end, NULL  ); /* Copyright */
+    in = get_gd3_pair( in, end, NULL ); /* Dumper */
+
+    id3->comment = (char *) in;
+    in = get_gd3_str ( in, end, p ); /* Comment */
+#endif
+}
+
+int const gd3_header_size = 12;
+
+static long check_gd3_header( byte* h, long remain )
+{
+    if ( remain < gd3_header_size ) return 0;
+    if ( memcmp( h, "Gd3 ", 4 ) ) return 0;
+    if ( get_long_le( h + 4 ) >= 0x200 ) return 0;
+
+    long gd3_size = get_long_le( h + 8 );
+    if ( gd3_size > remain - gd3_header_size )
+        gd3_size = remain - gd3_header_size;
+
+    return gd3_size;
+}
+
+static void get_vgm_length( struct header_t* h, struct mp3entry* id3 )
+{
+    long length = get_long_le( h->track_duration ) * 10 / 441;
+    if ( length > 0 )
+    {
+        long loop_length = 0, intro_length = 0;
+        long loop = get_long_le( h->loop_duration );
+        if ( loop > 0 && get_long_le( h->loop_offset ) )
+        {
+            loop_length = loop * 10 / 441;
+            intro_length = length - loop_length;
+        }
+        else
+        {
+            intro_length = length; /* make it clear that track is no longer than length */
+            loop_length = 0;
+        }
+        
+         id3->length = intro_length + 2 * loop_length; /* intro + 2 loops */
+         return;
+    }
+
+    id3->length = 150 * 1000; /* 2.5 minutes */
+}
+
+bool get_vgm_metadata(int fd, struct mp3entry* id3)
+{
+    /* Use the id3v2 part of the id3 structure as a temporary buffer */
+    unsigned char* buf = (unsigned char *)id3->id3v2buf;
+    int read_bytes;
+
+    memset(buf, 0, ID3V2_BUF_SIZE);
+    if ((lseek(fd, 0, SEEK_SET) < 0) 
+         || ((read_bytes = read(fd, buf, header_size)) < header_size))
+    {
+        return false;
+    }
+
+    id3->vbr = false;
+    id3->filesize = filesize(fd);
+
+    id3->bitrate = 706;
+    id3->frequency = 44100;
+
+    /* If file is gzipped, will get metadata later */
+    if (memcmp(buf, "Vgm ", 4))
+    {
+        /* We must set a default song length here because
+            the codec can't do it anymore */
+        id3->length = 150 * 1000; /* 2.5 minutes */
+        return true;
+    }
+
+    /* Get song length from header */
+    struct header_t* header = (struct header_t*) buf;
+    get_vgm_length( header, id3 );
+
+    long gd3_offset = get_long_le( header->gd3_offset ) - 0x2C;
+    
+    /* No gd3 tag found */
+    if ( gd3_offset < 0 )
+        return true;
+
+    /*  Seek to gd3 offset and read as 
+         many bytes posible */
+    gd3_offset = id3->filesize - (header_size + gd3_offset);
+    if ((lseek(fd, -gd3_offset, SEEK_END) < 0) 
+         || ((read_bytes = read(fd, buf, ID3V2_BUF_SIZE)) <= 0))
+        return true;
+
+    byte* gd3 = buf;
+    long gd3_size = check_gd3_header( gd3, read_bytes );
+
+    /* GD3 tag is zero */
+    if ( gd3_size == 0 )
+        return true;
+
+    /* Finally, parse gd3 tag */
+    if ( gd3 )
+        parse_gd3( gd3 + gd3_header_size, gd3 + read_bytes, id3 );
+
+    return true;
+}