Initial import of tagdb

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

25 files changed, 4144 insertions, 0 deletions

diff --git a/apps/tagdb/Makefile b/apps/tagdb/Makefile
new file mode 100644
index 0000000000..7f6ed63e22
--- /dev/null
+++ b/apps/tagdb/Makefile
@@ -0,0 +1,32 @@
+OBJECTS = main.o db.o array_buffer.o unique.o malloc.o \
+        header.o artist.o album.o song.o file.o \
+        tag_dummy.o
+
+all : tagdb parser
+
+tagdb : $(OBJECTS)
+        $(CC) -o tagdb $(OBJECTS)
+
+parser: parser.o malloc.o
+        $(CC) -o parser parser.o malloc.o
+        
+main.o : main.c config.h
+
+db.o : db.c db.h config.h
+
+array_buffer.o : array_buffer.c array_buffer.h config.h
+unique.o : unique.c unique.h
+malloc.o : malloc.c malloc.h config.h
+
+header.o : header.c header.h config.h
+artist.o : artist.c artist.h config.h
+album.o : album.c album.h config.h
+song.o : song.c song.h config.h
+file.o : file.c file.h config.h
+
+tag_dummy.o : tag_dummy.c tag_dummy.h config.h
+
+parser.o : parser.c config.h
+
+clean :
+        rm -rf *.o tagdb parser
diff --git a/apps/tagdb/README b/apps/tagdb/README
new file mode 100644
index 0000000000..90bf20a017
--- /dev/null
+++ b/apps/tagdb/README
@@ -0,0 +1,9 @@
+The code is currently a working mess... needs cleanup
+also it should be transformed into rockbox-format (header in each file).
+
+things that work:
+* DB creation
+
+things that don't work (yet)
+* Sorting
+* reading files to parse the tags
diff --git a/apps/tagdb/album.c b/apps/tagdb/album.c
new file mode 100644
index 0000000000..53b3660c90
--- /dev/null
+++ b/apps/tagdb/album.c
@@ -0,0 +1,454 @@
+#include "malloc.h" // realloc() and free()
+#include <strings.h> // strncasecmp()
+#include <string.h> // strlen()
+
+#include "album.h"
+
+// how is our flag organized?
+#define FLAG(deleted, spare) ( 0xE0 | (deleted?0x10:0x00) | (spare & 0x0F) )
+#define FLAG_VALID(flag) ((flag & 0xE0) == 0xE0)
+#define FLAG_DELETED(flag) (flag & 0x10)
+#define FLAG_SPARE(flag) (flag & 0x0F)
+
+static int do_resize(struct album_entry *e, const uint32_t name_len, const uint32_t song_count, const int zero_fill);
+
+struct album_entry* new_album_entry(const uint32_t name_len, const uint32_t song_count) {
+        // Start my allocating memory
+        struct album_entry *e = (struct album_entry*)malloc(sizeof(struct album_entry));
+        if( e == NULL ) {
+                DEBUGF("new_album_entry: could not allocate memory\n");
+                return NULL;
+        }
+        
+        // We begin empty
+        e->name = NULL;
+        e->size.name_len = 0;
+        e->key = NULL;
+        e->artist = 0;
+        e->song = NULL;
+        e->size.song_count = 0;
+
+        e->flag = FLAG(0, 0);
+
+        // and resize to the requested size
+        if( do_resize(e, name_len, song_count, 1) ) {
+                free(e);
+                return NULL;
+        }
+        return e;
+}
+
+int album_entry_destruct(struct album_entry *e) {
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        
+        free(e->name);
+        free(e->key);
+        free(e->song);
+
+        free(e);
+        
+        return ERR_NONE;
+}
+
+static int do_resize(struct album_entry *e, const uint32_t name_len, const uint32_t song_count, const int zero_fill) {
+        void* temp;
+        
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        
+        // begin with name
+        if( name_len != e->size.name_len ) {
+                temp = realloc(e->name, name_len);
+                if(temp == NULL && name_len > 0) {      // if realloc(,0) don't complain about NULL-pointer
+                        DEBUGF("do_resize: out of memory to resize name\n");
+                        return ERR_MALLOC;
+                }
+                e->name = (char*)temp;
+                
+                // if asked, fill it with zero's
+                if( zero_fill ) {
+                        uint32_t i;
+                        for(i=e->size.name_len; i<name_len; i++)
+                                e->name[i] = (char)0x00;
+                }
+                
+                e->size.name_len = name_len;
+        }
+        
+        // now the song[]
+        if( song_count != e->size.song_count ) {
+                temp = realloc(e->song, song_count * sizeof(*e->song));
+                if(temp == NULL && song_count > 0) {    // if realloc(,0) don't complain about NULL-pointer
+                        DEBUGF("album_entry_resize: out of memory to resize song[]\n");
+                        return ERR_MALLOC;
+                }
+                e->song = (uint32_t*)temp;
+                 
+                // if asked, fill it with zero's
+                if( zero_fill ) {
+                        uint32_t i;
+                        for(i=e->size.song_count; i<song_count; i++)
+                                e->song[i] = (uint32_t)0x00000000;
+                }
+                
+                e->size.song_count = song_count;
+        }
+
+        return ERR_NONE;
+}
+
+inline int album_entry_resize(struct album_entry *e, const uint32_t name_len, const uint32_t song_count) {
+        return do_resize(e, name_len, song_count, 1);
+}
+
+int album_entry_serialize(FILE *fd, const struct album_entry *e) {
+        uint32_t length;
+        
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        assert(fd != NULL);
+        
+        if( FLAG_DELETED(e->flag) ) { // we are deleted, do nothing
+                return ERR_NONE;
+        }
+
+        // First byte we write is a flag-byte
+        if( fwrite(&e->flag, 1, 1, fd) != 1 ) {
+                DEBUGF("album_entry_serialize: failed to write flag-byte\n");
+                return ERR_FILE;
+        }
+        
+        // First we write the length of the name field
+        if( fwrite(&e->size.name_len, sizeof(e->size.name_len), 1, fd) != 1 ) {
+                DEBUGF("album_entry_serialize: failed to write name_len\n");
+                return ERR_FILE;
+        }
+
+        // now the name field itself
+        if( fwrite(e->name, 1, e->size.name_len, fd) != e->size.name_len ) {
+                DEBUGF("album_entry_serialize: failed to write name\n");
+                return ERR_FILE;
+        }
+
+        // the key-field (if present)
+        if( e->key != NULL ) {
+                length = strlen(e->key);
+        } else {
+                length = 0;
+        }
+        // length (always, 0 if not present)
+        if( fwrite(&length, sizeof(length), 1, fd) != 1 ) {
+                DEBUGF("album_entry_serialize: failed to write length of key\n");
+                return ERR_FILE;
+        }
+        if( e->key != NULL ) {
+                // key itself
+                if( fwrite(e->key, 1, length, fd) != length ) {
+                        DEBUGF("album_entry_serialize: failed to write key\n");
+                        return ERR_FILE;
+                }
+        }
+
+        // Artist field
+        if( fwrite(&e->artist, sizeof(e->artist), 1, fd) != 1 ) {
+                DEBUGF("album_entry_serialize: failed to write artist\n");
+                return ERR_FILE;
+        }
+
+        // count of songs
+        if( fwrite(&e->size.song_count, sizeof(e->size.song_count), 1, fd) != 1 ) {
+                DEBUGF("album_entry_serialize: failed to write song_count\n");
+                return ERR_FILE;
+        }
+
+        // song[] itself
+        if( fwrite(e->song, sizeof(*e->song), e->size.song_count, fd) != e->size.song_count ) {
+                DEBUGF("album_entry_serialize: failed to write songs\n");
+                return ERR_FILE;
+        }
+
+        return ERR_NONE;
+}
+
+int album_entry_unserialize(struct album_entry **e, FILE *fd) {
+        uint32_t length;
+        unsigned char flag;
+        
+        assert(e != NULL);
+        assert(fd != NULL);
+        
+        // First byte we read are the flags
+        if( fread(&flag, 1, 1, fd) != 1 ) {
+                DEBUGF("album_entry_unserialize: failed to read flag-byte\n");
+                return ERR_FILE;
+        }
+
+        // See what we have:
+        if( ! FLAG_VALID(flag) ) {
+                DEBUGF("album_entry_unserialize: flag-byte is invalid\n");
+                return ERR_INVALID;
+        }
+        
+        // Allocate memory
+        *e = new_album_entry(0, 0);
+        if( *e == NULL ) {
+                DEBUGF("album_entry_unserialize: could not create new album_entry\n");
+                return ERR_MALLOC;
+        }
+
+        (*e)->flag = flag; // we had a valid entry, copy it over
+
+        // First we read the length of the name field
+        if( fread(&length, sizeof(length), 1, fd) != 1 ) {
+                DEBUGF("album_entry_unserialize: failed to read name_len\n");
+                album_entry_destruct(*e);
+                return ERR_FILE;
+        }
+
+        // allocate memory for the upcomming name-field
+        if( do_resize(*e, length, 0, 0) ) {
+                DEBUGF("album_entry_unserialize: failed to allocate memory for name\n");
+                album_entry_destruct(*e);
+                return ERR_MALLOC;
+        }
+
+        // read it in
+        if( fread((*e)->name, 1, (*e)->size.name_len, fd) != (*e)->size.name_len ) {
+                DEBUGF("album_entry_unserialize: failed to read name\n");
+                album_entry_destruct(*e);
+                return ERR_FILE;
+        }
+
+        if( FLAG_DELETED(flag) ) {
+                // all there is... free some memory
+                if( do_resize(*e, 0, 0, 0) ) {
+                        DEBUGF("album_entry_unserialize: couldn't free() name\n");
+                        return ERR_MALLOC;
+                }
+                return ERR_NONE;
+        }
+
+        // maybe a key-field
+        if( fread(&length, sizeof(length), 1, fd) != 1 ) {
+                DEBUGF("album_entry_unserialize: failed to read length of key\n");
+                album_entry_destruct(*e);
+                return ERR_FILE;
+        }
+        
+        if( length > 0 ) {
+                // allocate memory
+                if( ((*e)->key = malloc(length)) == NULL ) {
+                        DEBUGF("album_entry_unserialize: failed to allocate memory for key\n");
+                        album_entry_destruct(*e);
+                        return ERR_MALLOC;
+                }
+        
+                // read it
+                if( fread((*e)->key, 1, length, fd) != length ) {
+                        DEBUGF("album_entry_unserialize: failed to read key\n");
+                        album_entry_destruct(*e);
+                        return ERR_FILE;
+                }
+        }
+
+        // next the artist field
+        if( fread(&(*e)->artist, sizeof((*e)->artist), 1, fd) != 1 ) {
+                DEBUGF("album_entry_unserialize: failed to read artist\n");
+                album_entry_destruct(*e);
+                return ERR_FILE;
+        }
+
+        // Next the count of songs
+        if( fread(&length, sizeof(length), 1, fd) != 1 ) {
+                DEBUGF("album_entry_unserialize: failed to read song_count\n");
+                album_entry_destruct(*e);
+                return ERR_FILE;
+        }
+
+        // allocate memory for the upcomming name-field
+        if( do_resize(*e, (*e)->size.name_len, length, 0) ) {
+                DEBUGF("album_entry_unserialize: failed to allocate memory for song[]\n");
+                album_entry_destruct(*e);
+                return ERR_MALLOC;
+        }
+
+        // read it in
+        if( fread((*e)->song, sizeof(*(*e)->song), (*e)->size.song_count, fd) != (*e)->size.song_count ) {
+                DEBUGF("album_entry_unserialize: failed to read songs\n");
+                album_entry_destruct(*e);
+                return ERR_FILE;
+        }
+
+        return ERR_NONE;
+}
+
+int album_entry_write(FILE *fd, struct album_entry *e, struct album_size *s) {
+        uint32_t i, be;
+        char pad = 0x00;
+
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        assert(fd != NULL);
+        
+        if( FLAG_DELETED(e->flag) ) { // we are deleted, do nothing
+                return ERR_NONE;
+        }
+        
+        // resize-write to size *s
+        // First check if we are not reducing the size...
+        if( s != NULL && ( s->name_len < e->size.name_len || s->song_count < e->size.song_count ) ) {
+                // just do it in 2 steps
+                if( do_resize(e, s->name_len, s->song_count, 0) ) {
+                        DEBUGF("album_entry_write: failed to reduce size of entry, failing...\n");
+                        return ERR_MALLOC;
+                }
+        }
+        
+        // album name
+        if( fwrite(e->name, 1, e->size.name_len, fd) != e->size.name_len ) {
+                DEBUGF("album_entry_write: failed to write name\n");
+                return ERR_FILE;
+        }
+        // pad the rest
+        i = e->size.name_len;
+        while( s != NULL && s->name_len > i) {
+                if( fwrite(&pad, 1, 1, fd) == 1 ) {
+                        i++;
+                        continue;
+                } else {
+                        DEBUGF("album_entry_write: failed to pad name\n");
+                        return ERR_FILE;
+                }
+        }
+
+        // artist
+        be = BE32(e->artist);
+        if( fwrite(&be, sizeof(be), 1, fd) != 1 ) {
+                DEBUGF("album_entry_write: failed to write artist\n");
+                return ERR_FILE;
+        }
+
+        // song offsets, but in BIG ENDIAN!
+        // so we need to iterate over each item to convert it
+        for(i=0; i<e->size.song_count; i++) {
+                be = BE32(e->song[i]);
+                if( fwrite(&be, sizeof(be), 1, fd) != 1 ) {
+                        DEBUGF("album_entry_write: failed to write song[%d]\n", i);
+                        return ERR_FILE;
+                }
+        }
+        // pad the rest
+        be = BE32(0x00000000);
+        for(; s != NULL && i<s->song_count; i++) {
+                if( fwrite(&be, sizeof(be), 1, fd) != 1 ) {
+                        DEBUGF("album_entry_write: failed to pad song[]\n");
+                        return ERR_FILE;
+                }
+        }
+
+        return 0;
+}
+
+inline int album_entry_compare(const struct album_entry *a, const struct album_entry *b) {
+        assert(a != NULL);
+        assert(b != NULL);
+        assert(a->key != NULL);
+        assert(b->key != NULL);
+        return strcasecmp(a->key, b->key);
+}
+
+struct album_size* new_album_size() {
+        struct album_size *s;
+        s = (struct album_size*)malloc(sizeof(struct album_size));
+        if( s == NULL ) {
+                DEBUGF("new_album_size: failed to allocate memory\n");
+                return NULL;
+        }
+        s->name_len = 0;
+        s->song_count = 0;
+
+        return s;
+}
+
+inline uint32_t album_size_get_length(const struct album_size *size) {
+        assert(size != NULL);
+        return size->name_len + 4 + 4*size->song_count;
+}
+
+inline int album_size_max(struct album_size *s, const struct album_entry *e) {
+        assert(s != NULL);
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        
+        s->name_len   = ( s->name_len   >= e->size.name_len   ? s->name_len   : e->size.name_len );
+        s->song_count = ( s->song_count >= e->size.song_count ? s->song_count : e->size.song_count );
+        return ERR_NONE;
+}
+
+int album_size_destruct(struct album_size *s) {
+        assert(s != NULL);
+        // nothing to do...
+        free(s);
+        return ERR_NONE;
+}
+
+int album_entry_add_song_mem(struct album_entry *e, struct album_size *s, const uint32_t song) {
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        
+        if( do_resize(e, e->size.name_len, e->size.song_count+1, 0) ) {
+                DEBUGF("album_entry_add_song_mem: failed to resize song[]\n");
+                return ERR_MALLOC;
+        }
+
+        e->song[e->size.song_count-1] = song;
+
+        if( s != NULL) album_size_max(s, e); // can't fail
+
+        return ERR_NONE;
+}
+
+static int delete_serialized(FILE *fd, struct album_entry *e) {
+// the entry should be both, in memory and in file at the current location
+// this function will mark the file-entry as deleted
+        uint32_t size;
+        unsigned char flag;
+        
+        assert(fd != NULL);
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        
+        // overwrite the beginning of the serialized data:
+        flag = FLAG(1, 0); // set the delete flag, clear the spare flags
+        
+        // First byte we write is the flag-byte to indicate this is a deleted
+        if( fwrite(&flag, 1, 1, fd) != 1 ) {
+                DEBUGF("album_entry_delete_serialized: failed to write flag-byte\n");
+                return ERR_FILE;
+        }
+        
+        // Then we write the length of the COMPLETE entry
+        size = album_size_get_length(&e->size) + 4; // 4 = overhead for the song[]
+        if( fwrite(&size, sizeof(size), 1, fd) != 1 ) {
+                DEBUGF("album_entry_delete_serialized: failed to write len\n");
+                return ERR_FILE;
+        }
+
+        return ERR_NONE;
+}
+
+int album_entry_add_song_file(FILE *fd, struct album_entry *e, struct album_size *s, const uint32_t song) {
+        assert(fd != NULL);
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        
+        DEBUGF("album_entry_add_song_file() called\n");
+
+        if( delete_serialized(fd, e) ) {
+                DEBUGF("album_entry_add_song_file: could not mark as deleted\n");
+                return ERR_FILE;
+        }
+        
+        return ERR_NO_INPLACE_UPDATE;
+}
diff --git a/apps/tagdb/album.h b/apps/tagdb/album.h
new file mode 100644
index 0000000000..08995a2940
--- /dev/null
+++ b/apps/tagdb/album.h
@@ -0,0 +1,103 @@
+#ifndef __ALBUM_H__
+#define __ALBUM_H__
+
+#include "config.h"
+#include <stdio.h>
+
+struct album_entry {
+        char* name;             // album name
+        char* key;              // key for sorting/searching: album___artist___directory
+        uint32_t artist;        // pointer to artist
+        uint32_t *song;         // song-pointers
+        struct album_size {
+                uint32_t name_len;      // length of this field (must be mulitple of 4)
+                uint32_t song_count;    // number of song pointers
+        } size; // keeps the size of this thing
+        unsigned char flag;             // flags
+};
+
+struct album_entry* new_album_entry(const uint32_t name_len, const uint32_t song_count);
+/* Creates a new album_entry with the specified sizes
+ * Returns a pointer to the structure on success,
+ * NULL when malloc() fails
+ */
+
+int album_entry_destruct(struct album_entry *e);
+/* Destructs the given album_entry and free()'s it's memory
+ * returns ERR_NONE on success (can never fail)
+ */
+
+inline int album_entry_resize(struct album_entry *e, const uint32_t name_len, const uint32_t song_count);
+/* Change the size of the entry
+ * returns ERR_NONE on succes
+ *         ERR_MALLOC when malloc() fails
+ */
+
+int album_entry_serialize(FILE *fd, const struct album_entry *e);
+/* Serializes the entry in the file at the current position
+ * returns ERR_NONE on success
+ *         ERR_FILE on fwrite() failure
+ */
+
+int album_entry_unserialize(struct album_entry* *e, FILE *fd);
+/* Unserializes an entry from file into a new structure
+ * The address of the structure is saved into *e
+ * returns ERR_NONE on success
+ *         ERR_MALLOC on malloc() failure
+ *         ERR_FILE on fread() failure
+ */
+
+int album_entry_write(FILE *fd, struct album_entry *e, struct album_size *s);
+/* Writes the entry to file in the final form
+ * returns ERR_NONE on success
+ *         ERR_FILE on fwrite() failure
+ *         ERR_MALLOC when e could not be resized due to malloc() problems
+ * If s is smaller than e, s is used!!!
+ */
+
+inline int album_entry_compare(const struct album_entry *a, const struct album_entry *b);
+/* Compares 2 entries
+ * When a < b it returns <0
+ *      a = b             0
+ *      a > b            >0
+ */
+
+struct album_size* new_album_size();
+/* Creates a new size structure
+ * returns a pointer to the structure on success,
+ * NULL on malloc() failure
+ */
+
+inline uint32_t album_size_get_length(const struct album_size *size);
+/* Calculates the length of the entry when written by album_entry_write()
+ * returns the length on success (can never fail)
+ */
+
+inline int album_size_max(struct album_size *s, const struct album_entry *e);
+/* Updates the album_size structure to contain the maximal lengths of either
+ * the original entry in s, or the entry e
+ * returns ERR_NONE on success (can never fail)
+ */
+
+int album_size_destruct(struct album_size *s);
+/* destructs the album_size structure
+ * returns ERR_NONE on success (can never fail)
+ */
+
+
+int album_entry_add_song_mem(struct album_entry *e, struct album_size *s, const uint32_t song);
+/* Adds the song to the array
+ * returns ERR_NONE on success
+ *         ERR_MALLOC on malloc() failure
+ */
+
+int album_entry_add_song_file(FILE *fd, struct album_entry *e, struct album_size *s, const uint32_t song);
+/* Adds the song to the serialized entry in the file
+ * When this fails, the entry is invalidated and the function returns
+ * ERR_NO_INPLACE_UPDATE
+ * returns ERR_NONE on success
+ *         ERR_NO_INPLACE_UPDATE (see above)
+ *         ERR_FILE on fwrite() failure
+ */
+
+#endif
diff --git a/apps/tagdb/array_buffer.c b/apps/tagdb/array_buffer.c
new file mode 100644
index 0000000000..24772d6bc9
--- /dev/null
+++ b/apps/tagdb/array_buffer.c
@@ -0,0 +1,667 @@
+#include "malloc.h" // malloc() and free()
+
+#include "array_buffer.h"
+#include "unique.h"
+
+static int add_mem(struct array_buffer *b, void *e);
+static int add_file(struct array_buffer *b, void *e);
+
+static int update_entry_mem(struct array_buffer *b, const uint32_t index, uint32_t item);
+static int update_entry_file(struct array_buffer *b, const uint32_t index, uint32_t item);
+
+static int find_entry_mem(struct array_buffer *b, const void *needle, uint32_t *index);
+static int find_entry_file(struct array_buffer *b, const void *needle, uint32_t *index);
+
+static int sort_mem(struct array_buffer *b);
+static int sort_mem_merge_blocks(uint32_t *dest, uint32_t *s1, uint32_t s1_l, uint32_t *s2, uint32_t s2_l, struct array_buffer *b);
+static int sort_mem_merge(uint32_t *dest, uint32_t *src, struct array_buffer *b, uint32_t blocksize);
+static int sort_file(struct array_buffer *b);
+
+struct array_buffer* new_array_buffer( int      (*cmp)(const void *a, const void *b),
+                                       int      (*serialize)(FILE *fd, const void *e),
+                                       int      (*unserialize)(void **e, FILE *fd),
+                                       uint32_t (*get_length)(const void *size),
+                                       int      (*write)(FILE *fd, void *e, const void *size),
+                                       int      (*destruct)(void *e),
+                                       char*    file_name,
+                                       void*    max_size,
+                                       int      (*max_size_update)(void *max_size, const void *e),
+                                       int      (*max_size_destruct)(void *max_size),
+                                       int      (*add_item_mem)(void *e, void *s, uint32_t item),
+                                       int      (*add_item_file)(FILE *fd, void *e, void *s, uint32_t item),
+                                       int      (*pre_write)(void *e, void *s)
+                                     ) {
+        struct array_buffer *b;
+        b = (struct array_buffer*)malloc(sizeof(struct array_buffer));
+        if( b == NULL ) {
+                DEBUGF("new_array_buffer: failed to allocate memory\n");
+                return NULL;
+        }
+        
+        b->count = 0;
+        b->array = NULL;
+        b->sort = NULL;
+        
+        b->file_name = file_name;
+        
+        b->fd = NULL;
+
+        b->cmp = cmp;
+        b->serialize = serialize;
+        b->unserialize = unserialize;
+        b->get_length = get_length;
+        b->write = write;
+        b->destruct = destruct;
+        
+        b->max_size = max_size;
+        b->max_size_update = max_size_update;
+        b->max_size_destruct = max_size_destruct;
+
+        b->add_item_mem = add_item_mem;
+        b->add_item_file = add_item_file;
+
+        b->pre_write = pre_write;
+
+        return b;
+}
+
+int array_buffer_destruct(struct array_buffer *b, const int free_file_name) {
+        assert(b != NULL);
+        
+        if( b->fd == NULL ) {
+                if( b->destruct == NULL ) {
+                        DEBUGF("array_buffer_destruct: no destruct() function registered\n");
+                        return ERR_MALLOC;
+                }
+                //we have memory to clean up
+                // iterate over all stored objects:
+                for(; b->count > 0; b->count--) {
+                        if( b->destruct(b->array[b->count-1].mem) ) {
+                                DEBUGF("array_buffer_destruct: failed to destruct item[%u]\n", b->count-1);
+                                return ERR_MALLOC;
+                        }
+                }
+        }
+        free(b->array);
+
+        if( b->fd != NULL ) {
+                // we have a file to clean up
+                if( fclose(b->fd) != 0 ) {
+                        DEBUGF("array_buffer_destruct: fclose() failed\n");
+                        return ERR_FILE;
+                }
+                b->fd = NULL;
+
+                // remove that file
+                if( remove(b->file_name) != 0 ) {
+                        DEBUGF("array_buffer_destruct: remove() failed\n");
+                        return ERR_FILE;
+                }
+        }
+        if( free_file_name ) {
+                free(b->file_name);
+                b->file_name = NULL;
+        }
+
+        free(b->sort);
+        b->sort = NULL;
+        
+        // free the max_size
+        if( b->max_size != NULL ) {
+                if( b->max_size_destruct == NULL ) {
+                        DEBUGF("array_buffer_destruct: no max_size_destruct() function registered\n");
+                        return 1;
+                }
+        
+                if( b->max_size_destruct(b->max_size) ) {
+                        DEBUGF("array_buffer_destruct: failed to destruct max_size\n");
+                        return ERR_MALLOC;
+                }
+                b->max_size = NULL;
+        }
+
+        free(b);
+
+        return ERR_NONE;
+}
+
+int array_buffer_switch_to_file(struct array_buffer *b) {
+        uint32_t i;
+        long offset;
+
+        assert(b != NULL);
+        
+        if(b->file_name == NULL) {
+                DEBUGF("array_buffer_switch_to_file: no file_name, failing...\n");
+                return ERR_MALLOC;
+        }
+
+        if( b->fd != NULL ) {
+                DEBUGF("array_buffer_switch_to_file: already in file, failing...\n");
+                return ERR_MALLOC;
+        }
+
+        // function calls exist?
+        if( b->serialize == NULL || b->unserialize == NULL ) {
+                DEBUGF("array_buffer_switch_to_file: serialize() and/or unserialize() function(s) not registered\n");
+                return ERR_INVALID;
+        }
+         
+        // since we got here, we are VERY short on memory
+        // We cannot do any memory allocation before free()ing some
+        // The filename is already allocated in the constructor
+        
+        // open the file
+        b->fd = fopen(b->file_name, "w+");
+        if( b->fd == NULL ) {
+                DEBUGF("array_buffer_switch_to_file: failed to fopen() file\n");
+                return ERR_FILE;
+        }
+
+        for(i=0; i<b->count; i++) {
+                offset = ftell(b->fd);
+                if( offset == -1 ) {
+                        DEBUGF("array_buffer_switch_to_file: ftell() failed\n");
+                        return ERR_FILE;
+                }
+                        
+                if( b->serialize(b->fd, b->array[i].mem) ) {
+                        DEBUGF("array_buffer_switch_to_file: serialize() failed on item[%u], ignoring...\n", i);
+                }
+                b->destruct(b->array[i].mem);
+                
+                b->array[i].file_offset = offset;
+        }
+
+        return ERR_NONE;
+}
+
+static int add_mem(struct array_buffer *b, void *e) {
+        assert(b != NULL);
+        assert(e != NULL);
+        
+        // just copy over the pointer
+        b->array[b->count].mem = e;
+
+        return ERR_NONE;
+}
+
+static int add_file(struct array_buffer *b, void *e) {
+        int rc;
+
+        assert(b != NULL);
+        assert(e != NULL);
+        
+        if( fseek(b->fd, 0, SEEK_END) != 0 ) {
+                DEBUGF("add_file: could not seek to end of file\n");
+                return ERR_FILE;
+        }
+        if(( b->array[b->count].file_offset = ftell(b->fd) ) == -1) {
+                DEBUGF("add_file: ftell() failed to get file_offset\n");
+                return ERR_FILE;
+        }
+        
+        if(( rc = b->serialize(b->fd, e) )) {
+                DEBUGF("add_file: could not serialize entry\n");
+                return rc;
+        }
+        if( b->destruct(e) ) {
+                DEBUGF("add_file: could not destruct entry, ignoring... (memory leak)\n");
+        }
+        return ERR_NONE;
+}
+
+int array_buffer_add(struct array_buffer *b, void *e, uint32_t *index) {
+        void* temp;
+        int rc;
+
+        assert(b != NULL);
+        assert(e != NULL);
+
+        // allow the object to update the max_size
+        // Do this first, so if it fails we can just return without cleanup to do
+        if( b->max_size_update != NULL ) {
+                if(( rc = b->max_size_update(b->max_size, e) )) {
+                        DEBUGF("array_buffer_add: could not update max_size, failing...\n");
+                        return rc;
+                }
+        }
+        
+        // we need to enlarge the array[]
+        temp = (void*)realloc(b->array, sizeof(*b->array)*(b->count+1));
+        while( temp == NULL ) {
+                DEBUGF("array_buffer_add: failed to enlarge index_map[]. Switching to file\n");
+                if(( rc = array_buffer_switch_to_file(b) )) {
+                        DEBUGF("array_buffer_add: failed to switch to file, failing...\n");
+                        return rc;
+                }
+                // now retry
+                temp = (void*)realloc(b->array, sizeof(*b->array)*(b->count+1));
+        }
+        b->array = (union entry*)temp;
+
+        if( b->fd == NULL ) { // we are in memory
+                rc = add_mem(b, e);
+                if( rc == ERR_MALLOC ) {
+                        DEBUGF("array_buffer_add: failed to add in memory due to malloc() trouble, switching to file\n");
+                        if(( rc = array_buffer_switch_to_file(b) )) {
+                                DEBUGF("array_buffer_add: failed to switch to file, failing...\n");
+                                return rc;
+                        }
+                        // fall out and catch next if
+                }
+        } // NOT else, so we can catch the fall-through
+        if( b->fd != NULL) {
+                if(( rc = add_file(b, e) )) {
+                        DEBUGF("array_buffer_add: failed to add in file, failing...\n");
+                        return rc;
+                }
+        }
+
+        // count and index-stuff
+        if(index != NULL) *index = b->count;
+        b->count++;
+
+        return ERR_NONE;
+}
+
+inline uint32_t array_buffer_get_next_index(struct array_buffer *b) {
+        assert( b != NULL );
+        return b->count;
+}
+
+static int update_entry_mem(struct array_buffer *b, const uint32_t index, const uint32_t item) {
+        int rc;
+
+        assert(b != NULL);
+        assert(index < b->count);
+        
+        if( (rc = b->add_item_mem(b->array[index].mem, b->max_size, item)) ) {
+                DEBUGF("update_entry_mem: failed to update entry\n");
+                return rc;
+        }
+        
+        return ERR_NONE;
+}
+
+static int update_entry_file(struct array_buffer *b, const uint32_t index, uint32_t item) {
+/*      uint32_t i, index;
+        void *e;
+        int rc;
+        long prev_file_offset;*/
+
+        assert(b != NULL);
+        assert(index < b->count);
+
+        printf("TODO: update entry in file\n");
+
+        return 10; // TODO
+/*
+        rewind(b->fd);
+        
+        rc = ERR_NOTFOUND;
+        for(i=0; i<b->count; i++) {
+                prev_file_offset = ftell(b->fd); // keep this file-position
+                if( prev_file_offset == -1 ) {
+                        DEBUGF("file_entry_add_file: ftell() failed\n");
+                        return ERR_FILE;
+                }
+                
+                if( (rc = b->unserialize(&e, b->fd)) ) {
+                        DEBUGF("find_entry_add_file: unserialize failed\n");
+                        return rc;
+                }
+
+                if( b->cmp(e, needle) == 0 ) { // found
+                        if( fseek(b->fd, prev_file_offset, SEEK_SET) ) {
+                                DEBUGF("file_entry_add_file: fseek() to entry[%u] failed\n", i);
+                                return ERR_FILE;
+                        }
+                        
+                        rc = b->add_item_file(b->fd, e, b->max_size, item);
+                        if( !( rc == ERR_NONE || rc == ERR_NO_INPLACE_UPDATE )) {
+                                DEBUGF("find_entry_add_mem: failed to add item\n");
+                                return rc;
+                        }
+                        
+                        break; // stop looping
+                }
+                
+                b->destruct(e);
+        }
+        
+        // seek to the end
+        if( fseek(b->fd, 0, SEEK_END) != 0) {
+                DEBUGF("find_entry_add_file: fseek(SEEK_END) failed\n");
+                return ERR_FILE;
+        }
+
+        // We either succeded, deleted the entry or didn't find it:
+        if( rc == ERR_NOTFOUND ) {
+                return rc;      // quit
+        } else if( rc == ERR_NONE ) {
+                b->destruct(e); // delete the entry and quit
+                return rc;
+        }
+
+        // we could not update inplace
+        // the entry is deleted, update it and add it again
+        if( (rc = b->add_item_mem(e, b->max_size, item)) ) {
+                DEBUGF("find_entry_add_file: failed to add item in mem\n");
+                return rc;
+        }
+        
+        if( (rc = array_buffer_add(b, e, &index) ) ) {
+                DEBUGF("find_entry_add_file: failed to re-add item to array");
+                return rc;
+        }
+
+        // the entry is now re-added, but with another index number...
+        // change the index_map to reflect this:
+        b->index_map[i] = index;
+
+        return ERR_NONE;*/
+}
+
+int array_buffer_entry_update(struct array_buffer *b, const uint32_t index, uint32_t item) {
+        assert(b != NULL);
+
+        if(index >= b->count) {
+                DEBUGF("array_buffer_entry_update: index out of bounds\n");
+                return ERR_INVALID;
+        }
+        
+        if( b->fd == NULL ) {
+                return update_entry_mem(b, index, item);
+        } else {
+                return update_entry_file(b, index, item);
+        }
+}
+
+static int find_entry_mem(struct array_buffer *b, const void *needle, uint32_t *index) {
+        uint32_t i;
+
+        assert(b != NULL);
+        assert(needle != NULL);
+        assert(index != NULL);
+
+        for(i=0; i<b->count; i++) {
+                if( b->cmp(b->array[i].mem, needle) == 0 ) { // found
+                        *index = i;
+                        return ERR_NONE;
+                }
+        }
+        return ERR_NOTFOUND;
+}
+
+static int find_entry_file(struct array_buffer *b, const void *needle, uint32_t *index) {
+        uint32_t i;
+        void *e;
+        int rc;
+        long prev_file_offset;
+
+        assert(b != NULL);
+        assert(needle != NULL);
+        assert(index != NULL);
+        
+        // We do this search in the order of the entries in file.
+        // After we found one, we look for the index of that offset
+        // (in memory).
+        // This will (PROBABELY: TODO) be faster than random-access the file
+        rewind(b->fd);
+        
+        for(i=0; i<b->count; i++) {
+                prev_file_offset = ftell(b->fd); // keep this file-position
+                if( prev_file_offset == -1 ) {
+                        DEBUGF("file_entry_add_file: ftell() failed\n");
+                        return ERR_FILE;
+                }
+                
+                if( (rc = b->unserialize(&e, b->fd)) ) {
+                        DEBUGF("find_entry_add_file: unserialize failed\n");
+                        return rc;
+                }
+
+                if( b->cmp(e, needle) == 0 ) { // found
+                        if( fseek(b->fd, prev_file_offset, SEEK_SET) ) {
+                                DEBUGF("file_entry_add_file: fseek() to entry[%u] failed\n", i);
+                                return ERR_FILE;
+                        }
+                        
+                        b->destruct(e);
+                        break; // out of the for() loop
+                }
+                
+                b->destruct(e);
+        }
+
+        if( i == b->count ) {
+                // we didn't find anything
+                return ERR_NOTFOUND;
+        }
+
+        // we found an entry, look for the index number of that offset:
+        for(i=0; i<b->count; i++) {
+                if(prev_file_offset == b->array[i].file_offset) {
+                        // found
+                        *index = i;
+                        return ERR_NONE;
+                }
+        }
+
+        // we should never get here
+        DEBUGF("find_entry_file: found entry in file, but doens't match an index\n");
+        return ERR_INVALID;
+}
+
+int array_buffer_find_entry(struct array_buffer *b, const void *needle, uint32_t *index) {
+        assert(b != NULL);
+        assert(needle != NULL);
+        assert(index != NULL);  // TODO: if it is null, do the search but trash the index
+        
+        if( b->fd == NULL ) {
+                return find_entry_mem(b, needle, index);
+        } else {
+                return find_entry_file(b, needle, index);
+        }
+}
+
+/*
+static int sort_mem_merge_blocks(uint32_t *dest, const uint32_t *s1, const uint32_t s1_l, const uint32_t *s2, const uint32_t s2_l, struct array_buffer *b) {
+// merges the 2 blocks at s1 (with s1_l items) and s2 (with s2_l items)
+// together in dest
+        uint32_t *s1_max, s2_max;
+
+#define CMP(a, b) b->cmp( b->entry[a].mem, b->entry[b].mem )
+        
+        s1_max = s1 + s1_l;
+        s2_max = s2 + s2_l;
+        while( s1 < s1_max || s2 < s2_max ) {
+                while( s1 < s1_max && ( s2 == s2_max || CMP(s1, s2) <= 0 ) ) // s1 is smaller than s2 (or s2 is used up)
+                        *(dest++) = s1++; // copy and move to next
+                while( s2 < s2_max && ( s1 == s1_max || CMP(s1, s2) > 0 ) ) // s2 smaller
+                        *(dest++) = s2++;
+        }
+
+        return ERR_NONE;
+}
+
+#define MIN(a, b) ( (a) <= (b) ? (a) : (b) )
+static int sort_mem_merge(uint32_t *dest, uint32_t *src, struct array_buffer *b, uint32_t blocksize) {
+// does 1 merge from src[] into dest[]
+// asumes there are sorted blocks in src[] of size blocksize
+        assert( dest != NULL);
+        assert( src != NULL );
+
+        assert( b->count > blocksize );
+        
+        // TODO
+}
+*/
+
+static int sort_mem(struct array_buffer *b) {
+        uint32_t *tmp, blocksize;
+        
+        assert(b != NULL);
+
+        tmp = (uint32_t*)malloc(sizeof(uint32_t)*b->count);
+        if( tmp == NULL ) {
+                DEBUGF("sort_mem: could not malloc() for second sort[] array\n");
+                return ERR_MALLOC;
+        }
+
+        for( blocksize = 1; blocksize < b->count; blocksize++) {
+                b->sort[blocksize] = blocksize; // 1-1 map TODO
+        }
+
+        free(tmp);
+
+        return ERR_NONE;
+}
+
+static int sort_file(struct array_buffer *b) {
+        printf("TODO: file-sorting\n"); // TODO
+        return ERR_INVALID;
+}
+
+int array_buffer_sort(struct array_buffer *b) {
+        int rc;
+        
+        assert(b != NULL);
+
+        b->sort = (uint32_t*)malloc(sizeof(uint32_t)*b->count);
+        if( b->sort == NULL ) {
+                DEBUGF("array_buffer_sort: could not malloc() sort[] array\n");
+                return ERR_MALLOC;
+        }
+
+        if( b->fd == NULL ) { // in memory
+                rc = sort_mem(b);
+                if( rc == ERR_MALLOC ) {
+                        if(( rc = array_buffer_switch_to_file(b) )) {
+                                DEBUGF("array_buffer_sort: could not switch to file mode\n");
+                                return rc;
+                        }
+                        return sort_file(b);
+                } else if( rc ) {
+                        DEBUGF("array_buffer_sort: could not sort array\n");
+                        return rc;
+                }
+                return ERR_NONE;
+        } else {
+                return sort_file(b);
+        }
+}
+
+uint32_t array_buffer_get_offset(struct array_buffer *b, const uint32_t index) {
+        uint32_t offset;
+
+        assert(b != NULL);
+        
+        if( index >= b->count ) {
+                DEBUGF("array_buffer_get_offset: index out of bounds\n");
+                return (uint32_t)0xffffffff;
+        }
+
+        // what is the (max) length of 1 item
+        if( b->get_length == NULL ) {
+                DEBUGF("array_buffer_get_offset: get_length() function not registered\n");
+                return (uint32_t)0xffffffff;
+        }
+        offset = b->get_length(b->max_size);
+
+        // multiply that by the number of items before me
+        if( b->sort == NULL ) { // easy, we are unsorted
+                offset *= index;
+        } else {
+                uint32_t i;
+                for(i=0; i<b->count; i++) {
+                        if( b->sort[i] == index )
+                                break;
+                }
+                if( i == b->count ) {
+                        DEBUGF("array_buffer_get_offset: index does not appeat in sorted list\n");
+                        return ERR_INVALID;
+                }
+                offset *= i; // that many items are before me
+        }
+        return offset;
+}
+
+uint32_t array_buffer_get_length(struct array_buffer *b) {
+        uint32_t length;
+
+        assert(b != NULL);
+
+        // what is the (max) length of 1 item
+        if( b->get_length == NULL ) {
+                DEBUGF("array_buffer_get_offset: get_length() function not registered\n");
+                return (uint32_t)0xffffffff;
+        }
+        length = b->get_length(b->max_size);
+
+        // multiply that by the number of items
+        length *= b->count;
+        return length;
+}
+
+int array_buffer_write(FILE *fd, struct array_buffer *b) {
+        uint32_t i;
+        int rc;
+
+        assert(b != NULL);
+        assert(fd != NULL);
+        
+        // check if the functions exist
+        if( b->write == NULL ) {
+                DEBUGF("array_buffer_write: write() function not registered\n");
+                return ERR_INVALID;
+        }
+        // if the array is in file
+        // serialize and unserialize will exist, since they're checked
+        // in the array_buffer_switch_to_file()
+        
+        if( b->fd != NULL ) {
+                rewind(b->fd); // seek to the beginning
+        }
+        
+        for(i=0; i<b->count; i++) { // for each element
+                void* item;
+                uint32_t j;
+
+                // go through the sort-array and see which item should go next
+                if(b->sort != NULL) {
+                        j = b->sort[i];
+                } else j = i;
+                
+                // get the item in memory
+                if( b->fd == NULL ) { // it already is im memory, fetch the pointer
+                        item = b->array[j].mem;
+                } else {
+                        // since it's sorted, we shouldn't have to seek
+                        if( (rc = b->unserialize(&item, b->fd)) ) {
+                                DEBUGF("array_buffer_write: could not unserialize item[%u], failing...\n", i);
+                                return rc;
+                        }
+                }
+
+                if(b->pre_write != NULL && ( rc = b->pre_write(item, b->max_size) )) {
+                        DEBUGF("array_buffer_write: pre_write function failed, failing...\n");
+                        return rc;
+                }
+
+                // write item to file
+                if(( rc = b->write(fd, item, b->max_size) )) {
+                        DEBUGF("array_buffer_write: could not write item[%u], failing...\n", i);
+                        return rc;
+                }
+
+                // put it back where it came from
+                if( b->fd != NULL ) {
+                        b->destruct(item);
+                }
+        }
+
+        return ERR_NONE;
+}
+
diff --git a/apps/tagdb/array_buffer.h b/apps/tagdb/array_buffer.h
new file mode 100644
index 0000000000..6dccefe917
--- /dev/null
+++ b/apps/tagdb/array_buffer.h
@@ -0,0 +1,159 @@
+#ifndef __ARRAY_BUFFER_H__
+#define __ARRAY_BUFFER_H__
+
+#include "config.h"
+#include <stdio.h>
+#include <stdint.h>
+
+struct array_buffer {
+        uint32_t count;                 // how much items doe we have?
+        
+        union entry {
+                void* mem;
+                long file_offset;
+        } *array;                       // where is the data?
+                                        // This array will always point to the same data
+                                        // after sorting the position of the data may be canged
+                                        // but this array will also be canged accordingly
+
+        uint32_t *sort;                 // In what order should we put the entries on disk?
+        
+        char* file_name;                // filename
+        FILE *fd;                       // file where entries are being kept. (NULL if in mem)
+
+        int (*cmp)(const void *a, const void *b);       // compare a to b, should return:
+                                        //   a < b ==> <0
+                                        //   a = b ==>  0
+                                        //   a > b ==> >0
+
+        int  (*serialize)(FILE *fd, const void *e);     // serialize e into fd
+        int  (*unserialize)(void **e, FILE *fd);        // unserialize the entry in fd
+
+        uint32_t (*get_length)(const void *size);               // get's the length
+        int  (*write)(FILE *fd, void *e, const void *size);     // write e to file
+
+        int  (*destruct)(void *e);                      // destruct object
+
+        void *max_size;                 // keep the current maximal size
+        int  (*max_size_update)(void *max_size, const void *e); // update the max_size
+        int  (*max_size_destruct)(void *max_size);      // destruct the size-object
+
+        int  (*add_item_mem)(void *e, void *s, uint32_t item);
+        int  (*add_item_file)(FILE *fd, void *e, void *s, uint32_t item);
+
+        int  (*pre_write)(void *e, void *s);    // do whatever you want, just before the entry is wrtiiten
+};
+
+struct array_buffer* new_array_buffer( int      (*cmp)(const void *a, const void *b),
+                                       int      (*serialize)(FILE *fd, const void *e),
+                                       int      (*unserialize)(void **e, FILE *fd),
+                                       uint32_t (*get_length)(const void *size),
+                                       int      (*write)(FILE *fd, void *e, const void *size),
+                                       int      (*destruct)(void *e),
+                                       char*    file_name,
+                                       void*    max_size,
+                                       int      (*max_size_update)(void *max_size, const void *e),
+                                       int      (*max_size_destruct)(void *max_size),
+                                       int      (*add_item_mem)(void *e, void *s, uint32_t item),
+                                       int      (*add_item_file)(FILE *fd, void *e, void *s, uint32_t item),
+                                       int      (*pre_write)(void *e, void *s)
+                                     );
+/* This makes a new array_buffer
+ *  - cmp() is the compare function used to sort: after sort cmp(item[i], item[i+1])<=0
+ *  - serialize() should put the entry into the file at the current location, return 0 on success
+ *  - unserialize() should read an entry from file and return the entry in memory.
+ *                  return 0 on success, 1 on malloc() failures, 2 on fread() errors,
+ *                  anything else on other errors
+ *  - get_length() calculates the length of the entry as it will be written by write()
+ *  - write() should write the entry to file in it's final format
+ *  - destruct() should free all memory assigned to e (including e itself)
+ *  
+ *  - file_name should contain a filename that can be used as extra storage if needed
+ *              if malloc()'s fail, the array is automaticaly converted to file-mode
+ *              and array_buffer retries the operation.
+ *              by not setting file_name=NULL malloc() failures will result in call
+ *              failures
+ *
+ *  - max_size may be an object to record the maximal size                             \
+ *  - max_size_update() will be called on each add() to update the max_size-structure   | may be NULL
+ *  - max_size_destroy() should destroy the given max_size object                      /
+ *
+ *  - add_item_mem() add item to the entry when it is in memory    (may be NULL) 
+ *  - add_item_file() add item to the serialized entry at the current file position.
+ *                    the entry itself is also given in e for convenience.
+ *                    If the add cannot be done in-place the function should 
+ *                    - invalidate the serialized entry
+ *                    - return ERR_NO_INPLACE_UPDATE
+ *                    The add will be done in memory and re-added to the end of the
+ *                    array    (mey be NULL)
+ *             both functions must update the s-structure to reflect the maximal entry
+ *
+ *  - pre_write() is called right before the entry is written to disk in the write() call (may be NULL)
+ * 
+ * It returns that buffer on succes, NULL otherwise
+ * NULL indicates a memory-allocation failure
+ */
+
+int array_buffer_destruct(struct array_buffer *b, const int free_file_name);
+/* Destructs the buffer:
+ *  - destructs all containing elements using the supplied destruct() function
+ *  - free()'s all allocations
+ *  - optionaly free()'s the file_name
+ *  - free()'s b itself
+ */
+
+int array_buffer_switch_to_file(struct array_buffer *b);
+/* Asks the buffer to switch to file mode
+ * returns 0 on success, 1 on failure
+ */
+
+inline uint32_t array_buffer_get_next_index(struct array_buffer *b);
+/* Returns the index that will be given to the next added entry
+ */
+
+int array_buffer_add(struct array_buffer *b, void *e, uint32_t *index);
+/* Adds entry e to the buffer.
+ * If index!=NULL *index will contain a unique number for the entry
+ *
+ * Returns 0 on succes, 1 otherwise
+ * Once an entry is added, the caller should not use the pointer (e) anymore,
+ * since array_buffer may swap the entry out to file
+ */
+
+int array_buffer_entry_update(struct array_buffer *b, const uint32_t index, uint32_t item);
+/* Updates entry index with item, either in memory or in file, depending on the current
+ * state of the array
+ * Returns ERR_NONE on success
+ *         ERR_MALLOC on malloc() failure
+ *         ERR_FILE on fread(), fwrite(), fseek() problems
+ */
+
+int array_buffer_find_entry(struct array_buffer *b, const void *needle, uint32_t *index);
+/* This looks for an entry that is equal to needle (i.e. that cmp(e, needle) returns 0)
+ * Returns ERR_NONE on success (the entry is found)
+ *         ERR_NOTFOUNF when needle was not found,
+ *         ERR_MALLOC on malloc() failure
+ *         ERR_FILE on fread(), fwrite() of other file() failures
+ */
+
+int array_buffer_sort(struct array_buffer *b);
+/*
+ */
+
+uint32_t array_buffer_get_offset(struct array_buffer *b, const uint32_t index);
+/* Returns the offset of item[index] when it would be written by the
+ * array_buffer_write() call.
+ * Useful to get offsets after sorting!
+ */
+
+uint32_t array_buffer_get_length(struct array_buffer *b);
+/* Returns the total number of bytes array_buffer_write()
+ * would write to the file
+ */
+
+int array_buffer_write(FILE *fd, struct array_buffer *b);
+/* Iterate over each element and write it to file
+ * returns 0 on success, 1 on failure
+ */
+
+#endif
diff --git a/apps/tagdb/artist.c b/apps/tagdb/artist.c
new file mode 100644
index 0000000000..82db81df2f
--- /dev/null
+++ b/apps/tagdb/artist.c
@@ -0,0 +1,370 @@
+#include "malloc.h" // realloc() and free()
+#include <string.h> // strncasecmp()
+
+#include "artist.h"
+
+// how is our flag organized?
+#define FLAG(deleted, spare) ( 0xC0 | (deleted?0x10:0x00) | (spare & 0x0F) )
+#define FLAG_VALID(flag) ((flag & 0xE0) == 0xC0)
+#define FLAG_DELETED(flag) (flag & 0x10)
+#define FLAG_SPARE(flag) (flag & 0x0F)
+
+static int do_resize(struct artist_entry *e, const uint32_t name_len, const uint32_t album_count, const int zero_fill);
+
+struct artist_entry* new_artist_entry(const uint32_t name_len, const uint32_t album_count) {
+        // start by allocating memory
+        struct artist_entry *e = (struct artist_entry*)malloc(sizeof(struct artist_entry));
+        if( e == NULL ) {
+                DEBUGF("new_artist_entry: could not allocate memory\n");
+                return NULL;
+        }
+                
+        // We begin empty
+        e->name = NULL;
+        e->size.name_len = 0;
+        e->album = NULL;
+        e->size.album_count = 0;
+        e->flag = FLAG(0, 0);
+
+        // and resize to the requested size
+        if( do_resize(e, name_len, album_count, 1) ) {
+                free(e);
+                return NULL;
+        }
+        return e;                                                         
+}
+
+int artist_entry_destruct(struct artist_entry *e) {
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        
+        free(e->name);
+        free(e->album);
+        
+        free(e);
+        
+        return ERR_NONE;
+}
+
+static int do_resize(struct artist_entry *e, const uint32_t name_len, const uint32_t album_count, const int zero_fill) {
+        void* temp;
+        
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        
+        // begin with name
+        if( name_len != e->size.name_len ) {
+                temp = realloc(e->name, name_len);
+                if(temp == NULL && name_len > 0) {       // if realloc(,0) don't complain about NULL-pointer
+                        DEBUGF("artist_entry_resize: out of memory to resize name\n");
+                        return ERR_MALLOC;
+                }
+                e->name = (char*)temp;
+                
+                // if asked, fill it with zero's
+                if( zero_fill ) {
+                        uint32_t i;
+                        for(i=e->size.name_len; i<name_len; i++)
+                                e->name[i] = (char)0x00;
+                }
+                
+                e->size.name_len = name_len;
+        }
+        
+        // now the album
+        if( album_count != e->size.album_count ) {
+                temp = realloc(e->album, album_count * sizeof(*e->album));
+                if(temp == NULL && album_count > 0) {      // if realloc(,0) don't complain about NULL-pointer
+                        DEBUGF("artist_entry_resize: out of memory to resize album[]\n");
+                        return ERR_MALLOC;
+                }
+                e->album = (uint32_t*)temp;
+                 
+                // if asked, fill it with zero's
+                if( zero_fill ) {
+                        uint32_t i;
+                        for(i=e->size.album_count; i<album_count; i++)
+                                e->album[i] = (uint32_t)0x00000000;
+                }
+                
+                e->size.album_count = album_count;
+        }
+
+        return ERR_NONE;
+}
+
+int artist_entry_resize(struct artist_entry *e, const uint32_t name_len, const uint32_t album_count) {
+        return do_resize(e, name_len, album_count, 1);
+}
+
+int artist_entry_serialize(FILE *fd, const struct artist_entry *e) {
+        assert(fd != NULL);
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        
+        if( FLAG_DELETED(e->flag) ) { // we are deleted, do nothing
+                return ERR_NONE;
+        }
+        
+        // First byte we write is a flag-byte to indicate this is a valid record
+        if( fwrite(&e->flag, 1, 1, fd) != 1 ) {
+                DEBUGF("artist_entry_serialize: failed to write flag-byte\n");
+                return ERR_FILE;
+        }
+        
+        // First we write the length of the name field
+        if( fwrite(&e->size.name_len, sizeof(e->size.name_len), 1, fd) != 1 ) {
+                DEBUGF("artist_entry_serialize: failed to write name_len\n");
+                return ERR_FILE;
+        }
+
+        // now the name field itself
+        if( fwrite(e->name, 1, e->size.name_len, fd) != e->size.name_len ) {
+                DEBUGF("artist_entry_serialize: failed to write name\n");
+                return ERR_FILE;
+        }
+
+        // count of albums
+        if( fwrite(&e->size.album_count, sizeof(e->size.album_count), 1, fd) != 1 ) {
+                DEBUGF("artist_entry_serialize: failed to write album_count\n");
+                return ERR_FILE;
+        }
+
+        // album[] itself
+        if( fwrite(e->album, sizeof(*e->album), e->size.album_count, fd) != e->size.album_count ) {
+                DEBUGF("artist_entry_serialize: failed to write albums\n");
+                return ERR_FILE;
+        }
+
+        return ERR_NONE;
+}
+
+int artist_entry_unserialize(struct artist_entry **e, FILE *fd) {
+        uint32_t length;
+        unsigned char flag;
+
+        assert(e != NULL);
+        assert(fd != NULL);
+
+        // First byte we read is flag-byte
+        if( fread(&flag, 1, 1, fd) != 1 ) {
+                DEBUGF("artist_entry_unserialize: failed to read flag-byte\n");
+                return ERR_FILE;
+        }
+
+        // See what we have:
+        if( ! FLAG_VALID(flag) ) {
+                DEBUGF("artist_entry_unserialize: flag-byte not found\n");
+                return ERR_INVALID;
+        }
+        
+        // Allocate memory
+        *e = new_artist_entry(0, 0);
+        if( *e == NULL ) {
+                DEBUGF("artist_entry_unserialize: could not create new artist_entry\n");
+                return ERR_MALLOC;
+        }
+        
+        (*e)->flag = flag;
+
+        // First we read the length of the name field
+        if( fread(&length, sizeof(length), 1, fd) != 1 ) {
+                DEBUGF("artist_entry_unserialize: failed to read name_len\n");
+                artist_entry_destruct(*e);
+                return ERR_FILE;
+        }
+
+        // allocate memory for the upcomming name-field
+        if( do_resize((*e), length, 0, 0) ) {
+                DEBUGF("artist_entry_unserialize: failed to allocate memory for name\n");
+                artist_entry_destruct(*e);
+                return ERR_MALLOC;
+        }
+
+        // read it in
+        if( fread((*e)->name, 1, (*e)->size.name_len, fd) != (*e)->size.name_len ) {
+                DEBUGF("artist_entry_unserialize: failed to read name\n");
+                artist_entry_destruct(*e);
+                return ERR_FILE;
+        }
+
+        if( FLAG_DELETED(flag) ) {
+                // all there is... free some memory
+                if( do_resize(*e, 0, 0, 0) ) {
+                        DEBUGF("artist_entry_unserialize: couldn't free() name\n");
+                        return ERR_MALLOC;
+                }
+                return ERR_NONE;
+        }
+        
+        // Next the count of albums
+        if( fread(&length, sizeof(length), 1, fd) != 1 ) {
+                DEBUGF("artist_entry_unserialize: failed to read album_count\n");
+                artist_entry_destruct(*e);
+                return ERR_FILE;
+        }
+
+        // allocate memory for the upcomming name-field
+        if( do_resize(*e, (*e)->size.name_len, length, 0) ) {
+                DEBUGF("artist_entry_unserialize: failed to allocate memory for album[]\n");
+                artist_entry_destruct(*e);
+                return ERR_MALLOC;
+        }
+
+        // read it in
+        if( fread((*e)->album, sizeof(*(*e)->album), (*e)->size.album_count, fd) != (*e)->size.album_count ) {
+                DEBUGF("artist_entry_unserialize: failed to read albums\n");
+                artist_entry_destruct(*e);
+                return ERR_FILE;
+        }
+
+        return ERR_NONE;
+}
+
+int artist_entry_write(FILE *fd, const struct artist_entry *e, const struct artist_size *s) {
+        uint32_t i, be;
+        char pad = 0x00;
+
+        assert(fd != NULL);
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+
+        if( FLAG_DELETED(e->flag) ) { // we are deleted, do nothing
+                return ERR_NONE;
+        }
+        
+        // artist name
+        if( fwrite(e->name, 1, e->size.name_len, fd) != e->size.name_len ) {
+                DEBUGF("artist_entry_write: failed to write name\n");
+                return ERR_FILE;
+        }
+        // padd the rest
+        i = e->size.name_len;
+        while( s != NULL && s->name_len > i) {
+                if( fwrite(&pad, 1, 1, fd) == 1 ) {
+                        i++;
+                        continue;
+                } else {
+                        DEBUGF("artist_entry_write: failed to padd name\n");
+                        return ERR_FILE;
+                }
+        }
+
+        // album offsets, but in BIG ENDIAN!
+        // so we need to iterate over each item to convert it
+        for(i=0; i<e->size.album_count; i++) {
+                be = BE32(e->album[i]);
+                if( fwrite(&be, sizeof(be), 1, fd) != 1 ) {
+                        DEBUGF("artist_entry_write: failed to write album[%d]\n", i);
+                        return ERR_FILE;
+                }
+        }
+        // padd the rest
+        be = BE32(0x00000000);
+        for(; s != NULL && i<s->album_count; i++) {
+                if( fwrite(&be, sizeof(be), 1, fd) != 1 ) {
+                        DEBUGF("artist_entry_write: failed to padd album[]\n");
+                        return ERR_FILE;
+                }
+        }
+
+        return ERR_NONE;
+}
+
+inline int artist_entry_compare(const struct artist_entry *a, const struct artist_entry *b) {
+        assert(a != NULL);
+        assert(b != NULL);
+        if( a->name == NULL || b->name == NULL )
+                return 1; // never match on no-names
+        return strcasecmp(a->name, b->name);
+}
+
+struct artist_size* new_artist_size() {
+        struct artist_size *s;
+        s = (struct artist_size*)malloc(sizeof(struct artist_size));
+        if( s == NULL ) {
+                DEBUGF("new_artist_size: failed to allocate memory\n");
+                return NULL;
+        }
+        s->name_len = 0;
+        s->album_count = 0;
+        
+        return s;
+}
+
+inline uint32_t artist_size_get_length(const struct artist_size *size) {
+        assert(size != NULL);
+        return size->name_len + 4*size->album_count;
+}
+
+inline int artist_size_max(struct artist_size *s, const struct artist_entry *e) {
+        s->name_len    = ( s->name_len    >= e->size.name_len    ? s->name_len    : e->size.name_len );
+        s->album_count = ( s->album_count >= e->size.album_count ? s->album_count : e->size.album_count );
+        return ERR_NONE;        
+}
+
+int artist_size_destruct(struct artist_size *s) {
+        assert(s != NULL);
+        // nothing to do...
+        free(s);
+        return ERR_NONE;
+}
+
+int artist_entry_add_album_mem(struct artist_entry *e, struct artist_size *s, const uint32_t album) {
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+
+        if( do_resize(e, e->size.name_len, e->size.album_count+1, 0) ) {
+                DEBUGF("artist_entry_add_song_mem: failed to resize album[]\n");
+                return ERR_MALLOC;
+        }
+
+        e->album[e->size.album_count-1] = album;
+
+        if(s != NULL) artist_size_max(s, e); // can't fail
+
+        return ERR_NONE;
+}
+
+static int delete_serialized(FILE *fd, struct artist_entry *e) {
+// the entry should be both, in memory and in file at the current location
+// this function will mark the file-entry as deleted
+        uint32_t size;
+        unsigned char flag;
+        // overwrite the beginning of the serialized data:
+        assert(fd != NULL);
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        
+        flag = FLAG(1, 0); // mark as deleted
+
+        // First byte we write is the flag-byte to indicate this is a deleted
+        if( fwrite(&flag, 1, 1, fd) != 1 ) {
+                DEBUGF("artist_entry_delete_serialized: failed to write flag-byte\n");
+                return ERR_FILE;
+        }
+        
+        // Then we write the length of the COMPLETE entry
+        size = artist_size_get_length(&e->size) + 4; // 4 = overhead for the album[]
+        if( fwrite(&size, sizeof(size), 1, fd) != 1 ) {
+                DEBUGF("artist_entry_delete_serialized: failed to write len\n");
+                return ERR_FILE;
+        }
+
+        return ERR_NONE;
+}
+
+int artist_entry_add_album_file(FILE *fd, struct artist_entry *e, struct artist_size *s, const uint32_t album) {
+        assert(fd != NULL);
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+
+        DEBUGF("artist_entry_add_song_file() called\n");
+
+        if( delete_serialized(fd, e) ) {
+                DEBUGF("artist_entry_add_album_file: could not mark as deleted\n");
+                return ERR_FILE;
+        }
+        
+        return ERR_NO_INPLACE_UPDATE;
+}
diff --git a/apps/tagdb/artist.h b/apps/tagdb/artist.h
new file mode 100644
index 0000000000..c741594936
--- /dev/null
+++ b/apps/tagdb/artist.h
@@ -0,0 +1,100 @@
+#ifndef __ARTIST_H__
+#define __ARTIST_H__
+
+#include "config.h"
+#include <stdio.h>
+#include <stdint.h>
+
+struct artist_entry {
+        char* name;             // artist name
+        uint32_t *album;        // album-pointers
+        struct artist_size {
+                uint32_t name_len;      // length of this field (must be mulitple of 4)
+                uint32_t album_count;   // number of album pointers
+        } size;
+        unsigned char flag;             // flags
+};
+
+struct artist_entry* new_artist_entry(const uint32_t name_len, const uint32_t album_count);
+/* Creates a new artist_entry with the specified sizes
+ * Returns a pointer to the structure on success,
+ * NULL on failure
+*/
+
+int artist_entry_destruct(struct artist_entry *e);
+/* Destructs the given artist_entry and free()'s it's memory
+ * returns ERR_NONE on success (can't fail)
+ */
+
+int artist_entry_resize(struct artist_entry *e, const uint32_t name_len, const uint32_t album_count);
+/* Change the size of the entry
+ * returns ERR_NONE on succes
+ *         ERR_MALLOC on malloc() failure
+ */
+
+int artist_entry_serialize(FILE *fd, const struct artist_entry *e);
+/* Serializes the entry in the file at the current position
+ * returns ERR_NONE on success
+ *         ERR_FILE on fwrite() failure
+ */
+
+int artist_entry_unserialize(struct artist_entry* *e, FILE *fd);
+/* Unserializes an entry from file into a new structure
+ * The address of the structure is saved into *e
+ * returns ERR_NONE on success
+ *         ERR_MALLOC on malloc() failure
+ *         ERR_FILE on fread() failure
+ */
+
+int artist_entry_write(FILE *fd, const struct artist_entry *e, const struct artist_size *s);
+/* Writes the entry to file in the final form
+ * returns ERR_NONE on success
+ *         ERR_FILE on fwrite() failure
+ */
+
+inline int artist_entry_compare(const struct artist_entry *a, const struct artist_entry *b);
+/* Compares 2 entries
+ * When a < b it returns <0
+ *      a = b             0
+ *      a > b            >0
+ */
+
+struct artist_size* new_artist_size();
+/* Creates a new size structure
+ * returns a pointer to the structure on success,
+ * NULL on failure
+ */
+
+inline uint32_t artist_size_get_length(const struct artist_size *size);
+/* Calculates the length of the entry when written by artist_entry_write()
+ * returns the length on success (can't fail)
+ */
+
+inline int artist_size_max(struct artist_size *s, const struct artist_entry *e);
+/* Updates the artist_size structure to contain the maximal lengths of either
+ * the original entry in s, or the entry e
+ * returns ERR_NONE on success (can't fail)
+ */
+
+int artist_size_destruct(struct artist_size *s);
+/* destructs the artist_size structure
+ * returns ERR_NONE on success (can't fail)
+ */
+
+
+int artist_entry_add_album_mem(struct artist_entry *e, struct artist_size *s, const uint32_t album);
+/* Adds the album to the array
+ * returns ERR_NONE on success
+ *         ERR_MALLOC on malloc() failure
+ */
+
+int artist_entry_add_album_file(FILE *fd, struct artist_entry *e, struct artist_size *s, const uint32_t album);
+/* Adds the album to the serialized entry in the file
+ * When this fails, the entry is invalidated and the function returns
+ * ERR_NO_INPLACE_UPDATE
+ * returns ERR_NONE on success
+ *         ERR_NO_INPLACE_UPDATE (see above)
+ *         ERR_FILE on fread()/fwrite() error
+ */
+
+#endif
diff --git a/apps/tagdb/config.h b/apps/tagdb/config.h
new file mode 100644
index 0000000000..86461349e3
--- /dev/null
+++ b/apps/tagdb/config.h
@@ -0,0 +1,39 @@
+#ifndef __CONFIG_H      // Include me only once
+#define __CONFIG_H
+
+// DEBUGF will print in debug mode:
+#ifdef DEBUG
+#define DEBUGF(...) fprintf (stderr, __VA_ARGS__)
+#define DEBUGT(...) fprintf (stdout, __VA_ARGS__)
+#else //DEBUG
+#define DEBUGF(...)
+#endif //DEBUG
+
+
+#define OS_LINUX // architecture: LINUX, ROCKBOX, WINDOWS
+#define ROCKBOX_LITTLE_ENDIAN // we are intel... little-endian
+
+
+#ifdef ROCKBOX_LITTLE_ENDIAN
+#define BE32(_x_) ((( (_x_) & 0xff000000) >> 24) | \
+                   (( (_x_) & 0x00ff0000) >> 8) | \
+                   (( (_x_) & 0x0000ff00) << 8) | \
+                   (( (_x_) & 0x000000ff) << 24))
+#define BE16(_x_) ( (( (_x_) & 0xff00) >> 8) | (( (_x_) & 0x00ff) << 8))
+#else
+#define BE32(_x_) _x_
+#define BE16(_x_) _x_
+#endif
+
+#include <stdint.h>
+
+#define ERR_NONE 0      // no error
+#define ERR_NOTFOUND -1 // entry not found
+#define ERR_MALLOC 1    // memory allocation failed
+#define ERR_FILE 2      // file operation failed
+#define ERR_INVALID 3   // something is invalid
+#define ERR_NO_INPLACE_UPDATE 4 // can't update in this place
+
+#include <assert.h>
+
+#endif
diff --git a/apps/tagdb/db.c b/apps/tagdb/db.c
new file mode 100644
index 0000000000..1c84b2b75c
--- /dev/null
+++ b/apps/tagdb/db.c
@@ -0,0 +1,603 @@
+#include <string.h> // strlen() strcpy() strcat()
+
+#include "malloc.h"
+#include "db.h"
+#include "header.h"
+
+#include "artist.h"
+#include "album.h"
+#include "song.h"
+#include "file.h"
+
+#include "tag_dummy.h"
+
+#define CEIL32BIT(x) ( ((x) + 3) & 0xfffffffc )
+#define CEIL32BIT_LEN(x) CEIL32BIT(strlen(x) + 1) // +1 because we want to store the \0 at least once
+
+#define CATCH_MALLOC(condition) \
+        while( condition ) { \
+                int rc_catch_malloc = free_ram(); \
+                if (rc_catch_malloc != ERR_NONE) { \
+                        DEBUGF("catch_malloc: " #condition ": could not free memory, failing...\n"); \
+                        return rc_catch_malloc; \
+                } \
+        }
+
+#define CATCH_MALLOC_ERR(expr) CATCH_MALLOC( (expr) == ERR_MALLOC )
+#define CATCH_MALLOC_NULL(expr) CATCH_MALLOC( (expr) == NULL )
+// Loop the expression as long as it returns ERR_MALLOC (for CATCH_MALLOC_ERR)
+// or NULL (for CATCH_MALLOC_NULL)
+// on each failure, call free_ram() to free some ram. if free_ram() fails, return
+// the fail-code
+#define CATCH_ERR(expr) \
+        CATCH_MALLOC_ERR(rc = expr); \
+        if( rc != ERR_NONE ) { \
+                DEBUGF("catch_err: " #expr ": failed\n"); \
+                return rc; \
+        }
+// Catches all errors: if it's a MALLOC one, try to free memory,
+// if it's another one, return the code
+
+static int fill_artist_offsets(struct artist_entry *e, struct artist_size *max_s);
+static int fill_album_offsets(struct album_entry *e, struct album_size *max_s);
+static int fill_song_offsets(struct song_entry *e, struct song_size *max_s);
+static int fill_file_offsets(struct file_entry *e, struct file_size *max_s);
+
+static int do_add(const struct tag_info *t);
+
+static int tag_empty_get(struct tag_info *t);
+/* Adds "<no artist tag>" and "<no album tag>" if they're empty
+ */
+
+static int free_ram();
+static char in_file = 0;
+
+static int do_write(FILE *fd);
+
+static struct array_buffer *artists;
+static struct array_buffer *albums;
+static struct array_buffer *songs;
+static struct array_buffer *files;
+static uint32_t artist_start=0, album_start=0, song_start=0, file_start=0;
+static uint32_t artist_entry_len, album_entry_len, song_entry_len, file_entry_len;
+static char *artists_file, *albums_file, *songs_file, *files_file;
+
+int db_construct() {
+        void *max_size;
+        
+        // struct array_buffer* new_array_buffer( int      (*cmp)(const void *a, const void *b),
+        //                                        int      (*serialize)(FILE *fd, const void *e),
+        //                                        int      (*unserialize)(void **e, FILE *fd),
+        //                                        uint32_t (*get_length)(const void *size),
+        //                                        int      (*write)(FILE *fd, void *e, const void *size),
+        //                                        int      (*destruct)(void *e),
+        //                                        char*    file_name,
+        //                                        void*    max_size,
+        //                                        int      (*max_size_update)(void *max_size, const void *e),
+        //                                        int      (*max_size_destruct)(void *max_size),
+        //                                        int      (*add_item_mem)(void *e, void *s, uint32_t item),
+        //                                        int      (*add_item_file)(FILE *fd, void *e, void *s, uint32_t item)
+        //                                      );
+
+        if(!( max_size = (void*)new_artist_size() )) {
+                DEBUGF("new_db: new_artist_size() failed\n");
+                return ERR_MALLOC;
+        }
+        if(!( artists = new_array_buffer( (int      (*)(const void *a, const void *b)) artist_entry_compare,
+                                          (int      (*)(FILE *fd, const void *e)) artist_entry_serialize,
+                                          (int      (*)(void **e, FILE *fd)) artist_entry_unserialize,
+                                          (uint32_t (*)(const void *size)) artist_size_get_length,
+                                          (int      (*)(FILE *fd, void *e, const void *size)) artist_entry_write,
+                                          (int      (*)(void *e)) artist_entry_destruct,
+                                          NULL, // don't allow to switch to file
+                                          max_size,
+                                          (int      (*)(void *max_size, const void *e)) artist_size_max,
+                                          (int      (*)(void *max_size)) artist_size_destruct,
+                                          (int      (*)(void *e, void *s, uint32_t item)) artist_entry_add_album_mem,
+                                          (int      (*)(FILE *fd, void *e, void *s, uint32_t item)) artist_entry_add_album_file,
+                                          (int      (*)(void *e, void *s)) fill_artist_offsets
+                                        ) )) {
+                DEBUGF("new_db: new_array_buffer() failed on artists[]\n");
+                return ERR_MALLOC;
+        }
+        if(!( artists_file = malloc(12) )) { // artists.tmp
+                DEBUGF("new_db: could not malloc() for artists[] file_name\n");
+                return ERR_MALLOC;
+        }
+        strcpy(artists_file, "artists.tmp");
+        
+        if(!( max_size = (void*)new_album_size() )) {
+                DEBUGF("new_db: new_album_size() failed\n");
+                return ERR_MALLOC;
+        }
+        if(!( albums = new_array_buffer( (int      (*)(const void *a, const void *b)) album_entry_compare,
+                                         (int      (*)(FILE *fd, const void *e)) album_entry_serialize,
+                                         (int      (*)(void **e, FILE *fd)) album_entry_unserialize,
+                                         (uint32_t (*)(const void *size)) album_size_get_length,
+                                         (int      (*)(FILE *fd, void *e, const void *size)) album_entry_write,
+                                         (int      (*)(void *e)) album_entry_destruct,
+                                         NULL, // don't allow to switch to file
+                                         max_size,
+                                         (int      (*)(void *max_size, const void *e)) album_size_max,
+                                         (int      (*)(void *max_size)) album_size_destruct,
+                                         (int      (*)(void *e, void *s, uint32_t item)) album_entry_add_song_mem,
+                                         (int      (*)(FILE *fd, void *e, void *s, uint32_t item)) album_entry_add_song_file,
+                                         (int      (*)(void *e, void *s)) fill_album_offsets
+                                       ) )) {
+                DEBUGF("new_db: new_array_buffer() failed on albums[]\n");
+                return ERR_MALLOC;
+        }
+        if(!( albums_file = malloc(11) )) { // albums.tmp
+                DEBUGF("new_db: could not malloc() for albums[] file_name\n");
+                return ERR_MALLOC;
+        }
+        strcpy(albums_file, "albums.tmp");
+        
+        if(!( max_size = (void*)new_song_size() )) {
+                DEBUGF("new_db: new_song_size() failed\n");
+                return ERR_MALLOC;
+        }
+        if(!( songs = new_array_buffer( (int      (*)(const void *a, const void *b)) song_entry_compare,
+                                        (int      (*)(FILE *fd, const void *e)) song_entry_serialize,
+                                        (int      (*)(void **e, FILE *fd)) song_entry_unserialize,
+                                        (uint32_t (*)(const void *size)) song_size_get_length,
+                                        (int      (*)(FILE *fd, void *e, const void *size)) song_entry_write,
+                                        (int      (*)(void *e)) song_entry_destruct,
+                                        NULL, // may switch to file, but we'd like to know about it
+                                        max_size,
+                                        (int      (*)(void *max_size, const void *e)) song_size_max,
+                                        (int      (*)(void *max_size)) song_size_destruct,
+                                        NULL,
+                                        NULL,
+                                        (int      (*)(void *e, void *s)) fill_song_offsets
+                                      ) )) {
+                DEBUGF("new_db: new_array_buffer() failed on songs[]\n");
+                return ERR_MALLOC;
+        }
+        if(!( songs_file = malloc(10) )) { // songs.tmp
+                DEBUGF("new_db: could not malloc() for songs[] file_name\n");
+                return ERR_MALLOC;
+        }
+        strcpy(songs_file, "songs.tmp");
+        
+        if(!( max_size = (void*)new_file_size() )) {
+                DEBUGF("new_db: new_file_size() failed\n");
+                return ERR_MALLOC;
+        }
+        if(!( files = new_array_buffer( (int      (*)(const void *a, const void *b)) file_entry_compare,
+                                        (int      (*)(FILE *fd, const void *e)) file_entry_serialize,
+                                        (int      (*)(void **e, FILE *fd)) file_entry_unserialize,
+                                        (uint32_t (*)(const void *size)) file_size_get_length,
+                                        (int      (*)(FILE *fd, void *e, const void *size)) file_entry_write,
+                                        (int      (*)(void *e)) file_entry_destruct,
+                                        NULL,
+                                        max_size,
+                                        (int      (*)(void *max_size, const void *e)) file_size_max,
+                                        (int      (*)(void *max_size)) file_size_destruct,
+                                        NULL,
+                                        NULL,
+                                        (int      (*)(void *e, void *s)) fill_file_offsets
+                                      ) )) {
+                DEBUGF("new_db: new_array_buffer() failed on files[]\n");
+                return ERR_MALLOC;
+        }
+        if(!( files_file = malloc(10) )) { // files.tmp
+                DEBUGF("new_db: could not malloc() for files[] file_name\n");
+                return ERR_MALLOC;
+        }
+        strcpy(files_file, "files.tmp");
+        
+        return ERR_NONE;
+}
+
+int db_destruct() {
+        int rc;
+
+        CATCH_ERR( array_buffer_destruct(artists, 1) );
+        artists = NULL;
+        free(artists_file);
+        artists_file = NULL;
+
+        CATCH_ERR( array_buffer_destruct(albums, 1) );
+        albums = NULL;
+        free(albums_file);
+        albums_file = NULL;
+
+        CATCH_ERR( array_buffer_destruct(songs, 1) );
+        songs = NULL;
+        free(songs_file);
+        songs_file = NULL;
+
+        CATCH_ERR( array_buffer_destruct(files, 1) );
+        files = NULL;
+        free(files_file);
+        files_file = NULL;
+
+        return ERR_NONE;
+}
+
+static int do_add(const struct tag_info *t) {
+        struct artist_entry *artist; uint32_t artistn;
+        struct album_entry *album;  uint32_t albumn;
+        struct song_entry *song;  uint32_t songn;
+        struct file_entry *file;  uint32_t filen;
+        int rc;
+
+        // create file
+        CATCH_MALLOC_NULL( file = new_file_entry( CEIL32BIT( strlen(t->directory) + 1 + strlen(t->filename) + 1 ) ) ); // "dir"."/"."file"."\0"
+        
+        // fill in file
+        strcpy(file->name, t->directory);
+        strcat(file->name, "/");
+        strcat(file->name, t->filename);
+        file->hash = 0xffffffff; // TODO
+        file->song = songn = array_buffer_get_next_index(songs);
+        file->rundb = 0xffffffff; // TODO
+        
+        // add
+        CATCH_ERR( array_buffer_add(files, file, &filen) );
+        
+        // create artist
+        CATCH_MALLOC_NULL( artist = new_artist_entry( CEIL32BIT_LEN(t->artist), 0) );
+        // fill in
+        strcpy(artist->name, t->artist);
+        // see if it is already in
+        CATCH_MALLOC_ERR( rc = array_buffer_find_entry(artists, artist, &artistn) );
+        if( rc == ERR_NONE ) { // found it
+                // remove our self-made one
+                artist_entry_destruct(artist);
+                artist = NULL;
+        } else if( rc == ERR_NOTFOUND ) { // didn't find it
+                // fill in the rest and add
+                CATCH_ERR( artist_entry_resize(artist, artist->size.name_len, 1) );
+                artist->album[0] = albumn = array_buffer_get_next_index(albums); // if artist isn't in, album will not be in either
+                CATCH_ERR( array_buffer_add(artists, artist, &artistn) );
+                // leave artist != NULL, to indicate that we made a new one
+        } else { //error
+                DEBUGF("do_add: could not search for artist in artists[]\n");
+                return rc;
+        }       
+        
+        
+        // create album
+        CATCH_MALLOC_NULL( album = new_album_entry(0,0) );
+        // malloc for key
+        CATCH_MALLOC_NULL( album->key = malloc( strlen(t->album) + 3 + strlen(t->artist) + 3 + strlen(t->directory) + 1 ) );
+        // fill in
+        strcpy(album->key, t->album);
+        strcat(album->key, "___");
+        strcat(album->key, t->artist);
+        strcat(album->key, "___");
+        strcat(album->key, t->directory);
+        // see if it is already in
+        CATCH_MALLOC_ERR( rc = array_buffer_find_entry(albums, album, &albumn) );
+        if( rc == ERR_NONE ) { // found it
+                assert(artist == NULL); // make sure artist was found; else we have trouble!
+                // Remove our search-album and add the song to the already existing one
+                album_entry_destruct(album);
+                album = NULL;
+                CATCH_ERR( array_buffer_entry_update(albums, albumn, songn) );
+        } else if( rc == ERR_NOTFOUND ) { // didn't find it
+                // fill in the rest of the info in this album and add it
+                CATCH_ERR( album_entry_resize(album, CEIL32BIT_LEN(t->album), 1 ) );
+                strcpy(album->name, t->album);
+                album->artist = artistn;
+                album->song[0] = songn;
+                CATCH_ERR( array_buffer_add(albums, album, &albumn) );
+        } else { // error
+                DEBUGF("do_add: could not search for album in albums[]\n");
+                return rc;
+        }
+
+        
+        if( album != NULL && artist == NULL ) {
+                // we have a new album from an already existing artist
+                // add it!
+                CATCH_ERR( array_buffer_entry_update(artists, artistn, albumn) );
+        }
+
+
+        // song
+        CATCH_MALLOC_NULL( song = new_song_entry( CEIL32BIT_LEN(t->song), CEIL32BIT_LEN(t->genre)) );
+        // fill in
+        strcpy(song->name, t->song);
+        song->artist = artistn;
+        song->album = albumn;
+        song->file = filen;
+        strcpy(song->genre, t->genre);
+        song->bitrate = t->bitrate;
+        song->year = t->year;
+        song->playtime = t->playtime;
+        song->track = t->track;
+        song->samplerate = t->samplerate;
+        // add
+        CATCH_ERR( array_buffer_add(songs, song, NULL) );
+
+        return ERR_NONE;
+}
+
+static int tag_empty_get(struct tag_info *t) {
+        assert( t != NULL );
+
+        if( t->song == NULL ) {
+                CATCH_MALLOC_NULL( t->song = (char*)malloc(14) );
+                strcpy(t->song,   "<no song tag>");
+        }
+        if( t->genre == NULL ) {
+                CATCH_MALLOC_NULL( t->genre = (char*)malloc(15) );
+                strcpy(t->genre,  "<no genre tag>");
+        }
+        if( t->artist == NULL ) {
+                CATCH_MALLOC_NULL( t->artist = (char*)malloc(16) );
+                strcpy(t->artist, "<no artist tag>");
+        }
+        if( t->album == NULL ) {
+                CATCH_MALLOC_NULL( t->album = (char*)malloc(15) );
+                strcpy(t->album,  "<no album tag>");
+        }
+
+        return ERR_NONE;
+}
+
+int db_add(char* file_path, const char* strip_path, const char* add_path) {
+        char *basename, *dir;
+        struct tag_info *t;
+        int rc;
+        
+        assert(file_path != NULL);
+
+        // Create a new tag_info structure
+        CATCH_MALLOC_NULL( t = new_tag_info() );
+
+        // fill in the file_name
+        basename = strrchr(file_path, '/');     // TODO: add \ for windows
+        if( basename == NULL ) {
+                basename = file_path; // no / in the path, so it's only a filename
+                dir = NULL;
+        } else {
+                dir = file_path;
+                basename[0] = '\0'; // set the / to \0 to split the string
+                basename++; // skip past the /
+        }
+        CATCH_MALLOC_NULL( t->filename = malloc(strlen(basename)+1) ); // +1 for the '\0' termination
+        strcpy(t->filename, basename);
+
+        // convert the path
+        if( strip_path != NULL && strlen(strip_path) > 0) {
+                if( dir == NULL || strncmp(file_path, strip_path, strlen(strip_path)) ) {
+                        printf("db_add: could not strip path from \"%s\"\n", file_path);
+                } else {
+                        dir += strlen(strip_path); // skip the path to strip 
+                }
+        }
+        if( add_path != NULL ) {
+                CATCH_MALLOC_NULL( t->directory = malloc( strlen(add_path) + strlen(dir) + 1 ) ); // +1 for '\0' termination
+                strcpy(t->directory, add_path);
+                strcat(t->directory, dir);
+        } else {
+                CATCH_MALLOC_NULL( t->directory = malloc( strlen(dir) + 1 ) );
+                strcpy(t->directory, dir);
+        }
+
+        // restore the file_path to it's original state
+        if( dir != NULL) *(basename-1) = '/';
+
+        // So far we have:
+        //  filename
+        //  directory
+        // try to get the rest from tag-information:
+        //tag_id3v2_get(file_path, t);
+        //tag_id3v1_get(file_path, t);
+        tag_dummy(file_path, t);
+        
+        // If it is still empty here, skip this file
+        if( t->artist==NULL && t->song==NULL && t->album==NULL && t->genre==NULL) {
+                tag_info_destruct(t); // we won't need it anymore
+                return ERR_NONE;
+        }
+
+        // fill in empty tags with "<no ... tag>"
+        CATCH_ERR( tag_empty_get(t) );
+        
+        // all filled in, now add it
+        CATCH_ERR( do_add(t) );
+
+        tag_info_destruct(t); // we won't need it anymore
+
+        return ERR_NONE;
+}
+
+static int free_ram() {
+        // put things in file that we won't need to search a lot:
+        //  files[] and songs[] are write only
+        //  artists[] and albums[] should stay in memory as long as possible
+        // albums[] is updated for every song;
+        // artists[] for every album: artists[] will be the first to loose ram...
+        if(!( in_file & 0x01 )) { // files[] is still in ram
+                in_file |= 0x01;
+                // switch files[] to file-mode
+                files->file_name = files_file;
+                files_file = NULL; // since array_buffer will clean this up
+                return array_buffer_switch_to_file(files);
+        } else if(!( in_file & 0x02 )) { // song[] is still in ram
+                in_file |= 0x02;
+                // switch songs[] to file-mode
+                songs->file_name = songs_file;
+                songs_file = NULL; // since array_buffer will clean this up
+                return array_buffer_switch_to_file(songs);
+        } else if(!( in_file & 0x04 )) { // artists[] is still in ram
+                in_file |= 0x04;
+                // switch artists[] to file-mode
+                artists->file_name = artists_file;
+                artists_file = NULL; // since array_buffer will clean this up
+                return array_buffer_switch_to_file(artists);
+        } else if(!( in_file & 0x08 )) { // albums[] is still in ram
+                in_file |= 0x08;
+                // switch albums[] to file-mode
+                albums->file_name = albums_file;
+                albums_file = NULL; // since array_buffer will clean this up
+                return array_buffer_switch_to_file(albums);
+        } else {
+                // all is already in file mode, sorry...
+                DEBUGF("free_ram: everything is already in file-mode, cannot free more ram, sorry...\n");
+                return ERR_MALLOC;
+        }
+}
+
+static int fill_artist_offsets(struct artist_entry *e, struct artist_size *max_s) {
+        uint32_t i;
+        
+        assert(e != NULL);
+        assert(album_start != 0);
+        
+        for(i=0; i<e->size.album_count; i++) {
+                e->album[i] = album_start + e->album[i] * album_entry_len;
+        }
+        return ERR_NONE;
+}
+
+static int fill_album_offsets(struct album_entry *e, struct album_size *max_s) {
+        uint32_t i;
+        
+        assert(e != NULL);
+        assert(song_start != 0);
+        
+        e->artist = artist_start + e->artist * artist_entry_len;
+        for(i=0; i<e->size.song_count; i++) {
+                e->song[i] = song_start + e->song[i] * song_entry_len;
+        }
+        return ERR_NONE;
+}
+
+static int fill_song_offsets(struct song_entry *e, struct song_size *max_s) {
+        
+        assert(e != NULL);
+        assert(artist_start != 0);
+        assert(album_start != 0);
+        assert(file_start != 0);
+        
+        e->artist = artist_start + e->artist * artist_entry_len;
+        e->album  = album_start  + e->album  * album_entry_len;
+        e->file   = file_start   + e->file   * file_entry_len;
+        return ERR_NONE;
+}
+
+static int fill_file_offsets(struct file_entry *e, struct file_size *max_s) {
+        
+        assert(e != NULL);
+        assert(song_start != 0);
+
+        e->song = song_start + e->song * song_entry_len;
+        return ERR_NONE;
+}
+
+static int do_write(FILE *fd) {
+        int rc;
+        struct header h;
+        
+        assert(fd != NULL);
+
+        // make a header
+        h.magic[0] = 'R'; h.magic[1] = 'D'; h.magic[2] = 'B';
+        h.version = 0x03;
+        
+        h.artist_start = artist_start = HEADER_SIZE;
+        h.album_start  = album_start  = h.artist_start + array_buffer_get_length(artists); // TODO error check
+        h.song_start   = song_start   = h.album_start + array_buffer_get_length(albums);
+        h.file_start   = file_start   = h.song_start + array_buffer_get_length(songs);
+
+        h.artist_count = artists->count;
+        h.album_count = albums->count;
+        h.song_count = songs->count;
+        h.file_count = files->count;
+
+        h.artist_len = ((struct artist_size*)artists->max_size)->name_len;
+        h.album_len  = ((struct album_size*)albums->max_size)->name_len;
+        h.song_len   = ((struct song_size*)songs->max_size)->name_len;
+        h.genre_len  = ((struct song_size*)songs->max_size)->genre_len;
+        h.file_len   = ((struct file_size*)files->max_size)->name_len;
+
+        artist_entry_len = artist_size_get_length(artists->max_size); // TODO error check
+        album_entry_len = album_size_get_length(albums->max_size);
+        song_entry_len = song_size_get_length(songs->max_size);
+        file_entry_len = file_size_get_length(files->max_size);
+
+        h.song_array_count = ((struct album_size*)albums->max_size)->song_count;
+        h.album_array_count = ((struct artist_size*)artists->max_size)->album_count;
+
+        h.flags.reserved = 0;
+        h.flags.rundb_dirty = 1;
+
+        // write the header
+        CATCH_ERR( header_write(fd, &h) );
+
+        // write the arrays
+        CATCH_ERR( array_buffer_write(fd, artists) );
+        CATCH_ERR( array_buffer_write(fd, albums) );
+        CATCH_ERR( array_buffer_write(fd, songs) );
+        CATCH_ERR( array_buffer_write(fd, files) );
+
+        return ERR_NONE;
+}
+
+int db_write(FILE *fd) {
+        int rc;
+        // sort everything
+        CATCH_ERR( array_buffer_sort(artists) );
+        CATCH_ERR( array_buffer_sort(albums) );
+        CATCH_ERR( array_buffer_sort(songs) );
+        CATCH_ERR( array_buffer_sort(files) );
+
+        CATCH_ERR( do_write(fd) );
+
+        return ERR_NONE;
+}
+
+struct tag_info* new_tag_info() {
+        struct tag_info *t;
+        t = malloc(sizeof(struct tag_info));
+        if( t == NULL ) {
+                DEBUGF("new_tag_info: could not malloc() for tag_info\n");
+                return NULL;
+        }
+
+        t->directory = NULL;
+        t->filename = NULL;
+        t->song = NULL;
+        t->artist = NULL;
+        t->album = NULL;
+        t->genre = NULL;
+        t->bitrate = 0;
+        t->year = 0;
+        t->playtime = 0;
+        t->track = 0;
+        t->samplerate = 0;
+
+        return t;
+}
+
+int tag_info_destruct(struct tag_info *t) {
+        assert(t != NULL);
+
+        free(t->directory);
+        t->directory = NULL;
+        free(t->filename);
+        t->filename = NULL;
+        free(t->song);
+        t->song = NULL;
+        free(t->artist);
+        t->artist = NULL;
+        free(t->album);
+        t->album = NULL;
+        free(t->genre);
+        t->genre = NULL;
+        t->bitrate = 0;
+        t->year = 0;
+        t->playtime = 0;
+        t->track = 0;
+        t->samplerate = 0;
+
+        free(t);
+
+        return ERR_NONE;
+}
diff --git a/apps/tagdb/db.h b/apps/tagdb/db.h
new file mode 100644
index 0000000000..be29581a09
--- /dev/null
+++ b/apps/tagdb/db.h
@@ -0,0 +1,37 @@
+#ifndef __DB_H__
+#define __DB_H__
+
+#include "config.h"
+#include <stdio.h>
+
+#include "array_buffer.h"
+
+struct tag_info {
+        char* directory;
+        char* filename;         // \0 terminated string's
+        char* song;
+        char* artist;
+        char* album;
+        char* genre;
+        uint16_t bitrate;
+        uint16_t year;
+        uint32_t playtime;
+        uint16_t track;
+        uint16_t samplerate;
+};
+
+int db_construct();
+
+int db_destruct();
+
+int db_add(char* file_path, const char* strip_path, const char* add_path);
+
+int db_sort();
+
+int db_write(FILE *fd);
+
+struct tag_info* new_tag_info();
+
+int tag_info_destruct(struct tag_info *t);
+
+#endif
diff --git a/apps/tagdb/file.c b/apps/tagdb/file.c
new file mode 100644
index 0000000000..de641fec38
--- /dev/null
+++ b/apps/tagdb/file.c
@@ -0,0 +1,268 @@
+#include "malloc.h" // realloc() and free()
+#include <string.h> // strncasecmp()
+
+#include "file.h"
+
+// how is our flag organized?
+#define FLAG ( 0xBF )
+#define FLAG_VALID(flag) (flag == 0xBF)
+
+static int do_resize(struct file_entry *e, const uint32_t name_len, const int zero_fill);
+
+struct file_entry* new_file_entry(const uint32_t name_len) {
+        // Start my allocating memory
+        struct file_entry *e = (struct file_entry*)malloc(sizeof(struct file_entry));
+        if( e == NULL ) {
+                DEBUGF("new_file_entry: could not allocate memory\n");
+                return NULL;
+        }
+        
+        // We begin empty
+        e->name = NULL;
+        e->size.name_len = 0;
+        
+        e->hash = 0;
+        e->song = 0;
+        e->rundb = 0;
+
+        e->flag = FLAG;
+
+        // and resize to the requested size
+        if( do_resize(e, name_len, 1) ) {
+                free(e);
+                return NULL;
+        }
+        
+        return e;
+}
+
+int file_entry_destruct(struct file_entry *e) {
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        
+        free(e->name);
+        
+        free(e);
+
+        return ERR_NONE;
+}
+
+static int do_resize(struct file_entry *e, const uint32_t name_len, const int zero_fill) {
+        void* temp;
+
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+
+        if( name_len != e->size.name_len ) {
+                temp = realloc(e->name, name_len);
+                if(temp == NULL) {
+                        DEBUGF("file_entry_resize: out of memory to resize name\n");
+                        return ERR_MALLOC;
+                }
+                e->name = (char*)temp;
+                
+                // if asked, fill it with zero's
+                if( zero_fill ) {
+                        uint32_t i;
+                        for(i=e->size.name_len; i<name_len; i++)
+                                e->name[i] = (char)0x00;
+                }
+                
+                e->size.name_len = name_len;
+        }
+        
+        return ERR_NONE;
+}
+
+inline int file_entry_resize(struct file_entry *e, const uint32_t name_len) {
+        return do_resize(e, name_len, 1);
+}
+
+int file_entry_serialize(FILE *fd, const struct file_entry *e) {
+        assert(fd != NULL);
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+
+        // First byte we write is a flag-byte to indicate this is a valid record
+        if( fwrite(&e->flag, 1, 1, fd) != 1 ) {
+                DEBUGF("file_entry_serialize: failed to write flag-byte\n");
+                return ERR_FILE;
+        }
+
+        // First we write the length of the name field
+        if( fwrite(&e->size.name_len, sizeof(e->size.name_len), 1, fd) != 1 ) {
+                DEBUGF("file_entry_serialize: failed to write name_len\n");
+                return ERR_FILE;
+        }
+        // now the name field itself
+        if( fwrite(e->name, 1, e->size.name_len, fd) != e->size.name_len ) {
+                DEBUGF("file_entry_serialize: failed to write name\n");
+                return ERR_FILE;
+        }
+
+        // hash field
+        if( fwrite(&e->hash, sizeof(e->hash), 1, fd) != 1 ) {
+                DEBUGF("file_entry_serialize: failed to write hash\n");
+                return ERR_FILE;
+        }
+
+        // song field
+        if( fwrite(&e->song, sizeof(e->song), 1, fd) != 1 ) {
+                DEBUGF("file_entry_serialize: failed to write song\n");
+                return ERR_FILE;
+        }
+        
+        // rundb field
+        if( fwrite(&e->rundb, sizeof(e->rundb), 1, fd) != 1 ) {
+                DEBUGF("file_entry_serialize: failed to write rundb\n");
+                return ERR_FILE;
+        }
+
+        return ERR_NONE;
+}
+
+int file_entry_unserialize(struct file_entry **dest, FILE *fd) {
+        uint32_t length;
+        struct file_entry *e;
+
+        assert(dest != NULL);
+        assert(fd != NULL);
+
+        // Allocate memory
+        e = new_file_entry(0);
+        if( e == NULL ) {
+                DEBUGF("file_entry_unserialize: could not create new file_entry\n");
+                return ERR_MALLOC;
+        }
+        
+        // First we read the length of the name field
+        if( fread(&length, sizeof(length), 1, fd) != 1 ) {
+                DEBUGF("file_entry_unserialize: failed to read name_len\n");
+                file_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        // allocate memory for the upcomming name-field
+        if( do_resize(e, length, 0) ) {
+                DEBUGF("file_entry_unserialize: failed to allocate memory for name\n");
+                file_entry_destruct(e);
+                return ERR_MALLOC;
+        }
+
+        // read it in
+        if( fread(e->name, 1, e->size.name_len, fd) != e->size.name_len ) {
+                DEBUGF("file_entry_unserialize: failed to read name\n");
+                file_entry_destruct(e);
+                return ERR_FILE;
+        }
+        
+        // hash field
+        if( fread(&e->hash, sizeof(e->hash), 1, fd) != 1 ) {
+                DEBUGF("file_entry_unserialize: failed to read hash\n");
+                file_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        // song field
+        if( fread(&e->song, sizeof(e->song), 1, fd) != 1 ) {
+                DEBUGF("file_entry_unserialize: failed to read song\n");
+                file_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        // rundb field
+        if( fread(&e->rundb, sizeof(e->rundb), 1, fd) != 1 ) {
+                DEBUGF("file_entry_unserialize: failed to read rundb\n");
+                file_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        *dest = e;
+        return ERR_NONE;
+}
+
+int file_entry_write(FILE *fd, struct file_entry *e, struct file_size *s) {
+        uint32_t be32;
+        char pad = 0x00;
+
+        assert(fd != NULL);
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+
+        // file name
+        if( fwrite(e->name, 1, e->size.name_len, fd) != e->size.name_len ) {
+                DEBUGF("file_entry_write: failed to write name\n");
+                return ERR_FILE;
+        }
+        // pad the rest
+        be32 = e->size.name_len; // abuse be32 as counter
+        while( s != NULL && s->name_len > be32) {
+                if( fwrite(&pad, 1, 1, fd) == 1 ) {
+                        be32++;
+                } else {
+                        DEBUGF("file_entry_write: failed to pad name\n");
+                        return ERR_FILE;
+                }
+        }
+
+        // hash
+        be32 = BE32(e->hash);
+        if( fwrite(&be32, sizeof(be32), 1, fd) != 1 ) {
+                DEBUGF("file_entry_write: failed to write hash\n");
+                return ERR_FILE;
+        }
+
+        // song
+        be32 = BE32(e->song);
+        if( fwrite(&be32, sizeof(be32), 1, fd) != 1 ) {
+                DEBUGF("file_entry_write: failed to write song\n");
+                return ERR_FILE;
+        }
+
+        // rundb
+        be32 = BE32(e->rundb);
+        if( fwrite(&be32, sizeof(be32), 1, fd) != 1 ) {
+                DEBUGF("file_entry_write: failed to write rundb\n");
+                return ERR_FILE;
+        }
+
+        return ERR_NONE;
+}
+
+inline int file_entry_compare(const struct file_entry *a, const struct file_entry *b) {
+        assert(a != NULL);
+        assert(b != NULL);
+        return strncasecmp(a->name, b->name, (a->size.name_len <= b->size.name_len ? a->size.name_len : b->size.name_len) );
+}
+
+struct file_size* new_file_size() {
+        struct file_size *s;
+        s = (struct file_size*)malloc(sizeof(struct file_size));
+        if( s == NULL ) {
+                DEBUGF("new_file_size: failed to allocate memory\n");
+                return NULL;
+        }
+        s->name_len = 0;
+        
+        return s;
+}
+
+inline uint32_t file_size_get_length(const struct file_size *size) {
+        assert(size != NULL);
+        return size->name_len + 12;
+}
+
+inline int file_size_max(struct file_size *s, const struct file_entry *e) {
+        assert(s != NULL);
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        s->name_len   = ( s->name_len   >= e->size.name_len   ? s->name_len   : e->size.name_len );
+        return ERR_NONE;
+}
+
+int file_size_destruct(struct file_size *s) {
+        assert(s != NULL);
+        // nothing to do...
+        free(s);
+        return ERR_NONE;
+}
diff --git a/apps/tagdb/file.h b/apps/tagdb/file.h
new file mode 100644
index 0000000000..d2538a7569
--- /dev/null
+++ b/apps/tagdb/file.h
@@ -0,0 +1,84 @@
+#ifndef __FILE_H__
+#define __FILE_H__
+
+#include "config.h"
+#include <stdio.h>
+#include <stdint.h>
+
+struct file_entry {
+        char* name;             // song name
+        
+        uint32_t hash;
+        uint32_t song;          // pointer to song
+        uint32_t rundb;         // pointer to rundb
+
+        struct file_size {
+                uint32_t name_len;      // must be mulitple of 4
+        } size;
+        unsigned char flag;     // flags
+};
+
+struct file_entry* new_file_entry(const uint32_t name_len);
+/* Creates a new file_entry with the specified sizes
+ * Returns a pointer to the structure on success,
+ * NULL on failure
+ */
+
+int file_entry_destruct(struct file_entry *e);
+/* Destructs the given file_entry and free()'s it's memory
+ * returns 0 on success, 1 on failure
+ */
+
+inline int file_entry_resize(struct file_entry *e, const uint32_t name_len);
+/* Change the size of the entry
+ * returns 0 on succes, 1 on failure
+ */
+
+int file_entry_serialize(FILE *fd, const struct file_entry *e);
+/* Serializes the entry in the file at the current position
+ * returns 0 on success, 1 on failure
+ */
+
+int file_entry_unserialize(struct file_entry* *e, FILE *fd);
+/* Unserializes an entry from file into a new structure
+ * The address of the structure is saved into *e
+ * returns 0 on success
+ *         1 on malloc() failure
+ *         2 on fread() failure
+ */
+
+int file_entry_write(FILE *fd, struct file_entry *e, struct file_size *s);
+/* Writes the entry to file in the final form
+ * returns 0 (0) on success, 1 (1) on failure
+ */
+
+inline int file_entry_compare(const struct file_entry *a, const struct file_entry *b);
+/* Compares 2 entries
+ * When a < b it returns <0
+ *      a = b             0
+ *      a > b            >0
+ */
+
+struct file_size* new_file_size();
+/* Creates a new size structure
+ * returns a pointer to the structure on success,
+ * NULL on failure
+ */
+
+inline uint32_t file_size_get_length(const struct file_size *size);
+/* Calculates the length of the entry when written by file_entry_write()
+ * returns the length on success, 0xffffffff on failure
+ */
+
+inline int file_size_max(struct file_size *s, const struct file_entry *e);
+/* Updates the file_size structure to contain the maximal lengths of either
+ * the original entry in s, or the entry e
+ * returns 0 on success, 1 on failure
+ */
+
+int file_size_destruct(struct file_size *s);
+/* destructs the file_size structure
+ * returns 0 on success, 1 on failure
+ */
+
+#endif
diff --git a/apps/tagdb/header.c b/apps/tagdb/header.c
new file mode 100644
index 0000000000..01f973824b
--- /dev/null
+++ b/apps/tagdb/header.c
@@ -0,0 +1,121 @@
+
+#include <stdio.h>
+
+#include "header.h"
+
+int header_write(FILE *fd, const struct header *h) {
+// Write the header to file
+        uint32_t be;
+        
+        if( fwrite(h->magic, 3, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write magic[3]\n");
+                return ERR_FILE;
+        }
+        if( fwrite(&h->version, 1, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write version\n");
+                return ERR_FILE;
+        }
+        
+        be = BE32(h->artist_start);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write artist_start\n");
+                return ERR_FILE;
+        }
+        
+        be = BE32(h->album_start);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write album_start\n");
+                return ERR_FILE;
+        }
+        
+        be = BE32(h->song_start);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write song_start\n");
+                return ERR_FILE;
+        }
+        
+        be = BE32(h->file_start);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write file_start\n");
+                return ERR_FILE;
+        }
+        
+        
+        be = BE32(h->artist_count);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write artist_count\n");
+                return ERR_FILE;
+        }
+        
+        be = BE32(h->album_count);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write album_count\n");
+                return ERR_FILE;
+        }
+        
+        be = BE32(h->song_count);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write song_count\n");
+                return ERR_FILE;
+        }
+        
+        be = BE32(h->file_count);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write file_count\n");
+                return ERR_FILE;
+        }
+        
+        
+        be = BE32(h->artist_len);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write artist_len\n");
+                return ERR_FILE;
+        }
+        
+        be = BE32(h->album_len);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write album_len\n");
+                return ERR_FILE;
+        }
+        
+        be = BE32(h->song_len);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write song_len\n");
+                return ERR_FILE;
+        }
+        
+        be = BE32(h->genre_len);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write genre_len\n");
+                return ERR_FILE;
+        }
+        
+        be = BE32(h->file_len);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write file_len\n");
+                return ERR_FILE;
+        }
+
+                
+        be = BE32(h->song_array_count);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write song_array_count\n");
+                return ERR_FILE;
+        }
+        
+        be = BE32(h->album_array_count);
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write album_array_count\n");
+                return ERR_FILE;
+        }
+        
+        
+        be = BE32( (h->flags.reserved << 1) | (h->flags.rundb_dirty) );
+        if( fwrite(&be, 4, 1, fd) != 1 ) {
+                DEBUGF("header_write: failed to write flags\n");
+                return ERR_FILE;
+        }
+        
+        
+        return ERR_NONE;
+}
diff --git a/apps/tagdb/header.h b/apps/tagdb/header.h
new file mode 100644
index 0000000000..08a563ec72
--- /dev/null
+++ b/apps/tagdb/header.h
@@ -0,0 +1,39 @@
+#ifndef __HEADER_H__
+#define __HEADER_H__
+
+#include "config.h"
+
+#define HEADER_SIZE 68
+
+struct header {
+        char magic[3];                  // (four bytes: 'R' 'D' 'B' and a byte for version. This is version 2. (0x02)
+        unsigned char version;
+        
+        uint32_t artist_start;  // File Offset to the artist table(starting from 0)
+        uint32_t album_start;   // File Offset to the album table(starting from 0)
+        uint32_t song_start;            // File Offset of the song table(starting from 0)
+        uint32_t file_start;            // File Offset to the filename table(starting from 0)
+
+        uint32_t artist_count;  // Number of artists
+        uint32_t album_count;   // Number of albums
+        uint32_t song_count;            // Number of songs
+        uint32_t file_count;            // Number of File Entries, this is needed for the binary search.
+
+        uint32_t artist_len;            // Max Length of the artist name field
+        uint32_t album_len;             // Max Length of the album name field
+        uint32_t song_len;              // Max Length of the song name field
+        uint32_t genre_len;             // Max Length of the genre field
+        uint32_t file_len;              // Max Length of the filename field.
+
+        uint32_t song_array_count;      // Number of entries in songs-per-album array
+        uint32_t album_array_count;     // Number of entries in albums-per-artist array
+
+        struct {
+                unsigned reserved : 31;         // must be 0
+                unsigned rundb_dirty : 1;       // if the TagDatabase in unsynchronized with the RuntimeDatabase, 0 if synchronized.
+        } flags;
+};
+
+int header_write(FILE *fd, const struct header *header);
+
+#endif
diff --git a/apps/tagdb/main.c b/apps/tagdb/main.c
new file mode 100644
index 0000000000..61a0330c81
--- /dev/null
+++ b/apps/tagdb/main.c
@@ -0,0 +1,115 @@
+#include "config.h"
+
+#include <stdio.h>
+#include <string.h>     // strcmp()
+#include <dirent.h>     // opendir() readdir() closedir()
+#include <sys/stat.h>   // IS_DIR
+
+#include "malloc.h"
+#include "db.h"
+
+extern int out_of_memory;
+
+// dir-is-album: all files in the dir ARE the same album, use the first name found.
+// dir-is-album-name: if no tag found, use the dir's instead of "<no album tag>"
+//
+// files in different dirs are ALWAYS different albums
+
+static char* strip_path = NULL;
+static char* add_path = NULL;
+
+static int iterate_dir(char* dir);
+/* Iterates over each item in the given directory
+ * calls add_file() on each file
+ * calls iterate_directory() on each directory (recursively)
+ */
+
+static int iterate_dir(char* dir) {
+        DIR *d;
+        struct dirent *e;
+        struct stat s;
+        int rc;
+
+        assert(dir != NULL);
+
+        if(!( d = opendir(dir) )) {
+                DEBUGF("iterate_dir: could not open directory \"%s\"\n", dir);
+                return ERR_FILE;
+        }
+
+        while(( e = readdir(d) )) {
+                char *path;
+
+                if( strcmp(e->d_name, ".") == 0 || strcmp(e->d_name, "..") == 0 )
+                        continue; // we don't want to descend or loop around...
+
+                path = malloc(strlen(dir) + 1 + strlen(e->d_name) + 1); // "dir/d_name\0"
+                if( path == NULL ) {
+                        DEBUGF("iterate_dir: could not malloc() directory-entry-name\n");
+                        return ERR_MALLOC;
+                }
+                strcpy(path, dir);
+                strcat(path, "/");
+                strcat(path, e->d_name);
+#if defined OS_LINUX
+                if( stat(path, &s) ) {
+                        DEBUGF("iterate_dir: could not stat(\"%s\")\n", path);
+                        return ERR_FILE;
+                }
+                
+                if( S_ISDIR(s.st_mode) ) {
+#elif defined OS_ROCKBOX
+#error "Rockbox: not yet implemented: don't know how to list directory"
+                if( false ) {
+#elif defined OS_WINDOWS
+                if( false ) {
+#error "Windows: not yet implemented: don't know how to list directory"
+#else
+                if( false ) {
+#error "No OS specified: don't know how to list directory"
+#endif
+                        if(( rc = iterate_dir(path) )) {
+                                closedir(d);
+                                return rc;
+                        }
+                } else {
+                        if(( rc = db_add(path, strip_path, add_path) )) {
+                                closedir(d);
+                                return rc;
+                        }
+                }
+                free(path);
+        }
+
+        if( closedir(d) ) {
+                DEBUGF("iterate_dir: could not close directory \"%s\", ignoring...\n", dir);
+        }
+
+        return ERR_NONE;
+}
+
+int main(int argc, char* argv[]) {
+        FILE *fd;
+        
+        if( argc != 2 ) {
+                printf("usage: ./songdb dir\n");
+                return 1;
+        }
+
+        strip_path = "/home/niels/";
+        add_path   = "TEST/";
+
+        db_construct();
+
+        iterate_dir(argv[1]);
+        
+        fd = fopen("xxx.db", "w");
+        db_write(fd);
+        fclose(fd);
+
+        db_destruct();
+
+        malloc_stats();
+        
+        return 0;
+}
diff --git a/apps/tagdb/malloc.c b/apps/tagdb/malloc.c
new file mode 100644
index 0000000000..78d24f9d4e
--- /dev/null
+++ b/apps/tagdb/malloc.c
@@ -0,0 +1,131 @@
+#include "config.h"
+#include "malloc.h"
+
+#undef malloc
+#undef free
+#undef realloc
+
+#undef DEBUGF
+#define DEBUGF(...)
+
+#include <stdio.h>
+#include <stdlib.h>
+
+static size_t total=0;
+static size_t max_total=0;
+
+struct size_array {
+        void *ptr;
+        size_t size;
+} sizes[1000];
+#define NOT_FOUND 1001
+static unsigned long count=0;
+
+int out_of_memory = 1000000;
+
+void *do_malloc(size_t size) {
+        void *ret;
+        if(total + size > out_of_memory) {
+                DEBUGF("malloc(%d), total=%d: FAILED: simulating out-of-memory\n", size, total+size);
+                return NULL;
+        }
+        
+        ret = malloc(size);
+        if( ret == NULL ) {
+                DEBUGF("malloc(%d), total=%d FAILED\n", size, total+size);
+                return NULL;
+        } else {
+                total += size;
+                max_total = ( total > max_total ? total : max_total );
+                sizes[count].ptr = ret;
+                sizes[count].size = size;
+                DEBUGF("malloc(%d), total=%d OK => 0x%08lx (%lu)\n", size, total, (unsigned long)ret, count);
+                count++;
+                if(count == NOT_FOUND) {
+                        fprintf(stderr, "MALLOC MEMORY FULL!!!!!!! FAILING\n");
+                        free(ret);
+                        count--;
+                        return NULL;
+                }
+                return ret;
+        }
+}
+
+static unsigned long find(void* ptr) {
+        unsigned long i;
+        for(i=0; i<count; i++) {
+                if( ptr == sizes[i].ptr ) {
+                        return i;
+                }
+        }
+        return NOT_FOUND;
+}
+
+void do_free(void *ptr) {
+        unsigned long i;
+
+        i = find(ptr);
+        if( i == NOT_FOUND ) {
+                DEBUGF("free(%08lx) (?) ptr unknown\n", (unsigned long)ptr);
+                free(ptr);
+        } else {
+                total -= sizes[i].size;
+                DEBUGF("free(%08lx) (%lu, %dbytes) => total=%u\n", (unsigned long)ptr, i, sizes[i].size, total);
+                free(ptr);
+                sizes[i].ptr = NULL; // delete
+                sizes[i].size = 0;
+        }
+}
+
+void *do_realloc(void *ptr, size_t size) {
+        void *ret;
+        unsigned long i;
+        
+        if( ptr == NULL ) {
+                DEBUGF("realloc()=>");
+                return do_malloc(size);
+        }
+        
+        i = find(ptr);
+
+        if( i == NOT_FOUND ) {
+                DEBUGF("realloc(%08lx, %d) (?) ptr unknown ", (unsigned long)ptr, size);
+        } else {
+                DEBUGF("realloc(%08lx, %d) (%lu, %dbytes) => total=%d ", (unsigned long)ptr, size, i, sizes[i].size, total+size-sizes[i].size);
+        }
+        
+        if(total + size - sizes[i].size > out_of_memory) {
+                DEBUGF("FAILED: simulating out-of-memory\n");
+                return NULL;
+        }
+        
+        ret = realloc(ptr, size);
+        if( ret == NULL && size != 0) { // realloc(x, 0) returns NULL, but is valid!
+                DEBUGF("FAILED\n");
+        } else {
+                total += size - sizes[i].size;
+                max_total = ( total > max_total ? total : max_total );
+                sizes[i].ptr = ret;     // update the ptr if realloc changed it
+                sizes[i].size = size;
+                DEBUGF("=> %08lx\n", (unsigned long)ret);
+        }
+        return ret;
+}
+
+void malloc_stats() {
+        unsigned long i, j;
+        
+        printf("malloc stats:\n");
+        printf("  Total number of allocated items:    %lu\n", count);
+        printf("  Current number of allocated items:  ");
+        j=0;
+        for(i=0; i<count; i++) {
+                if( sizes[i].ptr != NULL) {
+                        printf("%lu ", i);
+                        j++;
+                }
+        }
+        printf("=> %lu items\n", j);
+        printf("  Maximum amount of allocated memory: %dbytes\n", max_total);
+        printf("  Current amount of allocated memory: %dbytes\n", total);
+}
diff --git a/apps/tagdb/malloc.h b/apps/tagdb/malloc.h
new file mode 100644
index 0000000000..c8c885bf6f
--- /dev/null
+++ b/apps/tagdb/malloc.h
@@ -0,0 +1,16 @@
+#ifndef __MALLOC_H__
+#define __MALLOC_H__
+
+#include <stdlib.h>
+
+#define malloc do_malloc
+#define free do_free
+#define realloc do_realloc
+
+void *do_malloc(size_t size);
+void do_free(void *ptr);
+void *do_realloc(void *ptr, size_t size);
+
+void malloc_stats();
+
+#endif
diff --git a/apps/tagdb/parser.c b/apps/tagdb/parser.c
new file mode 100644
index 0000000000..1d251dcbe3
--- /dev/null
+++ b/apps/tagdb/parser.c
@@ -0,0 +1,218 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "config.h"
+
+int errno;
+
+int read_failure(FILE *fd) {
+        fprintf(stderr, "Could not read from file: errno: %u ", errno);
+        if( feof(fd) ) fprintf(stderr, "EOF");
+        fprintf(stderr, "\n");
+        return 1;
+}
+
+int mem_failure() {
+        fprintf(stderr, "Could not (re)allocate memory\n");
+        return 1;
+}
+
+int main(int argc, char *argv[]) {
+        FILE *fd;
+        uint32_t artist_start, album_start, song_start, file_start;
+        uint32_t artist_count, album_count, song_count, file_count;
+        uint32_t artist_len, album_array_count;
+        uint32_t album_len, song_array_count;
+        uint32_t song_len, genre_len;
+        uint32_t file_len;
+#define header_start 0
+#define header_len 68
+
+        uint32_t i, j;
+        char *ct1 = NULL, *ct2 = NULL;  // char temp 1 and 2
+        uint32_t it = 0;                // integer temp
+
+        // input validation
+        if( argc != 2 ) {
+                fprintf(stderr, "usage: parser dbfile\n");
+                return 1;
+        }
+
+        // open file
+        fd = fopen(argv[1], "r");
+        if( fd == NULL ) {
+                fprintf(stderr, "Could not open file \"%s\"\n", argv[1]);
+                return 1;
+        }
+        
+        // read the header
+        ct1 = realloc(ct1, 4); if( ct1 == NULL ) return mem_failure();
+        if( fread(ct1, 4, 1, fd) != 1 ) return read_failure(fd);
+        if( ct1[0] != 'R' || ct1[1] != 'D' || ct1[2] != 'B' ) {
+                printf("No header found\n");
+                return 1;
+        }
+        if( ct1[3] != 0x03 ) {
+                printf("Not version 3\n");
+                return 1;
+        }
+
+        if( fread(&artist_start, 4, 1, fd) != 1 ) return read_failure(fd); artist_start = BE32(artist_start);
+        if( fread(&album_start, 4, 1, fd) != 1 ) return read_failure(fd); album_start = BE32(album_start);
+        if( fread(&song_start, 4, 1, fd) != 1 ) return read_failure(fd); song_start = BE32(song_start);
+        if( fread(&file_start, 4, 1, fd) != 1 ) return read_failure(fd); file_start = BE32(file_start);
+        
+        if( fread(&artist_count, 4, 1, fd) != 1 ) return read_failure(fd); artist_count = BE32(artist_count);
+        if( fread(&album_count, 4, 1, fd) != 1 ) return read_failure(fd); album_count = BE32(album_count);
+        if( fread(&song_count, 4, 1, fd) != 1 ) return read_failure(fd); song_count = BE32(song_count);
+        if( fread(&file_count, 4, 1, fd) != 1 ) return read_failure(fd); file_count = BE32(file_count);
+
+        if( fread(&artist_len, 4, 1, fd) != 1 ) return read_failure(fd); artist_len = BE32(artist_len);
+        if( fread(&album_len, 4, 1, fd) != 1 ) return read_failure(fd); album_len = BE32(album_len);
+        if( fread(&song_len, 4, 1, fd) != 1 ) return read_failure(fd); song_len = BE32(song_len);
+        if( fread(&genre_len, 4, 1, fd) != 1 ) return read_failure(fd); genre_len = BE32(genre_len);
+        if( fread(&file_len, 4, 1, fd) != 1 ) return read_failure(fd); file_len = BE32(file_len);
+
+        if( fread(&song_array_count, 4, 1, fd) != 1 ) return read_failure(fd); song_array_count = BE32(song_array_count);
+        if( fread(&album_array_count, 4, 1, fd) != 1 ) return read_failure(fd); album_array_count = BE32(album_array_count);
+
+        if( fread(ct1, 4, 1, fd) != 1 ) return read_failure(fd);
+
+        // print header info
+        printf("HEADER");
+        printf("\n  Artist start:  0x%08x = %u", artist_start, artist_start);
+        if( artist_start != header_start + header_len )
+                printf(" should be 0x%08x = %u", header_start + header_len, header_start + header_len);
+        printf("\n  Album  start:  0x%08x = %u", album_start, album_start);
+        if( album_start != artist_start + artist_count*(artist_len + 4*album_array_count) )
+                printf(" should be 0x%08x = %u", artist_start + artist_count*(artist_len + 4*album_array_count),
+                                                 artist_start + artist_count*(artist_len + 4*album_array_count));
+        printf("\n  Song   start:  0x%08x = %u", song_start, song_start);
+        if( song_start != album_start + album_count*(album_len + 4 + 4*song_array_count) )
+                printf(" should be 0x%08x = %u", album_start + album_count*(album_len + 4 + 4*song_array_count),
+                                                 album_start + album_count*(album_len + 4 + 4*song_array_count));
+        printf("\n  File   start:  0x%08x = %u", file_start, file_start);
+        if( file_start != song_start + song_count*(song_len + genre_len + 24) )
+                printf(" should be 0x%08x = %u", song_start + song_count*(song_len + genre_len + 24),
+                                                 song_start + song_count*(song_len + genre_len + 24));
+        
+        printf("\n  Artist count:  0x%08x = %u\n", artist_count, artist_count);
+        printf("  Album  count:  0x%08x = %u\n", album_count, album_count);
+        printf("  Song   count:  0x%08x = %u\n", song_count, song_count);
+        printf("  File   count:  0x%08x = %u\n", file_count, file_count);
+        
+        printf("  Artist len:    0x%08x = %u\n", artist_len, artist_len);
+        printf("  Album  len:    0x%08x = %u\n", album_len, album_len);
+        printf("  Song   len:    0x%08x = %u\n", song_len, song_len);
+        printf("  Genre  len:    0x%08x = %u\n", genre_len, genre_len);
+        printf("  File   len:    0x%08x = %u\n", file_len, file_len);
+        
+        printf("  Song[]  count: 0x%08x = %u\n", song_array_count, song_array_count);
+        printf("  Album[] count: 0x%08x = %u\n", album_array_count, album_array_count);
+        
+        printf("  Reserved:      0x%08x\n", ct1[0] & 0xFFFFFFFE);
+        printf("  Rundb dirty:   0x%01x\n", ct1[3] & 0x01);
+
+        // iterate over artists:
+        ct1 = realloc(ct1, artist_len); if( ct1 == NULL && artist_count!=0 ) return mem_failure();
+        for(i=0; i < artist_count; i++) {
+                printf("ARTIST %u/%u (offset 0x%08lx)\n", i, artist_count, (unsigned long)ftell(fd));
+                
+                if( fread(ct1, artist_len, 1, fd) != 1 ) return read_failure(fd);
+                printf("  Name: \"%s\"\n", ct1);
+
+                printf("  Albums:\n");
+                for(j=0; j < album_array_count; j++) {
+                        if( fread(&it, 4, 1, fd) != 1 ) return read_failure(fd); it = BE32(it);
+                        printf("    Offset 0x%08x = ", it);
+                        if(it != 0) {
+                                printf("item %u\n", (it - album_start) / (album_len + 4 + 4*song_array_count));
+                        } else {
+                                printf("padding\n");
+                        }
+                }
+        }
+        
+        // iterate over albums:
+        ct1 = realloc(ct1, album_len); if( ct1 == NULL && album_count!=0) return mem_failure();
+        for(i=0; i < album_count; i++) {
+                printf("ALBUM %u/%u (offset 0x%08lx)\n", i, album_count, (unsigned long)ftell(fd));
+                
+                if( fread(ct1, album_len, 1, fd) != 1 ) return read_failure(fd);
+                printf("  Name:          \"%s\"\n", ct1);
+
+                if( fread(&it, 4, 1, fd) != 1 ) return read_failure(fd); it = BE32(it);
+                printf("  Artist offset: 0x%08x = item %u\n", it, (it - artist_start) / (artist_len + 4*album_array_count));
+
+                printf("  Songs:\n");
+                for(j=0; j < song_array_count; j++) {
+                        if( fread(&it, 4, 1, fd) != 1 ) return read_failure(fd); it = BE32(it);
+                        printf("    Offset 0x%08x = ", it);
+                        if(it != 0) {
+                                printf("item %u\n", (it - song_start) / (song_len + genre_len + 24));
+                        } else {
+                                printf("padding\n");
+                        }
+                }
+        }
+
+        // iterate over songs:
+        ct1 = realloc(ct1, song_len); if( ct1 == NULL && song_count!=0) return mem_failure();
+        ct2 = realloc(ct2, genre_len); if( ct2 == NULL && song_count!=0) return mem_failure();
+        for(i=0; i < song_count; i++) {
+                printf("SONG %u/%u (offset 0x%08lx)\n", i, song_count, (unsigned long)ftell(fd));
+
+                if( fread(ct1, song_len, 1, fd) != 1 ) return read_failure(fd);
+                printf("  Name:          \"%s\"\n", ct1);
+                
+                if( fread(&it, 4, 1, fd) != 1 ) return read_failure(fd); it = BE32(it);
+                printf("  Artist offset: 0x%08x = item %u\n", it, (it - artist_start) / (artist_len + 4*album_array_count));
+                
+                if( fread(&it, 4, 1, fd) != 1 ) return read_failure(fd); it = BE32(it);
+                printf("  Album offset:  0x%08x = item %u\n", it, (it - album_start) / (album_len + 4 + 4*song_array_count));
+                
+                if( fread(&it, 4, 1, fd) != 1 ) return read_failure(fd); it = BE32(it);
+                printf("  File offset:   0x%08x = item %u\n", it, (it - file_start) / (file_len + 12));
+                
+                if( fread(ct2, genre_len, 1, fd) != 1 ) return read_failure(fd);
+                printf("  Genre:         \"%s\"\n", ct2);
+                
+                if( fread(&it, 4, 1, fd) != 1 ) return read_failure(fd); it = BE32(it);
+                printf("  Bitrate:       0x%04x = %u\n", (it & 0xFFFF0000) >> 16, (it & 0xFFFF0000) >> 16);
+                printf("  Year:          0x%04x = %u\n", it & 0x0000FFFF, it & 0x0000FFFF);
+                
+                if( fread(&it, 4, 1, fd) != 1 ) return read_failure(fd); it = BE32(it);
+                printf("  Playtime:      0x%08x = %u\n", it, it);
+                
+                if( fread(&it, 4, 1, fd) != 1 ) return read_failure(fd); it = BE32(it);
+                printf("  Track:         0x%04x = %u\n", (it & 0xFFFF0000) >> 16, (it & 0xFFFF0000) >> 16);
+                printf("  Samplerate:    0x%04x = %u\n", it & 0x0000FFFF, it & 0x0000FFFF);
+        }
+
+        // iterate over file:
+        ct1 = realloc(ct1, file_len); if( ct1 == NULL && file_count!=0) return mem_failure();
+        for(i=0; i < file_count; i++) {
+                printf("FILE %u/%u (offset 0x%08lx)\n", i, file_count, (unsigned long)ftell(fd));
+
+                if( fread(ct1, file_len, 1, fd) != 1 ) return read_failure(fd);
+                printf("  Name:         \"%s\"\n", ct1);
+
+                if( fread(&it, 4, 1, fd) != 1 ) return read_failure(fd); it = BE32(it);
+                printf("  Hash:         0x%08x = %u\n", it, it);
+                
+                if( fread(&it, 4, 1, fd) != 1 ) return read_failure(fd); it = BE32(it);
+                printf("  Song offset:  0x%08x = item %u\n", it, (it - song_start) / (song_len + genre_len + 24));
+
+                if( fread(&it, 4, 1, fd) != 1 ) return read_failure(fd); it = BE32(it);
+                printf("  Rundb offset: 0x%08x = %u\n", it, it);
+        }
+        
+        // close the file
+        if( fclose(fd) != 0 ) {
+                fprintf(stderr, "Could not close file\n");
+                return 1;
+        }
+        
+        return 0;
+}
diff --git a/apps/tagdb/song.c b/apps/tagdb/song.c
new file mode 100644
index 0000000000..16ae385eda
--- /dev/null
+++ b/apps/tagdb/song.c
@@ -0,0 +1,450 @@
+#include "malloc.h" // realloc() and free()
+#include <string.h> // strncasecmp()
+
+#include "song.h"
+
+// how is our flag organized?
+#define FLAG ( 0xCF )
+#define FLAG_VALID(flag) (flag == 0xCF)
+
+static int do_resize(struct song_entry *e, const uint32_t name_len, const uint32_t genre_len, const int zero_fill);
+
+struct song_entry* new_song_entry(const uint32_t name_len, const uint32_t genre_len) {
+        // Start my allocating memory
+        struct song_entry *e = (struct song_entry*)malloc(sizeof(struct song_entry));
+        if( e == NULL ) {
+                DEBUGF("new_song_entry: could not allocate memory\n");
+                return NULL;
+        }
+        
+        // We begin empty
+        e->name = NULL;
+        e->size.name_len = 0;
+        
+        e->artist = 0;
+        e->album = 0;
+        e->file = 0;
+        
+        e->genre = NULL;
+        e->size.genre_len = 0;
+
+        e->bitrate = 0;
+        e->year = 0;
+        e->playtime = 0;
+        e->track = 0;
+        e->samplerate = 0;
+
+        e->flag = FLAG;
+
+        // and resize to the requested size
+        if( do_resize(e, name_len, genre_len, 1) ) {
+                free(e);
+                return NULL;
+        }
+        return e;
+}
+
+int song_entry_destruct(struct song_entry *e) {
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+
+        free(e->name);
+        free(e->genre);
+
+        free(e);
+        
+        return ERR_NONE;
+}
+
+static int do_resize(struct song_entry *e, const uint32_t name_len, const uint32_t genre_len, const int zero_fill) {
+        void* temp;
+
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        
+        // begin with name
+        if( name_len != e->size.name_len ) {
+                temp = realloc(e->name, name_len);
+                if(temp == NULL && name_len > 0) {       // if realloc(,0) don't complain about NULL-pointer
+                        DEBUGF("song_entry_resize: out of memory to resize name\n");
+                        return ERR_MALLOC;
+                }
+                e->name = (char*)temp;
+                
+                // if asked, fill it with zero's
+                if( zero_fill ) {
+                        uint32_t i;
+                        for(i=e->size.name_len; i<name_len; i++)
+                                e->name[i] = (char)0x00;
+                }
+                
+                e->size.name_len = name_len;
+        }
+        
+        // now the genre
+        if( genre_len != e->size.genre_len ) {
+                temp = realloc(e->genre, genre_len);
+                if(temp == NULL && genre_len > 0) {      // if realloc(,0) don't complain about NULL-pointer
+                        DEBUGF("song_entry_resize: out of memory to resize genre\n");
+                        return ERR_MALLOC;
+                }
+                e->genre = (char*)temp;
+                 
+                // if asked, fill it with zero's
+                if( zero_fill ) {
+                        uint32_t i;
+                        for(i=e->size.genre_len; i<genre_len; i++)
+                                e->genre[i] = (char)0x00;
+                }
+                
+                e->size.genre_len = genre_len;
+        }
+
+        return ERR_NONE;
+}
+
+inline int song_entry_resize(struct song_entry *e, const uint32_t name_len, const uint32_t genre_len) { 
+        return do_resize(e, name_len, genre_len, 1);
+}
+
+int song_entry_serialize(FILE *fd, const struct song_entry *e) {
+        assert(fd != NULL);
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+
+        // First byte we write is a flag-byte to indicate this is a valid record
+        if( fwrite(&e->flag, 1, 1, fd) != 1 ) {
+                DEBUGF("song_entry_serialize: failed to write flag-byte\n");
+                return ERR_FILE;
+        }
+        
+        // Write the length of the name field
+        if( fwrite(&e->size.name_len, sizeof(e->size.name_len), 1, fd) != 1 ) {
+                DEBUGF("song_entry_serialize: failed to write name_len\n");
+                return ERR_FILE;
+        }
+
+        // now the name field itself
+        if( fwrite(e->name, 1, e->size.name_len, fd) != e->size.name_len ) {
+                DEBUGF("song_entry_serialize: failed to write name\n");
+                return ERR_FILE;
+        }
+
+        // Artist field
+        if( fwrite(&e->artist, sizeof(e->artist), 1, fd) != 1 ) {
+                DEBUGF("song_entry_serialize: failed to write artist\n");
+                return ERR_FILE;
+        }
+
+        // Album field
+        if( fwrite(&e->album, sizeof(e->album), 1, fd) != 1 ) {
+                DEBUGF("song_entry_serialize: failed to write album\n");
+                return ERR_FILE;
+        }
+        
+        // File field
+        if( fwrite(&e->file, sizeof(e->file), 1, fd) != 1 ) {
+                DEBUGF("song_entry_serialize: failed to write file\n");
+                return ERR_FILE;
+        }
+
+        // length of genre field
+        if( fwrite(&e->size.genre_len, sizeof(e->size.genre_len), 1, fd) != 1 ) {
+                DEBUGF("song_entry_serialize: failed to write genre_len\n");
+                return ERR_FILE;
+        }
+
+        // genre itself
+        if( fwrite(e->genre, 1, e->size.genre_len, fd) != e->size.genre_len ) {
+                DEBUGF("song_entry_serialize: failed to write genre\n");
+                return ERR_FILE;
+        }
+
+        // Bitrate field
+        if( fwrite(&e->bitrate, sizeof(e->bitrate), 1, fd) != 1 ) {
+                DEBUGF("song_entry_serialize: failed to write bitrate\n");
+                return ERR_FILE;
+        }
+
+        // Year field
+        if( fwrite(&e->year, sizeof(e->year), 1, fd) != 1 ) {
+                DEBUGF("song_entry_serialize: failed to write year\n");
+                return ERR_FILE;
+        }
+
+        // Playtime field
+        if( fwrite(&e->playtime, sizeof(e->playtime), 1, fd) != 1 ) {
+                DEBUGF("song_entry_serialize: failed to write playtime\n");
+                return ERR_FILE;
+        }
+
+        // Track field
+        if( fwrite(&e->track, sizeof(e->track), 1, fd) != 1 ) {
+                DEBUGF("song_entry_serialize: failed to write track\n");
+                return ERR_FILE;
+        }
+
+        // Samplerate field
+        if( fwrite(&e->samplerate, sizeof(e->samplerate), 1, fd) != 1 ) {
+                DEBUGF("song_entry_serialize: failed to write samplerate\n");
+                return ERR_FILE;
+        }
+
+        return ERR_NONE;
+}
+
+int song_entry_unserialize(struct song_entry **dest, FILE *fd) {
+        uint32_t length;
+        struct song_entry* e;
+
+        assert(dest != NULL);
+        assert(fd != NULL);
+
+        // Allocate memory
+        e = new_song_entry(0, 0);
+        if( e == NULL ) {
+                DEBUGF("song_entry_unserialize: could not create new song_entry\n");
+                return ERR_MALLOC;
+        }
+        
+        // First we read the length of the name field
+        if( fread(&length, sizeof(length), 1, fd) != 1 ) {
+                DEBUGF("song_entry_unserialize: failed to read name_len\n");
+                song_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        // allocate memory for the upcomming name-field
+        if( do_resize(e, length, 0, 0) ) {
+                DEBUGF("song_entry_unserialize: failed to allocate memory for name\n");
+                song_entry_destruct(e);
+                return ERR_MALLOC;
+        }
+
+        // read it in
+        if( fread(e->name, 1, e->size.name_len, fd) != e->size.name_len ) {
+                DEBUGF("song_entry_unserialize: failed to read name\n");
+                song_entry_destruct(e);
+                return ERR_FILE;
+        }
+        
+        // Artist field
+        if( fread(&e->artist, sizeof(e->artist), 1, fd) != 1 ) {
+                DEBUGF("song_entry_unserialize: failed to read artist\n");
+                song_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        // Album field
+        if( fread(&e->album, sizeof(e->album), 1, fd) != 1 ) {
+                DEBUGF("song_entry_unserialize: failed to read album\n");
+                song_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        // File field
+        if( fread(&e->file, sizeof(e->file), 1, fd) != 1 ) {
+                DEBUGF("song_entry_unserialize: failed to read file\n");
+                song_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        // Next the length of genre
+        if( fread(&length, sizeof(length), 1, fd) != 1 ) {
+                DEBUGF("song_entry_unserialize: failed to read genre_len\n");
+                song_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        // allocate memory for the upcomming name-field
+        if( do_resize(e, e->size.name_len, length, 0) ) {
+                DEBUGF("song_entry_unserialize: failed to allocate memory for song\n");
+                song_entry_destruct(e);
+                return ERR_MALLOC;
+        }
+
+        // read it in
+        if( fread(e->genre, 1, e->size.genre_len, fd) != e->size.genre_len ) {
+                DEBUGF("song_entry_unserialize: failed to read genre\n");
+                song_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        // Bitrate field
+        if( fread(&e->bitrate, sizeof(e->bitrate), 1, fd) != 1 ) {
+                DEBUGF("song_entry_unserialize: failed to read bitrate\n");
+                song_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        // Year field
+        if( fread(&e->year, sizeof(e->year), 1, fd) != 1 ) {
+                DEBUGF("song_entry_unserialize: failed to read year\n");
+                song_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        // Playtime field
+        if( fread(&e->playtime, sizeof(e->playtime), 1, fd) != 1 ) {
+                DEBUGF("song_entry_unserialize: failed to read playtime\n");
+                song_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        // Track field
+        if( fread(&e->track, sizeof(e->track), 1, fd) != 1 ) {
+                DEBUGF("song_entry_unserialize: failed to read track\n");
+                song_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        // Samplerate field
+        if( fread(&e->samplerate, sizeof(e->samplerate), 1, fd) != 1 ) {
+                DEBUGF("song_entry_unserialize: failed to read samplerate\n");
+                song_entry_destruct(e);
+                return ERR_FILE;
+        }
+
+        *dest = e;
+        return ERR_NONE;
+}
+
+int song_entry_write(FILE *fd, struct song_entry *e, struct song_size *s) {
+        uint32_t be32;
+        uint16_t be16;
+        char pad = 0x00;
+        
+        assert(fd != NULL);
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+
+        // song name
+        if( fwrite(e->name, 1, e->size.name_len, fd) != e->size.name_len ) {
+                DEBUGF("song_entry_write: failed to write name\n");
+                return ERR_FILE;
+        }
+        // pad the rest (abuse be32 for counter)
+        be32 = e->size.name_len;
+        while( s != NULL && s->name_len > be32) {
+                if( fwrite(&pad, 1, 1, fd) == 1 ) {
+                        be32++;
+                } else {
+                        DEBUGF("genre_entry_write: failed to pad name\n");
+                        return ERR_FILE;
+                }
+        }
+
+        // artist
+        be32 = BE32(e->artist);
+        if( fwrite(&be32, sizeof(be32), 1, fd) != 1 ) {
+                DEBUGF("song_entry_write: failed to write artist\n");
+                return ERR_FILE;
+        }
+
+        // album
+        be32 = BE32(e->album);
+        if( fwrite(&be32, sizeof(be32), 1, fd) != 1 ) {
+                DEBUGF("song_entry_write: failed to write album\n");
+                return ERR_FILE;
+        }
+
+        // file
+        be32 = BE32(e->file);
+        if( fwrite(&be32, sizeof(be32), 1, fd) != 1 ) {
+                DEBUGF("song_entry_write: failed to write file\n");
+                return ERR_FILE;
+        }
+
+        // genre
+        if( fwrite(e->genre, 1, e->size.genre_len, fd) != e->size.genre_len ) {
+                DEBUGF("song_entry_write: failed to write genre\n");
+                return ERR_FILE;
+        }
+        // pad the rest (abuse be32 for counter)
+        be32 = e->size.genre_len;
+        while( s != NULL && s->genre_len > be32) {
+                if( fwrite(&pad, 1, 1, fd) == 1 ) {
+                        be32++;
+                } else {
+                        DEBUGF("genre_entry_write: failed to pad genre\n");
+                        return ERR_FILE;
+                }
+        }
+
+        // bitrate
+        be16 = BE16(e->bitrate);
+        if( fwrite(&be16, sizeof(be16), 1, fd) != 1 ) {
+                DEBUGF("song_entry_write: failed to write bitrate\n");
+                return ERR_FILE;
+        }
+
+        // year
+        be16 = BE16(e->year);
+        if( fwrite(&be16, sizeof(be16), 1, fd) != 1 ) {
+                DEBUGF("song_entry_write: failed to write year\n");
+                return ERR_FILE;
+        }
+
+        // playtime
+        be32 = BE32(e->playtime);
+        if( fwrite(&be32, sizeof(be32), 1, fd) != 1 ) {
+                DEBUGF("song_entry_write: failed to write playtime\n");
+                return ERR_FILE;
+        }
+
+        // track
+        be16 = BE16(e->track);
+        if( fwrite(&be16, sizeof(be16), 1, fd) != 1 ) {
+                DEBUGF("song_entry_write: failed to write track\n");
+                return ERR_FILE;
+        }
+
+        // samplerate
+        be16 = BE16(e->samplerate);
+        if( fwrite(&be16, sizeof(be16), 1, fd) != 1 ) {
+                DEBUGF("song_entry_write: failed to write samplerate\n");
+                return ERR_FILE;
+        }
+
+        return ERR_NONE;
+}
+
+inline int song_entry_compare(const struct song_entry *a, const struct song_entry *b) {
+        assert(a != NULL);
+        assert(b != NULL);
+        return strncasecmp(a->name, b->name, (a->size.name_len <= b->size.name_len ? a->size.name_len : b->size.name_len) );
+}
+    
+struct song_size* new_song_size() {
+        struct song_size *s;
+        s = (struct song_size*)malloc(sizeof(struct song_size));
+        if( s == NULL ) {
+                DEBUGF("new_song_size: failed to allocate memory\n");
+                return NULL;
+        }
+        s->name_len = 0;
+        s->genre_len = 0;
+        
+        return s;
+}
+
+inline uint32_t song_size_get_length(const struct song_size *size) {
+        assert(size != NULL);
+        return size->name_len + size->genre_len + 6*4;
+}
+
+inline int song_size_max(struct song_size *s, const struct song_entry *e) {
+        assert(s != NULL);
+        assert(e != NULL);
+        assert(FLAG_VALID(e->flag));
+        s->name_len  = ( s->name_len  >= e->size.name_len  ? s->name_len  : e->size.name_len );
+        s->genre_len = ( s->genre_len >= e->size.genre_len ? s->genre_len : e->size.genre_len );
+        return ERR_NONE;
+}
+
+int song_size_destruct(struct song_size *s) {
+        assert(s != NULL);
+        // nothing to do...
+        free(s);
+        return ERR_NONE;
+}
diff --git a/apps/tagdb/song.h b/apps/tagdb/song.h
new file mode 100644
index 0000000000..1be81ccf0a
--- /dev/null
+++ b/apps/tagdb/song.h
@@ -0,0 +1,93 @@
+#ifndef __SONG_H__
+#define __SONG_H__
+
+#include "config.h"
+#include <stdio.h>
+#include <stdint.h>
+
+struct song_entry {
+        char* name;             // song name
+        
+        uint32_t artist;        // pointer to artist
+        uint32_t album;         // pointer to album
+        uint32_t file;          // pointer to file
+        
+        char* genre;            // genre
+
+        uint16_t bitrate;       // bitrate (-1 = VBR or unknown)
+        uint16_t year;
+        uint32_t playtime;      // in seconds
+        uint16_t track;
+        uint16_t samplerate;    // in Hz
+
+        struct song_size {
+                uint32_t name_len;      // must be mulitple of 4
+                uint32_t genre_len;     // must be multiple of 4
+        } size;
+        unsigned char flag;     // flags
+};
+
+struct song_entry* new_song_entry(const uint32_t name_len, const uint32_t genre_len);
+/* Creates a new song_entry with the specified sizes
+ * Returns a pointer to the structure on success,
+ * NULL on failure
+ */
+
+int song_entry_destruct(struct song_entry *e);
+/* Destructs the given song_entry and free()'s it's memory
+ * returns 0 on success, 1 on failure
+ */
+
+inline int song_entry_resize(struct song_entry *e, const uint32_t name_len, const uint32_t genre_len);
+/* Change the size of the entry
+ * returns 0 on succes, 1 on failure
+ */
+
+int song_entry_serialize(FILE *fd, const struct song_entry *e);
+/* Serializes the entry in the file at the current position
+ * returns 0 on success, 1 on failure
+ */
+
+int song_entry_unserialize(struct song_entry* *e, FILE *fd);
+/* Unserializes an entry from file into a new structure
+ * The address of the structure is saved into *e
+ * returns 0 on success
+ *         1 on malloc() failure
+ *         2 on fread() failure
+ */
+
+int song_entry_write(FILE *fd, struct song_entry *e, struct song_size *s);
+/* Writes the entry to file in the final form
+ * returns 0 (0) on success, 1 (1) on failure
+ */
+
+inline int song_entry_compare(const struct song_entry *a, const struct song_entry *b);
+/* Compares 2 entries
+ * When a < b it returns <0
+ *      a = b             0
+ *      a > b            >0
+ */
+
+struct song_size* new_song_size();
+/* Creates a new size structure
+ * returns a pointer to the structure on success,
+ * NULL on failure
+ */
+
+inline uint32_t song_size_get_length(const struct song_size *size);
+/* Calculates the length of the entry when written by song_entry_write()
+ * returns the length on success, 0xffffffff on failure
+ */
+
+inline int song_size_max(struct song_size *s, const struct song_entry *e);
+/* Updates the song_size structure to contain the maximal lengths of either
+ * the original entry in s, or the entry e
+ * returns 0 on success, 1 on failure
+ */
+
+int song_size_destruct(struct song_size *s);
+/* destructs the song_size structure
+ * returns 0 on success, 1 on failure
+ */
+
+#endif
diff --git a/apps/tagdb/tag_dummy.c b/apps/tagdb/tag_dummy.c
new file mode 100644
index 0000000000..f0125f32ea
--- /dev/null
+++ b/apps/tagdb/tag_dummy.c
@@ -0,0 +1,11 @@
+#include "config.h"
+#include "malloc.h"
+
+#include "tag_dummy.h"
+#include <string.h>
+
+int tag_dummy(char *file, struct tag_info *t) {
+        t->song = malloc(strlen(file)+1);
+        strcpy(t->song, file);
+        return ERR_NONE;
+}
diff --git a/apps/tagdb/tag_dummy.h b/apps/tagdb/tag_dummy.h
new file mode 100644
index 0000000000..856a0a5a2e
--- /dev/null
+++ b/apps/tagdb/tag_dummy.h
@@ -0,0 +1,3 @@
+#include "db.h"
+
+int tag_dummy(char *file, struct tag_info *t);
diff --git a/apps/tagdb/unique.c b/apps/tagdb/unique.c
new file mode 100644
index 0000000000..471f59e67f
--- /dev/null
+++ b/apps/tagdb/unique.c
@@ -0,0 +1,16 @@
+#include "unique.h"
+
+#include <string.h>
+#include <stdio.h>
+
+char *create_unique_name(char *buffer, const char *prefix, const char *suffix, int digits) {
+        static unsigned long i=0;
+
+        strcpy(buffer, prefix);
+        sprintf(buffer+strlen(prefix), "%05lu", i);
+        strcat(buffer, suffix);
+
+        i++;
+
+        return buffer;
+}
diff --git a/apps/tagdb/unique.h b/apps/tagdb/unique.h
new file mode 100644
index 0000000000..03dc261141
--- /dev/null
+++ b/apps/tagdb/unique.h
@@ -0,0 +1,6 @@
+#ifndef __UNIQUE_H__
+#define __UNIQUE_H__
+
+char *create_unique_name(char *buffer, const char *prefix, const char *suffix, int digits);
+
+#endif