00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00037 #include <string.h>
00038
00039 #include "splt.h"
00040
00041 static void splt_fu_free_freedb_search(splt_state *state);
00042 static int splt_fu_append_first_result(splt_freedb_results *res,
00043 const char *album_name);
00044 static int splt_fu_append_next_result(splt_freedb_results *res,
00045 const char *album_name);
00046 static int splt_fu_append_first_revision(splt_freedb_one_result *prev,
00047 const char *album_name);
00048 static int splt_fu_append_next_revision(splt_freedb_one_result *prev,
00049 const char *album_name);
00050
00051 void splt_fu_set_default_values(splt_state *state)
00052 {
00053 splt_freedb *fdb = &state->fdb;
00054 fdb->search_results = NULL;
00055 fdb->cdstate = NULL;
00056 }
00057
00058 void splt_fu_freedb_free_search(splt_state *state)
00059 {
00060 splt_fu_free_freedb_search(state);
00061 splt_cd_state *cdstate = state->fdb.cdstate;
00062 if (cdstate != NULL)
00063 {
00064 free(cdstate);
00065 cdstate = NULL;
00066 }
00067 }
00068
00069 int splt_fu_freedb_init_search(splt_state *state)
00070 {
00071 int error = SPLT_OK;
00072 splt_freedb *fdb = &state->fdb;
00073
00074 if ((fdb->cdstate = malloc(sizeof(splt_cd_state))) == NULL)
00075 {
00076 error = SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
00077 }
00078 else
00079 {
00080 fdb->cdstate->foundcd = 0;
00081 if ((fdb->search_results = malloc(sizeof(splt_freedb_results))) == NULL)
00082 {
00083 free(fdb->cdstate);
00084 fdb->cdstate = NULL;
00085 error = SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
00086 }
00087 else
00088 {
00089 fdb->search_results->number = 0;
00090 fdb->search_results->results = NULL;
00091 }
00092 }
00093
00094 return error;
00095 }
00096
00097 int splt_fu_freedb_append_result(splt_state *state, const char *album_name, int revision)
00098 {
00099 splt_freedb_results *res = state->fdb.search_results;
00100
00101 if (album_name == NULL)
00102 {
00103 return SPLT_OK;
00104 }
00105
00106 if (res->number == 0)
00107 {
00108 return splt_fu_append_first_result(res, album_name);
00109 }
00110
00111 if (revision != -1)
00112 {
00113 return splt_fu_append_next_result(res, album_name);
00114 }
00115
00116 splt_freedb_one_result *prev = &res->results[res->number-1];
00117
00118 if (prev->revision_number == 0)
00119 {
00120 return splt_fu_append_first_revision(prev, album_name);
00121 }
00122
00123 return splt_fu_append_next_revision(prev, album_name);
00124 }
00125
00126 int splt_fu_freedb_get_found_cds(splt_state *state)
00127 {
00128 return state->fdb.cdstate->foundcd;
00129 }
00130
00131 void splt_fu_freedb_found_cds_next(splt_state *state)
00132 {
00133 state->fdb.cdstate->foundcd = splt_fu_freedb_get_found_cds(state) + 1;
00134 }
00135
00136 void splt_fu_freedb_set_disc(splt_state *state, int index,
00137 const char *discid, const char *category, int category_size)
00138 {
00139 splt_cd_state *cdstate = state->fdb.cdstate;
00140
00141 if ((index >= 0) && (index < SPLT_MAXCD))
00142 {
00143 memset(cdstate->discs[index].category, '\0', 20);
00144 snprintf(cdstate->discs[index].category, category_size,"%s",category);
00145 #ifdef __WIN32__
00146
00147 cdstate->discs[index].category[category_size-1] = '\0';
00148 #endif
00149 splt_d_print_debug(state,"Setting disc category _%s_\n", cdstate->discs[index].category);
00150
00151 memset(cdstate->discs[index].discid, '\0', SPLT_DISCIDLEN+1);
00152 snprintf(cdstate->discs[index].discid,SPLT_DISCIDLEN+1,"%s",discid);
00153 #ifdef __WIN32__
00154
00155 cdstate->discs[index].discid[SPLT_DISCIDLEN] = '\0';
00156 #endif
00157 splt_d_print_debug(state,"Setting disc id _%s_\n", cdstate->discs[index].discid);
00158 }
00159 else
00160 {
00161 splt_e_error(SPLT_IERROR_INT, __func__, index, NULL);
00162 }
00163 }
00164
00165 const char *splt_fu_freedb_get_disc_category(splt_state *state, int index)
00166 {
00167 splt_cd_state *cdstate = state->fdb.cdstate;
00168
00169 if ((index >= 0) && (index < cdstate->foundcd))
00170 {
00171 return cdstate->discs[index].category;
00172 }
00173 else
00174 {
00175 splt_e_error(SPLT_IERROR_INT, __func__, index, NULL);
00176 return NULL;
00177 }
00178 }
00179
00180 const char *splt_fu_freedb_get_disc_id(splt_state *state, int index)
00181 {
00182 splt_cd_state *cdstate = state->fdb.cdstate;
00183
00184 if ((index >= 0) && (index < cdstate->foundcd))
00185 {
00186 return cdstate->discs[index].discid;
00187 }
00188 else
00189 {
00190 splt_e_error(SPLT_IERROR_INT, __func__, index, NULL);
00191 return NULL;
00192 }
00193 }
00194
00195 static void splt_fu_free_freedb_search(splt_state *state)
00196 {
00197 splt_freedb_results *res = state->fdb.search_results;
00198
00199 if (res)
00200 {
00201 int i = 0;
00202 for(i = 0; i < res->number;i++)
00203 {
00204 if (res->results[i].revisions)
00205 {
00206 free(res->results[i].revisions);
00207 res->results[i].revisions = NULL;
00208 }
00209
00210 if (res->results[i].name)
00211 {
00212 free(res->results[i].name);
00213 res->results[i].name = NULL;
00214 }
00215 }
00216
00217 if (res->results)
00218 {
00219 free(res->results);
00220 res->results = NULL;
00221 }
00222
00223 res->number = 0;
00224
00225 free(state->fdb.search_results);
00226 state->fdb.search_results = NULL;
00227 }
00228 }
00229
00230 static int splt_fu_append_first_result(splt_freedb_results *res,
00231 const char *album_name)
00232 {
00233 int error = SPLT_OK;
00234
00235 res->results = malloc(sizeof(splt_freedb_one_result));
00236 if (res->results == NULL)
00237 {
00238 return SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
00239 }
00240 memset(res->results, 0x0, sizeof(splt_freedb_one_result));
00241
00242 res->results[0].revisions = NULL;
00243 error = splt_su_copy(album_name, &res->results[0].name);
00244 if (error < 0) { return error; }
00245
00246 res->results[0].revision_number = 0;
00247 res->results[0].id = 0;
00248 res->number++;
00249
00250 return error;
00251 }
00252
00253 static int splt_fu_append_next_result(splt_freedb_results *res,
00254 const char *album_name)
00255 {
00256 int error = SPLT_OK;
00257
00258 res->results = realloc(res->results, (res->number + 1) * sizeof(splt_freedb_one_result));
00259 if (res->results == NULL)
00260 {
00261 return SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
00262 }
00263 memset(&res->results[res->number], 0x0, sizeof(splt_freedb_one_result));
00264
00265 error = splt_su_copy(album_name, &res->results[res->number].name);
00266 if (error < 0) { return error; }
00267
00268 splt_freedb_one_result *prev = &res->results[res->number-1];
00269
00270 res->results[res->number].revision_number = 0;
00271 res->results[res->number].id = (prev->id + prev->revision_number + 1);
00272 res->number++;
00273
00274 return error;
00275 }
00276
00277 static int splt_fu_append_first_revision(splt_freedb_one_result *prev,
00278 const char *album_name)
00279 {
00280 prev->revisions = malloc(sizeof(int));
00281 if (prev->revisions == NULL)
00282 {
00283 return SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
00284 }
00285
00286 prev->revisions[0] = atoi(album_name);
00287 prev->revision_number++;
00288
00289 return SPLT_OK;
00290 }
00291
00292 static int splt_fu_append_next_revision(splt_freedb_one_result *prev,
00293 const char *album_name)
00294 {
00295 prev->revisions = realloc(prev->revisions, (prev->revision_number + 1) * sizeof(int));
00296 if (prev->revisions == NULL)
00297 {
00298 return SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
00299 }
00300
00301 prev->revisions[prev->revision_number] = atoi(album_name);
00302 prev->revision_number++;
00303
00304 return SPLT_OK;
00305 }
00306