From d1c294c17de95615b7af428da938b686830b42df Mon Sep 17 00:00:00 2001 From: Niels Laukens Date: Wed, 6 Jul 2005 11:03:20 +0000 Subject: Initial import of tagdb git-svn-id: svn://svn.rockbox.org/rockbox/trunk@7039 a1c6a512-1295-4272-9138-f99709370657 --- apps/tagdb/Makefile | 32 +++ apps/tagdb/README | 9 + apps/tagdb/album.c | 454 +++++++++++++++++++++++++++++++ apps/tagdb/album.h | 103 +++++++ apps/tagdb/array_buffer.c | 667 ++++++++++++++++++++++++++++++++++++++++++++++ apps/tagdb/array_buffer.h | 159 +++++++++++ apps/tagdb/artist.c | 370 +++++++++++++++++++++++++ apps/tagdb/artist.h | 100 +++++++ apps/tagdb/config.h | 39 +++ apps/tagdb/db.c | 603 +++++++++++++++++++++++++++++++++++++++++ apps/tagdb/db.h | 37 +++ apps/tagdb/file.c | 268 +++++++++++++++++++ apps/tagdb/file.h | 84 ++++++ apps/tagdb/header.c | 121 +++++++++ apps/tagdb/header.h | 39 +++ apps/tagdb/main.c | 115 ++++++++ apps/tagdb/malloc.c | 131 +++++++++ apps/tagdb/malloc.h | 16 ++ apps/tagdb/parser.c | 218 +++++++++++++++ apps/tagdb/song.c | 450 +++++++++++++++++++++++++++++++ apps/tagdb/song.h | 93 +++++++ apps/tagdb/tag_dummy.c | 11 + apps/tagdb/tag_dummy.h | 3 + apps/tagdb/unique.c | 16 ++ apps/tagdb/unique.h | 6 + 25 files changed, 4144 insertions(+) create mode 100644 apps/tagdb/Makefile create mode 100644 apps/tagdb/README create mode 100644 apps/tagdb/album.c create mode 100644 apps/tagdb/album.h create mode 100644 apps/tagdb/array_buffer.c create mode 100644 apps/tagdb/array_buffer.h create mode 100644 apps/tagdb/artist.c create mode 100644 apps/tagdb/artist.h create mode 100644 apps/tagdb/config.h create mode 100644 apps/tagdb/db.c create mode 100644 apps/tagdb/db.h create mode 100644 apps/tagdb/file.c create mode 100644 apps/tagdb/file.h create mode 100644 apps/tagdb/header.c create mode 100644 apps/tagdb/header.h create mode 100644 apps/tagdb/main.c create mode 100644 apps/tagdb/malloc.c create mode 100644 apps/tagdb/malloc.h create mode 100644 apps/tagdb/parser.c create mode 100644 apps/tagdb/song.c create mode 100644 apps/tagdb/song.h create mode 100644 apps/tagdb/tag_dummy.c create mode 100644 apps/tagdb/tag_dummy.h create mode 100644 apps/tagdb/unique.c create mode 100644 apps/tagdb/unique.h (limited to 'apps') 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 // strncasecmp() +#include // 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; iname[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; isong[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; isize.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 && isong_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 + +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; icount; 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; icount; 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; icount; 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; icount; 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; icount; 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; icount; 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; icount; 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 +#include + +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 // 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; iname[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; ialbum[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; isize.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 && ialbum_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 +#include + +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 + +#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 + +#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 // 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 "" and "" 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, ""); + } + if( t->genre == NULL ) { + CATCH_MALLOC_NULL( t->genre = (char*)malloc(15) ); + strcpy(t->genre, ""); + } + if( t->artist == NULL ) { + CATCH_MALLOC_NULL( t->artist = (char*)malloc(16) ); + strcpy(t->artist, ""); + } + if( t->album == NULL ) { + CATCH_MALLOC_NULL( t->album = (char*)malloc(15) ); + strcpy(t->album, ""); + } + + 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 "" + 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; isize.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; isize.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 + +#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 // 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; iname[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 +#include + +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 + +#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 +#include // strcmp() +#include // opendir() readdir() closedir() +#include // 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 "" +// +// 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 +#include + +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 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 %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 + +#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 +#include +#include + +#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 // 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; iname[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; igenre[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 +#include + +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 + +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 +#include + +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 -- cgit v1.2.3