Moved id3.c, mpeg.c and replaygain.c from firmware/ to apps/. This is the first step in separating the generic metadata code and the id3-specific code.

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

4 files changed, 4687 insertions, 0 deletions

diff --git a/apps/SOURCES b/apps/SOURCES
index eb09797719..7622b416f7 100644
--- a/apps/SOURCES
+++ b/apps/SOURCES
@@ -7,6 +7,7 @@ abrepeat.c
 bookmark.c
 debug_menu.c
 filetypes.c
+id3.c
 language.c
 main.c
 menu.c
@@ -17,6 +18,9 @@ menus/theme_menu.c
 menus/eq_menu.c
 buffering.c
 voice_thread.c
+replaygain.c
+#else  /* !SWCODEC */
+mpeg.c
 #endif
 menus/main_menu.c
 menus/playback_menu.c
diff --git a/apps/id3.c b/apps/id3.c
new file mode 100644
index 0000000000..c1541e30df
--- /dev/null
+++ b/apps/id3.c
@@ -0,0 +1,1353 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2002 by Daniel Stenberg
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+/*
+ * Parts of this code has been stolen from the Ample project and was written
+ * by David H�deman. It has since been extended and enhanced pretty much by
+ * all sorts of friendly Rockbox people.
+ *
+ */
+
+ /* tagResolver and associated code copyright 2003 Thomas Paul Diffenbach
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <ctype.h>
+#include "config.h"
+#include "file.h"
+#include "logf.h"
+
+#include "id3.h"
+#include "mp3data.h"
+#include "system.h"
+#include "replaygain.h"
+#include "rbunicode.h"
+
+/** Database of audio formats **/
+const struct afmt_entry audio_formats[AFMT_NUM_CODECS] =
+{
+    /* Unknown file format */
+    [AFMT_UNKNOWN] =
+        AFMT_ENTRY("???", NULL,       NULL,          NULL         ),
+
+    /* MPEG Audio layer 1 */
+    [AFMT_MPA_L1] =
+        AFMT_ENTRY("MP1", "mpa",      NULL,          "mp1\0"      ),
+    /* MPEG Audio layer 2 */
+    [AFMT_MPA_L2] =
+        AFMT_ENTRY("MP2", "mpa",      NULL,          "mpa\0mp2\0" ),
+    /* MPEG Audio layer 3 */
+    [AFMT_MPA_L3] =
+        AFMT_ENTRY("MP3", "mpa",      "mp3_enc",     "mp3\0"      ),
+
+#if CONFIG_CODEC == SWCODEC
+    /* Audio Interchange File Format */
+    [AFMT_AIFF] =
+        AFMT_ENTRY("AIFF", "aiff",    "aiff_enc",    "aiff\0aif\0"),
+    /* Uncompressed PCM in a WAV file */
+    [AFMT_PCM_WAV] =
+        AFMT_ENTRY("WAV",  "wav",     "wav_enc",     "wav\0"      ),
+    /* Ogg Vorbis */
+    [AFMT_OGG_VORBIS] =
+        AFMT_ENTRY("Ogg",  "vorbis",  NULL,          "ogg\0"      ),
+    /* FLAC */
+    [AFMT_FLAC] =
+        AFMT_ENTRY("FLAC", "flac",    NULL,          "flac\0"     ),
+    /* Musepack */
+    [AFMT_MPC] =
+        AFMT_ENTRY("MPC",  "mpc",     NULL,          "mpc\0"      ),
+    /* A/52 (aka AC3) audio */
+    [AFMT_A52] =
+        AFMT_ENTRY("AC3",  "a52",     NULL,          "a52\0ac3\0" ),
+    /* WavPack */
+    [AFMT_WAVPACK] =
+        AFMT_ENTRY("WV",   "wavpack", "wavpack_enc", "wv\0"       ),
+    /* Apple Lossless Audio Codec */
+    [AFMT_ALAC] =
+        AFMT_ENTRY("ALAC", "alac",    NULL,          "m4a\0m4b\0" ),
+    /* Advanced Audio Coding in M4A container */
+    [AFMT_AAC] =
+        AFMT_ENTRY("AAC",  "aac",     NULL,          "mp4\0"      ),
+    /* Shorten */
+    [AFMT_SHN] =
+        AFMT_ENTRY("SHN",  "shorten", NULL,          "shn\0"      ),
+    /* SID File Format */
+    [AFMT_SID] =
+        AFMT_ENTRY("SID",  "sid",     NULL,          "sid\0"      ),
+    /* ADX File Format */
+    [AFMT_ADX] =
+        AFMT_ENTRY("ADX",  "adx",     NULL,          "adx\0"      ),
+    /* NESM (NES Sound Format) */
+    [AFMT_NSF] =
+        AFMT_ENTRY("NSF",  "nsf",     NULL,          "nsf\0nsfe\0"      ),
+    /* Speex File Format */
+    [AFMT_SPEEX] =
+        AFMT_ENTRY("Speex","speex",   NULL,          "spx\0"      ),
+    /* SPC700 Save State */
+    [AFMT_SPC] =
+        AFMT_ENTRY("SPC",  "spc",     NULL,          "spc\0"      ),
+    /* APE (Monkey's Audio) */
+    [AFMT_APE] =
+        AFMT_ENTRY("APE",  "ape",     NULL,          "ape\0mac\0"      ),
+    /* WMA (WMAV1/V2 in ASF) */
+    [AFMT_WMA] =
+        AFMT_ENTRY("WMA",  "wma",     NULL,          "wma\0wmv\0asf\0"   ),
+    /* Amiga MOD File */
+    [AFMT_MOD] =
+        AFMT_ENTRY("MOD",  "mod",     NULL,          "mod\0"      ),
+    /* Amiga SAP File */
+    [AFMT_SAP] =
+        AFMT_ENTRY("SAP",  "asap",     NULL,          "sap\0"      ),
+#endif
+};
+
+#if CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING)
+/* get REC_FORMAT_* corresponding AFMT_* */
+const int rec_format_afmt[REC_NUM_FORMATS] =
+{
+    /* give AFMT_UNKNOWN by default */
+    [0 ... REC_NUM_FORMATS-1] = AFMT_UNKNOWN,
+    /* add new entries below this line */
+    [REC_FORMAT_AIFF]    = AFMT_AIFF,
+    [REC_FORMAT_MPA_L3]  = AFMT_MPA_L3,
+    [REC_FORMAT_WAVPACK] = AFMT_WAVPACK,
+    [REC_FORMAT_PCM_WAV] = AFMT_PCM_WAV,
+};
+
+/* get AFMT_* corresponding REC_FORMAT_* */
+const int afmt_rec_format[AFMT_NUM_CODECS] =
+{
+    /* give -1 by default */
+    [0 ... AFMT_NUM_CODECS-1] = -1,
+    /* add new entries below this line */
+    [AFMT_AIFF]    = REC_FORMAT_AIFF,
+    [AFMT_MPA_L3]  = REC_FORMAT_MPA_L3,
+    [AFMT_WAVPACK] = REC_FORMAT_WAVPACK,
+    [AFMT_PCM_WAV] = REC_FORMAT_PCM_WAV,
+};
+#endif /* CONFIG_CODEC == SWCODEC && defined (HAVE_RECORDING) */
+/****/
+
+static unsigned long unsync(unsigned long b0,
+                            unsigned long b1,
+                            unsigned long b2,
+                            unsigned long b3)
+{
+   return (((long)(b0 & 0x7F) << (3*7)) |
+           ((long)(b1 & 0x7F) << (2*7)) |
+           ((long)(b2 & 0x7F) << (1*7)) |
+           ((long)(b3 & 0x7F) << (0*7)));
+}
+
+static const char* const genres[] = {
+    "Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge",
+    "Hip-Hop", "Jazz", "Metal", "New Age", "Oldies", "Other", "Pop", "R&B",
+    "Rap", "Reggae", "Rock", "Techno", "Industrial", "Alternative", "Ska",
+    "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop",
+    "Vocal", "Jazz+Funk", "Fusion", "Trance", "Classical", "Instrumental",
+    "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise", "AlternRock",
+    "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop",
+    "Instrumental Rock", "Ethnic", "Gothic", "Darkwave", "Techno-Industrial",
+    "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy",
+    "Cult", "Gangsta", "Top 40", "Christian Rap", "Pop/Funk", "Jungle",
+    "Native American", "Cabaret", "New Wave", "Psychadelic", "Rave",
+    "Showtunes", "Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz",
+    "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock",
+
+    /* winamp extensions */
+    "Folk", "Folk-Rock", "National Folk", "Swing", "Fast Fusion", "Bebob",
+    "Latin", "Revival", "Celtic", "Bluegrass", "Avantgarde", "Gothic Rock",
+    "Progressive Rock", "Psychedelic Rock", "Symphonic Rock", "Slow Rock",
+    "Big Band", "Chorus", "Easy Listening", "Acoustic", "Humour", "Speech",
+    "Chanson", "Opera", "Chamber Music", "Sonata", "Symphony", "Booty Bass",
+    "Primus", "Porn Groove", "Satire", "Slow Jam", "Club", "Tango", "Samba",
+    "Folklore", "Ballad", "Power Ballad", "Rhythmic Soul", "Freestyle",
+    "Duet", "Punk Rock", "Drum Solo", "A capella", "Euro-House", "Dance Hall",
+    "Goa", "Drum & Bass", "Club-House", "Hardcore", "Terror", "Indie",
+    "BritPop", "Negerpunk", "Polsk Punk", "Beat", "Christian Gangsta Rap",
+    "Heavy Metal", "Black Metal", "Crossover", "Contemporary Christian",
+    "Christian Rock", "Merengue", "Salsa", "Thrash Metal", "Anime", "Jpop",
+    "Synthpop"
+};
+
+char* id3_get_num_genre(unsigned int genre_num)
+{
+    if (genre_num < sizeof(genres)/sizeof(char*))
+        return (char*)genres[genre_num];
+    return NULL;
+}
+
+/* True if the string is from the "genres" array */
+static bool id3_is_genre_string(const char *string)
+{
+    return ( string >= genres[0] &&
+             string <= genres[sizeof(genres)/sizeof(char*) - 1] );
+}
+
+/*
+    HOW TO ADD ADDITIONAL ID3 VERSION 2 TAGS
+    Code and comments by Thomas Paul Diffenbach
+
+    To add another ID3v2 Tag, do the following:
+    1.  add a char* named for the tag to struct mp3entry in id3.h,
+        (I (tpd) prefer to use char* rather than ints, even for what seems like
+        numerical values, for cases where a number won't do, e.g.,
+        YEAR: "circa 1765", "1790/1977" (composed/performed), "28 Feb 1969"
+        TRACK: "1/12", "1 of 12", GENRE: "Freeform genre name"
+        Text is more flexible, and as the main use of id3 data is to
+        display it, converting it to an int just means reconverting to
+        display it, at a runtime cost.)
+
+    2. If any special processing beyond copying the tag value from the Id3
+       block to the struct mp3entry is rrequired (such as converting to an
+       int), write a function to perform this special processing.
+
+       This function's prototype must match that of
+       typedef tagPostProcessFunc, that is it must be:
+         int func( struct mp3entry*, char* tag, int bufferpos )
+       the first argument is a pointer to the current mp3entry structure the
+       second argument is a pointer to the null terminated string value of the
+       tag found the third argument is the offset of the next free byte in the
+       mp3entry's buffer your function should return the corrected offset; if
+       you don't lengthen or shorten the tag string, you can return the third
+       argument unchanged.
+
+       Unless you have a good reason no to, make the function static.
+       TO JUST COPY THE TAG NO SPECIAL PROCESSING FUNCTION IS NEEDED.
+
+    3. add one or more entries to the tagList array, using the format:
+            char* ID3 Tag symbolic name -- see the ID3 specification for these,
+            sizeof() that name minus 1,
+            offsetof( struct mp3entry, variable_name_in_struct_mp3entry ),
+            pointer to your special processing function or NULL
+                if you need no special processing
+            flag indicating if this tag is binary or textual
+        Many ID3 symbolic names come in more than one form. You can add both
+        forms, each referencing the same variable in struct mp3entry.
+        If both forms are present, the last found will be used.
+        Note that the offset can be zero, in which case no entry will be set
+        in the mp3entry struct; the frame is still read into the buffer and
+        the special processing function is called (several times, if there
+        are several frames with the same name).
+
+    4. Alternately, use the TAG_LIST_ENTRY macro with
+         ID3 tag symbolic name,
+         variable in struct mp3entry,
+         special processing function address
+
+    5.  Add code to wps-display.c function get_tag to assign a printf-like
+        format specifier for the tag */
+
+/* Structure for ID3 Tag extraction information */
+struct tag_resolver {
+    const char* tag;
+    int tag_length;
+    size_t offset;
+    int (*ppFunc)(struct mp3entry*, char* tag, int bufferpos);
+    bool binary;
+};
+
+static bool global_ff_found;
+
+static int unsynchronize(char* tag, int len, bool *ff_found)
+{
+    int i;
+    unsigned char c;
+    unsigned char *rp, *wp;
+
+    wp = rp = (unsigned char *)tag;
+
+    rp = (unsigned char *)tag;
+    for(i = 0;i < len;i++) {
+        /* Read the next byte and write it back, but don't increment the
+           write pointer */
+        c = *rp++;
+        *wp = c;
+        if(*ff_found) {
+            /* Increment the write pointer if it isn't an unsynch pattern */
+            if(c != 0)
+                wp++;
+            *ff_found = false;
+        } else {
+            if(c == 0xff)
+                *ff_found = true;
+            wp++;
+        }
+    }
+    return (long)wp - (long)tag;
+}
+
+static int unsynchronize_frame(char* tag, int len)
+{
+    bool ff_found = false;
+
+    return unsynchronize(tag, len, &ff_found);
+}
+
+static int read_unsynched(int fd, void *buf, int len)
+{
+    int i;
+    int rc;
+    int remaining = len;
+    char *wp;
+    char *rp;
+
+    wp = buf;
+
+    while(remaining) {
+        rp = wp;
+        rc = read(fd, rp, remaining);
+        if(rc <= 0)
+            return rc;
+
+        i = unsynchronize(wp, remaining, &global_ff_found);
+        remaining -= i;
+        wp += i;
+    }
+
+    return len;
+}
+
+static int skip_unsynched(int fd, int len)
+{
+    int rc;
+    int remaining = len;
+    int rlen;
+    char buf[32];
+
+    while(remaining) {
+        rlen = MIN(sizeof(buf), (unsigned int)remaining);
+        rc = read(fd, buf, rlen);
+        if(rc <= 0)
+            return rc;
+
+        remaining -= unsynchronize(buf, rlen, &global_ff_found);
+    }
+
+    return len;
+}
+
+/* parse numeric value from string */
+static int parsetracknum( struct mp3entry* entry, char* tag, int bufferpos )
+{
+    entry->tracknum = atoi( tag );
+    return bufferpos;
+}
+
+/* parse numeric value from string */
+static int parsediscnum( struct mp3entry* entry, char* tag, int bufferpos )
+{
+    entry->discnum = atoi( tag );
+    return bufferpos;
+}
+
+/* parse numeric value from string */
+static int parseyearnum( struct mp3entry* entry, char* tag, int bufferpos )
+{
+    entry->year = atoi( tag );
+    return bufferpos;
+}
+
+/* parse numeric genre from string, version 2.2 and 2.3 */
+static int parsegenre( struct mp3entry* entry, char* tag, int bufferpos )
+{
+    if(entry->id3version >= ID3_VER_2_4) {
+        /* In version 2.4 and up, there are no parentheses, and the genre frame
+           is a list of strings, either numbers or text. */
+
+        /* Is it a number? */
+        if(isdigit(tag[0])) {
+            entry->genre_string = id3_get_num_genre(atoi( tag ));
+            return tag - entry->id3v2buf;
+        } else {
+            entry->genre_string = tag;
+            return bufferpos;
+        }
+    } else {
+        if( tag[0] == '(' && tag[1] != '(' ) {
+            entry->genre_string = id3_get_num_genre(atoi( tag + 1 ));
+            return tag - entry->id3v2buf;
+        }
+        else {
+            entry->genre_string = tag;
+            return bufferpos;
+        }
+    }
+}
+
+#if CONFIG_CODEC == SWCODEC
+/* parse user defined text, looking for replaygain information. */
+static int parseuser( struct mp3entry* entry, char* tag, int bufferpos )
+{
+    char* value = NULL;
+    int desc_len = strlen(tag);
+    int value_len = 0;
+
+    if ((tag - entry->id3v2buf + desc_len + 2) < bufferpos) {
+        /* At least part of the value was read, so we can safely try to
+         * parse it
+         */
+        value = tag + desc_len + 1;
+        value_len = parse_replaygain(tag, value, entry, tag,
+            bufferpos - (tag - entry->id3v2buf));
+    }
+
+    return tag - entry->id3v2buf + value_len;
+}
+
+/* parse RVA2 binary data and convert to replaygain information. */
+static int parserva2( struct mp3entry* entry, char* tag, int bufferpos )
+{
+    int desc_len = strlen(tag);
+    int start_pos = tag - entry->id3v2buf;
+    int end_pos = start_pos + desc_len + 5;
+    int value_len = 0;
+    unsigned char* value = tag + desc_len + 1;
+
+    /* Only parse RVA2 replaygain tags if tag version == 2.4 and channel
+     * type is master volume.
+     */
+    if (entry->id3version == ID3_VER_2_4 && end_pos < bufferpos 
+            && *value++ == 1) {
+        long gain = 0;
+        long peak = 0;
+        long peakbits;
+        long peakbytes;
+        bool album = false;
+
+        /* The RVA2 specification is unclear on some things (id string and
+         * peak volume), but this matches how Quod Libet use them.
+         */
+            
+        gain = (int16_t) ((value[0] << 8) | value[1]);
+        value += 2;
+        peakbits = *value++;
+        peakbytes = (peakbits + 7) / 8;
+    
+        /* Only use the topmost 24 bits for peak volume */
+        if (peakbytes > 3) {
+            peakbytes = 3;
+        }
+
+        /* Make sure the peak bits were read */
+        if (end_pos + peakbytes < bufferpos) {
+            long shift = ((8 - (peakbits & 7)) & 7) + (3 - peakbytes) * 8;
+
+            for ( ; peakbytes; peakbytes--) {
+                peak <<= 8;
+                peak += *value++;
+            }
+    
+            peak <<= shift;
+    
+            if (peakbits > 24) {
+                peak += *value >> (8 - shift);
+            }
+        }
+    
+        if (strcasecmp(tag, "album") == 0) {
+            album = true;
+        } else if (strcasecmp(tag, "track") != 0) {
+            /* Only accept non-track values if we don't have any previous
+             * value.
+             */
+            if (entry->track_gain != 0) {
+                return start_pos;
+            }
+        }
+            
+        value_len = parse_replaygain_int(album, gain, peak * 2, entry,
+            tag, sizeof(entry->id3v2buf) - start_pos);
+    }
+
+    return start_pos + value_len;
+}
+#endif
+
+static int parsembtid( struct mp3entry* entry, char* tag, int bufferpos )
+{
+    char* value = NULL;
+    int desc_len = strlen(tag);
+    /*DEBUGF("MBID len: %d\n", desc_len);*/
+    int value_len = 0;
+
+    if ((tag - entry->id3v2buf + desc_len + 2) < bufferpos)
+    {
+        value = tag + desc_len + 1;
+
+        if (strcasecmp(tag, "http://musicbrainz.org") == 0)
+        {
+            /* Musicbrainz track IDs are always 36 chars long plus null */
+            value_len = 37;
+
+            entry->mb_track_id = value;
+
+            /*DEBUGF("ENTRY: %s LEN: %d\n", entry->mb_track_id, strlen(entry->mb_track_id));*/
+        }
+    }
+
+    return tag - entry->id3v2buf + value_len;
+}
+
+static const struct tag_resolver taglist[] = {
+    { "TPE1", 4, offsetof(struct mp3entry, artist), NULL, false },
+    { "TP1",  3, offsetof(struct mp3entry, artist), NULL, false },
+    { "TIT2", 4, offsetof(struct mp3entry, title), NULL, false },
+    { "TT2",  3, offsetof(struct mp3entry, title), NULL, false },
+    { "TALB", 4, offsetof(struct mp3entry, album), NULL, false },
+    { "TAL",  3, offsetof(struct mp3entry, album), NULL, false },
+    { "TRK",  3, offsetof(struct mp3entry, track_string), &parsetracknum, false },
+    { "TPOS", 4, offsetof(struct mp3entry, disc_string), &parsediscnum, false },
+    { "TRCK", 4, offsetof(struct mp3entry, track_string), &parsetracknum, false },
+    { "TDRC", 4, offsetof(struct mp3entry, year_string), &parseyearnum, false },
+    { "TYER", 4, offsetof(struct mp3entry, year_string), &parseyearnum, false },
+    { "TYE",  3, offsetof(struct mp3entry, year_string), &parseyearnum, false },
+    { "TCOM", 4, offsetof(struct mp3entry, composer), NULL, false },
+    { "TPE2", 4, offsetof(struct mp3entry, albumartist), NULL, false },
+    { "TP2",  3, offsetof(struct mp3entry, albumartist), NULL, false },
+    { "TIT1", 4, offsetof(struct mp3entry, grouping), NULL, false },
+    { "TT1",  3, offsetof(struct mp3entry, grouping), NULL, false },
+    { "COMM", 4, offsetof(struct mp3entry, comment), NULL, false }, 
+    { "TCON", 4, offsetof(struct mp3entry, genre_string), &parsegenre, false },
+    { "TCO",  3, offsetof(struct mp3entry, genre_string), &parsegenre, false },
+#if CONFIG_CODEC == SWCODEC
+    { "TXXX", 4, 0, &parseuser, false },
+    { "RVA2", 4, 0, &parserva2, true },
+#endif
+    { "UFID", 4, 0, &parsembtid, false },
+};
+
+#define TAGLIST_SIZE ((int)(sizeof(taglist) / sizeof(taglist[0])))
+
+/* Get the length of an ID3 string in the given encoding. Returns the length
+ * in bytes, including end nil, or -1 if the encoding is unknown.
+ */
+static int unicode_len(char encoding, const void* string)
+{
+    int len = 0;
+
+    if (encoding == 0x01 || encoding == 0x02) {
+        char first;
+        const char *s = string;
+        /* string might be unaligned, so using short* can crash on ARM and SH1 */
+        do {
+            first = *s++;
+        } while ((first | *s++) != 0);
+
+        len = s - (const char*) string;
+    } else {
+        len = strlen((char*) string) + 1;
+    }
+
+    return len;
+}
+
+/* Checks to see if the passed in string is a 16-bit wide Unicode v2
+   string.  If it is, we convert it to a UTF-8 string.  If it's not unicode,
+   we convert from the default codepage */
+static int unicode_munge(char* string, char* utf8buf, int *len) {
+    long tmp;
+    bool le = false;
+    int i = 0;
+    unsigned char *str = (unsigned char *)string;
+    int templen = 0;
+    unsigned char* utf8 = (unsigned char *)utf8buf;
+
+    switch (str[0]) {
+        case 0x00: /* Type 0x00 is ordinary ISO 8859-1 */
+            str++;
+            (*len)--;
+            utf8 = iso_decode(str, utf8, -1, *len);
+            *utf8 = 0;
+            *len = (unsigned long)utf8 - (unsigned long)utf8buf;
+            break;
+
+        case 0x01: /* Unicode with or without BOM */
+        case 0x02:
+            (*len)--;
+            str++;
+
+            /* Handle frames with more than one string
+               (needed for TXXX frames).*/
+            do {
+                tmp = bytes2int(0, 0, str[0], str[1]);
+
+                /* Now check if there is a BOM
+                   (zero-width non-breaking space, 0xfeff)
+                   and if it is in little or big endian format */
+                if(tmp == 0xfffe) { /* Little endian? */
+                    le = true;
+                    str += 2;
+                    (*len)-=2;
+                } else if(tmp == 0xfeff) { /* Big endian? */
+                    str += 2;
+                    (*len)-=2;
+                } else
+                /* If there is no BOM (which is a specification violation),
+                   let's try to guess it. If one of the bytes is 0x00, it is
+                   probably the most significant one. */
+                    if(str[1] == 0)
+                        le = true;
+
+                do {
+                    if(le)
+                        utf8 = utf16LEdecode(str, utf8, 1);
+                    else
+                        utf8 = utf16BEdecode(str, utf8, 1);
+
+                    str+=2;
+                    i += 2;
+                } while((str[0] || str[1]) && (i < *len));
+
+                *utf8++ = 0; /* Terminate the string */
+                templen += (strlen(&utf8buf[templen]) + 1);
+                str += 2;
+                i+=2;
+            } while(i < *len);
+            *len = templen - 1;
+            break;
+
+        case 0x03: /* UTF-8 encoded string */
+            for(i=0; i < *len; i++)
+                utf8[i] = str[i+1];
+            (*len)--;
+            break;
+
+        default: /* Plain old string */
+            utf8 = iso_decode(str, utf8, -1, *len);
+            *utf8 = 0;
+            *len = (unsigned long)utf8 - (unsigned long)utf8buf;
+            break;
+    }
+    return 0;
+}
+
+/*
+ * Sets the title of an MP3 entry based on its ID3v1 tag.
+ *
+ * Arguments: file - the MP3 file to scen for a ID3v1 tag
+ *            entry - the entry to set the title in
+ *
+ * Returns: true if a title was found and created, else false
+ */
+static bool setid3v1title(int fd, struct mp3entry *entry)
+{
+    unsigned char buffer[128];
+    static const char offsets[] = {3, 33, 63, 97, 93, 125, 127};
+    int i, j;
+    unsigned char* utf8;
+
+    if (-1 == lseek(fd, -128, SEEK_END))
+        return false;
+
+    if (read(fd, buffer, sizeof buffer) != sizeof buffer)
+        return false;
+
+    if (strncmp((char *)buffer, "TAG", 3))
+        return false;
+
+    entry->id3v1len = 128;
+    entry->id3version = ID3_VER_1_0;
+
+    for (i=0; i < (int)sizeof offsets; i++) {
+        unsigned char* ptr = (unsigned char *)buffer + offsets[i];
+
+        switch(i) {
+            case 0:
+            case 1:
+            case 2:
+                /* kill trailing space in strings */
+                for (j=29; j && (ptr[j]==0 || ptr[j]==' '); j--)
+                    ptr[j] = 0;
+                /* convert string to utf8 */
+                utf8 = (unsigned char *)entry->id3v1buf[i];
+                utf8 = iso_decode(ptr, utf8, -1, 30);
+                /* make sure string is terminated */
+                *utf8 = 0;
+                break;
+
+            case 3:
+                /* kill trailing space in strings */
+                for (j=27; j && (ptr[j]==0 || ptr[j]==' '); j--)
+                    ptr[j] = 0;
+                /* convert string to utf8 */
+                utf8 = (unsigned char *)entry->id3v1buf[3];
+                utf8 = iso_decode(ptr, utf8, -1, 28);
+                /* make sure string is terminated */
+                *utf8 = 0;
+                break;
+
+            case 4:
+                ptr[4] = 0;
+                entry->year = atoi((char *)ptr);
+                break;
+
+            case 5:
+                /* id3v1.1 uses last two bytes of comment field for track
+                   number: first must be 0 and second is track num */
+                if (!ptr[0] && ptr[1]) {
+                    entry->tracknum = ptr[1];
+                    entry->id3version = ID3_VER_1_1;
+                }
+                break;
+
+            case 6:
+                /* genre */
+                entry->genre_string = id3_get_num_genre(ptr[0]);
+                break;
+        }
+    }
+
+    entry->title = entry->id3v1buf[0];
+    entry->artist = entry->id3v1buf[1];
+    entry->album = entry->id3v1buf[2];
+    entry->comment = entry->id3v1buf[3];
+
+    return true;
+}
+
+
+/*
+ * Sets the title of an MP3 entry based on its ID3v2 tag.
+ *
+ * Arguments: file - the MP3 file to scan for a ID3v2 tag
+ *            entry - the entry to set the title in
+ *
+ * Returns: true if a title was found and created, else false
+ */
+static void setid3v2title(int fd, struct mp3entry *entry)
+{
+    int minframesize;
+    int size;
+    long bufferpos = 0, totframelen, framelen;
+    char header[10];
+    char tmp[4];
+    unsigned char version;
+    char *buffer = entry->id3v2buf;
+    int bytesread = 0;
+    int buffersize = sizeof(entry->id3v2buf);
+    unsigned char global_flags;
+    int flags;
+    int skip;
+    bool global_unsynch = false;
+    bool unsynch = false;
+    int i, j;
+    int rc;
+
+    global_ff_found = false;
+
+    /* Bail out if the tag is shorter than 10 bytes */
+    if(entry->id3v2len < 10)
+        return;
+
+    /* Read the ID3 tag version from the header */
+    lseek(fd, 0, SEEK_SET);
+    if(10 != read(fd, header, 10))
+        return;
+
+    /* Get the total ID3 tag size */
+    size = entry->id3v2len - 10;
+
+    version = header[3];
+    switch ( version ) {
+        case 2:
+            version = ID3_VER_2_2;
+            minframesize = 8;
+            break;
+
+        case 3:
+            version = ID3_VER_2_3;
+            minframesize = 12;
+            break;
+
+        case 4:
+            version = ID3_VER_2_4;
+            minframesize = 12;
+            break;
+
+        default:
+            /* unsupported id3 version */
+            return;
+    }
+    entry->id3version = version;
+    entry->tracknum = entry->year = entry->discnum = 0;
+    entry->title = entry->artist = entry->album = NULL; /* FIXME incomplete */
+
+    global_flags = header[5];
+
+    /* Skip the extended header if it is present */
+    if(global_flags & 0x40) {
+        if(version == ID3_VER_2_3) {
+            if(10 != read(fd, header, 10))
+                return;
+            /* The 2.3 extended header size doesn't include the header size
+               field itself. Also, it is not unsynched. */
+            framelen =
+                bytes2int(header[0], header[1], header[2], header[3]) + 4;
+
+            /* Skip the rest of the header */
+            lseek(fd, framelen - 10, SEEK_CUR);
+        }
+
+        if(version >= ID3_VER_2_4) {
+            if(4 != read(fd, header, 4))
+                return;
+
+            /* The 2.4 extended header size does include the entire header,
+               so here we can just skip it. This header is unsynched. */
+            framelen = unsync(header[0], header[1],
+                              header[2], header[3]);
+
+            lseek(fd, framelen - 4, SEEK_CUR);
+        }
+    }
+
+    /* Is unsynchronization applied? */
+    if(global_flags & 0x80) {
+        global_unsynch = true;
+    }
+
+    /*
+     * We must have at least minframesize bytes left for the
+     * remaining frames to be interesting
+     */
+    while (size >= minframesize && bufferpos < buffersize - 1) {
+        flags = 0;
+
+        /* Read frame header and check length */
+        if(version >= ID3_VER_2_3) {
+            if(global_unsynch && version <= ID3_VER_2_3)
+                rc = read_unsynched(fd, header, 10);
+            else
+                rc = read(fd, header, 10);
+            if(rc != 10)
+                return;
+            /* Adjust for the 10 bytes we read */
+            size -= 10;
+
+            flags = bytes2int(0, 0, header[8], header[9]);
+
+            if (version >= ID3_VER_2_4) {
+                framelen = unsync(header[4], header[5],
+                                  header[6], header[7]);
+            } else {
+                /* version .3 files don't use synchsafe ints for
+                 * size */
+                framelen = bytes2int(header[4], header[5],
+                                     header[6], header[7]);
+            }
+        } else {
+            if(6 != read(fd, header, 6))
+                return;
+            /* Adjust for the 6 bytes we read */
+            size -= 6;
+
+            framelen = bytes2int(0, header[3], header[4], header[5]);
+        }
+
+        logf("framelen = %ld", framelen);
+        if(framelen == 0){
+            if (header[0] == 0 && header[1] == 0 && header[2] == 0)
+                return;
+            else
+                continue;
+        }
+
+        unsynch = false;
+
+        if(flags)
+        {
+            skip = 0;
+
+            if (version >= ID3_VER_2_4) {
+                if(flags & 0x0040) { /* Grouping identity */
+                    lseek(fd, 1, SEEK_CUR); /* Skip 1 byte */
+                    framelen--;
+                }
+            } else {
+                if(flags & 0x0020) { /* Grouping identity */
+                    lseek(fd, 1, SEEK_CUR); /* Skip 1 byte */
+                    framelen--;
+                }
+            }
+
+            if(flags & 0x000c) /* Compression or encryption */
+            {
+                /* Skip it */
+                size -= framelen;
+                lseek(fd, framelen, SEEK_CUR);
+                continue;
+            }
+
+            if(flags & 0x0002) /* Unsynchronization */
+                unsynch = true;
+
+            if (version >= ID3_VER_2_4) {
+                if(flags & 0x0001) { /* Data length indicator */
+                    if(4 != read(fd, tmp, 4))
+                        return;
+
+                    /* We don't need the data length */
+                    framelen -= 4;
+                }
+            }
+        }
+
+        /* Keep track of the remaining frame size */
+        totframelen = framelen;
+
+        /* If the frame is larger than the remaining buffer space we try
+           to read as much as would fit in the buffer */
+        if(framelen >= buffersize - bufferpos)
+            framelen = buffersize - bufferpos - 1;
+
+        logf("id3v2 frame: %.4s", header);
+
+        /* Check for certain frame headers
+
+           'size' is the amount of frame bytes remaining.  We decrement it by
+           the amount of bytes we read.  If we fail to read as many bytes as
+           we expect, we assume that we can't read from this file, and bail
+           out.
+
+           For each frame. we will iterate over the list of supported tags,
+           and read the tag into entry's buffer. All tags will be kept as
+           strings, for cases where a number won't do, e.g., YEAR: "circa
+           1765", "1790/1977" (composed/performed), "28 Feb 1969" TRACK:
+           "1/12", "1 of 12", GENRE: "Freeform genre name" Text is more
+           flexible, and as the main use of id3 data is to display it,
+           converting it to an int just means reconverting to display it, at a
+           runtime cost.
+
+           For tags that the current code does convert to ints, a post
+           processing function will be called via a pointer to function. */
+
+        for (i=0; i<TAGLIST_SIZE; i++) {
+            const struct tag_resolver* tr = &taglist[i];
+            char** ptag = tr->offset ? (char**) (((char*)entry) + tr->offset)
+                : NULL;
+            char* tag;
+
+            /* Only ID3_VER_2_2 uses frames with three-character names. */
+            if (((version == ID3_VER_2_2) && (tr->tag_length != 3))
+                || ((version > ID3_VER_2_2) && (tr->tag_length != 4))) {
+                continue;
+            }
+
+            /* Note that parser functions sometimes set *ptag to NULL, so
+             * the "!*ptag" check here doesn't always have the desired
+             * effect. Should the parser functions (parsegenre in
+             * particular) be updated to handle the case of being called
+             * multiple times, or should the "*ptag" check be removed?
+             */
+            if( (!ptag || !*ptag) && !memcmp( header, tr->tag, tr->tag_length ) ) {
+
+                /* found a tag matching one in tagList, and not yet filled */
+                tag = buffer + bufferpos;
+
+                if(global_unsynch && version <= ID3_VER_2_3)
+                    bytesread = read_unsynched(fd, tag, framelen);
+                else
+                    bytesread = read(fd, tag, framelen);
+
+                if( bytesread != framelen )
+                    return;
+
+                size -= bytesread;
+
+                if(unsynch || (global_unsynch && version >= ID3_VER_2_4))
+                    bytesread = unsynchronize_frame(tag, bytesread);
+
+                /* the COMM frame has a 3 char field to hold an ISO-639-1 
+                 * language string and an optional short description;
+                 * remove them so unicode_munge can work correctly
+                 */
+                 
+                if(!memcmp( header, "COMM", 4 )) {
+                    int offset;
+                    /* ignore comments with iTunes 7 soundcheck/gapless data */
+                    if(!strncmp(tag+4, "iTun", 4))
+                        break;
+                    offset = 3 + unicode_len(*tag, tag + 4);
+                    if(bytesread > offset) {
+                        bytesread -= offset;
+                        memmove(tag + 1, tag + 1 + offset, bytesread - 1);
+                    }
+                }
+
+                /* Attempt to parse Unicode string only if the tag contents
+                   aren't binary */
+                if(!tr->binary) {
+                    /* UTF-8 could potentially be 3 times larger */
+                    /* so we need to create a new buffer         */
+                    char utf8buf[(3 * bytesread) + 1];
+
+                    unicode_munge( tag, utf8buf, &bytesread );
+
+                    if(bytesread >= buffersize - bufferpos)
+                        bytesread = buffersize - bufferpos - 1;
+
+                    for (j = 0; j < bytesread; j++)
+                        tag[j] = utf8buf[j];
+
+                    /* remove trailing spaces */
+                    while ( bytesread > 0 && isspace(tag[bytesread-1]))
+                        bytesread--;
+                }
+
+                tag[bytesread] = 0;
+                bufferpos += bytesread + 1;
+
+                if (ptag)
+                    *ptag = tag;
+
+                if( tr->ppFunc )
+                    bufferpos = tr->ppFunc(entry, tag, bufferpos);
+
+                /* Seek to the next frame */
+                if(framelen < totframelen)
+                    lseek(fd, totframelen - framelen, SEEK_CUR);
+                break;
+            }
+        }
+
+        if( i == TAGLIST_SIZE ) {
+            /* no tag in tagList was found, or it was a repeat.
+               skip it using the total size */
+
+            if(global_unsynch && version <= ID3_VER_2_3) {
+                size -= skip_unsynched(fd, totframelen);
+            } else {
+                size -= totframelen;
+                if( lseek(fd, totframelen, SEEK_CUR) == -1 )
+                    return;
+            }
+        }
+    }
+}
+
+/*
+ * Calculates the size of the ID3v2 tag.
+ *
+ * Arguments: file - the file to search for a tag.
+ *
+ * Returns: the size of the tag or 0 if none was found
+ */
+int getid3v2len(int fd)
+{
+    char buf[6];
+    int offset;
+
+    /* Make sure file has a ID3 tag */
+    if((-1 == lseek(fd, 0, SEEK_SET)) ||
+       (read(fd, buf, 6) != 6) ||
+       (strncmp(buf, "ID3", strlen("ID3")) != 0))
+        offset = 0;
+
+    /* Now check what the ID3v2 size field says */
+    else
+        if(read(fd, buf, 4) != 4)
+            offset = 0;
+        else
+            offset = unsync(buf[0], buf[1], buf[2], buf[3]) + 10;
+
+    logf("ID3V2 Length: 0x%x", offset);
+    return offset;
+}
+
+/*
+ * Calculates the length (in milliseconds) of an MP3 file.
+ *
+ * Modified to only use integers.
+ *
+ * Arguments: file - the file to calculate the length upon
+ *            entry - the entry to update with the length
+ *
+ * Returns: the song length in milliseconds,
+ *          0 means that it couldn't be calculated
+ */
+static int getsonglength(int fd, struct mp3entry *entry)
+{
+    unsigned long filetime = 0;
+    struct mp3info info;
+    long bytecount;
+
+    /* Start searching after ID3v2 header */
+    if(-1 == lseek(fd, entry->id3v2len, SEEK_SET))
+        return 0;
+
+    bytecount = get_mp3file_info(fd, &info);
+
+    logf("Space between ID3V2 tag and first audio frame: 0x%lx bytes",
+           bytecount);
+
+    if(bytecount < 0)
+        return -1;
+
+    bytecount += entry->id3v2len;
+
+    /* Validate byte count, in case the file has been edited without
+     * updating the header.
+     */
+    if (info.byte_count)
+    {
+        const unsigned long expected = entry->filesize - entry->id3v1len
+            - entry->id3v2len;
+        const unsigned long diff = MAX(10240, info.byte_count / 20);
+
+        if ((info.byte_count > expected + diff)
+            || (info.byte_count < expected - diff))
+        {
+            logf("Note: info.byte_count differs from expected value by "
+                 "%ld bytes", labs((long) (expected - info.byte_count)));
+            info.byte_count = 0;
+            info.frame_count = 0;
+            info.file_time = 0;
+            info.enc_padding = 0;
+
+            /* Even if the bitrate was based on "known bad" values, it
+             * should still be better for VBR files than using the bitrate
+             * of the first audio frame.
+             */
+        }
+    }
+
+    entry->bitrate = info.bitrate;
+    entry->frequency = info.frequency;
+    entry->version = info.version;
+    entry->layer = info.layer;
+    switch(entry->layer) {
+#if CONFIG_CODEC==SWCODEC
+        case 0:
+            entry->codectype=AFMT_MPA_L1;
+            break;
+#endif
+        case 1:
+            entry->codectype=AFMT_MPA_L2;
+            break;
+        case 2:
+            entry->codectype=AFMT_MPA_L3;
+            break;
+    }
+
+    /* If the file time hasn't been established, this may be a fixed
+       rate MP3, so just use the default formula */
+
+    filetime = info.file_time;
+
+    if(filetime == 0)
+    {
+        /* Prevent a division by zero */
+        if (info.bitrate < 8)
+            filetime = 0;
+        else
+            filetime = (entry->filesize - bytecount) / (info.bitrate / 8);
+        /* bitrate is in kbps so this delivers milliseconds. Doing bitrate / 8
+         * instead of filesize * 8 is exact, because mpeg audio bitrates are
+         * always multiples of 8, and it avoids overflows. */
+    }
+
+    entry->frame_count = info.frame_count;
+
+    entry->vbr = info.is_vbr;
+    entry->has_toc = info.has_toc;
+
+#if CONFIG_CODEC==SWCODEC
+    entry->lead_trim = info.enc_delay;
+    entry->tail_trim = info.enc_padding;
+#endif
+
+    memcpy(entry->toc, info.toc, sizeof(info.toc));
+
+    entry->vbr_header_pos = info.vbr_header_pos;
+
+    /* Update the seek point for the first playable frame */
+    entry->first_frame_offset = bytecount;
+    logf("First frame is at %lx", entry->first_frame_offset);
+
+    return filetime;
+}
+
+/*
+ * Checks all relevant information (such as ID3v1 tag, ID3v2 tag, length etc)
+ * about an MP3 file and updates it's entry accordingly.
+ *
+  Note, that this returns true for successful, false for error! */
+bool get_mp3_metadata(int fd, struct mp3entry *entry, const char *filename)
+{
+#if CONFIG_CODEC != SWCODEC
+    memset(entry, 0, sizeof(struct mp3entry));
+#endif
+
+    strncpy(entry->path, filename, sizeof(entry->path));
+
+    entry->title = NULL;
+    entry->filesize = filesize(fd);
+    entry->id3v2len = getid3v2len(fd);
+    entry->tracknum = 0;
+    entry->discnum = 0;
+
+    if (entry->id3v2len)
+        setid3v2title(fd, entry);
+    int len = getsonglength(fd, entry);
+    if (len < 0)
+        return false;
+    entry->length = len;
+
+    /* Subtract the meta information from the file size to get
+       the true size of the MP3 stream */
+    entry->filesize -= entry->first_frame_offset;
+
+    /* only seek to end of file if no id3v2 tags were found */
+    if (!entry->id3v2len) {
+        setid3v1title(fd, entry);
+    }
+
+    if(!entry->length || (entry->filesize < 8 ))
+        /* no song length or less than 8 bytes is hereby considered to be an
+           invalid mp3 and won't be played by us! */
+        return false;
+
+    return true;
+}
+
+/* Note, that this returns false for successful, true for error! */
+bool mp3info(struct mp3entry *entry, const char *filename)
+{
+    int fd;
+    bool result;
+
+    fd = open(filename, O_RDONLY);
+    if (fd < 0)
+        return true;
+
+    result = !get_mp3_metadata(fd, entry, filename);
+
+    close(fd);
+
+    return result;
+}
+
+void adjust_mp3entry(struct mp3entry *entry, void *dest, const void *orig)
+{
+    long offset;
+    if (orig > dest)
+        offset = - ((size_t)orig - (size_t)dest);
+    else
+        offset = (size_t)dest - (size_t)orig;
+
+    if (entry->title)
+        entry->title += offset;
+    if (entry->artist)
+        entry->artist += offset;
+    if (entry->album)
+        entry->album += offset;
+    if (entry->genre_string && !id3_is_genre_string(entry->genre_string))
+        /* Don't adjust that if it points to an entry of the "genres" array */
+        entry->genre_string += offset;
+    if (entry->track_string)
+        entry->track_string += offset;
+    if (entry->disc_string)
+        entry->disc_string += offset;
+    if (entry->year_string)
+        entry->year_string += offset;
+    if (entry->composer)
+        entry->composer += offset;
+    if (entry->comment)
+        entry->comment += offset;
+    if (entry->albumartist)
+        entry->albumartist += offset;
+    if (entry->grouping)
+        entry->grouping += offset;
+#if CONFIG_CODEC == SWCODEC
+    if (entry->track_gain_string)
+        entry->track_gain_string += offset;
+    if (entry->album_gain_string)
+        entry->album_gain_string += offset;
+#endif
+    if (entry->mb_track_id)
+        entry->mb_track_id += offset;
+}
+
+void copy_mp3entry(struct mp3entry *dest, const struct mp3entry *orig)
+{
+    memcpy(dest, orig, sizeof(struct mp3entry));
+    adjust_mp3entry(dest, dest, orig);
+}
+
+#ifdef DEBUG_STANDALONE
+
+char *secs2str(int ms)
+{
+    static char buffer[32];
+    int secs = ms/1000;
+    ms %= 1000;
+    snprintf(buffer, sizeof(buffer), "%d:%02d.%d", secs/60, secs%60, ms/100);
+    return buffer;
+}
+
+int main(int argc, char **argv)
+{
+    int i;
+    for(i=1; i<argc; i++) {
+        struct mp3entry mp3;
+        mp3.album = "Bogus";
+        if(mp3info(&mp3, argv[i], false)) {
+            printf("Failed to get %s\n", argv[i]);
+            return 0;
+        }
+
+        printf("****** File: %s\n"
+               "      Title: %s\n"
+               "     Artist: %s\n"
+               "      Album: %s\n"
+               "      Genre: %s (%d) \n"
+               "   Composer: %s\n"
+               "       Year: %s (%d)\n"
+               "      Track: %s (%d)\n"
+               "     Length: %s / %d s\n"
+               "    Bitrate: %d\n"
+               "  Frequency: %d\n",
+               argv[i],
+               mp3.title?mp3.title:"<blank>",
+               mp3.artist?mp3.artist:"<blank>",
+               mp3.album?mp3.album:"<blank>",
+               mp3.genre_string?mp3.genre_string:"<blank>",
+                    mp3.genre,
+               mp3.composer?mp3.composer:"<blank>",
+               mp3.year_string?mp3.year_string:"<blank>",
+                    mp3.year,
+               mp3.track_string?mp3.track_string:"<blank>",
+                    mp3.tracknum,
+               secs2str(mp3.length),
+               mp3.length/1000,
+               mp3.bitrate,
+               mp3.frequency);
+    }
+
+    return 0;
+}
+
+#endif
diff --git a/apps/mpeg.c b/apps/mpeg.c
new file mode 100644
index 0000000000..2c65e46060
--- /dev/null
+++ b/apps/mpeg.c
@@ -0,0 +1,2873 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2002 by Linus Nielsen Feltzing
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+#include <stdbool.h>
+#include <stdlib.h>
+#include "config.h"
+
+#if CONFIG_CODEC != SWCODEC
+
+#include "debug.h"
+#include "panic.h"
+#include "id3.h"
+#include "mpeg.h"
+#include "audio.h"
+#include "ata.h"
+#include "string.h"
+#include <kernel.h>
+#include "thread.h"
+#include "errno.h"
+#include "mp3data.h"
+#include "buffer.h"
+#include "mp3_playback.h"
+#include "sound.h"
+#include "bitswap.h"
+#include "events.h"
+#ifndef SIMULATOR
+#include "i2c.h"
+#include "mas.h"
+#include "system.h"
+#include "usb.h"
+#include "file.h"
+#include "hwcompat.h"
+#endif /* !SIMULATOR */
+#ifdef HAVE_LCD_BITMAP
+#include "lcd.h"
+#endif
+
+#ifndef SIMULATOR
+extern unsigned long mas_version_code;
+#endif
+
+#if CONFIG_CODEC == MAS3587F
+extern enum /* from mp3_playback.c */
+{
+    MPEG_DECODER,
+    MPEG_ENCODER
+} mpeg_mode;
+#endif /* CONFIG_CODEC == MAS3587F */
+
+extern char* playlist_peek(int steps);
+extern bool playlist_check(int steps);
+extern int playlist_next(int steps);
+extern int playlist_amount(void);
+extern int playlist_update_resume_info(const struct mp3entry* id3);
+
+#define MPEG_PLAY                  1
+#define MPEG_STOP                  2
+#define MPEG_PAUSE                 3
+#define MPEG_RESUME                4
+#define MPEG_NEXT                  5
+#define MPEG_PREV                  6
+#define MPEG_FF_REWIND             7
+#define MPEG_FLUSH_RELOAD          8
+#define MPEG_RECORD                9
+#define MPEG_INIT_RECORDING       10
+#define MPEG_INIT_PLAYBACK        11
+#define MPEG_NEW_FILE             12
+#define MPEG_PAUSE_RECORDING      13
+#define MPEG_RESUME_RECORDING     14
+#define MPEG_NEED_DATA           100
+#define MPEG_TRACK_CHANGE        101
+#define MPEG_SAVE_DATA           102
+#define MPEG_STOP_DONE           103
+#define MPEG_PRERECORDING_TICK   104
+
+/* indicator for MPEG_NEED_DATA */
+#define GENERATE_UNBUFFER_EVENTS 1
+
+/* list of tracks in memory */
+#define MAX_TRACK_ENTRIES (1<<4) /* Must be power of 2 */
+#define MAX_TRACK_ENTRIES_MASK (MAX_TRACK_ENTRIES - 1)
+
+struct trackdata
+{
+    struct mp3entry id3;
+    int mempos;
+    int load_ahead_index;
+};
+
+static struct trackdata trackdata[MAX_TRACK_ENTRIES];
+
+static unsigned int current_track_counter = 0;
+static unsigned int last_track_counter = 0;
+
+/* Play time of the previous track */
+unsigned long prev_track_elapsed;
+
+#ifndef SIMULATOR
+static int track_read_idx = 0;
+static int track_write_idx = 0;
+#endif /* !SIMULATOR */
+
+/* Cuesheet callback */
+static bool (*cuesheet_callback)(const char *filename) = NULL;
+
+static const char mpeg_thread_name[] = "mpeg";
+static unsigned int mpeg_errno;
+
+static bool playing = false;    /* We are playing an MP3 stream */
+static bool is_playing = false; /* We are (attempting to) playing MP3 files */
+static bool paused;             /* playback is paused */
+
+#ifdef SIMULATOR
+static char mpeg_stack[DEFAULT_STACK_SIZE];
+static struct mp3entry taginfo;
+
+#else /* !SIMULATOR */
+static struct event_queue mpeg_queue;
+static long mpeg_stack[(DEFAULT_STACK_SIZE + 0x1000)/sizeof(long)];
+
+static int audiobuflen;
+static int audiobuf_write;
+static int audiobuf_swapwrite;
+static int audiobuf_read;
+
+static int mpeg_file;
+
+static bool play_pending; /* We are about to start playing */
+static bool play_pending_track_change;  /* When starting play we're starting a new file */
+static bool filling;      /* We are filling the buffer with data from disk */
+static bool dma_underrun; /* True when the DMA has stopped because of
+                             slow disk reading (read error, shaking) */
+static bool mpeg_stop_done;
+
+static int last_dma_tick = 0;
+static int last_dma_chunk_size;
+
+static long low_watermark;          /* Dynamic low watermark level */
+static long low_watermark_margin = 0;   /* Extra time in seconds for watermark */
+static long lowest_watermark_level; /* Debug value to observe the buffer
+                                       usage */
+#if CONFIG_CODEC == MAS3587F
+static char recording_filename[MAX_PATH]; /* argument to thread */
+static char delayed_filename[MAX_PATH];   /* internal copy of above */
+
+static char xing_buffer[MAX_XING_HEADER_SIZE];
+
+static bool init_recording_done;
+static bool init_playback_done;
+static bool prerecording;        /* True if prerecording is enabled */
+static bool is_prerecording;     /* True if we are prerecording */
+static bool is_recording;        /* We are recording */
+
+static enum {
+    NOT_SAVING = 0,  /* reasons to save data, sorted by importance */
+    BUFFER_FULL,
+    NEW_FILE,
+    STOP_RECORDING
+} saving_status;
+
+static int rec_frequency_index; /* For create_xing_header() calls */
+static int rec_version_index;   /* For create_xing_header() calls */
+
+struct prerecord_info {
+    int mempos;
+    unsigned long framecount;
+};
+
+static struct prerecord_info prerecord_buffer[MPEG_MAX_PRERECORD_SECONDS];
+static int prerecord_index;       /* Current index in the prerecord buffer */
+static int prerecording_max_seconds;     /* Max number of seconds to store */
+static int prerecord_count;   /* Number of seconds in the prerecord buffer */
+static int prerecord_timeout; /* The tick count of the next prerecord data
+                                 store */
+
+unsigned long record_start_time; /* Value of current_tick when recording
+                                    was started */
+unsigned long pause_start_time;  /* Value of current_tick when pause was
+                                    started */
+static unsigned long last_rec_time;
+static unsigned long num_rec_bytes;
+static unsigned long last_rec_bytes;
+static unsigned long frame_count_start;
+static unsigned long frame_count_end;
+static unsigned long saved_header = 0;
+
+/* Shadow MAS registers */
+unsigned long shadow_encoder_control = 0;
+#endif /* CONFIG_CODEC == MAS3587F */
+
+#if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
+unsigned long shadow_io_control_main = 0;
+unsigned long shadow_soft_mute = 0;
+unsigned shadow_codec_reg0;
+#endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
+
+#ifdef HAVE_RECORDING
+static const unsigned char empty_id3_header[] =
+{
+    'I', 'D', '3', 0x03, 0x00, 0x00,
+    0x00, 0x00, 0x1f, 0x76 /* Size is 4096 minus 10 bytes for the header */
+};
+#endif /* HAVE_RECORDING */
+
+
+static int get_unplayed_space(void);
+static int get_playable_space(void);
+static int get_unswapped_space(void);
+#endif /* !SIMULATOR */
+
+#if (CONFIG_CODEC == MAS3587F) && !defined(SIMULATOR)
+static void init_recording(void);
+static void prepend_header(void);
+static void update_header(void);
+static void start_prerecording(void);
+static void start_recording(void);
+static void stop_recording(void);
+static int get_unsaved_space(void);
+static void pause_recording(void);
+static void resume_recording(void);
+#endif /* (CONFIG_CODEC == MAS3587F) && !defined(SIMULATOR) */
+
+
+#ifndef SIMULATOR
+static int num_tracks_in_memory(void)
+{
+    return (track_write_idx - track_read_idx) & MAX_TRACK_ENTRIES_MASK;
+}
+
+#ifdef DEBUG_TAGS
+static void debug_tags(void)
+{
+    int i;
+
+    for(i = 0;i < MAX_TRACK_ENTRIES;i++)
+    {
+        DEBUGF("%d - %s\n", i, trackdata[i].id3.path);
+    }
+    DEBUGF("read: %d, write :%d\n", track_read_idx, track_write_idx);
+    DEBUGF("num_tracks_in_memory: %d\n", num_tracks_in_memory());
+}
+#else /* !DEBUG_TAGS */
+#define debug_tags()
+#endif /* !DEBUG_TAGS */
+
+static void remove_current_tag(void)
+{
+    if(num_tracks_in_memory() > 0)
+    {
+        /* First move the index, so nobody tries to access the tag */
+        track_read_idx = (track_read_idx+1) & MAX_TRACK_ENTRIES_MASK;
+        debug_tags();
+    }
+    else
+    {
+        DEBUGF("remove_current_tag: no tracks to remove\n");
+    }
+}
+
+static void remove_all_non_current_tags(void)
+{
+    track_write_idx = (track_read_idx+1) & MAX_TRACK_ENTRIES_MASK;
+    debug_tags();
+}
+
+static void remove_all_tags(void)
+{
+    track_write_idx = track_read_idx;
+
+    debug_tags();
+}
+
+static struct trackdata *get_trackdata(int offset)
+{
+    if(offset >= num_tracks_in_memory())
+        return NULL;
+    else
+       return &trackdata[(track_read_idx + offset) & MAX_TRACK_ENTRIES_MASK];
+}
+#endif /* !SIMULATOR */
+
+/***********************************************************************/
+/* audio event handling */
+
+#define MAX_EVENT_HANDLERS 10
+struct event_handlers_table
+{
+    AUDIO_EVENT_HANDLER handler;
+    unsigned short mask;
+};
+static struct event_handlers_table event_handlers[MAX_EVENT_HANDLERS];
+static int event_handlers_count = 0;
+
+void audio_register_event_handler(AUDIO_EVENT_HANDLER handler, unsigned short mask)
+{
+    if (event_handlers_count < MAX_EVENT_HANDLERS)
+    {
+        event_handlers[event_handlers_count].handler = handler;
+        event_handlers[event_handlers_count].mask = mask;
+        event_handlers_count++;
+    }
+}
+
+/* dispatch calls each handler in the order registered and returns after some
+   handler actually handles the event (the event is assumed to no longer be valid
+   after this, due to the handler changing some condition); returns true if someone
+   handled the event, which is expected to cause the caller to skip its own handling
+   of the event */
+#ifndef SIMULATOR
+static bool audio_dispatch_event(unsigned short event, unsigned long data)
+{
+    int i = 0;
+    for(i=0; i < event_handlers_count; i++)
+    {
+        if ( event_handlers[i].mask & event )
+        {
+            int rc = event_handlers[i].handler(event, data);
+            if ( rc == AUDIO_EVENT_RC_HANDLED )
+                return true;
+        }
+    }
+    return false;
+}
+#endif
+
+/***********************************************************************/
+
+static void set_elapsed(struct mp3entry* id3)
+{
+    if ( id3->vbr ) {
+        if ( id3->has_toc ) {
+            /* calculate elapsed time using TOC */
+            int i;
+            unsigned int remainder, plen, relpos, nextpos;
+
+            /* find wich percent we're at */
+            for (i=0; i<100; i++ )
+            {
+                if ( id3->offset < id3->toc[i] * (id3->filesize / 256) )
+                {
+                    break;
+                }
+            }
+            
+            i--;
+            if (i < 0)
+                i = 0;
+
+            relpos = id3->toc[i];
+
+            if (i < 99)
+            {
+                nextpos = id3->toc[i+1];
+            }
+            else
+            {
+                nextpos = 256; 
+            }
+
+            remainder = id3->offset - (relpos * (id3->filesize / 256));
+
+            /* set time for this percent (divide before multiply to prevent
+               overflow on long files. loss of precision is negligible on
+               short files) */
+            id3->elapsed = i * (id3->length / 100);
+
+            /* calculate remainder time */
+            plen = (nextpos - relpos) * (id3->filesize / 256);
+            id3->elapsed += (((remainder * 100) / plen) *
+                             (id3->length / 10000));
+        }
+        else {
+            /* no TOC exists. set a rough estimate using average bitrate */
+            int tpk = id3->length / (id3->filesize / 1024);
+            id3->elapsed = id3->offset / 1024 * tpk;
+        }
+    }
+    else
+        /* constant bitrate, use exact calculation */
+        id3->elapsed = id3->offset / (id3->bitrate / 8);
+}
+
+int audio_get_file_pos(void)
+{
+    int pos = -1;
+    struct mp3entry *id3 = audio_current_track();
+    
+    if (id3->vbr)
+    {
+        if (id3->has_toc)
+        {
+            /* Use the TOC to find the new position */
+            unsigned int percent, remainder;
+            int curtoc, nexttoc, plen;
+                        
+            percent = (id3->elapsed*100)/id3->length;
+            if (percent > 99)
+                percent = 99;
+                        
+            curtoc = id3->toc[percent];
+                        
+            if (percent < 99)
+                nexttoc = id3->toc[percent+1];
+            else
+                nexttoc = 256;
+                        
+            pos = (id3->filesize/256)*curtoc;
+                        
+            /* Use the remainder to get a more accurate position */
+            remainder   = (id3->elapsed*100)%id3->length;
+            remainder   = (remainder*100)/id3->length;
+            plen        = (nexttoc - curtoc)*(id3->filesize/256);
+            pos     += (plen/100)*remainder;
+        }
+        else
+        {
+            /* No TOC exists, estimate the new position */
+            pos = (id3->filesize / (id3->length / 1000)) *
+                (id3->elapsed / 1000);
+        }
+    }
+    else if (id3->bitrate)
+        pos = id3->elapsed * (id3->bitrate / 8);
+    else
+    {
+        return -1;
+    }
+
+    if (pos >= (int)(id3->filesize - id3->id3v1len))
+    {
+        /* Don't seek right to the end of the file so that we can
+           transition properly to the next song */
+        pos = id3->filesize - id3->id3v1len - 1;
+    }
+    else if (pos < (int)id3->first_frame_offset)
+    {
+        /* skip past id3v2 tag and other leading garbage */
+        pos = id3->first_frame_offset;
+    }
+    return pos;    
+}
+
+unsigned long mpeg_get_last_header(void)
+{
+#ifdef SIMULATOR
+    return 0;
+#else /* !SIMULATOR */
+    unsigned long tmp[2];
+
+    /* Read the frame data from the MAS and reconstruct it with the
+       frame sync and all */
+    mas_readmem(MAS_BANK_D0, MAS_D0_MPEG_STATUS_1, tmp, 2);
+    return 0xffe00000 | ((tmp[0] & 0x7c00) << 6) | (tmp[1] & 0xffff);
+#endif /* !SIMULATOR */
+}
+
+void audio_set_cuesheet_callback(bool (*handler)(const char *filename))
+{
+    cuesheet_callback = handler;
+}
+
+#ifndef SIMULATOR
+/* Send callback events to notify about removing old tracks. */
+static void generate_unbuffer_events(void)
+{
+    int i;
+    int numentries = MAX_TRACK_ENTRIES - num_tracks_in_memory();
+    int cur_idx = track_write_idx;
+
+    for (i = 0; i < numentries; i++)
+    {
+        /* Send an event to notify that track has finished. */
+        send_event(PLAYBACK_EVENT_TRACK_FINISH, &trackdata[cur_idx].id3);
+        cur_idx = (cur_idx + 1) & MAX_TRACK_ENTRIES_MASK;
+    }
+}
+
+/* Send callback events to notify about new tracks. */
+static void generate_postbuffer_events(void)
+{
+    int i;
+    int numentries = num_tracks_in_memory();
+    int cur_idx = track_read_idx;
+
+    for (i = 0; i < numentries; i++)
+    {
+        send_event(PLAYBACK_EVENT_TRACK_BUFFER, &trackdata[cur_idx].id3);
+        cur_idx = (cur_idx + 1) & MAX_TRACK_ENTRIES_MASK;
+    }
+}
+
+static void recalculate_watermark(int bitrate)
+{
+    int bytes_per_sec;
+    int time = ata_spinup_time;
+
+    /* A bitrate of 0 probably means empty VBR header. We play safe
+       and set a high threshold */
+    if(bitrate == 0)
+        bitrate = 320;
+    
+    bytes_per_sec = bitrate * 1000 / 8;
+    
+    if(time)
+    {
+        /* No drive spins up faster than 3.5s */
+        if(time < 350)
+            time = 350;
+
+        time = time * 3;
+        low_watermark = ((low_watermark_margin * HZ + time) *
+                         bytes_per_sec) / HZ;
+    }
+    else
+    {
+        low_watermark = MPEG_LOW_WATER;
+    }
+}
+
+#ifdef HAVE_DISK_STORAGE
+void audio_set_buffer_margin(int seconds)
+{
+    low_watermark_margin = seconds;
+}
+#endif
+
+void audio_get_debugdata(struct audio_debug *dbgdata)
+{
+    dbgdata->audiobuflen = audiobuflen;
+    dbgdata->audiobuf_write = audiobuf_write;
+    dbgdata->audiobuf_swapwrite = audiobuf_swapwrite;
+    dbgdata->audiobuf_read = audiobuf_read;
+
+    dbgdata->last_dma_chunk_size = last_dma_chunk_size;
+
+#if CONFIG_CPU == SH7034
+    dbgdata->dma_on = (SCR0 & 0x80) != 0;
+#endif
+    dbgdata->playing = playing;
+    dbgdata->play_pending = play_pending;
+    dbgdata->is_playing = is_playing;
+    dbgdata->filling = filling;
+    dbgdata->dma_underrun = dma_underrun;
+
+    dbgdata->unplayed_space = get_unplayed_space();
+    dbgdata->playable_space = get_playable_space();
+    dbgdata->unswapped_space = get_unswapped_space();
+
+    dbgdata->low_watermark_level = low_watermark;
+    dbgdata->lowest_watermark_level = lowest_watermark_level;
+}
+
+#ifdef DEBUG
+static void dbg_timer_start(void)
+{
+    /* We are using timer 2 */
+    
+    TSTR &= ~0x04; /* Stop the timer */
+    TSNC &= ~0x04; /* No synchronization */
+    TMDR &= ~0x44; /* Operate normally */
+
+    TCNT2 = 0;   /* Start counting at 0 */
+    TCR2 = 0x03; /* Sysclock/8 */
+
+    TSTR |= 0x04; /* Start timer 2 */
+}
+
+static int dbg_cnt2us(unsigned int cnt)
+{
+    return (cnt * 10000) / (FREQ/800);
+}
+#endif /* DEBUG */
+
+static int get_unplayed_space(void)
+{
+    int space = audiobuf_write - audiobuf_read;
+    if (space < 0)
+        space += audiobuflen;
+    return space;
+}
+
+static int get_playable_space(void)
+{
+    int space = audiobuf_swapwrite - audiobuf_read;
+    if (space < 0)
+        space += audiobuflen;
+    return space;
+}
+
+static int get_unplayed_space_current_song(void)
+{
+    int space;
+
+    if (num_tracks_in_memory() > 1)
+    {
+        space = get_trackdata(1)->mempos - audiobuf_read;
+    }
+    else
+    {
+        space = audiobuf_write - audiobuf_read;
+    }
+
+    if (space < 0)
+        space += audiobuflen;
+
+    return space;
+}
+
+static int get_unswapped_space(void)
+{
+    int space = audiobuf_write - audiobuf_swapwrite;
+    if (space < 0)
+        space += audiobuflen;
+    return space;
+}
+
+#if CONFIG_CODEC == MAS3587F
+static int get_unsaved_space(void)
+{
+    int space = audiobuf_write - audiobuf_read;
+    if (space < 0)
+        space += audiobuflen;
+    return space;
+}
+
+static void drain_dma_buffer(void)
+{
+    while (PBDRH & 0x40)
+    {
+        xor_b(0x08, &PADRH);
+
+        while (PBDRH & 0x80);
+
+        xor_b(0x08, &PADRH);
+
+        while (!(PBDRH & 0x80));
+    }
+}
+
+#ifdef DEBUG
+static long timing_info_index = 0;
+static long timing_info[1024];
+#endif /* DEBUG */
+
+void rec_tick (void) __attribute__ ((section (".icode")));
+void rec_tick(void)
+{
+    int i;
+    int delay;
+    char data;
+
+    if(is_recording && (PBDRH & 0x40))
+    {
+#ifdef DEBUG
+        timing_info[timing_info_index++] = current_tick;
+        TCNT2 = 0;
+#endif /* DEBUG */
+        /* Note: Although this loop is run in interrupt context, further
+         * optimisation will do no good. The MAS would then deliver bad
+         * frames occasionally, as observed in extended experiments. */
+        i = 0;
+        while (PBDRH & 0x40)      /* We try to read as long as EOD is high */
+        {
+            xor_b(0x08, &PADRH);  /* Set PR active, independent of polarity */
+
+            delay = 100;
+            while (PBDRH & 0x80)  /* Wait until /RTW becomes active */
+            {
+                if (--delay <= 0) /* Bail out if we have to wait too long */
+                {                 /* i.e. the MAS doesn't want to talk to us */
+                    xor_b(0x08, &PADRH);         /* Set PR inactive */
+                    goto transfer_end;           /* and get out of here */
+                }
+            }
+
+            data = *(unsigned char *)0x04000000; /* read data byte */
+                
+            xor_b(0x08, &PADRH);                 /* Set PR inactive */
+
+            audiobuf[audiobuf_write++] = data;
+
+            if (audiobuf_write >= audiobuflen)
+                audiobuf_write = 0;
+
+            i++;
+        }
+      transfer_end:
+
+#ifdef DEBUG
+        timing_info[timing_info_index++] = TCNT2 + (i << 16);
+        timing_info_index &= 0x3ff;
+#endif /* DEBUG */
+
+        num_rec_bytes += i;
+
+        if(is_prerecording)
+        {
+            if(TIME_AFTER(current_tick, prerecord_timeout))
+            {
+                prerecord_timeout = current_tick + HZ;
+                queue_post(&mpeg_queue, MPEG_PRERECORDING_TICK, 0);
+            }
+        }
+        else
+        {
+            /* Signal to save the data if we are running out of buffer
+               space */
+            if (audiobuflen - get_unsaved_space() < MPEG_RECORDING_LOW_WATER
+                && saving_status == NOT_SAVING)
+            {
+                saving_status = BUFFER_FULL;
+                queue_post(&mpeg_queue, MPEG_SAVE_DATA, 0);
+            }
+        }
+    }
+}
+#endif /* CONFIG_CODEC == MAS3587F */
+
+void playback_tick(void)
+{
+    struct trackdata *ptd = get_trackdata(0);
+    if(ptd)
+    {
+        ptd->id3.elapsed += (current_tick - last_dma_tick) * 1000 / HZ;
+        last_dma_tick = current_tick;
+        audio_dispatch_event(AUDIO_EVENT_POS_REPORT,
+                             (unsigned long)ptd->id3.elapsed);
+    }
+}
+
+static void reset_mp3_buffer(void)
+{
+    audiobuf_read = 0;
+    audiobuf_write = 0;
+    audiobuf_swapwrite = 0;
+    lowest_watermark_level = audiobuflen;
+}
+
+ /* DMA transfer end interrupt callback */
+static void transfer_end(unsigned char** ppbuf, size_t* psize)
+{
+    if(playing && !paused)
+    {
+        int unplayed_space_left;
+        int space_until_end_of_buffer;
+        int track_offset = 1;
+        struct trackdata *track;
+
+        audiobuf_read += last_dma_chunk_size;
+        if(audiobuf_read >= audiobuflen)
+            audiobuf_read = 0;
+    
+        /* First, check if we are on a track boundary */
+        if (num_tracks_in_memory() > 1)
+        {
+            if (audiobuf_read == get_trackdata(track_offset)->mempos)
+            {
+                if ( ! audio_dispatch_event(AUDIO_EVENT_END_OF_TRACK, 0) )
+                {
+                    queue_post(&mpeg_queue, MPEG_TRACK_CHANGE, 0);
+                    track_offset++;
+                }
+            }
+        }
+        
+        unplayed_space_left = get_unplayed_space();
+        
+        space_until_end_of_buffer = audiobuflen - audiobuf_read;
+        
+        if(!filling && unplayed_space_left < low_watermark)
+        {
+            filling = true;
+            queue_post(&mpeg_queue, MPEG_NEED_DATA, GENERATE_UNBUFFER_EVENTS);
+        }
+        
+        if(unplayed_space_left)
+        {
+            last_dma_chunk_size = MIN(0x2000, unplayed_space_left);
+            last_dma_chunk_size = MIN(last_dma_chunk_size,
+                                      space_until_end_of_buffer);
+
+            /* several tracks loaded? */
+            track = get_trackdata(track_offset);
+            if(track)
+            {
+                /* will we move across the track boundary? */
+                if (( audiobuf_read < track->mempos ) &&
+                    ((audiobuf_read+last_dma_chunk_size) >
+                     track->mempos ))
+                {
+                    /* Make sure that we end exactly on the boundary */
+                    last_dma_chunk_size = track->mempos - audiobuf_read;
+                }
+            }
+
+            *psize = last_dma_chunk_size & 0xffff;
+            *ppbuf = audiobuf + audiobuf_read;
+            track = get_trackdata(0);
+            if(track)
+                track->id3.offset += last_dma_chunk_size;
+
+            /* Update the watermark debug level */
+            if(unplayed_space_left < lowest_watermark_level)
+                lowest_watermark_level = unplayed_space_left;
+        }
+        else
+        {
+            /* Check if the end of data is because of a hard disk error.
+               If there is an open file handle, we are still playing music.
+               If not, the last file has been loaded, and the file handle is
+               closed. */
+            if(mpeg_file >= 0)
+            {
+                /* Update the watermark debug level */
+                if(unplayed_space_left < lowest_watermark_level)
+                    lowest_watermark_level = unplayed_space_left;
+                
+                DEBUGF("DMA underrun.\n");
+                dma_underrun = true;
+            }
+            else
+            {
+                if ( ! audio_dispatch_event(AUDIO_EVENT_END_OF_TRACK, 0) )
+                {
+                    DEBUGF("No more MP3 data. Stopping.\n");
+                    queue_post(&mpeg_queue, MPEG_TRACK_CHANGE, 0);
+                    playing = false;
+                }
+            }
+            *psize = 0; /* no more transfer */
+        }
+    }
+}
+
+static struct trackdata *add_track_to_tag_list(const char *filename)
+{
+    struct trackdata *track;
+    
+    if(num_tracks_in_memory() >= MAX_TRACK_ENTRIES)
+    {
+        DEBUGF("Tag memory is full\n");
+        return NULL;
+    }
+
+    track = &trackdata[track_write_idx];
+    
+    /* grab id3 tag of new file and
+       remember where in memory it starts */
+    if(mp3info(&track->id3, filename))
+    {
+        DEBUGF("Bad mp3\n");
+        return NULL;
+    }
+    track->mempos = audiobuf_write;
+    track->id3.elapsed = 0;
+#ifdef HAVE_LCD_BITMAP
+    if (track->id3.title)
+        lcd_getstringsize(track->id3.title, NULL, NULL);
+    if (track->id3.artist)
+        lcd_getstringsize(track->id3.artist, NULL, NULL);
+    if (track->id3.album)
+        lcd_getstringsize(track->id3.album, NULL, NULL);
+#endif
+    if (cuesheet_callback)
+        if (cuesheet_callback(filename))
+            track->id3.cuesheet_type = 1;
+
+    track_write_idx = (track_write_idx+1) & MAX_TRACK_ENTRIES_MASK;
+    debug_tags();
+    return track;
+}
+
+static int new_file(int steps)
+{
+    int max_steps = playlist_amount();
+    int start = 0;
+    int i;
+    struct trackdata *track;
+
+    /* Find out how many steps to advance. The load_ahead_index field tells
+       us how many playlist entries it had to skip to get to a valid one.
+       We add those together to find out where to start. */
+    if(steps > 0 && num_tracks_in_memory() > 1)
+    {
+        /* Begin with the song after the currently playing one */
+        i = 1;
+        while((track = get_trackdata(i++)))
+        {
+            start += track->load_ahead_index;
+        }
+    }
+    
+    do {
+        char *trackname;
+
+        trackname = playlist_peek( start + steps );
+        if ( !trackname )
+            return -1;
+        
+        DEBUGF("Loading %s\n", trackname);
+        
+        mpeg_file = open(trackname, O_RDONLY);
+        if(mpeg_file < 0) {
+            DEBUGF("Couldn't open file: %s\n",trackname);
+            if(steps < 0)
+               steps--;
+            else
+               steps++;
+        }
+        else
+        {
+            struct trackdata *track = add_track_to_tag_list(trackname);
+
+            if(!track)
+            {
+                /* Bad mp3 file */
+                if(steps < 0)
+                    steps--;
+                else
+                    steps++;
+                close(mpeg_file);
+                mpeg_file = -1;
+            }
+            else
+            {
+                /* skip past id3v2 tag */
+                lseek(mpeg_file, 
+                      track->id3.first_frame_offset,
+                      SEEK_SET);
+                track->id3.index = steps;
+                track->load_ahead_index = steps;
+                track->id3.offset = 0;
+
+                if(track->id3.vbr)
+                    /* Average bitrate * 1.5 */
+                    recalculate_watermark(
+                        (track->id3.bitrate * 3) / 2);
+                else
+                    recalculate_watermark(
+                        track->id3.bitrate);
+                    
+            }
+        }
+
+        /* Bail out if no file could be opened */
+        if(abs(steps) > max_steps)
+           return -1;
+    } while ( mpeg_file < 0 );
+
+    return 0;
+}
+
+static void stop_playing(void)
+{
+    struct trackdata *track;
+
+    /* Stop the current stream */
+    mp3_play_stop();
+    playing = false;
+    filling = false;
+
+    track = get_trackdata(0);
+    if (track != NULL)
+        prev_track_elapsed = track->id3.elapsed;
+
+    if(mpeg_file >= 0)
+        close(mpeg_file);
+    mpeg_file = -1;
+    remove_all_tags();
+    generate_unbuffer_events();
+    reset_mp3_buffer();
+}
+
+static void end_current_track(void) {
+    struct trackdata *track;
+
+    play_pending = false;
+    playing = false;
+    mp3_play_pause(false);
+
+    track = get_trackdata(0);
+    if (track != NULL)
+        prev_track_elapsed = track->id3.elapsed;
+
+    reset_mp3_buffer();
+    remove_all_tags();
+    generate_unbuffer_events();
+
+    if(mpeg_file >= 0)
+        close(mpeg_file);
+}
+
+/* Is this a really the end of playback or is a new playlist starting */
+static void check_playlist_end(int direction)
+{
+    /* Use the largest possible step size to account for skipped tracks */
+    int steps = playlist_amount();
+
+    if (direction < 0)
+        steps = -steps;
+
+    if (playlist_next(steps) < 0)
+        is_playing = false;
+}
+
+static void update_playlist(void)
+{
+    if (num_tracks_in_memory() > 0)
+    {
+        struct trackdata *track = get_trackdata(0);
+        track->id3.index = playlist_next(track->id3.index);
+    }
+    else
+    {
+        /* End of playlist? */
+        check_playlist_end(1);
+    }
+
+    playlist_update_resume_info(audio_current_track());
+}
+
+static void track_change(void)
+{
+    DEBUGF("Track change\n");
+
+    struct trackdata *track = get_trackdata(0);
+    prev_track_elapsed = track->id3.elapsed;
+
+#if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
+    /* Reset the AVC */
+    sound_set_avc(-1);
+#endif /* (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F) */
+
+    if (num_tracks_in_memory() > 0)
+    {
+        remove_current_tag();
+        send_event(PLAYBACK_EVENT_TRACK_CHANGE, audio_current_track());
+        update_playlist();
+    }
+
+    current_track_counter++;
+}
+
+unsigned long audio_prev_elapsed(void)
+{
+    return prev_track_elapsed;
+}
+
+#ifdef DEBUG
+void hexdump(const unsigned char *buf, int len)
+{
+    int i;
+
+    for(i = 0;i < len;i++)
+    {
+        if(i && (i & 15) == 0)
+        {
+            DEBUGF("\n");
+        }
+        DEBUGF("%02x ", buf[i]);
+    }
+    DEBUGF("\n");
+}
+#endif /* DEBUG */
+
+static void start_playback_if_ready(void)
+{
+    int playable_space;
+
+    playable_space = audiobuf_swapwrite - audiobuf_read;
+    if(playable_space < 0)
+        playable_space += audiobuflen;
+    
+    /* See if we have started playing yet. If not, do it. */
+    if(play_pending || dma_underrun)
+    {
+        /* If the filling has stopped, and we still haven't reached
+           the watermark, the file must be smaller than the
+           watermark. We must still play it. */
+        if((playable_space >= MPEG_PLAY_PENDING_THRESHOLD) ||
+           !filling || dma_underrun)
+        {
+            DEBUGF("P\n");
+            if (play_pending) /* don't do this when recovering from DMA underrun */
+            {
+                generate_postbuffer_events(); /* signal first track as buffered */
+                if (play_pending_track_change)
+                {
+                    play_pending_track_change = false;
+                    send_event(PLAYBACK_EVENT_TRACK_CHANGE, audio_current_track());
+                }
+                play_pending = false;
+            }
+            playing = true;
+
+            last_dma_chunk_size = MIN(0x2000, get_unplayed_space_current_song());
+            mp3_play_data(audiobuf + audiobuf_read, last_dma_chunk_size, transfer_end);
+            dma_underrun = false;
+
+            if (!paused)
+            {
+                last_dma_tick = current_tick;
+                mp3_play_pause(true);
+            }
+
+            /* Tell ourselves that we need more data */
+            queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
+        }
+    }
+}
+
+static bool swap_one_chunk(void)
+{
+    int free_space_left;
+    int amount_to_swap;
+
+    free_space_left = get_unswapped_space();
+
+    if(free_space_left == 0 && !play_pending)
+        return false;
+
+    /* Swap in larger chunks when the user is waiting for the playback
+       to start, or when there is dangerously little playable data left */
+    if(play_pending)
+        amount_to_swap = MIN(MPEG_PLAY_PENDING_SWAPSIZE, free_space_left);
+    else
+    {
+        if(get_playable_space() < low_watermark)
+            amount_to_swap = MIN(MPEG_LOW_WATER_SWAP_CHUNKSIZE,
+                                 free_space_left);
+        else
+            amount_to_swap = MIN(MPEG_SWAP_CHUNKSIZE, free_space_left);
+    }
+    
+    if(audiobuf_write < audiobuf_swapwrite)
+        amount_to_swap = MIN(audiobuflen - audiobuf_swapwrite,
+                             amount_to_swap);
+    else
+        amount_to_swap = MIN(audiobuf_write - audiobuf_swapwrite,
+                             amount_to_swap);
+
+    bitswap(audiobuf + audiobuf_swapwrite, amount_to_swap);
+
+    audiobuf_swapwrite += amount_to_swap;
+    if(audiobuf_swapwrite >= audiobuflen)
+    {
+        audiobuf_swapwrite = 0;
+    }
+
+    return true;
+}
+
+static void mpeg_thread(void)
+{
+    static int pause_tick = 0;
+    static unsigned int pause_track = 0;
+    struct queue_event ev;
+    int len;
+    int free_space_left;
+    int unplayed_space_left;
+    int amount_to_read;
+    int t1, t2;
+    int start_offset;
+#if CONFIG_CODEC == MAS3587F
+    int amount_to_save;
+    int save_endpos = 0;
+    int rc;
+    int level;
+    long offset;
+#endif /* CONFIG_CODEC == MAS3587F */
+
+    is_playing = false;
+    play_pending = false;
+    playing = false;
+    mpeg_file = -1;
+
+    while(1)
+    {
+#if CONFIG_CODEC == MAS3587F
+        if(mpeg_mode == MPEG_DECODER)
+        {
+#endif /* CONFIG_CODEC == MAS3587F */
+        yield();
+
+        /* Swap if necessary, and don't block on the queue_wait() */
+        if(swap_one_chunk())
+        {
+            queue_wait_w_tmo(&mpeg_queue, &ev, 0);
+        }
+        else if (playing)
+        {
+            /* periodically update resume info */
+            queue_wait_w_tmo(&mpeg_queue, &ev, HZ/2);
+        }
+        else
+        {
+            DEBUGF("S R:%x W:%x SW:%x\n",
+                   audiobuf_read, audiobuf_write, audiobuf_swapwrite);
+            queue_wait(&mpeg_queue, &ev);
+        }
+
+        start_playback_if_ready();
+        
+        switch(ev.id)
+        {
+            case MPEG_PLAY:
+                DEBUGF("MPEG_PLAY\n");
+
+#if CONFIG_TUNER
+                /* Silence the A/D input, it may be on because the radio
+                   may be playing */
+                mas_codec_writereg(6, 0x0000);
+#endif /* CONFIG_TUNER */
+
+                /* Stop the current stream */
+                paused = false;
+                end_current_track();
+
+                if ( new_file(0) == -1 )
+                {
+                    is_playing = false;
+                    track_change();
+                    break;
+                }
+
+                start_offset = (int)ev.data;
+
+                /* mid-song resume? */
+                if (start_offset) {
+                    struct mp3entry* id3 = &get_trackdata(0)->id3;
+                    lseek(mpeg_file, start_offset, SEEK_SET);
+                    id3->offset = start_offset;
+                    set_elapsed(id3);
+                }
+                else {
+                    /* skip past id3v2 tag */
+                    lseek(mpeg_file, 
+                          get_trackdata(0)->id3.first_frame_offset, 
+                          SEEK_SET);
+
+                }
+
+                /* Make it read more data */
+                filling = true;
+                queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
+
+                /* Tell the file loading code that we want to start playing
+                   as soon as we have some data */
+                play_pending = true;
+                play_pending_track_change = true;
+
+                update_playlist();
+                current_track_counter++;
+                break;
+
+            case MPEG_STOP:
+                DEBUGF("MPEG_STOP\n");
+                is_playing = false;
+                paused = false;
+
+                if (playing)
+                    playlist_update_resume_info(audio_current_track());
+
+                stop_playing();
+                mpeg_stop_done = true;
+                break;
+
+            case MPEG_PAUSE:
+                DEBUGF("MPEG_PAUSE\n");
+                /* Stop the current stream */
+                if (playing)
+                    playlist_update_resume_info(audio_current_track());
+                paused = true;
+                playing = false;
+                pause_tick = current_tick;
+                pause_track = current_track_counter;
+                mp3_play_pause(false);
+                break;
+
+            case MPEG_RESUME:
+                DEBUGF("MPEG_RESUME\n");
+                /* Continue the current stream */
+                paused = false;
+                if (!play_pending)
+                {
+                    playing = true;
+                    if ( current_track_counter == pause_track )
+                        last_dma_tick += current_tick - pause_tick;
+                    else
+                        last_dma_tick = current_tick;                        
+                    pause_tick = 0;
+                    mp3_play_pause(true);
+                }
+                break;
+
+            case MPEG_NEXT:
+                DEBUGF("MPEG_NEXT\n");
+                /* is next track in ram? */
+                if ( num_tracks_in_memory() > 1 ) {
+                    int unplayed_space_left, unswapped_space_left;
+
+                    /* stop the current stream */
+                    play_pending = false;
+                    playing = false;
+                    mp3_play_pause(false);
+
+                    track_change();
+                    audiobuf_read = get_trackdata(0)->mempos;
+                    last_dma_chunk_size = MIN(0x2000, get_unplayed_space_current_song());
+                    mp3_play_data(audiobuf + audiobuf_read, last_dma_chunk_size, transfer_end);
+                    dma_underrun = false;
+                    last_dma_tick = current_tick;
+
+                    unplayed_space_left  = get_unplayed_space();
+                    unswapped_space_left = get_unswapped_space();
+
+                    /* should we start reading more data? */
+                    if(!filling && (unplayed_space_left < low_watermark)) {
+                        filling = true;
+                        queue_post(&mpeg_queue, MPEG_NEED_DATA, GENERATE_UNBUFFER_EVENTS);
+                        play_pending = true;
+                    } else if(unswapped_space_left &&
+                              unswapped_space_left > unplayed_space_left) {
+                        /* Stop swapping the data from the previous file */
+                        audiobuf_swapwrite = audiobuf_read;
+                        play_pending = true;
+                    } else {
+                        playing = true;
+                        if (!paused)
+                            mp3_play_pause(true);
+                    }
+                }
+                else {
+                    if (!playlist_check(1))
+                        break;
+
+                    /* stop the current stream */
+                    end_current_track();
+
+                    if (new_file(1) < 0) {
+                        DEBUGF("No more files to play\n");
+                        filling = false;
+
+                        check_playlist_end(1);
+                        current_track_counter++;
+                    } else {
+                        /* Make it read more data */
+                        filling = true;
+                        queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
+                        
+                        /* Tell the file loading code that we want
+                           to start playing as soon as we have some data */
+                        play_pending = true;
+                        play_pending_track_change = true;
+
+                        update_playlist();
+                        current_track_counter++;
+                    }
+                }
+                break;
+
+            case MPEG_PREV: {
+                DEBUGF("MPEG_PREV\n");
+
+                if (!playlist_check(-1))
+                    break;
+                
+                /* stop the current stream */
+                end_current_track();
+
+                /* Open the next file */
+                if (new_file(-1) < 0) {
+                    DEBUGF("No more files to play\n");
+                    filling = false;
+
+                    check_playlist_end(-1);
+                    current_track_counter++;
+                } else {
+                    /* Make it read more data */
+                    filling = true;
+                    queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
+
+                    /* Tell the file loading code that we want to
+                       start playing as soon as we have some data */
+                    play_pending = true;
+                    play_pending_track_change = true;
+
+                    update_playlist();
+                    current_track_counter++;
+                }
+                break;
+            }
+
+            case MPEG_FF_REWIND: {
+                struct mp3entry *id3  = audio_current_track();
+                unsigned int oldtime  = id3->elapsed;
+                unsigned int newtime  = (unsigned int)ev.data;
+                int curpos, newpos, diffpos;
+                DEBUGF("MPEG_FF_REWIND\n");
+
+                id3->elapsed = newtime;
+
+                newpos = audio_get_file_pos();
+                if(newpos < 0)
+                {
+                    id3->elapsed = oldtime;
+                    break;
+                }
+                
+                if (mpeg_file >= 0)
+                    curpos = lseek(mpeg_file, 0, SEEK_CUR);
+                else
+                    curpos = id3->filesize;
+
+                if (num_tracks_in_memory() > 1)
+                {
+                    /* We have started loading other tracks that need to be
+                       accounted for */
+                    struct trackdata *track;
+                    int i = 0;
+
+                    while((track = get_trackdata(i++)))
+                    {
+                        curpos += track->id3.filesize;
+                    }
+                }
+
+                diffpos = curpos - newpos;
+
+                if(!filling && diffpos >= 0 && diffpos < audiobuflen)
+                {
+                    int unplayed_space_left, unswapped_space_left;
+
+                    /* We are changing to a position that's already in
+                       memory, so we just move the DMA read pointer. */
+                    audiobuf_read = audiobuf_write - diffpos;
+                    if (audiobuf_read < 0)
+                    {
+                        audiobuf_read += audiobuflen;
+                    }
+
+                    unplayed_space_left  = get_unplayed_space();
+                    unswapped_space_left = get_unswapped_space();
+
+                    /* If unswapped_space_left is larger than
+                       unplayed_space_left, it means that the swapwrite pointer
+                       hasn't yet advanced up to the new location of the read
+                       pointer. We just move it, there is no need to swap
+                       data that won't be played anyway. */
+                    
+                    if (unswapped_space_left > unplayed_space_left)
+                    {
+                        DEBUGF("Moved swapwrite\n");
+                        audiobuf_swapwrite = audiobuf_read;
+                        play_pending = true;
+                    }
+
+                    if (mpeg_file>=0 && unplayed_space_left < low_watermark)
+                    {
+                        /* We need to load more data before starting */
+                        filling = true;
+                        queue_post(&mpeg_queue, MPEG_NEED_DATA, GENERATE_UNBUFFER_EVENTS);
+                        play_pending = true;
+                    }
+                    else
+                    {
+                        /* resume will start at new position */
+                        last_dma_chunk_size = 
+                            MIN(0x2000, get_unplayed_space_current_song());
+                        mp3_play_data(audiobuf + audiobuf_read, 
+                            last_dma_chunk_size, transfer_end);
+                        dma_underrun = false;
+                    }
+                }
+                else
+                {
+                    /* Move to the new position in the file and start
+                       loading data */
+                    reset_mp3_buffer();
+
+                    if (num_tracks_in_memory() > 1)
+                    {
+                        /* We have to reload the current track */
+                        close(mpeg_file);
+                        remove_all_non_current_tags();
+                        generate_unbuffer_events();
+                        mpeg_file = -1;
+                    }
+
+                    if (mpeg_file < 0)
+                    {
+                        mpeg_file = open(id3->path, O_RDONLY);
+                        if (mpeg_file < 0)
+                        {
+                            id3->elapsed = oldtime;
+                            break;
+                        }
+                    }
+
+                    if(-1 == lseek(mpeg_file, newpos, SEEK_SET))
+                    {
+                        id3->elapsed = oldtime;
+                        break;
+                    }
+
+                    filling = true;
+                    queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
+
+                    /* Tell the file loading code that we want to start playing
+                       as soon as we have some data */
+                    play_pending = true;
+                }
+
+                id3->offset = newpos;
+
+                break;
+            }
+
+            case MPEG_FLUSH_RELOAD: {
+                int  numtracks    = num_tracks_in_memory();
+                bool reload_track = false;
+
+                if (numtracks > 1)
+                {
+                    /* Reset the buffer */
+                    audiobuf_write = get_trackdata(1)->mempos;
+
+                    /* Reset swapwrite unless we're still swapping current
+                       track */
+                    if (get_unplayed_space() <= get_playable_space())
+                        audiobuf_swapwrite = audiobuf_write;
+
+                    close(mpeg_file);
+                    remove_all_non_current_tags();
+                    generate_unbuffer_events();
+                    mpeg_file = -1;
+                    reload_track = true;
+                }
+                else if (numtracks == 1 && mpeg_file < 0)
+                {
+                    reload_track = true;
+                }
+
+                if(reload_track && new_file(1) >= 0)
+                {
+                    /* Tell ourselves that we want more data */
+                    filling = true;
+                    queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
+                }
+
+                break;
+            }
+
+            case MPEG_NEED_DATA:
+                free_space_left = audiobuf_read - audiobuf_write;
+
+                /* We interpret 0 as "empty buffer" */
+                if(free_space_left <= 0)
+                    free_space_left += audiobuflen;
+
+                unplayed_space_left = audiobuflen - free_space_left;
+
+                /* Make sure that we don't fill the entire buffer */
+                free_space_left -= MPEG_HIGH_WATER;
+                
+                if (ev.data == GENERATE_UNBUFFER_EVENTS)
+                    generate_unbuffer_events();
+
+                /* do we have any more buffer space to fill? */
+                if(free_space_left <= 0)
+                {
+                    DEBUGF("0\n");
+                    filling = false;
+                    generate_postbuffer_events();
+                    ata_sleep();
+                    break;
+                }
+
+                /* Read small chunks while we are below the low water mark */
+                if(unplayed_space_left < low_watermark)
+                    amount_to_read = MIN(MPEG_LOW_WATER_CHUNKSIZE,
+                                         free_space_left);
+                else
+                    amount_to_read = free_space_left;
+
+                /* Don't read more than until the end of the buffer */
+                amount_to_read = MIN(audiobuflen - audiobuf_write,
+                                     amount_to_read);
+#ifdef HAVE_MMC /* MMC is slow, so don't read too large chunks */
+                amount_to_read = MIN(0x40000, amount_to_read);
+#elif MEM == 8
+                amount_to_read = MIN(0x100000, amount_to_read);
+#endif
+
+                /* Read as much mpeg data as we can fit in the buffer */
+                if(mpeg_file >= 0)
+                {
+                    DEBUGF("R\n");
+                    t1 = current_tick;
+                    len = read(mpeg_file, audiobuf + audiobuf_write,
+                               amount_to_read);
+                    if(len > 0)
+                    {
+                        t2 = current_tick;
+                        DEBUGF("time: %d\n", t2 - t1);
+                        DEBUGF("R: %x\n", len);
+
+                        /* Now make sure that we don't feed the MAS with ID3V1
+                           data */
+                        if (len < amount_to_read)
+                        {
+                            int i;
+                            static const unsigned char tag[] = "TAG";
+                            int taglen = 128;
+                            int tagptr = audiobuf_write + len - 128;
+                            
+                            /* Really rare case: entire potential tag wasn't
+                               read in this call AND audiobuf_write < 128 */
+                            if (tagptr < 0)
+                                tagptr += audiobuflen;
+                            
+                            for(i = 0;i < 3;i++)
+                            {
+                                if(tagptr >= audiobuflen)
+                                    tagptr -= audiobuflen;
+
+                                if(audiobuf[tagptr] != tag[i])
+                                {
+                                    taglen = 0;
+                                    break;
+                                }
+
+                                tagptr++;
+                            }
+
+                            if(taglen)
+                            {
+                                /* Skip id3v1 tag */
+                                DEBUGF("Skipping ID3v1 tag\n");
+                                len -= taglen;
+
+                                /* In the very rare case when the entire tag
+                                   wasn't read in this read() len will be < 0.
+                                   Take care of this when changing the write
+                                   pointer. */
+                            }
+                        }
+
+                        audiobuf_write += len;
+
+                        if (audiobuf_write < 0)
+                            audiobuf_write += audiobuflen;
+
+                        if(audiobuf_write >= audiobuflen)
+                        {
+                            audiobuf_write = 0;
+                            DEBUGF("W\n");
+                        }
+
+                        /* Tell ourselves that we want more data */
+                        queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
+                    }
+                    else
+                    {
+                        if(len < 0)
+                        {
+                            DEBUGF("MPEG read error\n");
+                        }
+                        
+                        close(mpeg_file);
+                        mpeg_file = -1;
+                    
+                        if(new_file(1) < 0)
+                        {
+                            /* No more data to play */
+                            DEBUGF("No more files to play\n");
+                            filling = false;
+                        }
+                        else
+                        {
+                            /* Tell ourselves that we want more data */
+                            queue_post(&mpeg_queue, MPEG_NEED_DATA, 0);
+                        }
+                    }
+                }
+                break;
+                
+            case MPEG_TRACK_CHANGE:
+                track_change();
+                break;
+
+#ifndef USB_NONE
+            case SYS_USB_CONNECTED:
+                is_playing = false;
+                paused = false;
+                stop_playing();
+
+                /* Tell the USB thread that we are safe */
+                DEBUGF("mpeg_thread got SYS_USB_CONNECTED\n");
+                usb_acknowledge(SYS_USB_CONNECTED_ACK);
+
+                /* Wait until the USB cable is extracted again */
+                usb_wait_for_disconnect(&mpeg_queue);
+                break;
+#endif /* !USB_NONE */
+                
+#if CONFIG_CODEC == MAS3587F
+            case MPEG_INIT_RECORDING:
+                init_recording();
+                init_recording_done = true;
+                break;
+#endif /* CONFIG_CODEC == MAS3587F */
+
+            case SYS_TIMEOUT:
+                if (playing)
+                    playlist_update_resume_info(audio_current_track());
+                break;
+        }
+#if CONFIG_CODEC == MAS3587F
+        }
+        else
+        {
+            queue_wait(&mpeg_queue, &ev);
+            switch(ev.id)
+            {
+                case MPEG_RECORD:
+                    if (is_prerecording)
+                    {
+                        int startpos;
+
+                        /* Go back prerecord_count seconds in the buffer */
+                        startpos = prerecord_index - prerecord_count;
+                        if(startpos < 0)
+                            startpos += prerecording_max_seconds;
+
+                        /* Read the position data from the prerecord buffer */
+                        frame_count_start = prerecord_buffer[startpos].framecount;
+                        startpos = prerecord_buffer[startpos].mempos;
+
+                        DEBUGF("Start looking at address %x (%x)\n",
+                               audiobuf+startpos, startpos);
+
+                        saved_header = mpeg_get_last_header();
+                        
+                        mem_find_next_frame(startpos, &offset, 1800,
+                                            saved_header);
+
+                        audiobuf_read = startpos + offset;
+                        if(audiobuf_read >= audiobuflen)
+                            audiobuf_read -= audiobuflen;
+
+                        DEBUGF("New audiobuf_read address: %x (%x)\n",
+                               audiobuf+audiobuf_read, audiobuf_read);
+
+                        level = disable_irq_save();
+                        num_rec_bytes = get_unsaved_space();
+                        restore_irq(level);
+                    }
+                    else
+                    {
+                        frame_count_start = 0;
+                        num_rec_bytes = 0;
+                        audiobuf_read = MPEG_RESERVED_HEADER_SPACE;
+                        audiobuf_write = MPEG_RESERVED_HEADER_SPACE;
+                    }
+
+                    prepend_header();
+                    DEBUGF("Recording...\n");
+                    start_recording();
+
+                    /* Wait until at least one frame is encoded and get the
+                       frame header, for later use by the Xing header
+                       generation */
+                    sleep(HZ/5);
+                    saved_header = mpeg_get_last_header();
+
+                    /* delayed until buffer is saved, don't open yet */
+                    strcpy(delayed_filename, recording_filename);
+                    mpeg_file = -1; 
+
+                    break;
+                    
+                case MPEG_STOP:
+                    DEBUGF("MPEG_STOP\n");
+
+                    stop_recording();
+
+                    /* Save the remaining data in the buffer */
+                    save_endpos = audiobuf_write;
+                    saving_status = STOP_RECORDING;
+                    queue_post(&mpeg_queue, MPEG_SAVE_DATA, 0);
+                    break;
+
+                case MPEG_STOP_DONE:
+                    DEBUGF("MPEG_STOP_DONE\n");
+
+                    if (mpeg_file >= 0)
+                        close(mpeg_file);
+                    mpeg_file = -1;
+
+                    update_header();
+#ifdef DEBUG1
+                    {
+                        int i;
+                        for(i = 0;i < 512;i++)
+                        {
+                            DEBUGF("%d - %d us (%d bytes)\n",
+                                   timing_info[i*2],
+                                   (timing_info[i*2+1] & 0xffff) *
+                                   10000 / 13824,
+                                   timing_info[i*2+1] >> 16);
+                        }
+                    }
+#endif /* DEBUG1 */
+
+                    if (prerecording)
+                    {
+                        start_prerecording();
+                    }
+                    mpeg_stop_done = true;
+                    break;
+
+                case MPEG_NEW_FILE:
+                    /* Bail out when a more important save is happening */
+                    if (saving_status > NEW_FILE)
+                        break;
+
+                    /* Make sure we have at least one complete frame
+                       in the buffer. If we haven't recorded a single
+                       frame within 200ms, the MAS is probably not recording
+                       anything, and we bail out. */
+                    amount_to_save = get_unsaved_space();
+                    if (amount_to_save < 1800)
+                    {
+                        sleep(HZ/5);
+                        amount_to_save = get_unsaved_space();
+                    }
+
+                    mas_readmem(MAS_BANK_D0, MAS_D0_MPEG_FRAME_COUNT,
+                                &frame_count_end, 1);
+ 
+                    last_rec_time = current_tick - record_start_time;
+                    record_start_time = current_tick;
+                    if (paused)
+                        pause_start_time = record_start_time;
+
+                    /* capture all values at one point */
+                    level = disable_irq_save();
+                    save_endpos = audiobuf_write;
+                    last_rec_bytes = num_rec_bytes;
+                    num_rec_bytes = 0;
+                    restore_irq(level);
+
+                    if (amount_to_save >= 1800)
+                    {
+                        /* Now find a frame boundary to split at */
+                        save_endpos -= 1800;
+                        if (save_endpos < 0)
+                            save_endpos += audiobuflen;
+
+                        rc = mem_find_next_frame(save_endpos, &offset, 1800,
+                                                 saved_header);
+                        if (!rc) /* No header found, save whole buffer */
+                            offset = 1800;
+
+                        save_endpos += offset;
+                        if (save_endpos >= audiobuflen)
+                            save_endpos -= audiobuflen;
+
+                        last_rec_bytes += offset - 1800;
+                        level = disable_irq_save();
+                        num_rec_bytes += 1800 - offset;
+                        restore_irq(level);
+                    }
+
+                    saving_status = NEW_FILE;
+                    queue_post(&mpeg_queue, MPEG_SAVE_DATA, 0);
+                    break;
+
+                case MPEG_SAVE_DATA:    
+                    if (saving_status == BUFFER_FULL)
+                        save_endpos = audiobuf_write;
+
+                    if (mpeg_file < 0) /* delayed file open */
+                    {
+                        mpeg_file = open(delayed_filename, O_WRONLY|O_CREAT);
+
+                        if (mpeg_file < 0)
+                            panicf("recfile: %d", mpeg_file);
+                    }
+
+                    amount_to_save = save_endpos - audiobuf_read;
+                    if (amount_to_save < 0)
+                        amount_to_save += audiobuflen;
+
+                    amount_to_save = MIN(amount_to_save,
+                                         audiobuflen - audiobuf_read);
+#ifdef HAVE_MMC /* MMC is slow, so don't save too large chunks at once */
+                    amount_to_save = MIN(0x40000, amount_to_save);
+#elif MEM == 8
+                    amount_to_save = MIN(0x100000, amount_to_save);
+#endif
+                    rc = write(mpeg_file, audiobuf + audiobuf_read,
+                               amount_to_save);
+                    if (rc < 0)
+                    {
+                        if (errno == ENOSPC)
+                        {
+                            mpeg_errno = AUDIOERR_DISK_FULL;
+                            stop_recording();
+                            queue_post(&mpeg_queue, MPEG_STOP_DONE, 0);
+                            /* will close the file */
+                            break;
+                        }
+                        else
+                            panicf("rec wrt: %d", rc);
+                    }
+
+                    audiobuf_read += amount_to_save;
+                    if (audiobuf_read >= audiobuflen)
+                        audiobuf_read = 0;
+
+                    if (audiobuf_read == save_endpos) /* all saved */
+                    {
+                        switch (saving_status)
+                        {
+                            case BUFFER_FULL:
+                                rc = fsync(mpeg_file);
+                                if (rc < 0)
+                                    panicf("rec fls: %d", rc);
+                                ata_sleep();
+                                break;
+
+                            case NEW_FILE:
+                                /* Close the current file */
+                                rc = close(mpeg_file);
+                                if (rc < 0)
+                                    panicf("rec cls: %d", rc);
+                                mpeg_file = -1;
+                                update_header();
+                                ata_sleep();
+
+                                /* copy new filename */
+                                strcpy(delayed_filename, recording_filename);
+                                prepend_header();
+                                frame_count_start = frame_count_end;
+                                break;
+
+                            case STOP_RECORDING:
+                                queue_post(&mpeg_queue, MPEG_STOP_DONE, 0);
+                                /* will close the file */
+                                break;
+
+                            default:
+                                break;
+                        }
+                        saving_status = NOT_SAVING;
+                    }
+                    else /* tell ourselves to save the next chunk */
+                        queue_post(&mpeg_queue, MPEG_SAVE_DATA, 0);
+
+                    break;
+                    
+                case MPEG_PRERECORDING_TICK:
+                    if(!is_prerecording)
+                        break;
+
+                    /* Store the write pointer every second */
+                    prerecord_buffer[prerecord_index].mempos = audiobuf_write;
+                    mas_readmem(MAS_BANK_D0, MAS_D0_MPEG_FRAME_COUNT,
+                                &prerecord_buffer[prerecord_index].framecount, 1);
+
+                    /* Wrap if necessary */
+                    if(++prerecord_index == prerecording_max_seconds)
+                        prerecord_index = 0;
+
+                    /* Update the number of seconds recorded */
+                    if(prerecord_count < prerecording_max_seconds)
+                        prerecord_count++;
+                    break;
+
+                case MPEG_INIT_PLAYBACK:
+                    /* Stop the prerecording */ 
+                    stop_recording();
+                    reset_mp3_buffer();
+                    mp3_play_init();
+                    init_playback_done = true;
+                    break;
+                    
+                case MPEG_PAUSE_RECORDING:
+                    pause_recording();
+                    break;
+                   
+                case MPEG_RESUME_RECORDING:
+                    resume_recording();
+                    break;
+                   
+                case SYS_USB_CONNECTED:
+                    /* We can safely go to USB mode if no recording
+                       is taking place */
+                    if((!is_recording || is_prerecording) && mpeg_stop_done)
+                    {
+                        /* Even if we aren't recording, we still call this
+                           function, to put the MAS in monitoring mode,
+                           to save power. */
+                        stop_recording();
+                
+                        /* Tell the USB thread that we are safe */
+                        DEBUGF("mpeg_thread got SYS_USB_CONNECTED\n");
+                        usb_acknowledge(SYS_USB_CONNECTED_ACK);
+                    
+                        /* Wait until the USB cable is extracted again */
+                        usb_wait_for_disconnect(&mpeg_queue);
+                    }
+                    break;
+            }
+        }
+#endif /* CONFIG_CODEC == MAS3587F */
+    }
+}
+#endif /* !SIMULATOR */
+
+struct mp3entry* audio_current_track()
+{
+#ifdef SIMULATOR
+    return &taginfo;
+#else /* !SIMULATOR */
+    if(num_tracks_in_memory())
+        return &get_trackdata(0)->id3;
+    else
+        return NULL;
+#endif /* !SIMULATOR */
+}
+
+struct mp3entry* audio_next_track()
+{
+#ifdef SIMULATOR
+    return &taginfo;
+#else /* !SIMULATOR */
+    if(num_tracks_in_memory() > 1)
+        return &get_trackdata(1)->id3;
+    else
+        return NULL;
+#endif /* !SIMULATOR */
+}
+
+bool audio_has_changed_track(void)
+{
+    if(last_track_counter != current_track_counter)
+    {
+        last_track_counter = current_track_counter;
+        return true;
+    }
+    return false;
+}
+
+#if CONFIG_CODEC == MAS3587F
+#ifndef SIMULATOR
+void audio_init_playback(void)
+{
+    init_playback_done = false;
+    queue_post(&mpeg_queue, MPEG_INIT_PLAYBACK, 0);
+
+    while(!init_playback_done)
+        sleep(1);
+}
+
+
+/****************************************************************************
+ * Recording functions
+ ***************************************************************************/
+void audio_init_recording(unsigned int buffer_offset)
+{
+    buffer_offset = buffer_offset;
+    init_recording_done = false;
+    queue_post(&mpeg_queue, MPEG_INIT_RECORDING, 0);
+
+    while(!init_recording_done)
+        sleep(1);
+}
+
+static void init_recording(void)
+{
+    unsigned long val;
+    int rc;
+
+    /* Disable IRQ6 */
+    IPRB &= 0xff0f;
+
+    stop_playing();
+    is_playing = false;
+    paused = false;
+
+    /* Init the recording variables */
+    is_recording = false;
+    is_prerecording = false;
+
+    mpeg_stop_done = true;
+    
+    mas_reset();
+    
+    /* Enable the audio CODEC and the DSP core, max analog voltage range */
+    rc = mas_direct_config_write(MAS_CONTROL, 0x8c00);
+    if(rc < 0)
+        panicf("mas_ctrl_w: %d", rc);
+
+    /* Stop the current application */
+    val = 0;
+    mas_writemem(MAS_BANK_D0, MAS_D0_APP_SELECT, &val, 1);
+    do
+    {
+        mas_readmem(MAS_BANK_D0, MAS_D0_APP_RUNNING, &val, 1);
+    } while(val);
+
+    /* Perform black magic as described by the data sheet */
+    if((mas_version_code & 0x0fff) == 0x0102)
+    {       
+        DEBUGF("Performing MAS black magic for B2 version\n");
+        mas_writereg(0xa3, 0x98);
+        mas_writereg(0x94, 0xfffff);
+        val = 0;
+        mas_writemem(MAS_BANK_D1, 0, &val, 1);
+        mas_writereg(0xa3, 0x90);
+    }
+
+    /* Enable A/D Converters */
+    shadow_codec_reg0 = 0xcccd;
+    mas_codec_writereg(0x0, shadow_codec_reg0);
+
+    /* Copy left channel to right (mono mode) */
+    mas_codec_writereg(8, 0x8000);
+    
+    /* ADC scale 0%, DSP scale 100%
+       We use the DSP output for monitoring, because it works with all
+       sources including S/PDIF */
+    mas_codec_writereg(6, 0x0000);
+    mas_codec_writereg(7, 0x4000);
+
+    /* No mute */
+    shadow_soft_mute = 0;
+    mas_writemem(MAS_BANK_D0, MAS_D0_SOFT_MUTE, &shadow_soft_mute, 1);
+    
+#ifdef HAVE_SPDIF_OUT
+    val = 0x09; /* Disable SDO and SDI, low impedance S/PDIF outputs */
+#else
+    val = 0x2d; /* Disable SDO and SDI, disable S/PDIF output */
+#endif
+    mas_writemem(MAS_BANK_D0, MAS_D0_INTERFACE_CONTROL, &val, 1);
+
+    /* Set Demand mode, monitoring OFF and validate all settings */
+    shadow_io_control_main = 0x125;
+    mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1);
+
+    /* Start the encoder application */
+    val = 0x40;
+    mas_writemem(MAS_BANK_D0, MAS_D0_APP_SELECT, &val, 1);
+    do
+    {
+        mas_readmem(MAS_BANK_D0, MAS_D0_APP_RUNNING, &val, 1);
+    } while(!(val & 0x40));
+
+    /* We have started the recording application with monitoring OFF.
+       This is because we want to record at least one frame to fill the DMA
+       buffer, because the silly MAS will not negate EOD until at least one
+       DMA transfer has taken place.
+       Now let's wait for some data to be encoded. */
+    sleep(HZ/5);
+    
+    /* Now set it to Monitoring mode as default, saves power */
+    shadow_io_control_main = 0x525;
+    mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1);
+
+    /* Wait until the DSP has accepted the settings */
+    do
+    {
+        mas_readmem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &val,1);
+    } while(val & 1);
+
+    drain_dma_buffer();
+    mpeg_mode = MPEG_ENCODER;
+
+    DEBUGF("MAS Recording application started\n");
+
+    /* At this point, all settings are the reset MAS defaults, next thing is to
+       call mpeg_set_recording_options(). */
+}
+
+void audio_record(const char *filename)
+{
+    mpeg_errno = 0;
+    
+    strncpy(recording_filename, filename, MAX_PATH - 1);
+    recording_filename[MAX_PATH - 1] = 0;
+
+    queue_post(&mpeg_queue, MPEG_RECORD, 0);
+}
+
+void audio_pause_recording(void)
+{
+    queue_post(&mpeg_queue, MPEG_PAUSE_RECORDING, 0);
+}
+
+void audio_resume_recording(void)
+{
+    queue_post(&mpeg_queue, MPEG_RESUME_RECORDING, 0);
+}
+
+static void prepend_header(void)
+{
+    int startpos;
+    unsigned i;
+
+    /* Make room for header */
+    audiobuf_read -= MPEG_RESERVED_HEADER_SPACE;
+    if(audiobuf_read < 0)
+    {
+        /* Clear the bottom half */
+        memset(audiobuf, 0, audiobuf_read + MPEG_RESERVED_HEADER_SPACE);
+
+        /* And the top half */
+        audiobuf_read += audiobuflen;
+        memset(audiobuf + audiobuf_read, 0, audiobuflen - audiobuf_read);
+    }
+    else
+    {
+        memset(audiobuf + audiobuf_read, 0, MPEG_RESERVED_HEADER_SPACE);
+    }
+    /* Copy the empty ID3 header */
+    startpos = audiobuf_read;
+    for(i = 0; i < sizeof(empty_id3_header); i++)
+    {
+        audiobuf[startpos++] = empty_id3_header[i];
+        if(startpos == audiobuflen)
+            startpos = 0;
+    }
+}
+
+static void update_header(void)
+{
+    int fd, framelen;
+    unsigned long frames;
+
+    if (last_rec_bytes > 0)
+    {
+        /* Create the Xing header */
+        fd = open(delayed_filename, O_RDWR);
+        if (fd < 0)
+            panicf("rec upd: %d (%s)", fd, recording_filename);
+
+        frames = frame_count_end - frame_count_start;
+        /* If the number of recorded frames has reached 0x7ffff,
+           we can no longer trust it */
+        if (frame_count_end == 0x7ffff)
+            frames = 0;
+
+        /* saved_header is saved right before stopping the MAS */
+        framelen = create_xing_header(fd, 0, last_rec_bytes, xing_buffer,
+                                      frames, last_rec_time * (1000/HZ),
+                                      saved_header, NULL, false);
+
+        lseek(fd, MPEG_RESERVED_HEADER_SPACE - framelen, SEEK_SET);
+        write(fd, xing_buffer, framelen);
+        close(fd);
+    }
+}
+
+static void start_prerecording(void)
+{
+    unsigned long val;
+
+    DEBUGF("Starting prerecording\n");
+    
+    prerecord_index = 0;
+    prerecord_count = 0;
+    prerecord_timeout = current_tick + HZ;
+    memset(prerecord_buffer, 0, sizeof(prerecord_buffer));
+    reset_mp3_buffer();
+    
+    is_prerecording = true;
+
+    /* Stop monitoring and start the encoder */
+    shadow_io_control_main &= ~(1 << 10);
+    mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1);
+    DEBUGF("mas_writemem(MAS_BANK_D0, IO_CONTROL_MAIN, %x)\n", shadow_io_control_main);
+
+    /* Wait until the DSP has accepted the settings */
+    do
+    {
+        mas_readmem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &val,1);
+    } while(val & 1);
+    
+    is_recording = true;
+    saving_status = NOT_SAVING;
+
+    demand_irq_enable(true);
+}
+
+static void start_recording(void)
+{
+    unsigned long val;
+
+    if(is_prerecording)
+    {
+        /* This will make the IRQ handler start recording
+           for real, i.e send MPEG_SAVE_DATA messages when
+           the buffer is full */
+        is_prerecording = false;
+    }
+    else
+    {
+        /* If prerecording is off, we need to stop the monitoring
+           and start the encoder */
+        shadow_io_control_main &= ~(1 << 10);
+        mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1);
+        DEBUGF("mas_writemem(MAS_BANK_D0, IO_CONTROL_MAIN, %x)\n", shadow_io_control_main);
+
+        /* Wait until the DSP has accepted the settings */
+        do
+        {
+            mas_readmem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &val,1);
+        } while(val & 1);
+    }
+    
+    is_recording = true;
+    saving_status = NOT_SAVING;
+    paused = false;
+
+    /* Store the current time */
+    if(prerecording)
+        record_start_time = current_tick - prerecord_count * HZ;
+    else
+        record_start_time = current_tick;
+
+    pause_start_time = 0;
+
+    demand_irq_enable(true);
+}
+
+static void pause_recording(void)
+{
+    pause_start_time = current_tick;
+
+    /* Set the pause bit */
+    shadow_soft_mute |= 2;
+    mas_writemem(MAS_BANK_D0, MAS_D0_SOFT_MUTE, &shadow_soft_mute, 1);
+
+    paused = true;
+}
+
+static void resume_recording(void)
+{
+    paused = false;
+    
+    /* Clear the pause bit */
+    shadow_soft_mute &= ~2;
+    mas_writemem(MAS_BANK_D0,  MAS_D0_SOFT_MUTE, &shadow_soft_mute, 1);
+
+    /* Compensate for the time we have been paused */
+    if(pause_start_time)
+    {
+       record_start_time =
+          current_tick - (pause_start_time - record_start_time);
+       pause_start_time = 0;
+    }
+}
+
+static void stop_recording(void)
+{
+    unsigned long val;
+
+    /* Let it finish the last frame */
+    if(!paused)
+       pause_recording();
+    sleep(HZ/5);
+    
+    demand_irq_enable(false);
+
+    is_recording = false;
+    is_prerecording = false;
+
+    last_rec_bytes = num_rec_bytes;
+    mas_readmem(MAS_BANK_D0, MAS_D0_MPEG_FRAME_COUNT, &frame_count_end, 1);
+    last_rec_time = current_tick - record_start_time;
+
+    /* Start monitoring */
+    shadow_io_control_main |= (1 << 10);
+    mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main, 1);
+    DEBUGF("mas_writemem(MAS_BANK_D0, IO_CONTROL_MAIN, %x)\n", shadow_io_control_main);
+    
+    /* Wait until the DSP has accepted the settings */
+    do
+    {
+        mas_readmem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &val,1);
+    } while(val & 1);
+
+    resume_recording();
+}
+
+void audio_set_recording_options(struct audio_recording_options *options)
+{
+    bool is_mpeg1;
+
+    is_mpeg1 = (options->rec_frequency < 3)?true:false;
+
+    rec_version_index = is_mpeg1?3:2;
+    rec_frequency_index = options->rec_frequency % 3;
+
+    shadow_encoder_control = (options->rec_quality << 17) |
+        (rec_frequency_index << 10) |
+        ((is_mpeg1?1:0) << 9) |
+        (((options->rec_channels * 2 + 1) & 3) << 6) |
+        (1 << 5) /* MS-stereo */ |
+        (1 << 2) /* Is an original */;
+    mas_writemem(MAS_BANK_D0, MAS_D0_ENCODER_CONTROL, &shadow_encoder_control,1);
+
+    DEBUGF("mas_writemem(MAS_BANK_D0, ENCODER_CONTROL, %x)\n", shadow_encoder_control);
+
+    shadow_soft_mute = options->rec_editable?4:0;
+    mas_writemem(MAS_BANK_D0, MAS_D0_SOFT_MUTE, &shadow_soft_mute,1);
+
+    DEBUGF("mas_writemem(MAS_BANK_D0, SOFT_MUTE, %x)\n", shadow_soft_mute);
+
+    shadow_io_control_main = ((1 << 10) | /* Monitoring ON */
+        ((options->rec_source < 2)?1:2) << 8) | /* Input select */
+        (1 << 5) | /* SDO strobe invert */
+        ((is_mpeg1?0:1) << 3) |
+        (1 << 2) | /* Inverted SIBC clock signal */
+        1; /* Validate */
+    mas_writemem(MAS_BANK_D0, MAS_D0_IO_CONTROL_MAIN, &shadow_io_control_main,1);
+
+    DEBUGF("mas_writemem(MAS_BANK_D0, IO_CONTROL_MAIN, %x)\n", shadow_io_control_main);
+
+    if(options->rec_source == AUDIO_SRC_MIC)
+    {
+        /* Copy left channel to right (mono mode) */
+        mas_codec_writereg(8, 0x8000);
+    }
+    else
+    {
+        /* Stereo input mode */
+        mas_codec_writereg(8, 0);
+    }
+
+    prerecording_max_seconds = options->rec_prerecord_time;
+    if(prerecording_max_seconds)
+    {
+        prerecording = true;
+        start_prerecording();
+    }
+    else
+    {
+        prerecording = false;
+        is_prerecording = false;
+        is_recording = false;
+    }
+}
+
+/* If use_mic is true, the left gain is used */
+void audio_set_recording_gain(int left, int right, int type)
+{
+    /* Enable both left and right A/D */
+    shadow_codec_reg0 = (left << 12) |
+                        (right << 8) |
+                        (left << 4) |
+                        (type==AUDIO_GAIN_MIC?0x0008:0) | /* Connect left A/D to mic */
+                        0x0007;
+    mas_codec_writereg(0x0, shadow_codec_reg0);
+}
+
+#if CONFIG_TUNER & S1A0903X01
+/* Get the (unpitched) MAS PLL frequency, for avoiding FM interference with the
+ * Samsung tuner. Zero means unknown. Currently handles recording from analog
+ * input only. */
+int mpeg_get_mas_pllfreq(void)
+{
+    if (mpeg_mode != MPEG_ENCODER)
+        return 0;
+
+    if (rec_frequency_index == 0)  /* 44.1 kHz / 22.05 kHz */
+        return 22579000;
+    else
+        return 24576000;
+}
+#endif /* CONFIG_TUNER & S1A0903X01 */
+
+/* try to make some kind of beep, also in recording mode */
+void audio_beep(int duration)
+{
+    long starttick = current_tick;
+    do
+    {  /* toggle bit 0 of codec register 0, toggling the DAC off & on.
+        * While this is still audible even without an external signal,
+        * it doesn't affect the (pre-)recording. */
+        mas_codec_writereg(0, shadow_codec_reg0 ^ 1);
+        mas_codec_writereg(0, shadow_codec_reg0);
+        yield();
+    }
+    while (current_tick - starttick < duration);
+}
+
+void audio_new_file(const char *filename)
+{
+    mpeg_errno = 0;
+
+    strncpy(recording_filename, filename, MAX_PATH - 1);
+    recording_filename[MAX_PATH - 1] = 0;
+
+    queue_post(&mpeg_queue, MPEG_NEW_FILE, 0);
+}
+
+unsigned long audio_recorded_time(void)
+{
+    if(is_prerecording)
+        return prerecord_count * HZ;
+    
+    if(is_recording)
+    {
+       if(paused)
+          return pause_start_time - record_start_time;
+       else
+          return current_tick - record_start_time;
+    }
+
+    return 0;
+}
+
+unsigned long audio_num_recorded_bytes(void)
+{
+    int num_bytes;
+    int index;
+    
+    if(is_recording)
+    {
+        if(is_prerecording)
+        {
+            index = prerecord_index - prerecord_count;
+            if(index < 0)
+                index += prerecording_max_seconds;
+            
+            num_bytes = audiobuf_write - prerecord_buffer[index].mempos;
+            if(num_bytes < 0)
+                num_bytes += audiobuflen;
+            
+            return num_bytes;;
+        }
+        else
+            return num_rec_bytes;
+    }
+    else
+        return 0;
+}
+
+#else /* SIMULATOR */
+
+/* dummies coming up */
+
+void audio_init_playback(void)
+{
+    /* a dummy */
+}
+unsigned long audio_recorded_time(void)
+{
+    /* a dummy */
+    return 0;
+}
+void audio_beep(int duration)
+{
+    /* a dummy */
+    (void)duration;
+}
+void audio_pause_recording(void)
+{
+    /* a dummy */
+}
+void audio_resume_recording(void)
+{
+    /* a dummy */
+}
+unsigned long audio_num_recorded_bytes(void)
+{
+    /* a dummy */
+    return 0;
+}
+void audio_record(const char *filename)
+{
+    /* a dummy */
+    (void)filename;
+}
+void audio_new_file(const char *filename)
+{
+    /* a dummy */
+    (void)filename;
+}
+
+void audio_set_recording_gain(int left, int right, int type)
+{
+    /* a dummy */
+    (void)left;
+    (void)right;
+    (void)type;
+}
+void audio_init_recording(unsigned int buffer_offset)
+{
+    /* a dummy */
+    (void)buffer_offset;
+}
+void audio_set_recording_options(struct audio_recording_options *options)
+{
+    /* a dummy */
+    (void)options;
+}
+#endif /* SIMULATOR */
+#endif /* CONFIG_CODEC == MAS3587F */
+
+void audio_play(long offset)
+{
+#ifdef SIMULATOR
+    char* trackname;
+    int steps=0;
+
+    is_playing = true;
+    
+    do {
+        trackname = playlist_peek( steps );
+        if (!trackname)
+            break;
+        if(mp3info(&taginfo, trackname)) {
+            /* bad mp3, move on */
+            if(++steps > playlist_amount())
+                break;
+            continue;
+        }
+#ifdef HAVE_MPEG_PLAY
+        real_mpeg_play(trackname);
+#endif
+        playlist_next(steps);
+        taginfo.offset = offset;
+        set_elapsed(&taginfo);
+        is_playing = true;
+        playing = true;
+        break;
+    } while(1);
+#else /* !SIMULATOR */
+    is_playing = true;
+
+    queue_post(&mpeg_queue, MPEG_PLAY, offset);
+#endif /* !SIMULATOR */
+
+    mpeg_errno = 0;
+}
+
+void audio_stop(void)
+{
+#ifndef SIMULATOR
+    if (playing)
+    {
+        struct trackdata *track = get_trackdata(0);
+        prev_track_elapsed = track->id3.elapsed;
+    }
+    mpeg_stop_done = false;
+    queue_post(&mpeg_queue, MPEG_STOP, 0);
+    while(!mpeg_stop_done)
+        yield();
+#else /* SIMULATOR */
+    paused = false;
+    is_playing = false;
+    playing = false;
+#endif /* SIMULATOR */
+}
+
+/* dummy */
+void audio_stop_recording(void)
+{
+    audio_stop(); 
+}
+
+void audio_pause(void)
+{
+#ifndef SIMULATOR
+    queue_post(&mpeg_queue, MPEG_PAUSE, 0);
+#else /* SIMULATOR */
+    is_playing = true;
+    playing = false;
+    paused = true;
+#endif /* SIMULATOR */
+}
+
+void audio_resume(void)
+{
+#ifndef SIMULATOR
+    queue_post(&mpeg_queue, MPEG_RESUME, 0);
+#else /* SIMULATOR */
+    is_playing = true;
+    playing = true;
+    paused = false;
+#endif /* SIMULATOR */
+}
+
+void audio_next(void)
+{
+#ifndef SIMULATOR
+    queue_remove_from_head(&mpeg_queue, MPEG_NEED_DATA);
+    queue_post(&mpeg_queue, MPEG_NEXT, 0);
+#else /* SIMULATOR */
+    char* file;
+    int steps = 1;
+    int index;
+
+    do {
+        file = playlist_peek(steps);
+        if(!file)
+            break;
+        if(mp3info(&taginfo, file)) {
+            if(++steps > playlist_amount())
+                break;
+            continue;
+        }
+        index = playlist_next(steps);
+        taginfo.index = index;
+        current_track_counter++;
+        is_playing = true;
+        playing = true;
+        break;
+    } while(1);
+#endif /* SIMULATOR */
+}
+
+void audio_prev(void)
+{
+#ifndef SIMULATOR
+    queue_remove_from_head(&mpeg_queue, MPEG_NEED_DATA);
+    queue_post(&mpeg_queue, MPEG_PREV, 0);
+#else /* SIMULATOR */
+    char* file;
+    int steps = -1;
+    int index;
+
+    do {
+        file = playlist_peek(steps);
+        if(!file)
+            break;
+        if(mp3info(&taginfo, file)) {
+            steps--;
+            continue;
+        }
+        index = playlist_next(steps);
+        taginfo.index = index;
+        current_track_counter++;
+        is_playing = true;
+        playing = true;
+        break;
+    } while(1);
+#endif /* SIMULATOR */
+}
+
+void audio_ff_rewind(long newtime)
+{
+#ifndef SIMULATOR
+    queue_post(&mpeg_queue, MPEG_FF_REWIND, newtime);
+#else /* SIMULATOR */
+    (void)newtime;
+#endif /* SIMULATOR */
+}
+
+void audio_flush_and_reload_tracks(void)
+{
+#ifndef SIMULATOR
+    queue_post(&mpeg_queue, MPEG_FLUSH_RELOAD, 0);
+#endif /* !SIMULATOR*/
+}
+
+int audio_status(void)
+{
+    int ret = 0;
+
+    if(is_playing)
+        ret |= AUDIO_STATUS_PLAY;
+
+    if(paused)
+        ret |= AUDIO_STATUS_PAUSE;
+    
+#if (CONFIG_CODEC == MAS3587F) && !defined(SIMULATOR)
+    if(is_recording && !is_prerecording)
+        ret |= AUDIO_STATUS_RECORD;
+
+    if(is_prerecording)
+        ret |= AUDIO_STATUS_PRERECORD;
+#endif /* CONFIG_CODEC == MAS3587F */
+
+    if(mpeg_errno)
+        ret |= AUDIO_STATUS_ERROR;
+    
+    return ret;
+}
+
+unsigned int audio_error(void)
+{
+    return mpeg_errno;
+}
+
+void audio_error_clear(void)
+{
+    mpeg_errno = 0;
+}
+
+#ifdef SIMULATOR
+static void mpeg_thread(void)
+{
+    struct mp3entry* id3;
+    while ( 1 ) {
+        if (is_playing) {
+            id3 = audio_current_track();
+            if (!paused)
+            {
+                id3->elapsed+=1000;
+                id3->offset+=1000;
+            }
+            if (id3->elapsed>=id3->length)
+                audio_next();
+        }
+        sleep(HZ);
+    }
+}
+#endif /* SIMULATOR */
+
+void audio_init(void)
+{
+    mpeg_errno = 0;
+
+#ifndef SIMULATOR
+    audiobuflen = audiobufend - audiobuf;
+    queue_init(&mpeg_queue, true);
+#endif /* !SIMULATOR */
+    create_thread(mpeg_thread, mpeg_stack,
+                  sizeof(mpeg_stack), 0, mpeg_thread_name
+                  IF_PRIO(, PRIORITY_SYSTEM)
+		          IF_COP(, CPU));
+
+    memset(trackdata, sizeof(trackdata), 0);
+
+#if (CONFIG_CODEC == MAS3587F) && !defined(SIMULATOR)
+    if (HW_MASK & PR_ACTIVE_HIGH)
+        and_b(~0x08, &PADRH);
+    else
+        or_b(0x08, &PADRH);
+#endif /* CONFIG_CODEC == MAS3587F */
+
+#ifdef DEBUG
+#ifndef SIMULATOR
+    dbg_timer_start();
+    dbg_cnt2us(0);
+#endif /* !SIMULATOR */
+#endif /* DEBUG */
+}
+
+#endif /* CONFIG_CODEC != SWCODEC */
diff --git a/apps/replaygain.c b/apps/replaygain.c
new file mode 100644
index 0000000000..e160a1b23d
--- /dev/null
+++ b/apps/replaygain.c
@@ -0,0 +1,457 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2005 Magnus Holmgren
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include <ctype.h>
+#include <inttypes.h>
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <system.h>
+#include "id3.h"
+#include "debug.h"
+#include "replaygain.h"
+
+/* The fixed point math routines (with the exception of fp_atof) are based
+ * on oMathFP by Dan Carter (http://orbisstudios.com).
+ */
+
+/* 12 bits of precision gives fairly accurate result, but still allows a
+ * compact implementation. The math code supports up to 13...
+ */
+
+#define FP_BITS         (12)
+#define FP_MASK         ((1 << FP_BITS) - 1)
+#define FP_ONE          (1 << FP_BITS)
+#define FP_TWO          (2 << FP_BITS)
+#define FP_HALF         (1 << (FP_BITS - 1))
+#define FP_LN2          ( 45426 >> (16 - FP_BITS))
+#define FP_LN2_INV      ( 94548 >> (16 - FP_BITS))
+#define FP_EXP_ZERO     ( 10922 >> (16 - FP_BITS))
+#define FP_EXP_ONE      (  -182 >> (16 - FP_BITS))
+#define FP_EXP_TWO      (     4 >> (16 - FP_BITS))
+#define FP_INF          (0x7fffffff)
+#define FP_LN10         (150902 >> (16 - FP_BITS))
+
+#define FP_MAX_DIGITS       (4)
+#define FP_MAX_DIGITS_INT   (10000)
+
+#define FP_FAST_MUL_DIV
+
+#ifdef FP_FAST_MUL_DIV
+
+/* These macros can easily overflow, but they are good enough for our uses,
+ * and saves some code.
+ */
+#define fp_mul(x, y) (((x) * (y)) >> FP_BITS)
+#define fp_div(x, y) (((x) << FP_BITS) / (y))
+
+#else
+
+static long fp_mul(long x, long y)
+{
+    long x_neg = 0;
+    long y_neg = 0;
+    long rc;
+
+    if ((x == 0) || (y == 0))
+    {
+        return 0;
+    }
+
+    if (x < 0)
+    {
+        x_neg = 1;
+        x = -x;
+    }
+
+    if (y < 0)
+    {
+        y_neg = 1;
+        y = -y;
+    }
+
+    rc = (((x >> FP_BITS) * (y >> FP_BITS)) << FP_BITS)
+        + (((x & FP_MASK) * (y & FP_MASK)) >> FP_BITS)
+        + ((x & FP_MASK) * (y >> FP_BITS))
+        + ((x >> FP_BITS) * (y & FP_MASK));
+
+    if ((x_neg ^ y_neg) == 1)
+    {
+        rc = -rc;
+    }
+
+    return rc;
+}
+
+static long fp_div(long x, long y)
+{
+    long x_neg = 0;
+    long y_neg = 0;
+    long shifty;
+    long rc;
+    int msb = 0;
+    int lsb = 0;
+
+    if (x == 0)
+    {
+        return 0;
+    }
+
+    if (y == 0)
+    {
+        return (x < 0) ? -FP_INF : FP_INF;
+    }
+
+    if (x < 0)
+    {
+        x_neg = 1;
+        x = -x;
+    }
+
+    if (y < 0)
+    {
+        y_neg = 1;
+        y = -y;
+    }
+
+    while ((x & (1 << (30 - msb))) == 0)
+    {
+        msb++;
+    }
+
+    while ((y & (1 << lsb)) == 0)
+    {
+        lsb++;
+    }
+
+    shifty = FP_BITS - (msb + lsb);
+    rc = ((x << msb) / (y >> lsb));
+
+    if (shifty > 0)
+    {
+        rc <<= shifty;
+    }
+    else
+    {
+        rc >>= -shifty;
+    }
+
+    if ((x_neg ^ y_neg) == 1)
+    {
+        rc = -rc;
+    }
+
+    return rc;
+}
+
+#endif /* FP_FAST_MUL_DIV */
+
+static long fp_exp(long x)
+{
+    long k;
+    long z;
+    long R;
+    long xp;
+
+    if (x == 0)
+    {
+        return FP_ONE;
+    }
+
+    k = (fp_mul(abs(x), FP_LN2_INV) + FP_HALF) & ~FP_MASK;
+
+    if (x < 0)
+    {
+        k = -k;
+    }
+
+    x -= fp_mul(k, FP_LN2);
+    z = fp_mul(x, x);
+    R = FP_TWO + fp_mul(z, FP_EXP_ZERO + fp_mul(z, FP_EXP_ONE
+        + fp_mul(z, FP_EXP_TWO)));
+    xp = FP_ONE + fp_div(fp_mul(FP_TWO, x), R - x);
+
+    if (k < 0)
+    {
+        k = FP_ONE >> (-k >> FP_BITS);
+    }
+    else
+    {
+        k = FP_ONE << (k >> FP_BITS);
+    }
+
+    return fp_mul(k, xp);
+}
+
+static long fp_exp10(long x)
+{
+    if (x == 0)
+    {
+        return FP_ONE;
+    }
+
+    return fp_exp(fp_mul(FP_LN10, x));
+}
+
+static long fp_atof(const char* s, int precision)
+{
+    long int_part = 0;
+    long int_one = 1 << precision;
+    long frac_part = 0;
+    long frac_count = 0;
+    long frac_max = ((precision * 4) + 12) / 13;
+    long frac_max_int = 1;
+    long sign = 1;
+    bool point = false;
+
+    while ((*s != '\0') && isspace(*s))
+    {
+        s++;
+    }
+
+    if (*s == '-')
+    {
+        sign = -1;
+        s++;
+    }
+    else if (*s == '+')
+    {
+        s++;
+    }
+
+    while (*s != '\0')
+    {
+        if (*s == '.')
+        {
+            if (point)
+            {
+                break;
+            }
+
+            point = true;
+        }
+        else if (isdigit(*s))
+        {
+            if (point)
+            {
+                if (frac_count < frac_max)
+                {
+                    frac_part = frac_part * 10 + (*s - '0');
+                    frac_count++;
+                    frac_max_int *= 10;
+                }
+            }
+            else
+            {
+                int_part = int_part * 10 + (*s - '0');
+            }
+        }
+        else
+        {
+            break;
+        }
+
+        s++;
+    }
+
+    while (frac_count < frac_max)
+    {
+      frac_part *= 10;
+      frac_count++;
+      frac_max_int *= 10;
+    }
+
+    return sign * ((int_part * int_one)
+        + (((int64_t) frac_part * int_one) / frac_max_int));
+}
+
+static long convert_gain(long gain)
+{
+    /* Don't allow unreasonably low or high gain changes.
+     * Our math code can't handle it properly anyway. :)
+     */
+    if (gain < (-48 * FP_ONE))
+    {
+        gain = -48 * FP_ONE;
+    }
+
+    if (gain > (17 * FP_ONE))
+    {
+        gain = 17 * FP_ONE;
+    }
+
+    gain = fp_exp10(gain / 20) << (24 - FP_BITS);
+
+    return gain;
+}
+
+/* Get the sample scale factor in Q7.24 format from a gain value. Returns 0
+ * for no gain.
+ *
+ * str  Gain in dB as a string. E.g., "-3.45 dB"; the "dB" part is ignored.
+ */
+static long get_replaygain(const char* str)
+{
+    long gain = 0;
+
+    if (str)
+    {
+        gain = fp_atof(str, FP_BITS);
+        gain = convert_gain(gain);
+    }
+
+    return gain;
+}
+
+/* Get the peak volume in Q7.24 format.
+ *
+ * str  Peak volume. Full scale is specified as "1.0". Returns 0 for no peak.
+ */
+static long get_replaypeak(const char* str)
+{
+    long peak = 0;
+
+    if (str)
+    {
+        peak = fp_atof(str, 24);
+    }
+
+    return peak;
+}
+
+/* Get a sample scale factor in Q7.24 format from a gain value.
+ *
+ * int_gain  Gain in dB, multiplied by 100.
+ */
+long get_replaygain_int(long int_gain)
+{
+    return convert_gain(int_gain * FP_ONE / 100);
+}
+
+/* Parse a ReplayGain tag conforming to the "VorbisGain standard". If a
+ * valid tag is found, update mp3entry struct accordingly. Existing values 
+ * are not overwritten. Returns number of bytes written to buffer.
+ *
+ * key     Name of the tag.
+ * value   Value of the tag.
+ * entry   mp3entry struct to update.
+ * buffer  Where to store the text for gain values (for later display).
+ * length  Bytes left in buffer.
+ */
+long parse_replaygain(const char* key, const char* value,
+    struct mp3entry* entry, char* buffer, int length)
+{
+    char **p = NULL;
+
+    if (((strcasecmp(key, "replaygain_track_gain") == 0)
+        || (strcasecmp(key, "rg_radio") == 0)) && !entry->track_gain)
+    {
+        entry->track_gain = get_replaygain(value);
+        p = &(entry->track_gain_string);
+    }
+    else if (((strcasecmp(key, "replaygain_album_gain") == 0)
+        || (strcasecmp(key, "rg_audiophile") == 0)) && !entry->album_gain)
+    {
+        entry->album_gain = get_replaygain(value);
+        p = &(entry->album_gain_string);
+    }
+    else if (((strcasecmp(key, "replaygain_track_peak") == 0)
+        || (strcasecmp(key, "rg_peak") == 0)) && !entry->track_peak)
+    {
+        entry->track_peak = get_replaypeak(value);
+    }
+    else if ((strcasecmp(key, "replaygain_album_peak") == 0)
+        && !entry->album_peak)
+    {
+        entry->album_peak = get_replaypeak(value);
+    }
+
+    if (p)
+    {
+        int len = strlen(value);
+
+        len = MIN(len, length - 1);
+
+        /* A few characters just isn't interesting... */
+        if (len > 1)
+        {
+            strncpy(buffer, value, len);
+            buffer[len] = 0;
+            *p = buffer;
+            return len + 1;
+        }
+    }
+
+    return 0;
+}
+
+/* Set ReplayGain values from integers. Existing values are not overwritten. 
+ * Returns number of bytes written to buffer.
+ *
+ * album   If true, set album values, otherwise set track values.
+ * gain    Gain value in dB, multiplied by 512. 0 for no gain.
+ * peak    Peak volume in Q7.24 format, where 1.0 is full scale. 0 for no 
+ *         peak volume.
+ * buffer  Where to store the text for gain values (for later display).
+ * length  Bytes left in buffer.
+ */
+long parse_replaygain_int(bool album, long gain, long peak,
+    struct mp3entry* entry, char* buffer, int length)
+{
+    long len = 0;
+
+    if (buffer != NULL)
+    {
+        len = snprintf(buffer, length, "%d.%02d dB", gain / 512,
+            ((abs(gain) & 0x01ff) * 100 + 256) / 512);
+        len++;
+    }
+
+    if (gain != 0)
+    {
+        gain = convert_gain(gain * FP_ONE / 512);
+    }
+
+    if (album)
+    {
+        entry->album_gain = gain;
+        entry->album_gain_string = buffer;
+
+        if (peak)
+        {
+            entry->album_peak = peak;
+        }
+    }
+    else
+    {
+        entry->track_gain = gain;
+        entry->track_gain_string = buffer;
+
+        if (peak)
+        {
+            entry->track_peak = peak;
+        }
+    }
+    
+    return len;
+}