Menu
▾
▴
[Pmplib-commits] SF.net SVN: pmplib: [420] trunk/pmplib/lib/pmp_ipod
|
From: <ny...@us...> - 2007-10-05 14:47:50
|
Revision: 420
http://pmplib.svn.sourceforge.net/pmplib/?rev=420&view=rev
Author: nyaochi
Date: 2007-10-05 07:47:54 -0700 (Fri, 05 Oct 2007)
Log Message:
-----------
Initial commit of ArtworkDB routines.
Added Paths:
-----------
trunk/pmplib/lib/pmp_ipod/artworkdb.c
trunk/pmplib/lib/pmp_ipod/artworkdb.h
Added: trunk/pmplib/lib/pmp_ipod/artworkdb.c
===================================================================
--- trunk/pmplib/lib/pmp_ipod/artworkdb.c (rev 0)
+++ trunk/pmplib/lib/pmp_ipod/artworkdb.c 2007-10-05 14:47:54 UTC (rev 420)
@@ -0,0 +1,375 @@
+/*
+ * ArtworkDB reader/writer/dumper.
+ *
+ * Copyright (c) 2005-2007 Naoaki Okazaki
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+/* $Id:$ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif/*HAVE_CONFIG_H*/
+
+#include <os.h>
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif/*HAVE_STRING_H*/
+#include <pmplib/ucs2char.h>
+
+#include "status.h"
+#include "ipod.h"
+#include "serialize.h"
+#include "util.h"
+#include "artworkdb.h"
+
+static void chunk_finish(artworkdb_chunk_t* chunk)
+{
+ free(chunk->data);
+ free(chunk->padding);
+ memset(chunk, 0, sizeof(*chunk));
+}
+
+static int mhfd_init(artworkdb_chunk_t* chunk, int def)
+{
+ artworkdb_mhfd_t* mhfd = NULL;
+
+ if (def) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhfd", 4);
+ chunk->size = 132;
+ chunk->overall_size = 0; /* to be filled */
+ }
+
+ mhfd = (artworkdb_mhfd_t*)calloc(1, sizeof(artworkdb_mhfd_t));
+ if (def && mhfd) {
+ mhfd->unknown1 = 0;
+ mhfd->version = 2; /* iTunes 4.9 or above */
+ mhfd->num_children = 0; /* to be filled */
+ mhfd->unknown3 = 0;
+ mhfd->next_nhii = 0;
+ mhfd->unknown5 = 0;
+ mhfd->unknown6 = 0;
+ mhfd->unknown7 = 2;
+ mhfd->unknown8 = 0;
+ mhfd->unknown9 = 0;
+ mhfd->unknown10 = 0;
+ mhfd->unknown11 = 0;
+ }
+ chunk->data = mhfd;
+ return mhfd ? 0 : IPODE_OUTOFMEMORY;
+}
+
+static int mhfd_serialize(artworkdb_chunk_t* chunk, serializer_t* sio)
+{
+ int ret = 0;
+ artworkdb_mhfd_t* mhfd = (artworkdb_mhfd_t*)chunk->data;
+
+ if (ret = serialize_uint32le(sio, "unknown1", "%d", &mhfd->unknown1)) return ret;
+ if (ret = serialize_uint32le(sio, "version", "%d", &mhfd->version)) return ret;
+ if (ret = serialize_uint32le(sio, "num_children", "%d", &mhfd->num_children)) return ret;
+ if (ret = serialize_uint32le(sio, "unknown3", "%d", &mhfd->unknown3)) return ret;
+ if (ret = serialize_uint32le(sio, "next_nhii", "%d", &mhfd->next_nhii)) return ret;
+ if (ret = serialize_uint64le(sio, "unknown5", "%016llX", &mhfd->unknown5)) return ret;
+ if (ret = serialize_uint64le(sio, "unknown6", "%016llX", &mhfd->unknown6)) return ret;
+ if (ret = serialize_uint32le(sio, "unknown7", "%d", &mhfd->unknown7)) return ret;
+ if (ret = serialize_uint32le(sio, "unknown8", "%d", &mhfd->unknown8)) return ret;
+ if (ret = serialize_uint32le(sio, "unknown9", "%d", &mhfd->unknown9)) return ret;
+ if (ret = serialize_uint32le(sio, "unknown10", "%d", &mhfd->unknown10)) return ret;
+ if (ret = serialize_uint32le(sio, "unknown11", "%d", &mhfd->unknown10)) return ret;
+
+ return 0;
+}
+
+
+
+static mhsd_init(artworkdb_chunk_t* chunk, int def)
+{
+ artworkdb_mhsd_t* mhsd = NULL;
+
+ if (def) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhsd", 4);
+ chunk->size = 96;
+ chunk->overall_size = 0; /* to be filled */
+ }
+
+ mhsd = (artworkdb_mhsd_t*)calloc(1, sizeof(artworkdb_mhsd_t));
+ if (mhsd && def) {
+ mhsd->type = 0; /* to be filled */
+ }
+
+ chunk->data = mhsd;
+ return mhsd ? 0 : IPODE_OUTOFMEMORY;
+}
+
+static int mhsd_serialize(artworkdb_chunk_t* chunk, serializer_t* sio)
+{
+ int ret = 0;
+ artworkdb_mhsd_t* mhsd = (artworkdb_mhsd_t*)chunk->data;
+
+ if (ret = serialize_uint32le(sio, "type", "%d", &mhsd->type)) return ret;
+
+ return 0;
+}
+
+
+
+static mhli_init(artworkdb_chunk_t* chunk, int def)
+{
+ if (def) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhli", 4);
+ chunk->size = 96;
+ chunk->overall_size = 0; /* to be filled */
+ }
+
+ chunk->data = 0;
+ return 0;
+}
+
+static int mhli_serialize(artworkdb_chunk_t* chunk, serializer_t* sio)
+{
+ return 0;
+}
+
+
+
+static int mhii_init(artworkdb_chunk_t* chunk, int def)
+{
+ artworkdb_mhii_t* mhii = NULL;
+
+ if (def) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhii", 4);
+ chunk->size = 104;
+ chunk->overall_size = 0; /* to be filled */
+ }
+
+ mhii = (artworkdb_mhii_t*)calloc(1, sizeof(artworkdb_mhii_t));
+ if (def && mhii) {
+ mhii->num_children = 0;
+ mhii->id = 0;
+ mhii->song_id = 0;
+ mhii->unknown4 = 0;
+ mhii->rating = 0;
+ mhii->unknown6 = 0;
+ mhii->ts_file = 0;
+ mhii->ts_import = 0;
+ mhii->original_size = 0;
+ }
+ chunk->data = mhii;
+ return mhii ? 0 : IPODE_OUTOFMEMORY;
+}
+
+static int mhii_serialize(artworkdb_chunk_t* chunk, serializer_t* sio)
+{
+ int ret = 0;
+ artworkdb_mhii_t* mhii = (artworkdb_mhii_t*)chunk->data;
+
+ if (ret = serialize_uint32le(sio, "num_children", "%d", &mhii->num_children)) return ret;
+ if (ret = serialize_uint32le(sio, "id", "%d", &mhii->id)) return ret;
+ if (ret = serialize_uint64le(sio, "song_id", "%016llX", &mhii->song_id)) return ret;
+ if (ret = serialize_uint32le(sio, "unknown4", "%d", &mhii->unknown4)) return ret;
+ if (ret = serialize_uint32le(sio, "rating", "%d", &mhii->rating)) return ret;
+ if (ret = serialize_uint32le(sio, "unknown6", "%d", &mhii->unknown6)) return ret;
+ if (ret = serialize_uint32le(sio, "ts_file", "%d", &mhii->ts_file)) return ret;
+ if (ret = serialize_uint32le(sio, "ts_import", "%d", &mhii->ts_import)) return ret;
+ if (ret = serialize_uint32le(sio, "original_size", "%d", &mhii->original_size)) return ret;
+
+ return 0;
+}
+
+
+static int mhni_init(artworkdb_chunk_t* chunk, int def)
+{
+ artworkdb_mhni_t* mhni = NULL;
+
+ if (def) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhni", 4);
+ chunk->size = 104;
+ chunk->overall_size = 0; /* to be filled */
+ }
+
+ mhni = (artworkdb_mhni_t*)calloc(1, sizeof(artworkdb_mhni_t));
+ if (def && mhni) {
+ mhni->num_children = 0;
+ mhni->correlation_id = 0;
+ mhni->ithmb_offset = 0;
+ mhni->ithmb_size = 0;
+ mhni->vertical_padding = 0;
+ mhni->horizontal_padding = 0;
+ mhni->height = 0;
+ mhni->width = 0;
+ }
+ chunk->data = mhni;
+ return mhni ? 0 : IPODE_OUTOFMEMORY;
+}
+
+static int mhni_serialize(artworkdb_chunk_t* chunk, serializer_t* sio)
+{
+ int ret = 0;
+ artworkdb_mhni_t* mhni = (artworkdb_mhni_t*)chunk->data;
+
+ if (ret = serialize_uint32le(sio, "num_children", "%d", &mhni->num_children)) return ret;
+ if (ret = serialize_uint32le(sio, "correlation_id", "%d", &mhni->correlation_id)) return ret;
+ if (ret = serialize_uint32le(sio, "ithmb_offset", "%d", &mhni->ithmb_offset)) return ret;
+ if (ret = serialize_uint32le(sio, "ithmb_size", "%d", &mhni->ithmb_size)) return ret;
+ if (ret = serialize_uint16le(sio, "vertical_padding", "%d", &mhni->vertical_padding)) return ret;
+ if (ret = serialize_uint16le(sio, "horizontal_padding", "%d", &mhni->horizontal_padding)) return ret;
+ if (ret = serialize_uint16le(sio, "height", "%d", &mhni->height)) return ret;
+ if (ret = serialize_uint16le(sio, "width", "%d", &mhni->width)) return ret;
+ if (ret = serialize_uint32le(sio, "unknown", "%d", &mhni->unknown)) return ret;
+ if (ret = serialize_uint32le(sio, "image_size", "%d", &mhni->image_size)) return ret;
+
+ return 0;
+}
+
+
+
+static int mhba_init(artworkdb_chunk_t* chunk, int def)
+{
+ artworkdb_mhba_t* mhba = NULL;
+
+ if (def) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhba", 4);
+ chunk->size = 104;
+ chunk->overall_size = 0; /* to be filled */
+ }
+
+ mhba = (artworkdb_mhba_t*)calloc(1, sizeof(artworkdb_mhba_t));
+ if (def && mhba) {
+ }
+ chunk->data = mhba;
+ return mhba ? 0 : IPODE_OUTOFMEMORY;
+}
+
+static int mhba_serialize(artworkdb_chunk_t* chunk, serializer_t* sio)
+{
+ int ret = 0;
+ artworkdb_mhba_t* mhba = (artworkdb_mhba_t*)chunk->data;
+
+ if (ret = serialize_uint32le(sio, "num_mhod", "%d", &mhba->num_mhod)) return ret;
+ if (ret = serialize_uint32le(sio, "num_mhia", "%d", &mhba->num_mhia)) return ret;
+ if (ret = serialize_uint32le(sio, "playlist_id", "%d", &mhba->playlist_id)) return ret;
+ if (ret = serialize_uint32le(sio, "unk2", "%d", &mhba->unk2)) return ret;
+ if (ret = serialize_uint16le(sio, "unk3", "%d", &mhba->unk3)) return ret;
+ if (ret = serialize_uint8(sio, "album_type", "%d", &mhba->album_type)) return ret;
+ if (ret = serialize_uint8(sio, "play_music", "%d", &mhba->play_music)) return ret;
+ if (ret = serialize_uint8(sio, "repeat", "%d", &mhba->repeat)) return ret;
+ if (ret = serialize_uint8(sio, "random", "%d", &mhba->random)) return ret;
+ if (ret = serialize_uint8(sio, "show_titles", "%d", &mhba->show_titles)) return ret;
+ if (ret = serialize_uint8(sio, "transition_direction", "%d", &mhba->transition_direction)) return ret;
+ if (ret = serialize_uint32le(sio, "slide_duration", "%d", &mhba->slide_duration)) return ret;
+ if (ret = serialize_uint32le(sio, "transition_duration", "%d", &mhba->transition_duration)) return ret;
+ if (ret = serialize_uint32le(sio, "unk7", "%d", &mhba->unk7)) return ret;
+ if (ret = serialize_uint32le(sio, "unk8", "%d", &mhba->unk8)) return ret;
+ if (ret = serialize_uint64le(sio, "dbid2", "%016llX", &mhba->dbid2)) return ret;
+ if (ret = serialize_uint32le(sio, "prev_playlist_id", "%d", &mhba->prev_playlist_id)) return ret;
+
+ return 0;
+}
+
+
+
+static mhia_init(artworkdb_chunk_t* chunk, int def)
+{
+ artworkdb_mhia_t* mhia = NULL;
+
+ if (def) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhia", 4);
+ chunk->size = 96;
+ chunk->overall_size = 0; /* to be filled */
+ }
+
+ mhia = (artworkdb_mhia_t*)calloc(1, sizeof(artworkdb_mhia_t));
+ if (mhia && def) {
+ }
+
+ chunk->data = mhia;
+ return mhia ? 0 : IPODE_OUTOFMEMORY;
+}
+
+static int mhia_serialize(artworkdb_chunk_t* chunk, serializer_t* sio)
+{
+ int ret = 0;
+ artworkdb_mhia_t* mhia = (artworkdb_mhia_t*)chunk->data;
+
+ if (ret = serialize_uint32le(sio, "unk1", "%d", &mhia->unk1)) return ret;
+ if (ret = serialize_uint32le(sio, "image_id", "%d", &mhia->image_id)) return ret;
+
+ return 0;
+}
+
+
+
+static mhlf_init(artworkdb_chunk_t* chunk, int def)
+{
+ if (def) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhlf", 4);
+ chunk->size = 96;
+ chunk->overall_size = 0; /* to be filled */
+ }
+
+ chunk->data = 0;
+ return 0;
+}
+
+static int mhlf_serialize(artworkdb_chunk_t* chunk, serializer_t* sio)
+{
+ return 0;
+}
+
+
+
+static mhif_init(artworkdb_chunk_t* chunk, int def)
+{
+ artworkdb_mhif_t* mhif = NULL;
+
+ if (def) {
+ memset(chunk, 0, sizeof(*chunk));
+ strncpy(chunk->id, "mhif", 4);
+ chunk->size = 96;
+ chunk->overall_size = 0; /* to be filled */
+ }
+
+ mhif = (artworkdb_mhif_t*)calloc(1, sizeof(artworkdb_mhif_t));
+ if (mhif && def) {
+ }
+
+ chunk->data = mhif;
+ return mhif ? 0 : IPODE_OUTOFMEMORY;
+}
+
+static int mhif_serialize(artworkdb_chunk_t* chunk, serializer_t* sio)
+{
+ int ret = 0;
+ artworkdb_mhif_t* mhif = (artworkdb_mhif_t*)chunk->data;
+
+ if (ret = serialize_uint32le(sio, "unknown1", "%d", &mhif->unknown1)) return ret;
+ if (ret = serialize_uint32le(sio, "correlation_id", "%d", &mhif->correlation_id)) return ret;
+ if (ret = serialize_uint32le(sio, "image_size", "%d", &mhif->image_size)) return ret;
+
+ return 0;
+}
+
Property changes on: trunk/pmplib/lib/pmp_ipod/artworkdb.c
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
Added: trunk/pmplib/lib/pmp_ipod/artworkdb.h
===================================================================
--- trunk/pmplib/lib/pmp_ipod/artworkdb.h (rev 0)
+++ trunk/pmplib/lib/pmp_ipod/artworkdb.h 2007-10-05 14:47:54 UTC (rev 420)
@@ -0,0 +1,183 @@
+/*
+ * ArtworkDB reader/writer/dumper.
+ *
+ * Copyright (c) 2005-2007 Naoaki Okazaki
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+/* $Id:$ */
+
+#ifndef __ARTWORKDB_H__
+#define __ARTWORKDB_H__
+
+typedef struct {
+ uint32_t unknown1; /* always set to 0. */
+ uint32_t version; /* should be 2. */
+ uint32_t num_children; /* usually 3. */
+ uint32_t unknown3; /* always set to 0. */
+ uint32_t next_nhii;
+ uint64_t unknown5;
+ uint64_t unknown6;
+ uint32_t unknown7; /* always set to 2. */
+ uint32_t unknown8; /* always set to 0. */
+ uint32_t unknown9; /* always set to 0. */
+ uint32_t unknown10;
+ uint32_t unknown11;
+} artworkdb_mhfd_t;
+
+typedef struct {
+ uint32_t type; /* 1 (image list), 2 (album list), or 3 (file list). */
+} artworkdb_mhsd_t;
+
+typedef struct {
+ uint8_t unknown; /* zero padded. */
+} artworkdb_mhli_t;
+
+typedef struct {
+ uint32_t num_children;
+ uint32_t id;
+ uint64_t song_id;
+ uint32_t unknown4;
+ uint32_t rating;
+ uint32_t unknown6;
+ uint32_t ts_file;
+ uint32_t ts_import;
+ uint32_t original_size;
+} artworkdb_mhii_t;
+
+typedef struct {
+ uint32_t num_children;
+ uint32_t correlation_id;
+ uint32_t ithmb_offset;
+ uint32_t ithmb_size;
+ uint16_t vertical_padding;
+ uint16_t horizontal_padding;
+ uint16_t height;
+ uint16_t width;
+ uint32_t unknown;
+ uint32_t image_size;
+} artworkdb_mhni_t;
+
+typedef struct {
+ uint32_t num_mhod;
+ uint32_t num_mhia;
+ uint32_t playlist_id;
+ uint32_t unk2;
+ uint16_t unk3;
+ uint8_t album_type;
+ uint8_t play_music;
+ uint8_t repeat;
+ uint8_t random;
+ uint8_t show_titles;
+ uint8_t transition_direction;
+ uint32_t slide_duration;
+ uint32_t transition_duration;
+ uint32_t unk7;
+ uint32_t unk8;
+ uint64_t dbid2;
+ uint32_t prev_playlist_id;
+} artworkdb_mhba_t;
+
+typedef struct {
+ uint32_t unk1;
+ uint32_t image_id;
+} artworkdb_mhia_t;
+
+typedef struct {
+ uint32_t unknown1;
+ uint32_t correlation_id;
+ uint32_t image_size;
+} artworkdb_mhif_t;
+
+typedef struct {
+ uint32_t length;
+ uint32_t encoding;
+ uint32_t unknown;
+ ucs2char_t* value;
+} artworkdb_mhod_ucs2string_t;
+
+typedef struct {
+ uint32_t length;
+ uint32_t encoding;
+ uint32_t unknown;
+ char* value;
+} artworkdb_mhod_utf8string_t;
+
+typedef struct {
+ uint16_t type;
+ uint16_t unk1;
+ union {
+ artworkdb_mhod_ucs2string_t ucs2str;
+ artworkdb_mhod_utf8string_t ucs8str;
+ } data;
+} artworkdb_mhod_t;
+
+
+struct tag_artworkdb_chunk {
+ int8_t id[4];
+ uint32_t size;
+ uint32_t overall_size;
+
+ void* data;
+
+ uint32_t num_children; /* This field does not exist in the actual database. */
+ struct tag_artworkdb_chunk* childlen;
+
+ int32_t padding_size;
+ uint8_t* padding;
+
+ uint32_t offset; /* This field does not exist in the actual database. */
+};
+
+typedef struct tag_artworkdb_chunk artworkdb_chunk_t;
+
+typedef struct {
+ uint32_t type;
+ const char* name;
+ uint32_t overall_size;
+ void (*finish)(artworkdb_chunk_t* chunk);
+ int (*serialize)(artworkdb_chunk_t* chunk, const char *name, serializer_t* sio);
+} albumartdb_mhoddecl_t;
+
+typedef struct {
+ const char* name;
+ int (*init)(artworkdb_chunk_t* chunk, int dataonly);
+ void (*finish)(artworkdb_chunk_t* chunk);
+ int (*serialize)(artworkdb_chunk_t* chunk, serializer_t* sio);
+} albumartdb_chunkdecl_t;
+
+int albumartdb_init(artworkdb_chunk_t* chunk, const char *identifer, const char *subtype);
+
+int albumartdb_ischunk(artworkdb_chunk_t* chunk, const char *name, const char *subtype);
+
+artworkdb_chunk_t* albumartdb_new_child(artworkdb_chunk_t* chunk);
+
+void albumartdb_finish(artworkdb_chunk_t* chunk);
+
+int albumartdb_set_mhod_ucs2string(artworkdb_chunk_t* chunk, const ucs2char_t* str);
+
+int albumartdb_get_mhod_ucs2string(artworkdb_chunk_t* chunk, ucs2char_t** str);
+
+int albumartdb_set_mhod_utf8string(artworkdb_chunk_t* chunk, const char* str);
+
+int albumartdb_get_mhod_utf8string(artworkdb_chunk_t* chunk, char** str);
+
+int albumartdb_repr(artworkdb_chunk_t* chunk, size_t index, serializer_t* sio);
+int albumartdb_read(artworkdb_chunk_t* chunk, serializer_t* sio);
+int albumartdb_write(artworkdb_chunk_t* chunk, serializer_t* sio);
+
+#endif/*__ARTWORKDB_H__*/
Property changes on: trunk/pmplib/lib/pmp_ipod/artworkdb.h
___________________________________________________________________
Name: svn:keywords
+ Id
Name: svn:eol-style
+ native
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
