1 /**********************************************************
2 *
3 * libmp3splt -- library based on mp3splt,
4 * for mp3/ogg splitting without decoding
5 *
6 * Copyright (c) 2002-2005 M. Trotta - <mtrotta@users.sourceforge.net>
7 * Copyright (c) 2005-2014 Alexandru Munteanu - m@ioalex.net
8 *
9 * http://mp3splt.sourceforge.net
10 *
11 *********************************************************/
12
13 /**********************************************************
14 *
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version 2
18 * of the License, or (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
28 * USA.
29 *
30 *********************************************************/
31
32 /*! \file
33
34 Utilities used by the functions in freedb.c
35 */
36 #include <string.h>
37
38 #include "splt.h"
39
40 static void splt_fu_free_freedb_search(splt_state *state);
41 static int splt_fu_append_first_result(splt_freedb_results *res,
42 const char *album_name);
43 static int splt_fu_append_next_result(splt_freedb_results *res,
44 const char *album_name);
45 static int splt_fu_append_first_revision(splt_freedb_one_result *prev,
46 const char *album_name);
47 static int splt_fu_append_next_revision(splt_freedb_one_result *prev,
48 const char *album_name);
49
splt_fu_set_default_values(splt_state * state)50 void splt_fu_set_default_values(splt_state *state)
51 {
52 splt_freedb *fdb = &state->fdb;
53 fdb->search_results = NULL;
54 fdb->cdstate = NULL;
55 }
56
splt_fu_freedb_free_search(splt_state * state)57 void splt_fu_freedb_free_search(splt_state *state)
58 {
59 splt_fu_free_freedb_search(state);
60 splt_cd_state *cdstate = state->fdb.cdstate;
61 if (cdstate != NULL)
62 {
63 free(cdstate);
64 cdstate = NULL;
65 }
66 }
67
splt_fu_freedb_init_search(splt_state * state)68 int splt_fu_freedb_init_search(splt_state *state)
69 {
70 int error = SPLT_OK;
71 splt_freedb *fdb = &state->fdb;
72
73 if ((fdb->cdstate = malloc(sizeof(splt_cd_state))) == NULL)
74 {
75 error = SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
76 }
77 else
78 {
79 fdb->cdstate->foundcd = 0;
80 if ((fdb->search_results = malloc(sizeof(splt_freedb_results))) == NULL)
81 {
82 free(fdb->cdstate);
83 fdb->cdstate = NULL;
84 error = SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
85 }
86 else
87 {
88 fdb->search_results->number = 0;
89 fdb->search_results->results = NULL;
90 fdb->search_results->iterator_counter = 0;
91 }
92 }
93
94 return error;
95 }
96
splt_fu_freedb_append_result(splt_state * state,const char * album_name,int revision)97 int splt_fu_freedb_append_result(splt_state *state, const char *album_name, int revision)
98 {
99 splt_freedb_results *res = state->fdb.search_results;
100
101 if (album_name == NULL)
102 {
103 return SPLT_OK;
104 }
105
106 if (res->number == 0)
107 {
108 return splt_fu_append_first_result(res, album_name);
109 }
110
111 if (revision != -1)
112 {
113 return splt_fu_append_next_result(res, album_name);
114 }
115
116 splt_freedb_one_result *prev = &res->results[res->number-1];
117
118 if (prev->revision_number == 0)
119 {
120 return splt_fu_append_first_revision(prev, album_name);
121 }
122
123 return splt_fu_append_next_revision(prev, album_name);
124 }
125
splt_fu_freedb_get_found_cds(splt_state * state)126 int splt_fu_freedb_get_found_cds(splt_state *state)
127 {
128 return state->fdb.cdstate->foundcd;
129 }
130
splt_fu_freedb_found_cds_next(splt_state * state)131 void splt_fu_freedb_found_cds_next(splt_state *state)
132 {
133 state->fdb.cdstate->foundcd = splt_fu_freedb_get_found_cds(state) + 1;
134 }
135
splt_fu_freedb_set_disc(splt_state * state,int index,const char * discid,const char * category,int category_size)136 void splt_fu_freedb_set_disc(splt_state *state, int index,
137 const char *discid, const char *category, int category_size)
138 {
139 splt_cd_state *cdstate = state->fdb.cdstate;
140
141 if ((index >= 0) && (index < SPLT_MAXCD))
142 {
143 memset(cdstate->discs[index].category, '\0', 20);
144 snprintf(cdstate->discs[index].category, category_size,"%s",category);
145 #ifdef __WIN32__
146 //snprintf seems buggy
147 cdstate->discs[index].category[category_size-1] = '\0';
148 #endif
149 splt_d_print_debug(state,"Setting disc category _%s_\n", cdstate->discs[index].category);
150
151 memset(cdstate->discs[index].discid, '\0', SPLT_DISCIDLEN+1);
152 snprintf(cdstate->discs[index].discid,SPLT_DISCIDLEN+1,"%s",discid);
153 #ifdef __WIN32__
154 //snprintf seems buggy
155 cdstate->discs[index].discid[SPLT_DISCIDLEN] = '\0';
156 #endif
157 splt_d_print_debug(state,"Setting disc id _%s_\n", cdstate->discs[index].discid);
158 }
159 else
160 {
161 splt_e_error(SPLT_IERROR_INT, __func__, index, NULL);
162 }
163 }
164
splt_fu_freedb_get_disc_category(splt_state * state,int index)165 const char *splt_fu_freedb_get_disc_category(splt_state *state, int index)
166 {
167 splt_cd_state *cdstate = state->fdb.cdstate;
168
169 if ((index >= 0) && (index < cdstate->foundcd))
170 {
171 return cdstate->discs[index].category;
172 }
173 else
174 {
175 splt_e_error(SPLT_IERROR_INT, __func__, index, NULL);
176 return NULL;
177 }
178 }
179
splt_fu_freedb_get_disc_id(splt_state * state,int index)180 const char *splt_fu_freedb_get_disc_id(splt_state *state, int index)
181 {
182 splt_cd_state *cdstate = state->fdb.cdstate;
183
184 if ((index >= 0) && (index < cdstate->foundcd))
185 {
186 return cdstate->discs[index].discid;
187 }
188 else
189 {
190 splt_e_error(SPLT_IERROR_INT, __func__, index, NULL);
191 return NULL;
192 }
193 }
194
splt_fu_free_freedb_search(splt_state * state)195 static void splt_fu_free_freedb_search(splt_state *state)
196 {
197 splt_freedb_results *res = state->fdb.search_results;
198
199 if (res)
200 {
201 int i = 0;
202 for (i = 0; i < res->number;i++)
203 {
204 if (res->results[i].revisions)
205 {
206 free(res->results[i].revisions);
207 res->results[i].revisions = NULL;
208 }
209
210 if (res->results[i].name)
211 {
212 free(res->results[i].name);
213 res->results[i].name = NULL;
214 }
215 }
216
217 if (res->results)
218 {
219 free(res->results);
220 res->results = NULL;
221 }
222
223 res->number = 0;
224 res->iterator_counter = 0;
225
226 free(state->fdb.search_results);
227 state->fdb.search_results = NULL;
228 }
229 }
230
splt_fu_append_first_result(splt_freedb_results * res,const char * album_name)231 static int splt_fu_append_first_result(splt_freedb_results *res,
232 const char *album_name)
233 {
234 int error = SPLT_OK;
235
236 res->results = malloc(sizeof(splt_freedb_one_result));
237 if (res->results == NULL)
238 {
239 return SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
240 }
241 memset(res->results, 0x0, sizeof(splt_freedb_one_result));
242
243 res->results[0].revisions = NULL;
244 error = splt_su_copy(album_name, &res->results[0].name);
245 if (error < 0) { return error; }
246
247 res->results[0].revision_number = 0;
248 res->results[0].id = 0;
249 res->number++;
250
251 return error;
252 }
253
splt_fu_append_next_result(splt_freedb_results * res,const char * album_name)254 static int splt_fu_append_next_result(splt_freedb_results *res,
255 const char *album_name)
256 {
257 int error = SPLT_OK;
258
259 res->results = realloc(res->results, (res->number + 1) * sizeof(splt_freedb_one_result));
260 if (res->results == NULL)
261 {
262 return SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
263 }
264 memset(&res->results[res->number], 0x0, sizeof(splt_freedb_one_result));
265
266 error = splt_su_copy(album_name, &res->results[res->number].name);
267 if (error < 0) { return error; }
268
269 splt_freedb_one_result *prev = &res->results[res->number-1];
270
271 res->results[res->number].revision_number = 0;
272 res->results[res->number].id = (prev->id + prev->revision_number + 1);
273 res->number++;
274
275 return error;
276 }
277
splt_fu_append_first_revision(splt_freedb_one_result * prev,const char * album_name)278 static int splt_fu_append_first_revision(splt_freedb_one_result *prev,
279 const char *album_name)
280 {
281 prev->revisions = malloc(sizeof(int));
282 if (prev->revisions == NULL)
283 {
284 return SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
285 }
286
287 prev->revisions[0] = atoi(album_name);
288 prev->revision_number++;
289
290 return SPLT_OK;
291 }
292
splt_fu_append_next_revision(splt_freedb_one_result * prev,const char * album_name)293 static int splt_fu_append_next_revision(splt_freedb_one_result *prev,
294 const char *album_name)
295 {
296 prev->revisions = realloc(prev->revisions, (prev->revision_number + 1) * sizeof(int));
297 if (prev->revisions == NULL)
298 {
299 return SPLT_ERROR_CANNOT_ALLOCATE_MEMORY;
300 }
301
302 prev->revisions[prev->revision_number] = atoi(album_name);
303 prev->revision_number++;
304
305 return SPLT_OK;
306 }
307
308