Menu
▾
▴
[Pmplib-commits] SF.net SVN: pmplib: [197] trunk/pmplib/lib/pmp_iriverplus3
|
From: <ny...@us...> - 2006-12-24 18:03:21
|
Revision: 197
http://svn.sourceforge.net/pmplib/?rev=197&view=rev
Author: nyaochi
Date: 2006-12-24 10:03:21 -0800 (Sun, 24 Dec 2006)
Log Message:
-----------
Generalized fields in db.dat by using field type definitions in db.dic
Modified Paths:
--------------
trunk/pmplib/lib/pmp_iriverplus3/dat.c
trunk/pmplib/lib/pmp_iriverplus3/dat.h
trunk/pmplib/lib/pmp_iriverplus3/dic.c
trunk/pmplib/lib/pmp_iriverplus3/dic.h
trunk/pmplib/lib/pmp_iriverplus3/idx.c
trunk/pmplib/lib/pmp_iriverplus3/ip3db.c
trunk/pmplib/lib/pmp_iriverplus3/ip3db.h
Modified: trunk/pmplib/lib/pmp_iriverplus3/dat.c
===================================================================
--- trunk/pmplib/lib/pmp_iriverplus3/dat.c 2006-12-24 15:38:22 UTC (rev 196)
+++ trunk/pmplib/lib/pmp_iriverplus3/dat.c 2006-12-24 18:03:21 UTC (rev 197)
@@ -19,7 +19,7 @@
*
*/
-/* $Id:$ */
+/* $Id$ */
/*
Brief summary of db.dat structure:
@@ -42,277 +42,179 @@
#include "serialize.h"
#include "util.h"
+#include "ip3db.h"
+#include "dic.h"
#include "dat.h"
-static void dat_object_finish(dat_object_t* entry)
+static void dat_entry_init(dat_entry_t* entry, const dic_list_t* dic_list)
{
- ucs2free(entry->object_name);
- ucs2free(entry->name);
+ int i;
+ memset(entry, 0, sizeof(*entry));
+ entry->num_fields = dic_list->num_fields;
+ entry->fields = (ip3db_variant_t*)malloc(sizeof(ip3db_variant_t) * entry->num_fields);
+ for (i = 0;i < entry->num_fields;++i) {
+ ip3db_variant_init(&entry->fields[i], dic_list->fields[i].type);
+ }
}
-static void dat_objects_init(dat_objects_t* objects)
+static void dat_entry_finish(dat_entry_t* entry)
{
- memset(objects, 0, sizeof(dat_objects_t));
-}
-
-static void dat_objects_finish(dat_objects_t* objects)
-{
- uint32_t i;
- for (i = 0;i < objects->num_entries;++i) {
- dat_object_finish(&objects->entries[i]);
+ int i;
+ for (i = 0;i < entry->num_fields;++i) {
+ ip3db_variant_finish(&entry->fields[i]);
}
- free(objects->entries);
- free(objects->offsets);
- dat_objects_init(objects);
+ free(entry->fields);
+ memset(entry, 0, sizeof(*entry));
}
-static size_t dat_objects_serialize(uint8_t* buffer, dat_objects_t* objects, int is_storing)
+static size_t dat_entry_serialize(uint8_t* block, uint8_t* q, dat_entry_t* entry, int is_storing)
{
- uint32_t i;
- uint8_t *p = buffer;
- uint8_t *q = buffer + 0x00020000 - sizeof(uint32_t);
+ int i;
+ uint8_t *p = block;
- p += serialize_uint32be(p, &objects->size, is_storing);
- p += serialize_uint32be(p, &objects->num_entries, is_storing);
- p += serialize_uint32be(p, &objects->unknown1, is_storing);
- p += serialize_uint32be(p, &objects->unknown2, is_storing);
+ q -= serialize_uint32be(q, &entry->offset, is_storing);
- if (!is_storing) {
- free(objects->entries);
- free(objects->offsets);
- objects->entries = (dat_object_t*)calloc(objects->num_entries, sizeof(dat_object_t));
- objects->offsets = (uint32_t*)calloc(objects->num_entries, sizeof(uint32_t));
- }
-
- for (i = 0;i < objects->num_entries;++i) {
- dat_object_t* entry = &objects->entries[i];
-
- /* Read an element in the offset table. */
- q -= serialize_uint32be(q, &objects->offsets[i], is_storing);
-
- /* Read an entry. */
- p += serialize_uint32be(p, &entry->uid, is_storing);
- p += serialize_uint32be(p, &entry->parent_uid, is_storing);
- p += serialize_uint8(p, &entry->properties, is_storing);
- p += serialize_uint16be(p, &entry->filetype, is_storing);
- if (is_storing) {
- p += (serialize_ucs2be_string_var(p, entry->object_name, is_storing) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var(p, entry->name, is_storing) + 1) * sizeof(ucs2char_t);
- } else {
- p += (serialize_ucs2be_string_var_alloc(p, &entry->object_name) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var_alloc(p, &entry->name) + 1) * sizeof(ucs2char_t);
+ for (i = 0;i < entry->num_fields;++i) {
+ ip3db_variant_t* var = &entry->fields[i];
+ switch (var->type) {
+ case IP3DBVT_STRING:
+ if (is_storing) {
+ p += (serialize_ucs2be_string_var(p, var->value.str, is_storing) + 1) * sizeof(ucs2char_t);
+ } else {
+ p += (serialize_ucs2be_string_var_alloc(p, &var->value.str) + 1) * sizeof(ucs2char_t);
+ }
+ break;
+ case IP3DBVT_BYTE:
+ p += serialize_uint8(p, &var->value.byte, is_storing);
+ break;
+ case IP3DBVT_WORD:
+ p += serialize_uint16be(p, &var->value.word, is_storing);
+ break;
+ case IP3DBVT_DWORD:
+ p += serialize_uint32be(p, &var->value.dword, is_storing);
+ break;
}
- p += serialize_uint32be(p, &entry->filesize, is_storing);
- p += serialize_uint32be(p, &entry->datecrea, is_storing);
- p += serialize_uint32be(p, &entry->rawid, is_storing);
- p += serialize_uint32be(p, &entry->puoid1, is_storing);
- p += serialize_uint32be(p, &entry->puoid2, is_storing);
}
- return (size_t)(p - buffer);
+ return (size_t)(p - block);
}
-static void dat_objects_dump(FILE *fp, dat_objects_t* objects)
+static void dat_entry_dump(dat_entry_t* entry, FILE *fp, const dic_list_t* dic_list)
{
- uint32_t i;
+ int i;
- fprintf(fp, "OBJECTS {\n");
- fprintf(fp, " size: 0x%08X\n", objects->size);
- fprintf(fp, " num_entries: %d\n", objects->num_entries);
- fprintf(fp, " unknown1: 0x%08X\n", objects->unknown1);
- fprintf(fp, " unknown2: 0x%08X\n", objects->unknown2);
+ for (i = 0;i < entry->num_fields;++i) {
+ ip3db_variant_t* var = &entry->fields[i];
- for (i = 0;i < objects->num_entries;++i) {
- dat_object_t* entry = &objects->entries[i];
- fprintf(fp, " ENTRY %d (0x%08X) = {\n", i, objects->offsets[i]);
- fprintf(fp, " uid: %d\n", entry->uid);
- fprintf(fp, " parent_uid: %d\n", entry->parent_uid);
- fprintf(fp, " properties: 0x%02X\n", entry->properties);
- fprintf(fp, " filetype: 0x%04X\n", entry->filetype);
- fprints(fp, " object_name: %s\n", entry->object_name);
- fprints(fp, " name: %s\n", entry->name);
- fprintf(fp, " filesize: %d\n", entry->filesize);
- fprintf(fp, " datecrea: %d\n", entry->datecrea);
- fprintf(fp, " rawid: %d\n", entry->rawid);
- fprintf(fp, " puoid1: %d\n", entry->puoid1);
- fprintf(fp, " puoid2: %d\n", entry->puoid2);
- fprintf(fp, " }\n");
+ fprints(fp, " %s: ", dic_list->fields[i].name);
+ switch (var->type) {
+ case IP3DBVT_STRING:
+ fprints(fp, "%s\n", var->value.str);
+ break;
+ case IP3DBVT_BYTE:
+ fprintf(fp, "0x%02X\n", var->value.byte);
+ break;
+ case IP3DBVT_WORD:
+ fprintf(fp, "%d\n", var->value.word);
+ break;
+ case IP3DBVT_DWORD:
+ fprintf(fp, "%d\n", var->value.dword);
+ break;
+ }
}
- fprintf(fp, "}\n");
}
-
-
-static void dat_music_finish(dat_music_t* entry)
+static void dat_list_init(dat_list_t* list)
{
- ucs2free(entry->artist);
- ucs2free(entry->album);
- ucs2free(entry->genre);
- ucs2free(entry->title);
- ucs2free(entry->filepath);
- ucs2free(entry->filename);
- ucs2free(entry->release);
- ucs2free(entry->album_artist);
+ memset(list, 0, sizeof(*list));
}
-static void dat_musics_init(dat_musics_t* musics)
+static void dat_list_finish(dat_list_t* list)
{
- memset(musics, 0, sizeof(dat_musics_t));
-}
-
-static void dat_musics_finish(dat_musics_t* musics)
-{
uint32_t i;
- for (i = 0;i < musics->num_entries;++i) {
- dat_music_finish(&musics->entries[i]);
+ for (i = 0;i < list->num_entries;++i) {
+ dat_entry_finish(&list->entries[i]);
}
- free(musics->entries);
- free(musics->offsets);
- dat_musics_init(musics);
+ free(list->entries);
+ dat_list_init(list);
}
-static size_t dat_musics_serialize(uint8_t* buffer, dat_musics_t* musics, int is_storing)
+static size_t dat_list_serialize(uint8_t* buffer, dat_list_t* list, int is_storing, const dic_list_t* dic_list)
{
uint32_t i;
uint8_t *p = buffer;
uint8_t *q = buffer + 0x00020000 - sizeof(uint32_t);
- p += serialize_uint32be(p, &musics->size, is_storing);
- p += serialize_uint32be(p, &musics->num_entries, is_storing);
- p += serialize_uint32be(p, &musics->unknown1, is_storing);
- p += serialize_uint32be(p, &musics->unknown2, is_storing);
+ p += serialize_uint32be(p, &list->size, is_storing);
+ p += serialize_uint32be(p, &list->num_entries, is_storing);
+ p += serialize_uint32be(p, &list->unknown1, is_storing);
+ p += serialize_uint32be(p, &list->unknown2, is_storing);
if (!is_storing) {
- free(musics->entries);
- free(musics->offsets);
- musics->entries = (dat_music_t*)calloc(musics->num_entries, sizeof(dat_music_t));
- musics->offsets = (uint32_t*)calloc(musics->num_entries, sizeof(uint32_t));
+ free(list->entries);
+ list->entries = (dat_entry_t*)calloc(list->num_entries, sizeof(dat_entry_t));
+ for (i = 0;i < list->num_entries;++i) {
+ dat_entry_init(&list->entries[i], dic_list);
+ }
}
- for (i = 0;i < musics->num_entries;++i) {
- dat_music_t* entry = &musics->entries[i];
-
- /* Read an element in the offset table. */
- q -= serialize_uint32be(q, &musics->offsets[i], is_storing);
-
- /* Read an entry. */
- if (is_storing) {
- p += (serialize_ucs2be_string_var(p, entry->artist, is_storing) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var(p, entry->album, is_storing) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var(p, entry->genre, is_storing) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var(p, entry->title, is_storing) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var(p, entry->filepath, is_storing) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var(p, entry->filename, is_storing) + 1) * sizeof(ucs2char_t);
- } else {
- p += (serialize_ucs2be_string_var_alloc(p, &entry->artist) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var_alloc(p, &entry->album) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var_alloc(p, &entry->genre) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var_alloc(p, &entry->title) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var_alloc(p, &entry->filepath) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var_alloc(p, &entry->filename) + 1) * sizeof(ucs2char_t);
- }
- p += serialize_uint32be(p, &entry->duration, is_storing);
- p += serialize_uint16be(p, &entry->rating, is_storing);
- p += serialize_uint32be(p, &entry->use_count, is_storing);
- p += serialize_uint16be(p, &entry->format, is_storing);
- p += serialize_uint16be(p, &entry->tracknumber, is_storing);
- p += serialize_uint8(p, &entry->drm, is_storing);
- p += serialize_uint8(p, &entry->lyric, is_storing);
- p += serialize_uint8(p, &entry->purchase, is_storing);
- p += serialize_uint16be(p, &entry->protection, is_storing);
- p += serialize_uint32be(p, &entry->samplerate, is_storing);
- p += serialize_uint32be(p, &entry->bitrate, is_storing);
- p += serialize_uint8(p, &entry->changed_flag, is_storing);
- p += serialize_uint32be(p, &entry->codec, is_storing);
- p += serialize_uint32be(p, &entry->clusm, is_storing);
- p += serialize_uint32be(p, &entry->clusa, is_storing);
- p += serialize_uint32be(p, &entry->albumart_pos, is_storing);
- if (is_storing) {
- p += (serialize_ucs2be_string_var(p, entry->release, is_storing) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var(p, entry->album_artist, is_storing) + 1) * sizeof(ucs2char_t);
- } else {
- p += (serialize_ucs2be_string_var_alloc(p, &entry->release) + 1) * sizeof(ucs2char_t);
- p += (serialize_ucs2be_string_var_alloc(p, &entry->album_artist) + 1) * sizeof(ucs2char_t);
- }
- p += serialize_uint32be(p, &entry->object_uid, is_storing);
- p += serialize_uint32be(p, &entry->ratingtime, is_storing);
+ for (i = 0;i < list->num_entries;++i) {
+ dat_entry_t* entry = &list->entries[i];
+ p += dat_entry_serialize(p, q, entry, is_storing);
+ q -= sizeof(uint32_t);
}
return (size_t)(p - buffer);
}
-static void dat_musics_dump(FILE *fp, dat_musics_t* musics)
+static void dat_list_dump(dat_list_t* list, FILE *fp, const dic_list_t* dic_list)
{
uint32_t i;
- fprintf(fp, "MUSICS {\n");
- fprintf(fp, " size: 0x%08X\n", musics->size);
- fprintf(fp, " num_entries: %d\n", musics->num_entries);
- fprintf(fp, " unknown1: 0x%08X\n", musics->unknown1);
- fprintf(fp, " unknown2: 0x%08X\n", musics->unknown2);
+ fprintf(fp, " size: 0x%08X\n", list->size);
+ fprintf(fp, " num_entries: %d\n", list->num_entries);
+ fprintf(fp, " unknown1: 0x%08X\n", list->unknown1);
+ fprintf(fp, " unknown2: 0x%08X\n", list->unknown2);
- for (i = 0;i < musics->num_entries;++i) {
- dat_music_t* entry = &musics->entries[i];
-
- fprintf(fp, " ENTRY %d (0x%08X) = {\n", i, musics->offsets[i]);
- fprints(fp, " artist: %s\n", entry->artist);
- fprints(fp, " album: %s\n", entry->album);
- fprints(fp, " genre: %s\n", entry->genre);
- fprints(fp, " title: %s\n", entry->title);
- fprints(fp, " filepath: %s\n", entry->filepath);
- fprints(fp, " filename: %s\n", entry->filename);
- fprintf(fp, " duration: %d\n", entry->duration);
- fprintf(fp, " rating: %d\n", entry->rating);
- fprintf(fp, " use_count: %d\n", entry->use_count);
- fprintf(fp, " format: 0x%04X\n", entry->format);
- fprintf(fp, " tracknumber: %d\n", entry->tracknumber);
- fprintf(fp, " drm: 0x%02X\n", entry->drm);
- fprintf(fp, " lyric: 0x%02X\n", entry->lyric);
- fprintf(fp, " purchase: 0x%02X\n", entry->purchase);
- fprintf(fp, " protection: 0x%04X\n", entry->protection);
- fprintf(fp, " samplerate: %d\n", entry->samplerate);
- fprintf(fp, " bitrate: %d\n", entry->bitrate);
- fprintf(fp, " changed_flag: 0x%02X\n", entry->changed_flag);
- fprintf(fp, " codec: 0x%08X\n", entry->codec);
- fprintf(fp, " clusm: 0x%08X\n", entry->clusm);
- fprintf(fp, " clusa: 0x%08X\n", entry->clusa);
- fprintf(fp, " albumart_pos: 0x%08X\n", entry->albumart_pos);
- fprints(fp, " release: %s\n", entry->release);
- fprints(fp, " album_artist: %s\n", entry->album_artist);
- fprintf(fp, " object_uid: %d\n", entry->object_uid);
- fprintf(fp, " ratingtime: %d\n", entry->ratingtime);
+ for (i = 0;i < list->num_entries;++i) {
+ dat_entry_t* entry = &list->entries[i];
+ fprintf(fp, " ENTRY %d (0x%08X) = {\n", i, entry->offset);
+ dat_entry_dump(entry, fp, dic_list);
fprintf(fp, " }\n");
}
- fprintf(fp, "}\n");
}
dat_t* dat_new()
{
dat_t* dat = (dat_t*)malloc(sizeof(dat_t));
if (dat) {
- dat_objects_init(&dat->objects);
- dat_musics_init(&dat->musics);
+ dat_list_init(&dat->objects);
+ dat_list_init(&dat->musics);
}
return dat;
}
void dat_finish(dat_t* dat)
{
- dat_objects_finish(&dat->objects);
- dat_musics_finish(&dat->musics);
+ dat_list_finish(&dat->objects);
+ dat_list_finish(&dat->musics);
free(dat);
}
-size_t dat_serialize(uint8_t* buffer, dat_t* dat, int is_storing)
+size_t dat_serialize(dat_t* dat, const dic_t* dic, uint8_t* buffer, int is_storing)
{
- dat_objects_serialize(buffer, &dat->objects, is_storing);
- dat_musics_serialize(buffer + 0x00020000, &dat->musics, is_storing);
+ dat_list_serialize(buffer, &dat->objects, is_storing, &dic->objects);
+ dat_list_serialize(buffer + 0x00020000, &dat->musics, is_storing, &dic->music);
return 0;
}
-void dat_dump(FILE *fp, dat_t* dat)
+void dat_dump(dat_t* dat, const dic_t* dic, FILE *fp)
{
fprintf(fp, "===== db.dat =====\n");
- dat_objects_dump(fp, &dat->objects);
- dat_musics_dump(fp, &dat->musics);
+ fprintf(fp, "OBJECTS = {\n");
+ dat_list_dump(&dat->objects, fp, &dic->objects);
+ fprintf(fp, "}\n");
+ fprintf(fp, "MUSIC = {\n");
+ dat_list_dump(&dat->musics, fp, &dic->music);
+ fprintf(fp, "}\n");
}
Modified: trunk/pmplib/lib/pmp_iriverplus3/dat.h
===================================================================
--- trunk/pmplib/lib/pmp_iriverplus3/dat.h 2006-12-24 15:38:22 UTC (rev 196)
+++ trunk/pmplib/lib/pmp_iriverplus3/dat.h 2006-12-24 18:03:21 UTC (rev 197)
@@ -25,75 +25,28 @@
#define __IP3DB_DAT_H__
typedef struct {
- uint32_t uid;
- uint32_t parent_uid;
- uint8_t properties;
- uint16_t filetype;
- ucs2char_t* object_name;
- ucs2char_t* name;
- uint32_t filesize;
- uint32_t datecrea;
- uint32_t rawid;
- uint32_t puoid1;
- uint32_t puoid2;
-} dat_object_t;
+ int num_fields;
+ ip3db_variant_t *fields;
+ uint32_t offset;
+} dat_entry_t;
typedef struct {
uint32_t size;
uint32_t num_entries;
uint32_t unknown1;
uint32_t unknown2;
- dat_object_t* entries;
- uint32_t* offsets;
-} dat_objects_t;
+ dat_entry_t* entries;
+} dat_list_t;
-typedef struct {
- ucs2char_t* artist;
- ucs2char_t* album;
- ucs2char_t* genre;
- ucs2char_t* title;
- ucs2char_t* filepath;
- ucs2char_t* filename;
- uint32_t duration;
- uint16_t rating;
- uint32_t use_count;
- uint16_t format;
- uint16_t tracknumber;
- uint8_t drm;
- uint8_t lyric;
- uint8_t purchase;
- uint16_t protection;
- uint32_t samplerate;
- uint32_t bitrate;
- uint8_t changed_flag;
- uint32_t codec;
- uint32_t clusm;
- uint32_t clusa;
- uint32_t albumart_pos;
- ucs2char_t* release;
- ucs2char_t* album_artist;
- uint32_t object_uid;
- uint32_t ratingtime;
-} dat_music_t;
-
-typedef struct {
- uint32_t size;
- uint32_t num_entries;
- uint32_t unknown1;
- uint32_t unknown2;
- dat_music_t* entries;
- uint32_t* offsets;
-} dat_musics_t;
-
struct tag_dat_t {
- dat_objects_t objects;
- dat_musics_t musics;
+ dat_list_t objects;
+ dat_list_t musics;
};
typedef struct tag_dat_t dat_t;
dat_t* dat_new();
void dat_finish(dat_t* dat);
-size_t dat_serialize(uint8_t* buffer, dat_t* dat, int is_storing);
-void dat_dump(FILE *fp, dat_t* dat);
+size_t dat_serialize(dat_t* dat, const dic_t* dic, uint8_t* buffer, int is_storing);
+void dat_dump(dat_t* dat, const dic_t* dic, FILE *fp);
#endif/*__IP3DB_DAT_H__*/
Modified: trunk/pmplib/lib/pmp_iriverplus3/dic.c
===================================================================
--- trunk/pmplib/lib/pmp_iriverplus3/dic.c 2006-12-24 15:38:22 UTC (rev 196)
+++ trunk/pmplib/lib/pmp_iriverplus3/dic.c 2006-12-24 18:03:21 UTC (rev 197)
@@ -42,15 +42,60 @@
#include "ip3db.h"
#include "dic.h"
+static void dic_entry_init(dic_entry_t* entry)
+{
+ memset(entry, 0, sizeof(*entry));
+}
+
+static void dic_entry_finish(dic_entry_t* entry)
+{
+ ucs2free(entry->name);
+ dic_entry_init(entry);
+}
+
+static void dic_entry_dump(const dic_entry_t* entry, FILE *fp)
+{
+ fprintf(fp, " next: 0x%08X\n", entry->next);
+ fprintf(fp, " type: 0x%08X\n", entry->type);
+ fprintf(fp, " idx_root: 0x%08X\n", entry->idx_root);
+ fprints(fp, " name: %s\n", entry->name);
+}
+
+static void dic_list_init(dic_list_t* list)
+{
+ memset(list, 0, sizeof(*list));
+}
+
+static void dic_list_finish(dic_list_t* list)
+{
+ int i;
+ for (i = 0;i < list->num_fields;++i) {
+ dic_entry_finish(&list->fields[i]);
+ }
+ free(list->fields);
+}
+
+static void dic_list_dump(dic_list_t* list, FILE *fp)
+{
+ int i;
+ for (i = 0;i < list->num_fields;++i) {
+ const dic_entry_t* entry = &list->fields[i];
+ fprintf(fp, " FIELD %d = {\n", i);
+ dic_entry_dump(entry, fp);
+ fprintf(fp, " }\n");
+ }
+}
+
dic_t* dic_new()
{
dic_t* dic = (dic_t*)malloc(sizeof(dic_t));
if (dic) {
- memset(dic, 0, sizeof(*dic));
- dic->num_music_fields = IP3DBF_MUSIC_LAST;
- dic->music_fields = (dic_entry_t*)calloc(dic->num_music_fields, sizeof(dic_entry_t));
- dic->num_objects_fields = IP3DBF_OBJECTS_LAST;
- dic->objects_fields = (dic_entry_t*)calloc(dic->num_objects_fields, sizeof(dic_entry_t));
+ dic_list_init(&dic->music);
+ dic->music.num_fields = IP3DBF_MUSIC_LAST;
+ dic->music.fields = (dic_entry_t*)calloc(dic->music.num_fields, sizeof(dic_entry_t));
+ dic_list_init(&dic->objects);
+ dic->objects.num_fields = IP3DBF_OBJECTS_LAST;
+ dic->objects.fields = (dic_entry_t*)calloc(dic->objects.num_fields, sizeof(dic_entry_t));
}
return dic;
}
@@ -58,13 +103,13 @@
void dic_finish(dic_t* dic)
{
if (dic) {
- free(dic->music_fields);
- free(dic->objects_fields);
+ dic_list_finish(&dic->music);
+ dic_list_finish(&dic->objects);
free(dic);
}
}
-static size_t dic_serialize_field(uint8_t* block, dic_entry_t* entry, int is_storing)
+static size_t dic_serialize_entry(uint8_t* block, dic_entry_t* entry, int is_storing)
{
uint8_t *p = block;
p += serialize_uint32be(p, &entry->next, 0);
@@ -83,16 +128,16 @@
int i;
uint32_t next = 0;
- next = 0x00000056;
- for (i = 0;i < IP3DBF_MUSIC_LAST;++i) {
- dic_serialize_field(buffer + next, &dic->music_fields[i], is_storing);
- next = dic->music_fields[i].next;
+ next = 0x0000003C;
+ for (i = 0;i < dic->music.num_fields;++i) {
+ dic_serialize_entry(buffer + next, &dic->music.fields[i], is_storing);
+ next = dic->music.fields[i].next;
}
next = 0x0000099A;
- for (i = 0;i < IP3DBF_OBJECTS_LAST;++i) {
- dic_serialize_field(buffer + next, &dic->objects_fields[i], is_storing);
- next = dic->objects_fields[i].next;
+ for (i = 0;i < dic->objects.num_fields;++i) {
+ dic_serialize_entry(buffer + next, &dic->objects.fields[i], is_storing);
+ next = dic->objects.fields[i].next;
}
return 0;
@@ -100,34 +145,11 @@
void dic_dump(dic_t* dic, FILE *fp)
{
- int i;
-
fprintf(fp, "===== db.dic =====\n");
-
fprintf(fp, "MUSIC {\n");
- for (i = 0;i < IP3DBF_MUSIC_LAST;++i) {
- const dic_entry_t* entry = &dic->music_fields[i];
- fprintf(fp, " FIELD %d = {\n", i);
- fprintf(fp, " next: 0x%08X\n", entry->next);
- fprintf(fp, " type: 0x%08X\n", entry->type);
- fprintf(fp, " idx_root: 0x%08X\n", entry->idx_root);
- fprints(fp, " name: %s\n", entry->name);
- fprintf(fp, " }\n");
- }
- fprintf(fp, "}\n");
-
+ dic_list_dump(&dic->music, fp);
fprintf(fp, "OBJECTS {\n");
- for (i = 0;i < IP3DBF_OBJECTS_LAST;++i) {
- const dic_entry_t* entry = &dic->objects_fields[i];
- fprintf(fp, " FIELD %d = {\n", i);
- fprintf(fp, " next: 0x%08X\n", entry->next);
- fprintf(fp, " type: 0x%08X\n", entry->type);
- fprintf(fp, " idx_root: 0x%08X\n", entry->idx_root);
- fprints(fp, " name: %s\n", entry->name);
- fprintf(fp, " }\n");
- }
- fprintf(fp, "}\n");
-
+ dic_list_dump(&dic->objects, fp);
fprintf(fp, "\n");
}
Modified: trunk/pmplib/lib/pmp_iriverplus3/dic.h
===================================================================
--- trunk/pmplib/lib/pmp_iriverplus3/dic.h 2006-12-24 15:38:22 UTC (rev 196)
+++ trunk/pmplib/lib/pmp_iriverplus3/dic.h 2006-12-24 18:03:21 UTC (rev 197)
@@ -31,11 +31,14 @@
ucs2char_t* name;
} dic_entry_t;
+typedef struct {
+ int num_fields;
+ dic_entry_t *fields;
+} dic_list_t;
+
struct tag_dic_t {
- int num_music_fields;
- dic_entry_t *music_fields;
- int num_objects_fields;
- dic_entry_t *objects_fields;
+ dic_list_t music;
+ dic_list_t objects;
};
typedef struct tag_dic_t dic_t;
Modified: trunk/pmplib/lib/pmp_iriverplus3/idx.c
===================================================================
--- trunk/pmplib/lib/pmp_iriverplus3/idx.c 2006-12-24 15:38:22 UTC (rev 196)
+++ trunk/pmplib/lib/pmp_iriverplus3/idx.c 2006-12-24 18:03:21 UTC (rev 197)
@@ -88,20 +88,6 @@
return sizeof(tail_t);
}
-void variant_init(ip3db_variant_t* var, int type)
-{
- memset(var, 0, sizeof(*var));
- var->type = type;
-}
-
-void variant_finish(ip3db_variant_t* var)
-{
- if (var->type == IP3DBVT_STRING) {
- ucs2free(var->value.str);
- }
- variant_init(var, IP3DBVT_NONE);
-}
-
/**
* Prototype definition of a callback function for idx_walk.
* @param buffer The pointer to the index buffer.
@@ -147,7 +133,7 @@
}
/* Read the key value. */
- variant_init(&key, type);
+ ip3db_variant_init(&key, type);
switch (type) {
case IP3DBVT_BYTE:
p += serialize_uint8(p, &key.value.byte, 0);
Modified: trunk/pmplib/lib/pmp_iriverplus3/ip3db.c
===================================================================
--- trunk/pmplib/lib/pmp_iriverplus3/ip3db.c 2006-12-24 15:38:22 UTC (rev 196)
+++ trunk/pmplib/lib/pmp_iriverplus3/ip3db.c 2006-12-24 18:03:21 UTC (rev 197)
@@ -32,8 +32,8 @@
#include "util.h"
#include "ip3db.h"
+#include "dic.h"
#include "dat.h"
-#include "dic.h"
static ip3db_index_param_t ip3db_index_param[IP3DBIDX_LAST] = {
{"Music.Title", 0x0086, {IP3DBVT_STRING, IP3DBVT_NONE, IP3DBVT_NONE}},
@@ -54,6 +54,20 @@
{"Object.FileType-ParentUid-Properties", 0x0ACE, {IP3DBVT_WORD, IP3DBVT_DWORD, IP3DBVT_BYTE}},
};
+void ip3db_variant_init(ip3db_variant_t* var, int type)
+{
+ memset(var, 0, sizeof(*var));
+ var->type = type;
+}
+
+void ip3db_variant_finish(ip3db_variant_t* var)
+{
+ if (var->type == IP3DBVT_STRING) {
+ ucs2free(var->value.str);
+ }
+ ip3db_variant_init(var, IP3DBVT_NONE);
+}
+
ip3db_index_param_t* ip3db_get_indexparam(int field)
{
return &ip3db_index_param[field];
@@ -109,7 +123,7 @@
return 1;
}
- if (dat_serialize(db->dat_buffer, db->dat, 0) != 0) {
+ if (dat_serialize(db->dat, db->dic, db->dat_buffer, 0) != 0) {
ip3db_finish(db);
return 1;
}
@@ -123,7 +137,7 @@
dic_dump(db->dic, fpo);
/* Dump db.dat */
- dat_dump(fpo, db->dat);
+ dat_dump(db->dat, db->dic, fpo);
/* Dump db.idx */
idx_dump(fpo, db);
Modified: trunk/pmplib/lib/pmp_iriverplus3/ip3db.h
===================================================================
--- trunk/pmplib/lib/pmp_iriverplus3/ip3db.h 2006-12-24 15:38:22 UTC (rev 196)
+++ trunk/pmplib/lib/pmp_iriverplus3/ip3db.h 2006-12-24 18:03:21 UTC (rev 197)
@@ -97,6 +97,7 @@
IP3DBF_MUSIC_CLUSA,
IP3DBF_MUSIC_ALBUMARTPOS,
IP3DBF_MUSIC_ORGRELEASEDATE,
+ IP3DBF_MUSIC_ALBUMARTIST,
IP3DBF_MUSIC_UID,
IP3DBF_MUSIC_RATINGTIME,
IP3DBF_MUSIC_LAST,
@@ -146,6 +147,9 @@
ip3db_index_param_t* ip3db_get_indexparam(int field);
+void ip3db_variant_init(ip3db_variant_t* var, int type);
+void ip3db_variant_finish(ip3db_variant_t* var);
+
void ip3db_init(ip3db_t* db);
void ip3db_finish(ip3db_t* db);
result_t ip3db_read(ip3db_t* db, const ucs2char_t* datfn, const ucs2char_t* dicfn, const ucs2char_t* idxfn);
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
