Menu
▾
▴
[Pmplib-commits] SF.net SVN: pmplib: [281] trunk/pmplib
|
From: <ny...@us...> - 2007-01-26 02:36:02
|
Revision: 281
http://svn.sourceforge.net/pmplib/?rev=281&view=rev
Author: nyaochi
Date: 2007-01-25 18:36:01 -0800 (Thu, 25 Jan 2007)
Log Message:
-----------
Synchronize pmp_iriverplus2 with the latest API.
Modified Paths:
--------------
trunk/pmplib/include/pmp.h
trunk/pmplib/lib/pmp/pmp.c
trunk/pmplib/lib/pmp_iriverplus2/ip2db.h
trunk/pmplib/lib/pmp_iriverplus2/playlist.c
trunk/pmplib/lib/pmp_iriverplus2/pmp_iriverplus2.c
trunk/pmplib/lib/pmp_iriverplus3/pmp_iriverplus3.c
Modified: trunk/pmplib/include/pmp.h
===================================================================
--- trunk/pmplib/include/pmp.h 2007-01-26 01:21:22 UTC (rev 280)
+++ trunk/pmplib/include/pmp.h 2007-01-26 02:36:01 UTC (rev 281)
@@ -619,6 +619,9 @@
PMPAPI void pmplib_playlist_finish(pmp_playlist_t* playlist);
PMPAPI void pmplib_playlist_clone(pmp_playlist_t* dst, const pmp_playlist_t* src);
+PMPAPI void pmplib_playlists_finish(pmp_playlist_t* playlist, int num_playlists);
+PMPAPI void pmplib_playlists_clone(pmp_playlist_t* dst, const pmp_playlist_t* src, int num_playlists);
+
/**
* @}
*/
Modified: trunk/pmplib/lib/pmp/pmp.c
===================================================================
--- trunk/pmplib/lib/pmp/pmp.c 2007-01-26 01:21:22 UTC (rev 280)
+++ trunk/pmplib/lib/pmp/pmp.c 2007-01-26 02:36:01 UTC (rev 281)
@@ -106,3 +106,20 @@
dst->entries[i] = ucs2dup(src->entries[i]);
}
}
+
+void pmplib_playlists_finish(pmp_playlist_t* playlists, int num_playlists)
+{
+ int i;
+ for (i = 0;i < num_playlists;++i) {
+ pmplib_playlist_finish(&playlists[i]);
+ }
+ ucs2free(playlists);
+}
+
+void pmplib_playlists_clone(pmp_playlist_t* dst, const pmp_playlist_t* src, int num_playlists)
+{
+ int i;
+ for (i = 0;i < num_playlists;++i) {
+ pmplib_playlist_clone(&dst[i], &src[i]);
+ }
+}
Modified: trunk/pmplib/lib/pmp_iriverplus2/ip2db.h
===================================================================
--- trunk/pmplib/lib/pmp_iriverplus2/ip2db.h 2007-01-26 01:21:22 UTC (rev 280)
+++ trunk/pmplib/lib/pmp_iriverplus2/ip2db.h 2007-01-26 02:36:01 UTC (rev 281)
@@ -277,10 +277,12 @@
// playlist.c
int ip2db_playlist_write(
ip2db_t* db,
- const ucs2char_t *filename,
+ const ucs2char_t *name,
ucs2char_t* const mediafiles[],
int num_mediafiles,
- const ucs2char_t *path_to_root
+ const ucs2char_t *path_to_root,
+ const ucs2char_t *path_to_playlist,
+ const ucs2char_t *ext
);
#endif/*__IP2DB_IP2DB_H__*/
Modified: trunk/pmplib/lib/pmp_iriverplus2/playlist.c
===================================================================
--- trunk/pmplib/lib/pmp_iriverplus2/playlist.c 2007-01-26 01:21:22 UTC (rev 280)
+++ trunk/pmplib/lib/pmp_iriverplus2/playlist.c 2007-01-26 02:36:01 UTC (rev 281)
@@ -92,17 +92,25 @@
int ip2db_playlist_write(
ip2db_t* db,
- const ucs2char_t *filename,
+ const ucs2char_t *name,
ucs2char_t* const mediafiles[],
int num_mediafiles,
- const ucs2char_t *path_to_root
+ const ucs2char_t *path_to_root,
+ const ucs2char_t *path_to_playlist,
+ const ucs2char_t *ext
)
{
int i;
FILE *fp = NULL;
uint32_t* recids = NULL;
uint32_t num_recids = 0;
+ ucs2char_t dst[MAX_PATH];
+ filepath_combinepath(dst, MAX_PATH, path_to_root, path_to_playlist);
+ filepath_addslash(dst);
+ ucs2cat(dst, name);
+ ucs2cat(dst, ext);
+
for (i = 0;i < num_mediafiles;i++) {
if (mediafiles[i][0]) {
uint32_t recid = 0;
@@ -124,7 +132,7 @@
}
}
- fp = ucs2fopen(filename, "wb");
+ fp = ucs2fopen(dst, "wb");
if (fp) {
size_t size = sizeof(uint32_t) + sizeof(uint32_t) * num_recids;
uint8_t* buffer = (uint8_t*)malloc(size);
Modified: trunk/pmplib/lib/pmp_iriverplus2/pmp_iriverplus2.c
===================================================================
--- trunk/pmplib/lib/pmp_iriverplus2/pmp_iriverplus2.c 2007-01-26 01:21:22 UTC (rev 280)
+++ trunk/pmplib/lib/pmp_iriverplus2/pmp_iriverplus2.c 2007-01-26 02:36:01 UTC (rev 281)
@@ -54,6 +54,9 @@
const char *sys_filename;
const char *dat_filename;
const char *idx_filename;
+ const char *extensions;
+ uint32_t codecs[8];
+ const char *path_to_system;
const char *path_to_music;
const char *path_to_playlist;
const char *playlist_ext;
@@ -64,151 +67,169 @@
"iriver_h10jr_ums_1.00-1.61", "iriver", "H10Jr UMS", "UM",
"1.00", "1.61",
"System\\H10_Jr.SYS", "System\\H10_Jr.DAT", "System\\H10_Jr.IDX",
- "Music\\", "Playlists\\",
+ ".mp3\0.ogg\0.wma\0.wav\0",
+ {PMPCODEC_MPEGLAYER3, PMPCODEC_VORBIS, PMPCODEC_WMA, PMPCODEC_WAV, 0, 0, 0, 0},
+ "System\\", "Music\\", "Playlists\\",
".plp",
},
{
"iriver_u10_ums_1.00-1.65", "iriver", "U10 UMS", "UM",
"1.00", "1.65",
"System\\U10.SYS", "System\\U10.dat", "System\\U10.idx",
- "Music\\", "Playlists\\",
+ ".mp3\0.ogg\0.wma\0.wav\0",
+ {PMPCODEC_MPEGLAYER3, PMPCODEC_VORBIS, PMPCODEC_WMA, PMPCODEC_WAV, 0, 0, 0, 0},
+ "System\\", "Music\\", "Playlists\\",
".plp",
},
{
NULL, NULL, NULL, NULL,
NULL, NULL,
NULL, NULL, NULL,
- NULL, NULL,
NULL,
+ {0, 0, 0, 0, 0, 0, 0, 0},
+ NULL, NULL, NULL,
+ NULL,
},
};
typedef struct {
- char id[128];
- char name[128];
- char mode[128];
- char language[128];
- char version[128];
-
- ucs2char_t path_to_root[MAX_PATH];
- ucs2char_t path_to_music[MAX_PATH];
- ucs2char_t path_to_playlist[MAX_PATH];
- ucs2char_t sys_filename[MAX_PATH];
- ucs2char_t dat_filename[MAX_PATH];
- ucs2char_t idx_filename[MAX_PATH];
- ucs2char_t playlist_ext[MAX_PATH];
-} ip2_environment_t;
-
-
-typedef struct {
- ip2_environment_t env;
+ const ip2model_descriptor_t* decl;
} pmp_internal_t;
typedef struct {
ip2db_t ip2db;
-} pmpdb_internal_t;
+ pmp_music_record_t* records;
+ int num_records;
+ pmp_playlist_t* playlists;
+ int num_playlists;
+} pmp_music_internal_t;
-typedef struct {
- ip2db_t ip2db;
-} pmppl_internal_t;
-
-
static uint32_t pmp_add_ref(pmp_t* pmp);
static uint32_t pmp_release(pmp_t* pmp);
static result_t pmp_open(pmp_t* pmp, uint32_t flag);
-static result_t pmp_close(pmp_t* pmp, uint32_t flag);
-static result_t pmp_create_instance_db(pmp_t* pmp, pmp_music_t** ptr_pmpdb);
-static result_t pmp_create_instance_pl(pmp_t* pmp, pmp_playlist_t** ptr_pmppl);
+static result_t pmp_close(pmp_t* pmp);
+static result_t pmp_create_instance_music(pmp_t* pmp, pmp_music_t** ptr_pmpdb);
-static uint32_t pmpdb_release(pmp_music_t* pmpdb);
-static result_t pmpdb_read(pmp_music_t* pmpdb);
-static result_t pmpdb_write(pmp_music_t* pmpdb);
-static result_t pmpdb_set(pmp_music_t* pmpdb, const pmp_music_record_t* records, uint32_t num_records);
-static result_t pmpdb_get(pmp_music_t* pmpdb, pmp_music_record_t* records, uint32_t* num_records);
-static result_t pmpdb_dump(pmp_music_t* pmpdb, FILE *fp, int level);
-static int pmpdb_is_supported_codec(pmp_music_t* pmpdb, uint32_t codec);
-static int pmpdb_is_supported_ext(pmp_music_t* pmpdb, const ucs2char_t* filename);
+static uint32_t pmpmusic_release(pmp_music_t* music);
+static uint32_t pmpmusic_open(pmp_music_t* music);
+static uint32_t pmpmusic_close(pmp_music_t* music);
+static result_t pmpmusic_set_records(pmp_music_t* music, const pmp_music_record_t* records, uint32_t num_records);
+static result_t pmpmusic_get_records(pmp_music_t* music, pmp_music_record_t* records, uint32_t* num_records);
+static result_t pmpmusic_dump(pmp_music_t* music, FILE *fp, int level);
+static result_t pmpmusic_set_playlists(pmp_music_t* music, const pmp_playlist_t* playlists, uint32_t num_playlists);
-static uint32_t pmppl_add_ref(pmp_playlist_t* pmppl);
-static uint32_t pmppl_release(pmp_playlist_t* pmppl);
-static result_t pmppl_write(pmp_playlist_t* pmppl, const ucs2char_t* filename, ucs2char_t* const files[], uint32_t num_files);
+#define COMP(a, b) ((a)>(b))-((a)<(b))
-static void set_environment(
- ip2_environment_t* env,
+static char* strip(char *str)
+{
+ char *p = str + strlen(str) - 1;
+ while (*str && isspace(*str)) {
+ str++;
+ }
+ while (str <= p && isspace(*p)) {
+ *p-- = 0;
+ }
+ return str;
+}
+
+static const char *strcpy_if_empty(char *dst, const char *src)
+{
+ return *dst ? dst : strcpy(dst, src);
+}
+
+static void set_device_info(
+ const char *id,
+ const ucs2char_t* path_to_device,
const ip2model_descriptor_t* md,
- const ucs2char_t* path_to_device
+ pmp_device_information_t* info
)
{
+ uint32_t n;
+ const char *p = NULL;
ucs2char_t* ucs2 = NULL;
+ pmp_device_description_t* decl = (pmp_device_description_t*)&info->decl;
- ucs2cpy(env->path_to_root, path_to_device);
+ strcpy_if_empty(decl->id, id);
+ strcpy_if_empty(decl->manufacturer, md->manufacturer);
+ strcpy_if_empty(decl->name, md->name);
+ strcpy_if_empty(decl->mode, md->mode);
+ //strcpy_if_empty(decl->language, md->language);
+ //strcpy_if_empty(decl->version, md->version);
+ strcpy_if_empty(decl->min_version, md->min_version);
+ strcpy_if_empty(decl->max_version, md->max_version);
- ucs2cpy(env->path_to_music, path_to_device);
- filepath_addslash(env->path_to_music);
+ ucs2cpy(info->path_to_root, path_to_device);
+
+ ucs2 = mbsdupucs2(md->path_to_system);
+ ucs2cpy(info->path_to_system, ucs2);
+ ucs2free(ucs2);
+
ucs2 = mbsdupucs2(md->path_to_music);
- ucs2cat(env->path_to_music, ucs2);
+ ucs2cpy(info->path_to_music, ucs2);
ucs2free(ucs2);
- ucs2cpy(env->path_to_playlist, path_to_device);
- filepath_addslash(env->path_to_playlist);
ucs2 = mbsdupucs2(md->path_to_playlist);
- ucs2cat(env->path_to_playlist, ucs2);
+ ucs2cpy(info->path_to_playlist, ucs2);
ucs2free(ucs2);
- ucs2cpy(env->sys_filename, path_to_device);
- filepath_addslash(env->sys_filename);
- ucs2 = mbsdupucs2(md->sys_filename);
- ucs2cat(env->sys_filename, ucs2);
- ucs2free(ucs2);
+ info->music_flag = PMPMF_SUPPORT | PMPMF_RECURSIVE;
+ info->playlist_flag = PMPPF_SUPPORT;
- ucs2cpy(env->dat_filename, path_to_device);
- filepath_addslash(env->dat_filename);
- ucs2 = mbsdupucs2(md->dat_filename);
- ucs2cat(env->dat_filename, ucs2);
- ucs2free(ucs2);
+ // Audio codecs.
+ for (n = 0;md->codecs[n];++n) ;
+ info->num_audio_codecs = n;
+ info->audio_codecs = (uint32_t*)ucs2malloc(sizeof(uint32_t) * info->num_audio_codecs);
+ for (n = 0;n < info->num_audio_codecs;++n) {
+ info->audio_codecs[n] = md->codecs[n];
+ }
- ucs2cpy(env->idx_filename, path_to_device);
- filepath_addslash(env->idx_filename);
- ucs2 = mbsdupucs2(md->idx_filename);
- ucs2cat(env->idx_filename, ucs2);
- ucs2free(ucs2);
+ // Obtain the number of extensions separated by '\0' characters.
+ for (n = 0, p = md->extensions;*p;p += (strlen(p)+1)) {
+ n++;
+ }
+ info->num_audio_extensions = n;
+ info->audio_extensions = (ucs2char_t**)ucs2malloc(sizeof(ucs2char_t*) * info->num_audio_extensions);
+ for (n = 0, p = md->extensions;*p;p += (strlen(p)+1)) {
+ info->audio_extensions[n++] = mbsdupucs2(p);
+ }
+}
- ucs2 = mbsdupucs2(md->playlist_ext);
- ucs2cat(env->playlist_ext, ucs2);
- ucs2free(ucs2);
+static void free_device_info(pmp_device_information_t* info)
+{
+ uint32_t i;
+ for (i = 0;i < info->num_audio_extensions;++i) {
+ ucs2free(info->audio_extensions[i]);
+ }
+ ucs2free(info->audio_codecs);
+ ucs2free(info->audio_extensions);
+ memset(info, 0, sizeof(*info));
}
-static int match_model(
- const char *id,
- const ucs2char_t* path_to_device,
- const ip2model_descriptor_t* md,
- ip2_environment_t* env
- )
+static void set_filenames(ucs2char_t *sys, ucs2char_t *dat, ucs2char_t *idx, pmp_t *pmp)
{
- memset(env, 0, sizeof(*env));
+ ucs2char_t* ucs2 = NULL;
+ pmp_internal_t* pmpi = (pmp_internal_t*)pmp->instance;
- if (!id || strcmp(md->id, id) != 0) {
- return 0;
- }
+ ucs2cpy(sys, pmp->info.path_to_root);
+ filepath_addslash(sys);
+ ucs2 = mbsdupucs2(pmpi->decl->sys_filename);
+ ucs2cat(sys, ucs2);
+ ucs2free(ucs2);
- set_environment(env, md, path_to_device);
- return 1;
-}
+ ucs2cpy(dat, pmp->info.path_to_root);
+ filepath_addslash(dat);
+ ucs2 = mbsdupucs2(pmpi->decl->dat_filename);
+ ucs2cat(dat, ucs2);
+ ucs2free(ucs2);
-static char* strip(char *str)
-{
- char *p = str + strlen(str) - 1;
- while (*str && isspace(*str)) {
- str++;
- }
- while (str <= p && isspace(*p)) {
- *p-- = 0;
- }
- return str;
+ ucs2cpy(idx, pmp->info.path_to_root);
+ filepath_addslash(idx);
+ ucs2 = mbsdupucs2(pmpi->decl->idx_filename);
+ ucs2cat(idx, ucs2);
+ ucs2free(ucs2);
}
-#define COMP(a, b) ((a)>(b))-((a)<(b))
static int compare_version(const char *x, const char *y)
{
@@ -232,19 +253,22 @@
static int detect_model(
const ucs2char_t* path_to_device,
const ip2model_descriptor_t* md,
- ip2_environment_t* env
+ pmp_device_information_t* ptr_info
)
{
ucs2char_t* ucs2 = NULL;
ucs2char_t filename[MAX_PATH];
+ pmp_device_description_t decl;
- memset(env, 0, sizeof(*env));
+ memset(&decl, 0, sizeof(decl));
+ // filename = "${path_to_device}/${md->sys_filename}"
ucs2cpy(filename, path_to_device);
filepath_addslash(filename);
ucs2 = mbsdupucs2(md->sys_filename);
ucs2cat(filename, ucs2);
ucs2free(ucs2);
+
if (filepath_file_exists(filename)) {
int match = 1;
char line[128];
@@ -257,23 +281,23 @@
char *p = strip(line);
if (p[0] == '[' && line[strlen(p)-1] == ']') {
p[strlen(p)-1] = 0;
- strcpy(env->name, p+1);
+ strcpy(decl.name, p+1);
} else if (strncmp(p, "version = ", 10) == 0) {
- strcpy(env->version, p+10);
+ strcpy(decl.version, p+10);
} else if (strncmp(p, "language = ", 11) == 0) {
- strcpy(env->language, p+11);
+ strcpy(decl.language, p+11);
} else if (strncmp(p, "mode = ", 7) == 0) {
- strcpy(env->mode, p+7);
+ strcpy(decl.mode, p+7);
}
}
fclose(fp);
- match &= (strcmp(env->mode, md->mode) == 0);
- match &= (compare_version(md->min_version, env->version) <= 0);
- match &= (compare_version(env->version, md->max_version) <= 0);
+ match &= (strcmp(decl.mode, md->mode) == 0);
+ match &= (compare_version(md->min_version, decl.version) <= 0);
+ match &= (compare_version(decl.version, md->max_version) <= 0);
if (match) {
- set_environment(env, md, path_to_device);
+ memcpy((pmp_device_description_t*)&ptr_info->decl, &decl, sizeof(decl));
return 1;
}
}
@@ -297,25 +321,32 @@
pmp_t* pmp = NULL;
pmp_internal_t* pmpi = NULL;
const ip2model_descriptor_t* md = NULL;
- ip2_environment_t env;
- pmp_device_environment_t* pmpenv = NULL;
+ pmp_device_information_t info;
+ // Initialize device information.
+ memset(&info, 0, sizeof(info));
+
+ // Return a NULL pointer by default.
*ptr_pmp = 0;
// Find a suitable model for the device.
md = g_model_descriptions;
for (;md->id;++md) {
- if (detect_model(path_to_device, md, &env)) {
- if (!id || !id[0]) {
+ if (id && *id) {
+ // Match the device identifier.
+ if (strcmp(md->id, id) == 0) {
+ // This will fill some members in decl.
+ detect_model(path_to_device, md, &info);
+ set_device_info(id, path_to_device, md, &info);
break;
}
- if (strcmp(md->id, id) == 0) {
+ } else {
+ // Detect the model automatically.
+ if (detect_model(path_to_device, md, &info)) {
+ set_device_info(md->id, path_to_device, md, &info);
break;
}
}
- if (match_model(id, path_to_device, md, &env)) {
- break;
- }
}
if (!md->id) {
return PMP_DEVICENOTFOUND;
@@ -331,41 +362,22 @@
pmp->release = pmp_release;
pmp->open = pmp_open;
pmp->close = pmp_close;
- pmp->create_instance_pl = pmp_create_instance_pl;
pmp->add_ref(pmp);
// Allocate the internal variables.
pmpi = (pmp_internal_t*)calloc(1, sizeof(pmp_internal_t));
if (!pmpi) {
- pmp_release(pmp);
+ free(pmp);
return PMPDBE_OUTOFMEMORY;
}
- pmp->instance = pmpi;
+ pmpi->decl = md;
// Initialize the internal variables.
- memcpy(&pmpi->env, &env, sizeof(env));
+ pmp->instance = pmpi;
+ memcpy((pmp_device_information_t*)&pmp->info, &info, sizeof(info));
- // Initialize the (exportable) env.
- strcpy(pmp->decl.id, md->id);
- strcpy(pmp->decl.manufacturer, md->manufacturer);
- strcpy(pmp->decl.name, md->name);
- strcpy(pmp->decl.mode, md->mode);
- strcpy(pmp->decl.language, pmpi->env.language);
- strcpy(pmp->decl.version, pmpi->env.version);
- strcpy(pmp->decl.min_version, md->min_version);
- strcpy(pmp->decl.max_version, md->max_version);
-
- pmpenv = &pmp->env;
- pmpenv->path_to_root.flag = PMPPEF_SUPPORT | PMPPEF_CONSTANT;
- ucs2cpy(pmpenv->path_to_root.path, pmpi->env.path_to_root);
- pmpenv->path_to_music.flag = PMPPEF_SUPPORT | PMPPEF_RECURSIVE;
- ucs2cpy(pmpenv->path_to_music.path, pmpi->env.path_to_music);
- pmpenv->path_to_playlist.flag = PMPPEF_SUPPORT;
- ucs2cpy(pmpenv->path_to_playlist.path, pmpi->env.path_to_playlist);
- ucs2cpy(pmpenv->playlist_ext, pmpi->env.playlist_ext);
-
// Create music instance.
- ret = pmp_create_instance_db(pmp, &pmp->music);
+ ret = pmp_create_instance_music(pmp, &pmp->music);
if (ret != 0) {
pmp_release(pmp);
return ret;
@@ -385,7 +397,8 @@
{
uint32_t count = pmplib_interlocked_decrement(&pmp->ref_count);
if (count == 0) {
- pmpdb_release(pmp->music);
+ pmpmusic_release(pmp->music);
+ free_device_info(&pmp->info);
free(pmp->instance);
free(pmp);
}
@@ -395,140 +408,240 @@
static result_t pmp_open(pmp_t* pmp, uint32_t flag)
{
result_t ret = 0;
+
+ // Set the open flag.
pmp->flag = flag;
- if (pmp->flag & PMPOF_MUSIC_DB_READ) {
- ret = pmpdb_read(pmp->music);
- if (ret != 0) {
- return ret;
- }
+ // Open the music database.
+ ret = pmpmusic_open(pmp->music);
+ if (ret) {
+ return ret;
}
+
return 0;
}
-static result_t pmp_close(pmp_t* pmp, uint32_t flag)
+static result_t pmp_close(pmp_t* pmp)
{
result_t ret = 0;
- if (pmp->flag & PMPOF_MUSIC_DB_WRITE) {
- ret = pmpdb_write(pmp->music);
- if (ret != 0) {
- return ret;
- }
+
+ // Close the music database.
+ ret = pmpmusic_close(pmp->music);
+ if (ret) {
+ return ret;
}
+
return 0;
}
-static result_t pmp_create_instance_db(pmp_t* pmp, pmp_music_t** ptr_pmpdb)
+static result_t pmp_create_instance_music(pmp_t* pmp, pmp_music_t** ptr_music)
{
- pmp_music_t* pmpdb = NULL;
+ pmp_music_t* music = NULL;
pmp_internal_t* pmpi = (pmp_internal_t*)pmp->instance;
- pmpdb_internal_t* pmpdbi = NULL;
+ pmp_music_internal_t* pmpmi = NULL;
- *ptr_pmpdb = 0;
+ *ptr_music = 0;
- pmpdb = calloc(1, sizeof(pmp_music_t));
- if (!pmpdb) {
+ music = calloc(1, sizeof(pmp_music_t));
+ if (!music) {
return PMPDBE_OUTOFMEMORY;
}
- pmpdb->set = pmpdb_set;
- pmpdb->get = pmpdb_get;
- pmpdb->dump = pmpdb_dump;
- pmpdb->is_supported_codec = pmpdb_is_supported_codec;
- pmpdb->is_supported_ext = pmpdb_is_supported_ext;
-
- pmpdbi = calloc(1, sizeof(pmpdb_internal_t));
- if (!pmpdbi) {
- free(pmpdb);
+ pmpmi = calloc(1, sizeof(pmp_music_internal_t));
+ if (!pmpmi) {
+ free(music);
return PMPDBE_OUTOFMEMORY;
}
- ip2db_init(&pmpdbi->ip2db);
+ ip2db_init(&pmpmi->ip2db);
- pmpdb->pmp = pmp;
- pmpdb->instance = pmpdbi;
+ music->set_records = pmpmusic_set_records;
+ music->get_records = pmpmusic_get_records;
+ music->dump = pmpmusic_dump;
+ music->set_playlists = pmpmusic_set_playlists;
+ music->pmp = pmp;
+ music->instance = pmpmi;
- *ptr_pmpdb = pmpdb;
+ *ptr_music = music;
return 0;
}
-static result_t pmp_create_instance_pl(pmp_t* pmp, pmp_playlist_t** ptr_pmppl)
+
+
+
+
+
+static uint32_t pmpmusic_release(pmp_music_t* music)
{
- pmp_internal_t* pmpi = (pmp_internal_t*)pmp->instance;
- pmp_playlist_t* pmppl = NULL;
- pmppl_internal_t* pmppli = NULL;
+ pmp_music_internal_t* pmpmi = (pmp_music_internal_t*)music->instance;
+ ip2db_finish(&pmpmi->ip2db);
+ pmplib_records_finish(pmpmi->records, pmpmi->num_records);
+ free(pmpmi->playlists);
+ free(pmpmi);
+ free(music);
+ return 0;
+}
- *ptr_pmppl = 0;
+static uint32_t pmpmusic_open(pmp_music_t* music)
+{
+ result_t ret = 0;
+ pmp_t* pmp = music->pmp;
+ pmp_music_internal_t* pmpmi = (pmp_music_internal_t*)music->instance;
- pmppl = calloc(1, sizeof(pmp_playlist_t));
- if (!pmppl) {
- return PMPDBE_OUTOFMEMORY;
+ // Free the existing records.
+ pmplib_records_finish(pmpmi->records, pmpmi->num_records);
+ pmpmi->records = 0;
+ pmpmi->num_records = 0;
+
+ // Open the music database if necessary.
+ if (pmp->flag & PMPOF_MUSIC_DB_READ) {
+ ucs2char_t sys[MAX_PATH], dat[MAX_PATH], idx[MAX_PATH];
+ pmp_music_internal_t* pmpmi = (pmp_music_internal_t*)pmp->music->instance;
+
+ // Read the music database.
+ set_filenames(sys, dat, idx, pmp);
+ ret = ip2db_read(&pmpmi->ip2db, dat, idx);
+ if (ret) {
+ return ret;
+ }
+
+ return ip2db_get(&pmpmi->ip2db, pmpmi->records, &pmpmi->num_records, pmp->info.path_to_root);
}
- pmppl->add_ref = pmppl_add_ref;
- pmppl->release = pmppl_release;
- pmppl->write = pmppl_write;
+ return 0;
+}
- pmppli = calloc(1, sizeof(pmppl_internal_t));
- if (!pmppli) {
- free(pmppl);
- return PMPDBE_OUTOFMEMORY;
+static uint32_t pmpmusic_close(pmp_music_t* music)
+{
+ result_t ret = 0;
+ pmp_t* pmp = music->pmp;
+ pmp_music_internal_t* pmpmi = (pmp_music_internal_t*)music->instance;
+ static const ucs2char_t plp_ext[] = {'.','p','l','p',0};
+
+ if (pmp->flag & PMPOF_MUSIC_DB_WRITE) {
+ ucs2char_t sys[MAX_PATH], dat[MAX_PATH], idx[MAX_PATH];
+
+ ip2db_set(&pmpmi->ip2db, pmpmi->records, pmpmi->num_records, pmp->info.path_to_root);
+
+ set_filenames(sys, dat, idx, pmp);
+ ret = ip2db_write(&pmpmi->ip2db, dat, idx);
+ if (ret) {
+ return ret;
+ }
}
- ip2db_init(&pmppli->ip2db);
- ip2db_read(&pmppli->ip2db, pmpi->env.dat_filename, pmpi->env.idx_filename);
- pmppl->pmp = pmp;
- pmppl->instance = pmppli;
+ if (pmp->flag & PMPOF_MUSIC_PL_WRITE) {
+ int i;
- pmppl->add_ref(pmppl);
- *ptr_pmppl = pmppl;
+ for (i = 0;i < pmpmi->num_playlists;++i) {
+ const pmp_playlist_t* pl = &pmpmi->playlists[i];
+ if (ip2db_playlist_write(
+ &pmpmi->ip2db,
+ pl->name,
+ pl->entries,
+ pl->num_entries,
+ pmp->info.path_to_root,
+ pmp->info.path_to_playlist,
+ plp_ext
+ ) != 0) {
+ return PMPPLE_WRITE;
+ }
+ }
+ }
+
+ return ret;
+}
+
+static result_t pmpmusic_set_records(pmp_music_t* music, const pmp_music_record_t* records, uint32_t num_records)
+{
+ pmp_t* pmp = music->pmp;
+ pmp_music_internal_t* pmpmi = (pmp_music_internal_t*)music->instance;
+
+ /* Free records attached to pmpmi. */
+ pmplib_records_finish(pmpmi->records, pmpmi->num_records);
+
+ /* Allocate new records. */
+ pmpmi->records = (pmp_music_record_t*)ucs2malloc(sizeof(pmp_music_record_t) * num_records);
+ pmpmi->num_records = num_records;
+ pmplib_records_clone(pmpmi->records, records, num_records);
+
return 0;
+ }
+
+static result_t pmpmusic_get_records(pmp_music_t* music, pmp_music_record_t* records, uint32_t* num_records)
+{
+ pmp_t* pmp = music->pmp;
+ pmp_music_internal_t* pmpmi = (pmp_music_internal_t*)music->instance;
+
+ if (!records) {
+ *num_records = pmpmi->num_records;
+ return 0;
+ } else if (*num_records == pmpmi->num_records) {
+ pmplib_records_clone(records, pmpmi->records, pmpmi->num_records);
+ return 0;
+ } else {
+ return PMPDBE_INSUFFICIENT;
+ }
}
+static result_t pmpmusic_dump(pmp_music_t* music, FILE *fp, int level)
+{
+ pmp_music_internal_t* pmpmi = (pmp_music_internal_t*)music->instance;
+ if (level > 0) {
+ return ip2db_repr(&pmpmi->ip2db, fp);
+ } else {
+ return ip2db_dump(&pmpmi->ip2db, fp);
+ }
+}
+static result_t pmpmusic_set_playlists(pmp_music_t* music, const pmp_playlist_t* playlists, uint32_t num_playlists)
+{
+ pmp_music_internal_t* pmpmi = (pmp_music_internal_t*)music->instance;
+ // Free playlists attached to pmpmi.
+ pmplib_playlists_finish(pmpmi->playlists, pmpmi->num_playlists);
+ // Allocate a new playlists.
+ pmpmi->playlists = (pmp_playlist_t*)calloc(num_playlists, sizeof(pmp_playlist_t));
+ pmpmi->num_playlists = num_playlists;
+ // Copy the playlist array.
+ pmplib_playlists_clone(pmpmi->playlists, playlists, num_playlists);
-static uint32_t pmpdb_release(pmp_music_t* pmpdb)
-{
- pmpdb_internal_t* pmpdbi = (pmpdb_internal_t*)pmpdb->instance;
- ip2db_finish(&pmpdbi->ip2db);
- free(pmpdb->instance);
- free(pmpdb);
return 0;
}
+/*
static result_t pmpdb_read(pmp_music_t* pmpdb)
{
- pmpdb_internal_t* pmpdbi = (pmpdb_internal_t*)pmpdb->instance;
+ pmp_music_internal_t* pmpdbi = (pmp_music_internal_t*)pmpdb->instance;
pmp_internal_t* pmpi = (pmp_internal_t*)pmpdb->pmp->instance;
return ip2db_read(&pmpdbi->ip2db, pmpi->env.dat_filename, pmpi->env.idx_filename);
}
static result_t pmpdb_write(pmp_music_t* pmpdb)
{
- pmpdb_internal_t* pmpdbi = (pmpdb_internal_t*)pmpdb->instance;
+ pmp_music_internal_t* pmpdbi = (pmp_music_internal_t*)pmpdb->instance;
pmp_internal_t* pmpi = (pmp_internal_t*)pmpdb->pmp->instance;
return ip2db_write(&pmpdbi->ip2db, pmpi->env.dat_filename, pmpi->env.idx_filename);
}
static result_t pmpdb_set(pmp_music_t* pmpdb, const pmp_music_record_t* records, uint32_t num_records)
{
- pmpdb_internal_t* pmpdbi = (pmpdb_internal_t*)pmpdb->instance;
+ pmp_music_internal_t* pmpdbi = (pmp_music_internal_t*)pmpdb->instance;
pmp_internal_t* pmpi = (pmp_internal_t*)pmpdb->pmp->instance;
return ip2db_set(&pmpdbi->ip2db, records, num_records, pmpi->env.path_to_root);
}
static result_t pmpdb_get(pmp_music_t* pmpdb, pmp_music_record_t* records, uint32_t* num_records)
{
- pmpdb_internal_t* pmpdbi = (pmpdb_internal_t*)pmpdb->instance;
+ pmp_music_internal_t* pmpdbi = (pmp_music_internal_t*)pmpdb->instance;
pmp_internal_t* pmpi = (pmp_internal_t*)pmpdb->pmp->instance;
return ip2db_get(&pmpdbi->ip2db, records, num_records, pmpi->env.path_to_root);
}
static result_t pmpdb_dump(pmp_music_t* pmpdb, FILE *fp, int level)
{
- pmpdb_internal_t* pmpdbi = (pmpdb_internal_t*)pmpdb->instance;
+ pmp_music_internal_t* pmpdbi = (pmp_music_internal_t*)pmpdb->instance;
if (level > 0) {
return ip2db_repr(&pmpdbi->ip2db, fp);
} else {
@@ -575,3 +688,4 @@
}
return 0;
}
+*/
\ No newline at end of file
Modified: trunk/pmplib/lib/pmp_iriverplus3/pmp_iriverplus3.c
===================================================================
--- trunk/pmplib/lib/pmp_iriverplus3/pmp_iriverplus3.c 2007-01-26 01:21:22 UTC (rev 280)
+++ trunk/pmplib/lib/pmp_iriverplus3/pmp_iriverplus3.c 2007-01-26 02:36:01 UTC (rev 281)
@@ -80,7 +80,7 @@
NULL, NULL, NULL, NULL,
NULL,
{0, 0, 0, 0, 0, 0, 0, 0},
- NULL, NULL,
+ NULL, NULL, NULL,
NULL,
},
};
@@ -186,8 +186,6 @@
for (n = 0, p = md->extensions;*p;p += (strlen(p)+1)) {
info->audio_extensions[n++] = mbsdupucs2(p);
}
-
-
}
static void free_device_info(pmp_device_information_t* info)
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
