summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorNiels Laukens <niobos@rockbox.org>2005-07-06 11:03:20 +0000
committerNiels Laukens <niobos@rockbox.org>2005-07-06 11:03:20 +0000
commitd1c294c17de95615b7af428da938b686830b42df (patch)
tree950080f5b6c9503c090df6e4f0929f13eae8891e
parent5e9f52f6d1f3356bc6df75a675e1a2d5cdbf9d77 (diff)
downloadrockbox-d1c294c17de95615b7af428da938b686830b42df.tar.gz
rockbox-d1c294c17de95615b7af428da938b686830b42df.zip
Initial import of tagdb
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@7039 a1c6a512-1295-4272-9138-f99709370657
-rw-r--r--apps/tagdb/Makefile32
-rw-r--r--apps/tagdb/README9
-rw-r--r--apps/tagdb/album.c454
-rw-r--r--apps/tagdb/album.h103
-rw-r--r--apps/tagdb/array_buffer.c667
-rw-r--r--apps/tagdb/array_buffer.h159
-rw-r--r--apps/tagdb/artist.c370
-rw-r--r--apps/tagdb/artist.h100
-rw-r--r--apps/tagdb/config.h39
-rw-r--r--apps/tagdb/db.c603
-rw-r--r--apps/tagdb/db.h37
-rw-r--r--apps/tagdb/file.c268
-rw-r--r--apps/tagdb/file.h84
-rw-r--r--apps/tagdb/header.c121
-rw-r--r--apps/tagdb/header.h39
-rw-r--r--apps/tagdb/main.c115
-rw-r--r--apps/tagdb/malloc.c131
-rw-r--r--apps/tagdb/malloc.h16
-rw-r--r--apps/tagdb/parser.c218
-rw-r--r--apps/tagdb/song.c450
-rw-r--r--apps/tagdb/song.h93
-rw-r--r--apps/tagdb/tag_dummy.c11
-rw-r--r--apps/tagdb/tag_dummy.h3
-rw-r--r--apps/tagdb/unique.c16
-rw-r--r--apps/tagdb/unique.h6
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