Menu
▾
▴
[Pmplib-commits] SF.net SVN: pmplib: [383] trunk/pmplib/lib/pmp_ipod
|
From: <ny...@us...> - 2007-02-21 17:36:25
|
Revision: 383
http://svn.sourceforge.net/pmplib/?rev=383&view=rev
Author: nyaochi
Date: 2007-02-21 09:36:23 -0800 (Wed, 21 Feb 2007)
Log Message:
-----------
Incremental commit: free allocated memory blocks.
Modified Paths:
--------------
trunk/pmplib/lib/pmp_ipod/ipod.c
trunk/pmplib/lib/pmp_ipod/itunesdb.c
trunk/pmplib/lib/pmp_ipod/itunesdb.h
trunk/pmplib/lib/pmp_ipod/pmp_ipod.c
trunk/pmplib/lib/pmp_ipod/serialize.c
trunk/pmplib/lib/pmp_ipod/serialize.h
Modified: trunk/pmplib/lib/pmp_ipod/ipod.c
===================================================================
--- trunk/pmplib/lib/pmp_ipod/ipod.c 2007-02-21 15:56:22 UTC (rev 382)
+++ trunk/pmplib/lib/pmp_ipod/ipod.c 2007-02-21 17:36:23 UTC (rev 383)
@@ -19,7 +19,7 @@
*
*/
-/* $Id:$ */
+/* $Id$ */
#ifdef HAVE_CONFIG_H
#include <config.h>
@@ -45,7 +45,7 @@
void ipod_finish(ipod_t* ipod)
{
-
+ itunesdb_finish(ipod->itunesdb);
}
result_t ipod_read(ipod_t* ipod, const ucs2char_t* itunesdb)
Modified: trunk/pmplib/lib/pmp_ipod/itunesdb.c
===================================================================
--- trunk/pmplib/lib/pmp_ipod/itunesdb.c 2007-02-21 15:56:22 UTC (rev 382)
+++ trunk/pmplib/lib/pmp_ipod/itunesdb.c 2007-02-21 17:36:23 UTC (rev 383)
@@ -19,7 +19,7 @@
*
*/
-/* $Id:$ */
+/* $Id$ */
#ifdef HAVE_CONFIG_H
#include <config.h>
@@ -38,6 +38,26 @@
#include "util.h"
#include "itunesdb.h"
+
+
+static void chunk_finish(itunesdb_chunk_t* chunk)
+{
+ free(chunk->data);
+ memset(chunk, 0, sizeof(*chunk));
+}
+
+static int mhbd_init(itunesdb_chunk_t* chunk, int dataonly)
+{
+ if (!dataonly) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhbd", 4);
+ chunk->size = sizeof(chunk_mhbd_t) + 12;
+ chunk->overall_size = chunk->size;
+ }
+ chunk->data = calloc(1, sizeof(chunk_mhbd_t));
+ return chunk->data ? 0 : 1;
+}
+
static int mhbd_serialize(itunesdb_chunk_t* chunk, serializer_t* sio)
{
chunk_mhbd_t* mhbd = (chunk_mhbd_t*)chunk->data;
@@ -45,10 +65,10 @@
if (serialize_uint32le(sio, "unknown1", "%d", &mhbd->unknown1)) return 1;
if (serialize_uint32le(sio, "version", "%d", &mhbd->version)) return 1;
if (serialize_uint32le(sio, "num_children", "%d", &mhbd->num_children)) return 1;
- if (serialize_uint64le(sio, "identifier", "%lX", &mhbd->identifier)) return 1;
+ if (serialize_uint64le(sio, "identifier", "%016llX", &mhbd->identifier)) return 1;
if (serialize_uint16le(sio, "unkonwn2", "%d", &mhbd->unknown2)) return 1;
if (serialize_uint16le(sio, "unkonwn3", "%d", &mhbd->unknown3)) return 1;
- if (serialize_uint64le(sio, "unknown4", "%lX", &mhbd->unknown4)) return 1;
+ if (serialize_uint64le(sio, "unknown4", "%016llX", &mhbd->unknown4)) return 1;
if (serialize_uint8_array(sio, "unknown5", "%02X ", mhbd->unknown5, sizeof(mhbd->unknown5))) return 1;
if (serialize_uint8_array(sio, "language", "%c ", mhbd->language, sizeof(mhbd->language))) return 1;
if (serialize_uint8_array(sio, "unknown6", "%02X ", mhbd->unknown6, sizeof(mhbd->unknown6))) return 1;
@@ -56,6 +76,20 @@
return 0;
}
+
+
+static mhsd_init(itunesdb_chunk_t* chunk, int dataonly)
+{
+ if (!dataonly) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhsd", 4);
+ chunk->size = sizeof(chunk_mhsd_t) + 12;
+ chunk->overall_size = chunk->size;
+ }
+ chunk->data = calloc(1, sizeof(chunk_mhsd_t));
+ return chunk->data ? 0 : 1;
+}
+
static int mhsd_serialize(itunesdb_chunk_t* chunk, serializer_t* sio)
{
chunk_mhsd_t* mhsd = (chunk_mhsd_t*)chunk->data;
@@ -66,6 +100,20 @@
return 0;
}
+
+
+static mhlt_init(itunesdb_chunk_t* chunk, int dataonly)
+{
+ if (!dataonly) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhlt", 4);
+ chunk->size = 0; /* stands for number of children for "mhlt" chunk. */
+ chunk->overall_size = sizeof(chunk_mhlt_t) + 12;
+ }
+ chunk->data = calloc(1, sizeof(chunk_mhlt_t));
+ return chunk->data ? 0 : 1;
+}
+
static int mhlt_serialize(itunesdb_chunk_t* chunk, serializer_t* sio)
{
chunk_mhlt_t* mhlt = (chunk_mhlt_t*)chunk->data;
@@ -75,6 +123,20 @@
return 0;
}
+
+
+static mhit_init(itunesdb_chunk_t* chunk, int dataonly)
+{
+ if (!dataonly) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhit", 4);
+ chunk->size = sizeof(chunk_mhit_t) + 12;
+ chunk->overall_size = chunk->size;
+ }
+ chunk->data = calloc(1, sizeof(chunk_mhit_t));
+ return chunk->data ? 0 : 1;
+}
+
static int mhit_serialize(itunesdb_chunk_t* chunk, serializer_t* sio)
{
chunk_mhit_t* mhit = (chunk_mhit_t*)chunk->data;
@@ -108,7 +170,7 @@
if (serialize_uint32le(sio, "user_id", "%u", &mhit->user_id)) return 1;
if (serialize_uint32le(sio, "date_added", "%u", &mhit->date_added)) return 1;
if (serialize_uint32le(sio, "bookmark_time", "%u", &mhit->bookmark_time)) return 1;
- if (serialize_uint64le(sio, "dbid", "%X", &mhit->dbid)) return 1;
+ if (serialize_uint64le(sio, "dbid", "%016llX", &mhit->dbid)) return 1;
if (serialize_uint8(sio, "is_checked", "%u", &mhit->is_checked)) return 1;
if (serialize_uint8(sio, "rating_itunes", "%u", &mhit->rating_itunes)) return 1;
if (serialize_uint16le(sio, "bpm", "%u", &mhit->bpm)) return 1;
@@ -128,14 +190,14 @@
if (serialize_uint8(sio, "skip_when_shuffling", "%u", &mhit->skip_when_shuffling)) return 1;
if (serialize_uint8(sio, "remember_playback_position", "%u", &mhit->remember_playback_position)) return 1;
if (serialize_uint8(sio, "flag4", "%u", &mhit->flag4)) return 1;
- if (serialize_uint64le(sio, "dbid2", "%X", &mhit->dbid2)) return 1;
+ if (serialize_uint64le(sio, "dbid2", "%016llX", &mhit->dbid2)) return 1;
if (serialize_uint8(sio, "has_lyrics", "%u", &mhit->has_lyrics)) return 1;
if (serialize_uint8(sio, "is_movie", "%u", &mhit->is_movie)) return 1;
if (serialize_uint8(sio, "is_played", "%u", &mhit->is_played)) return 1;
if (serialize_uint8(sio, "unk17", "%u", &mhit->unk17)) return 1;
if (serialize_uint32le(sio, "unk21", "%u", &mhit->unk21)) return 1;
if (serialize_int32le(sio, "encoder_delay", "%d", &mhit->encoder_delay)) return 1;
- if (serialize_uint64le(sio, "num_samples", "%u", &mhit->num_samples)) return 1;
+ if (serialize_uint64le(sio, "num_samples", "%llu", &mhit->num_samples)) return 1;
if (serialize_uint32le(sio, "unk25", "%u", &mhit->unk25)) return 1;
if (serialize_int32le(sio, "padding_samples", "%d", &mhit->padding_samples)) return 1;
if (serialize_uint32le(sio, "unk27", "%u", &mhit->unk27)) return 1;
@@ -157,6 +219,20 @@
return 0;
}
+
+
+static mhlp_init(itunesdb_chunk_t* chunk, int dataonly)
+{
+ if (!dataonly) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhlp", 4);
+ chunk->size = 0; /* stands for number of children for "mhlt" chunk. */
+ chunk->overall_size = sizeof(chunk_mhlp_t) + 12;
+ }
+ chunk->data = calloc(1, sizeof(chunk_mhlp_t));
+ return chunk->data ? 0 : 1;
+}
+
static int mhlp_serialize(itunesdb_chunk_t* chunk, serializer_t* sio)
{
chunk_mhlp_t* mhlp = (chunk_mhlp_t*)chunk->data;
@@ -166,6 +242,20 @@
return 0;
}
+
+
+static mhyp_init(itunesdb_chunk_t* chunk, int dataonly)
+{
+ if (dataonly) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhyp", 4);
+ chunk->size = sizeof(chunk_mhyp_t) + 12;
+ chunk->overall_size = chunk->size;
+ }
+ chunk->data = calloc(1, sizeof(chunk_mhyp_t));
+ return chunk->data ? 0 : 1;
+}
+
static int mhyp_serialize(itunesdb_chunk_t* chunk, serializer_t* sio)
{
chunk_mhyp_t* mhyp = (chunk_mhyp_t*)chunk->data;
@@ -177,7 +267,7 @@
if (serialize_uint8(sio, "flag_unkonwn2", "%u", &mhyp->flag_unkonwn2)) return 1;
if (serialize_uint8(sio, "flag_unkonwn3", "%u", &mhyp->flag_unkonwn3)) return 1;
if (serialize_uint32le(sio, "timestamp", "%u", &mhyp->timestamp)) return 1;
- if (serialize_uint64le(sio, "id", "%u", &mhyp->id)) return 1;
+ if (serialize_uint64le(sio, "id", "%016llX", &mhyp->id)) return 1;
if (serialize_uint32le(sio, "unk3", "%u", &mhyp->unk3)) return 1;
if (serialize_uint16le(sio, "unk4", "%u", &mhyp->unk4)) return 1;
if (serialize_uint16le(sio, "flag_podcast", "%u", &mhyp->flag_podcast)) return 1;
@@ -187,6 +277,20 @@
return 0;
}
+
+
+static mhip_init(itunesdb_chunk_t* chunk, int dataonly)
+{
+ if (!dataonly) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhip", 4);
+ chunk->size = sizeof(chunk_mhip_t) + 12;
+ chunk->overall_size = chunk->size;
+ }
+ chunk->data = calloc(1, sizeof(chunk_mhip_t));
+ return chunk->data ? 0 : 1;
+}
+
static int mhip_serialize(itunesdb_chunk_t* chunk, serializer_t* sio)
{
chunk_mhip_t* mhyp = (chunk_mhip_t*)chunk->data;
@@ -201,12 +305,20 @@
return 0;
}
+
+
+static void mhod_string_finish(itunesdb_chunk_t* chunk)
+{
+ chunk_mhod_t* mhod = (chunk_mhod_t*)chunk->data;
+ chunk_mhod_string_t* string = &mhod->data.str;
+ ucs2free(string->value);
+ memset(string, 0, sizeof(*string));
+}
+
static int mhod_string_serialize(itunesdb_chunk_t* chunk, const char *name, serializer_t* sio)
{
chunk_mhod_string_t* string = &((chunk_mhod_t*)chunk->data)->data.str;
- if (serialize_uint32le(sio, "unk1", "%u", &string->unk1)) return 1;
- if (serialize_uint32le(sio, "unk2", "%u", &string->unk2)) return 1;
if (serialize_uint32le(sio, "position", "%u", &string->position)) return 1;
if (serialize_uint32le(sio, "size", "%u", &string->size)) return 1;
if (serialize_uint32le(sio, "unknown", "%u", &string->unknown)) return 1;
@@ -216,26 +328,38 @@
return 0;
}
+static void mhod_url_finish(itunesdb_chunk_t* chunk)
+{
+ chunk_mhod_t* mhod = (chunk_mhod_t*)chunk->data;
+ chunk_mhod_url_t* url = &mhod->data.url;
+ ucs2free(url->value);
+ memset(url, 0, sizeof(*url));
+}
+
static int mhod_url_serialize(itunesdb_chunk_t* chunk, const char *name, serializer_t* sio)
{
chunk_mhod_t* mhod = (chunk_mhod_t*)chunk->data;
chunk_mhod_url_t* url = &mhod->data.url;
- if (serialize_uint32le(sio, "unk1", "%u", &url->unk1)) return 1;
- if (serialize_uint32le(sio, "unk2", "%u", &url->unk2)) return 1;
- if (serialize_utf8str_fixed(sio, name, "%s", &url->value, chunk->data_size - chunk->chunk_size)) return 1;
+ if (serialize_utf8str_fixed(sio, name, "%s", &url->value, chunk->size - chunk->overall_size)) return 1;
return 0;
}
+static void mhod_index_finish(itunesdb_chunk_t* chunk)
+{
+ chunk_mhod_t* mhod = (chunk_mhod_t*)chunk->data;
+ chunk_mhod_index_t* index = &mhod->data.index;
+ ucs2free(index->entries);
+ memset(index, 0, sizeof(*index));
+}
+
static int mhod_index_serialize(itunesdb_chunk_t* chunk, const char *name, serializer_t* sio)
{
uint32_t i;
chunk_mhod_t* mhod = (chunk_mhod_t*)chunk->data;
chunk_mhod_index_t* index = &mhod->data.index;
- if (serialize_uint32le(sio, "unk1", "%u", &index->unk1)) return 1;
- if (serialize_uint32le(sio, "unk2", "%u", &index->unk2)) return 1;
if (serialize_uint32le(sio, "type", "%u", &index->type)) return 1;
if (serialize_uint32le(sio, "num_entries", "%u", &index->num_entries)) return 1;
if (serialize_uint8_array(sio, "padding", "%02X ", index->padding, sizeof(index->padding))) return 1;
@@ -257,16 +381,22 @@
return 0;
}
+static void mhod_playlist_column_finish(itunesdb_chunk_t* chunk)
+{
+ chunk_mhod_t* mhod = (chunk_mhod_t*)chunk->data;
+ chunk_mhod_playlist_column_t* pc = &mhod->data.pc;
+ ucs2free(pc->columns);
+ memset(pc, 0, sizeof(*pc));
+}
+
static int mhod_playlist_column_serialize(itunesdb_chunk_t* chunk, const char *name, serializer_t* sio)
{
uint32_t i;
chunk_mhod_t* mhod = (chunk_mhod_t*)chunk->data;
chunk_mhod_playlist_column_t* pc = &mhod->data.pc;
- if (serialize_uint32le(sio, "unk1", "%u", &pc->unk1)) return 1;
- if (serialize_uint32le(sio, "unk2", "%u", &pc->unk2)) return 1;
if (serialize_uint32le(sio, "unk3", "%u", &pc->unk3)) return 1;
- if (serialize_uint64le(sio, "unk4", "%u", &pc->unk4)) return 1;
+ if (serialize_uint64le(sio, "unk4", "%016llX", &pc->unk4)) return 1;
if (serialize_uint32le(sio, "unk8", "%u", &pc->unk8)) return 1;
if (serialize_uint16le(sio, "unk9", "%u", &pc->unk9)) return 1;
if (serialize_uint16le(sio, "unk10", "%u", &pc->unk10)) return 1;
@@ -294,19 +424,24 @@
sprintf(fieldname, "columns[%d].sort_direction", i);
if (serialize_uint32le(sio, fieldname, "%u", &def->sort_direction)) return 1;
sprintf(fieldname, "columns[%d].padding", i);
- if (serialize_uint64le(sio, fieldname, "%u", &def->padding)) return 1;
+ if (serialize_uint64le(sio, fieldname, "%016llX", &def->padding)) return 1;
}
return 0;
}
+static void mhod_playlist_order_finish(itunesdb_chunk_t* chunk)
+{
+ chunk_mhod_t* mhod = (chunk_mhod_t*)chunk->data;
+ chunk_mhod_playlist_order_t* po = &mhod->data.po;
+ memset(po, 0, sizeof(*po));
+}
+
static int mhod_playlist_order_serialize(itunesdb_chunk_t* chunk, const char *name, serializer_t* sio)
{
chunk_mhod_t* mhod = (chunk_mhod_t*)chunk->data;
chunk_mhod_playlist_order_t* po = &mhod->data.po;
- if (serialize_uint32le(sio, "unk1", "%u", &po->unk1)) return 1;
- if (serialize_uint32le(sio, "unk2", "%u", &po->unk2)) return 1;
if (serialize_uint32le(sio, "position", "%u", &po->position)) return 1;
if (serialize_uint8_array(sio, "padding", "%02X ", po->padding, sizeof(po->padding))) return 1;
@@ -316,23 +451,23 @@
static const itunesdb_mhoddecl_t* find_mhoddecl(itunesdb_chunk_t* chunk)
{
static const itunesdb_mhoddecl_t mds[] = {
- {1, "title", 0, mhod_string_serialize},
- {2, "location", 0, mhod_string_serialize},
- {3, "album", 0, mhod_string_serialize},
- {4, "artist", 0, mhod_string_serialize},
- {5, "genre", 0, mhod_string_serialize},
- {6, "filetype", 0, mhod_string_serialize},
- {7, "EQ setting", 0, mhod_string_serialize},
- {8, "comment", 0, mhod_string_serialize},
- {9, "category", 0, mhod_string_serialize},
- {12, "composer", 0, mhod_string_serialize},
- {13, "grouping", 0, mhod_string_serialize},
- {14, "description", 0, mhod_string_serialize},
- {15, "podcast_enclosure_url", 0, mhod_url_serialize},
- {16, "podcast_rss_url", 0, mhod_url_serialize},
- {52, "index", 0, mhod_index_serialize},
- {100, "playlist_column", 0x288, mhod_playlist_column_serialize},
- {100, "playlist_order", 0x2C, mhod_playlist_order_serialize},
+ {1, "title", 0, mhod_string_finish, mhod_string_serialize},
+ {2, "location", 0, mhod_string_finish, mhod_string_serialize},
+ {3, "album", 0, mhod_string_finish, mhod_string_serialize},
+ {4, "artist", 0, mhod_string_finish, mhod_string_serialize},
+ {5, "genre", 0, mhod_string_finish, mhod_string_serialize},
+ {6, "filetype", 0, mhod_string_finish, mhod_string_serialize},
+ {7, "EQ setting", 0, mhod_string_finish, mhod_string_serialize},
+ {8, "comment", 0, mhod_string_finish, mhod_string_serialize},
+ {9, "category", 0, mhod_string_finish, mhod_string_serialize},
+ {12, "composer", 0, mhod_string_finish, mhod_string_serialize},
+ {13, "grouping", 0, mhod_string_finish, mhod_string_serialize},
+ {14, "description", 0, mhod_string_finish, mhod_string_serialize},
+ {15, "podcast_enclosure_url", 0, mhod_url_finish, mhod_url_serialize},
+ {16, "podcast_rss_url", 0, mhod_url_finish, mhod_url_serialize},
+ {52, "index", 0, mhod_index_finish, mhod_index_serialize},
+ {100, "playlist_column", 0x288, mhod_playlist_column_finish, mhod_playlist_column_serialize},
+ {100, "playlist_order", 0x2C, mhod_playlist_order_finish, mhod_playlist_order_serialize},
{0, NULL, 0, NULL},
};
const itunesdb_mhoddecl_t* decl = mds;
@@ -340,7 +475,7 @@
while (decl->name) {
if (decl->type == mhod->type) {
- if (decl->chunk_size == 0 || decl->chunk_size == chunk->chunk_size) {
+ if (decl->overall_size == 0 || decl->overall_size == chunk->overall_size) {
return decl;
}
}
@@ -349,12 +484,36 @@
return NULL;
}
+static int mhod_init(itunesdb_chunk_t* chunk, int dataonly)
+{
+ if (!dataonly) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhod", 4);
+ chunk->size = 0x18;
+ chunk->overall_size = chunk->size;
+ }
+ chunk->data = calloc(1, sizeof(chunk_mhod_t));
+ return chunk->data ? 0 : 1;
+}
+
+static void mhod_finish(itunesdb_chunk_t* chunk)
+{
+ chunk_mhod_t* mhod = (chunk_mhod_t*)chunk->data;
+ const itunesdb_mhoddecl_t* decl = NULL;
+ decl = find_mhoddecl(chunk);
+ if (decl) {
+ decl->finish(chunk);
+ }
+}
+
static int mhod_serialize(itunesdb_chunk_t* chunk, serializer_t* sio)
{
chunk_mhod_t* mhod = (chunk_mhod_t*)chunk->data;
const itunesdb_mhoddecl_t* decl = NULL;
if (serialize_uint32le(sio, "type", "%u", &mhod->type)) return 1;
+ if (serialize_uint32le(sio, "unk1", "%u", &mhod->unk1)) return 1;
+ if (serialize_uint32le(sio, "unk2", "%u", &mhod->unk2)) return 1;
decl = find_mhoddecl(chunk);
if (decl) {
@@ -373,15 +532,15 @@
static const itunesdb_chunkdecl_t* find_chunkdecl(itunesdb_chunk_t* chunk)
{
static const itunesdb_chunkdecl_t cds[] = {
- {"mhbd", sizeof(chunk_mhbd_t), mhbd_serialize},
- {"mhsd", sizeof(chunk_mhsd_t), mhsd_serialize},
- {"mhlt", sizeof(chunk_mhlt_t), mhlt_serialize},
- {"mhit", sizeof(chunk_mhit_t), mhit_serialize},
- {"mhlp", sizeof(chunk_mhlp_t), mhlp_serialize},
- {"mhyp", sizeof(chunk_mhyp_t), mhyp_serialize},
- {"mhip", sizeof(chunk_mhip_t), mhip_serialize},
- {"mhod", sizeof(chunk_mhod_t), mhod_serialize},
- {NULL, 0, NULL},
+ {"mhbd", mhbd_init, chunk_finish, mhbd_serialize},
+ {"mhsd", mhsd_init, chunk_finish, mhsd_serialize},
+ {"mhlt", mhlt_init, chunk_finish, mhlt_serialize},
+ {"mhit", mhit_init, chunk_finish, mhit_serialize},
+ {"mhlp", mhlp_init, chunk_finish, mhlp_serialize},
+ {"mhyp", mhyp_init, chunk_finish, mhyp_serialize},
+ {"mhip", mhip_init, chunk_finish, mhip_serialize},
+ {"mhod", mhod_init, mhod_finish, mhod_serialize},
+ {NULL, NULL, NULL, NULL},
};
const itunesdb_chunkdecl_t* decl = cds;
@@ -394,6 +553,21 @@
return NULL;
}
+void itunesdb_finish(itunesdb_chunk_t* chunk)
+{
+ uint32_t i;
+ const itunesdb_chunkdecl_t* decl = NULL;
+
+ for (i = 0;i < chunk->num_children;++i) {
+ itunesdb_finish(&chunk->childlen[i]);
+ }
+
+ decl = find_chunkdecl(chunk);
+ if (decl) {
+ decl->finish(chunk);
+ }
+}
+
int itunesdb_repr(itunesdb_chunk_t* chunk, size_t index, serializer_t* sio)
{
uint32_t i;
@@ -409,9 +583,9 @@
serialize_indent(sio);
fprintf(sio->fp, "offset: %08X\n", chunk->offset);
serialize_indent(sio);
- fprintf(sio->fp, "data_size: %d\n", chunk->data_size);
+ fprintf(sio->fp, "size: %d\n", chunk->size);
serialize_indent(sio);
- fprintf(sio->fp, "chunk_size: %d\n", chunk->chunk_size);
+ fprintf(sio->fp, "overall_size: %d\n", chunk->overall_size);
/* Show fields in the chunk data */
decl = find_chunkdecl(chunk);
@@ -449,26 +623,25 @@
/* Read the chunk ID and header information */
chunk->offset = begin;
if (serialize_uint8_array(sio, "id", "%c ", chunk->id, sizeof(chunk->id))) return 1;
- if (serialize_uint32le(sio, "data_size", "%d", &chunk->data_size)) return 1;
- if (serialize_uint32le(sio, "chunk_size", "%d", &chunk->chunk_size)) return 1;
+ if (serialize_uint32le(sio, "size", "%d", &chunk->size)) return 1;
+ if (serialize_uint32le(sio, "overall_size", "%d", &chunk->overall_size)) return 1;
/* Read the chunk data if this chunk is 'known' */
decl = find_chunkdecl(chunk);
if (decl) {
- chunk->data = calloc(1, decl->data_size);
- if (chunk->data) {
+ if (decl->init(chunk, 1) == 0) {
if (decl->serialize(chunk, sio)) return 1;
}
}
if (strncmp(chunk->id, "mhod", 4) == 0) {
- uint32_t next = begin + chunk->chunk_size;
+ uint32_t next = begin + chunk->overall_size;
if (next < serialize_tell(sio)) {
fprintf(stderr, "WARNING: backward seeking.\n");
}
serialize_seek(sio, next);
} else {
- uint32_t next = begin + chunk->data_size;
+ uint32_t next = begin + chunk->size;
if (next < serialize_tell(sio)) {
fprintf(stderr, "WARNING: backward seeking.\n");
}
@@ -477,17 +650,17 @@
/* Read children for this chunk. */
if (strncmp(chunk->id, "mhlt", 4) == 0 || strncmp(chunk->id, "mhlp", 4) == 0) {
- /* chunk->chunk_size represents the number of children for "mhlt" and "mhlp" chunks */
- chunk->num_children = chunk->chunk_size;
+ /* chunk->overall_size represents the number of children for "mhlt" and "mhlp" chunks */
+ chunk->num_children = chunk->overall_size;
chunk->childlen = (itunesdb_chunk_t*)calloc(chunk->num_children, sizeof(itunesdb_chunk_t));
for (i = 0;i < chunk->num_children;++i) {
itunesdb_read(&chunk->childlen[i], sio);
}
} else {
- /* chunk->chunk_size represents the size in bytes of this chunk */
+ /* chunk->overall_size represents the size in bytes of this chunk */
chunk->num_children = 0;
chunk->childlen = NULL;
- while (sio->offset - begin < chunk->chunk_size) {
+ while (sio->offset - begin < chunk->overall_size) {
chunk->num_children;
chunk->childlen = realloc(chunk->childlen, sizeof(itunesdb_chunk_t) * (chunk->num_children + 1));
memset(&chunk->childlen[chunk->num_children], 0, sizeof(itunesdb_chunk_t));
@@ -498,29 +671,3 @@
return 0;
}
-
-#if 0
-int main(int argc, char *argv[])
-{
- FILE *fp = fopen("C:\\pmplib\\ipod_nano\\iPod_Control\\iTunes\\iTunesDB", "rb");
- if (fp) {
- serializer_t sio;
- uint8_t* buffer = NULL;
- long size = 0;
- itunesdb_chunk_t root;
-
- fread_all(fp, &buffer, &size);
- fclose(fp);
-
- serialize_init_read(&sio, buffer, (size_t)size);
- chunk_read(&root, &sio);
- serialize_finish(&sio);
-
- serialize_init_dump(&sio, stdout, 2);
- chunk_repr(&root, 0, &sio);
- serialize_finish(&sio);
- }
-
- return 0;
-}
-#endif
\ No newline at end of file
Modified: trunk/pmplib/lib/pmp_ipod/itunesdb.h
===================================================================
--- trunk/pmplib/lib/pmp_ipod/itunesdb.h 2007-02-21 15:56:22 UTC (rev 382)
+++ trunk/pmplib/lib/pmp_ipod/itunesdb.h 2007-02-21 17:36:23 UTC (rev 383)
@@ -19,7 +19,7 @@
*
*/
-/* $Id:$ */
+/* $Id$ */
#ifndef __ITUNESDB_H__
#define __ITUNESDB_H__
@@ -153,8 +153,6 @@
} chunk_mhip_t;
typedef struct {
- uint32_t unk1;
- uint32_t unk2;
uint32_t position;
uint32_t size;
uint32_t unknown;
@@ -163,14 +161,10 @@
} chunk_mhod_string_t;
typedef struct {
- uint32_t unk1;
- uint32_t unk2;
char* value;
} chunk_mhod_url_t;
typedef struct {
- uint32_t unk1;
- uint32_t unk2;
uint32_t type;
uint32_t num_entries;
uint8_t padding[40];
@@ -199,14 +193,14 @@
} chunk_mhod_playlist_column_t;
typedef struct {
- uint32_t unk1;
- uint32_t unk2;
uint32_t position;
uint8_t padding[16];
} chunk_mhod_playlist_order_t;
typedef struct {
uint32_t type;
+ uint32_t unk1;
+ uint32_t unk2;
union {
chunk_mhod_string_t str;
chunk_mhod_url_t url;
@@ -219,8 +213,8 @@
struct tag_itunesdb_chunk {
int8_t id[4];
- uint32_t data_size;
- uint32_t chunk_size;
+ uint32_t size;
+ uint32_t overall_size;
void* data;
uint32_t num_children; /* This field does not exist in iTunesDB. */
@@ -231,17 +225,20 @@
typedef struct {
uint32_t type;
const char* name;
- size_t chunk_size;
+ size_t overall_size;
+ void (*finish)(itunesdb_chunk_t* chunk);
int (*serialize)(itunesdb_chunk_t* chunk, const char *name, serializer_t* sio);
} itunesdb_mhoddecl_t;
typedef struct {
const char* name;
- size_t data_size;
+ int (*init)(itunesdb_chunk_t* chunk, int dataonly);
+ void (*finish)(itunesdb_chunk_t* chunk);
int (*serialize)(itunesdb_chunk_t* chunk, serializer_t* sio);
} itunesdb_chunkdecl_t;
-int itunesdb_repr(itunesdb_chunk_t* chunk, size_t index, serializer_t* sio);
-int itunesdb_read(itunesdb_chunk_t* chunk, serializer_t* sio);
+void itunesdb_finish(itunesdb_chunk_t* mhbd);
+int itunesdb_repr(itunesdb_chunk_t* mhbd, size_t index, serializer_t* sio);
+int itunesdb_read(itunesdb_chunk_t* mhbd, serializer_t* sio);
#endif/*__ITUNESDB_H__*/
Modified: trunk/pmplib/lib/pmp_ipod/pmp_ipod.c
===================================================================
--- trunk/pmplib/lib/pmp_ipod/pmp_ipod.c 2007-02-21 15:56:22 UTC (rev 382)
+++ trunk/pmplib/lib/pmp_ipod/pmp_ipod.c 2007-02-21 17:36:23 UTC (rev 383)
@@ -19,7 +19,7 @@
*
*/
-/* $Id:$ */
+/* $Id$ */
#ifdef HAVE_CONFIG_H
#include <config.h>
@@ -63,7 +63,7 @@
static const ipod_descriptor_t g_model_descriptions[] = {
{
- "ipod", "Apple", "iPod", "UM",
+ "apple_ipod", "Apple", "iPod", "UM",
"---", "---",
"iPod_Control\\iTunes\\iTunesDB",
".mp3\0",
Modified: trunk/pmplib/lib/pmp_ipod/serialize.c
===================================================================
--- trunk/pmplib/lib/pmp_ipod/serialize.c 2007-02-21 15:56:22 UTC (rev 382)
+++ trunk/pmplib/lib/pmp_ipod/serialize.c 2007-02-21 17:36:23 UTC (rev 383)
@@ -251,7 +251,7 @@
serialize_uint8(sio, name, format, (uint8_t*)&str[i]);
}
} else if (sio->mode < 0) {
- char* str = calloc(size+1, sizeof(char));
+ char* str = (char*)ucs2calloc(sizeof(char) * (size+1));
for (i = 0;i < size;++i) {
serialize_uint8(sio, name, format, (uint8_t*)&str[i]);
}
@@ -276,7 +276,7 @@
return 0;
}
-uint32_t serialize_tell(serializer_t* sio)
+size_t serialize_tell(serializer_t* sio)
{
return sio->offset;
}
Modified: trunk/pmplib/lib/pmp_ipod/serialize.h
===================================================================
--- trunk/pmplib/lib/pmp_ipod/serialize.h 2007-02-21 15:56:22 UTC (rev 382)
+++ trunk/pmplib/lib/pmp_ipod/serialize.h 2007-02-21 17:36:23 UTC (rev 383)
@@ -54,7 +54,7 @@
int serialize_utf8str_fixed(serializer_t* sio, const char *name, const char *format, char** value, size_t size);
int serialize_seek(serializer_t* sio, size_t offset);
-uint32_t serialize_tell(serializer_t* sio);
+size_t serialize_tell(serializer_t* sio);
void serialize_indent(serializer_t* sio);
void serialize_indent_ascend(serializer_t* sio);
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
