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 #include "splt.h"
33
34 extern int global_debug;
35
splt_o_set_options_default_values(splt_state * state)36 void splt_o_set_options_default_values(splt_state *state)
37 {
38 state->options.split_mode = SPLT_OPTION_NORMAL_MODE;
39 state->options.tags = SPLT_CURRENT_TAGS;
40 state->options.xing = SPLT_TRUE;
41 state->options.output_filenames = SPLT_OUTPUT_DEFAULT;
42 state->options.quiet_mode = SPLT_FALSE;
43 state->options.pretend_to_split = SPLT_FALSE;
44 state->options.option_frame_mode = SPLT_FALSE;
45 state->options.split_time = 6000;
46 state->options.overlap_time = 0;
47 state->options.option_auto_adjust = SPLT_FALSE;
48 state->options.option_input_not_seekable = SPLT_FALSE;
49 state->options.create_dirs_from_filenames = SPLT_FALSE;
50 state->options.parameter_threshold = SPLT_DEFAULT_PARAM_THRESHOLD;
51 state->options.parameter_offset = SPLT_DEFAULT_PARAM_OFFSET;
52 state->options.parameter_number_tracks = SPLT_DEFAULT_PARAM_TRACKS;
53 state->options.parameter_shots = SPLT_DEFAULT_PARAM_SHOTS;
54 state->options.parameter_minimum_length = SPLT_DEFAULT_PARAM_MINIMUM_LENGTH;
55 state->options.parameter_min_track_length = SPLT_DEFAULT_PARAM_MINIMUM_TRACK_LENGTH;
56 state->options.parameter_min_track_join = SPLT_DEFAULT_PARAM_MIN_TRACK_JOIN;
57
58 state->options.artist_tag_format = SPLT_NO_CONVERSION;
59 state->options.album_tag_format = SPLT_NO_CONVERSION;
60 state->options.title_tag_format = SPLT_NO_CONVERSION;
61 state->options.comment_tag_format = SPLT_NO_CONVERSION;
62 state->options.replace_underscores_tag_format = SPLT_FALSE;
63 state->options.set_file_from_cue_if_file_tag_found = SPLT_FALSE;
64
65 state->options.parameter_remove_silence = SPLT_FALSE;
66 state->options.keep_silence_right = SPLT_DEFAULT_KEEP_SILENCE_RIGHT;
67 state->options.keep_silence_left = SPLT_DEFAULT_KEEP_SILENCE_LEFT;
68 state->options.parameter_gap = SPLT_DEFAULT_PARAM_GAP;
69 state->options.remaining_tags_like_x = -1;
70 state->options.auto_increment_tracknumber_tags = 0;
71 state->options.enable_silence_log = SPLT_FALSE;
72 state->options.force_tags_version = 0;
73 state->options.length_split_file_number = 1;
74 state->options.replace_tags_in_tags = SPLT_FALSE;
75 state->options.cue_set_splitpoint_names_from_rem_name = SPLT_FALSE;
76 state->options.cue_disable_cue_file_created_message = SPLT_FALSE;
77 state->options.cue_cddb_add_tags_with_keep_original_tags = SPLT_FALSE;
78 state->options.warn_if_no_auto_adjust_found = SPLT_FALSE;
79 state->options.stop_if_no_auto_adjust_found = SPLT_FALSE;
80 state->options.decode_and_write_flac_md5sum = SPLT_FALSE;
81 state->options.handle_bit_reservoir = SPLT_FALSE;
82 state->options.id3v2_encoding = SPLT_ID3V2_UTF16;
83 state->options.input_tags_encoding = SPLT_ID3V2_UTF8;
84 state->options.time_minimum_length = 0;
85 }
86
splt_o_set_option(splt_state * state,int option_name,const void * data)87 void splt_o_set_option(splt_state *state, int option_name, const void *data)
88 {
89 switch (option_name)
90 {
91 case SPLT_OPT_DEBUG_MODE:
92 global_debug = *((int *)data);
93 break;
94 case SPLT_OPT_QUIET_MODE:
95 state->options.quiet_mode = *((int *)data);
96 break;
97 case SPLT_OPT_PRETEND_TO_SPLIT:
98 state->options.pretend_to_split = *((int *)data);
99 break;
100 case SPLT_OPT_OUTPUT_FILENAMES:
101 state->options.output_filenames = *((int *)data);
102 break;
103 case SPLT_OPT_SPLIT_MODE:
104 state->options.split_mode = *((int *)data);
105 break;
106 case SPLT_OPT_TAGS:
107 state->options.tags = *((int *)data);
108 break;
109 case SPLT_OPT_XING:
110 state->options.xing = *((int *)data);
111 break;
112 case SPLT_OPT_CREATE_DIRS_FROM_FILENAMES:
113 state->options.create_dirs_from_filenames = *((int *)data);
114 break;
115 case SPLT_OPT_FRAME_MODE:
116 state->options.option_frame_mode = *((int *)data);
117 break;
118 case SPLT_OPT_AUTO_ADJUST:
119 state->options.option_auto_adjust = *((int *)data);
120 break;
121 case SPLT_OPT_INPUT_NOT_SEEKABLE:
122 state->options.option_input_not_seekable = *((int *)data);
123 break;
124 case SPLT_OPT_PARAM_NUMBER_TRACKS:
125 state->options.parameter_number_tracks = *((int *)data);
126 break;
127 case SPLT_OPT_PARAM_SHOTS:
128 state->options.parameter_shots = *((int *)data);
129 break;
130 case SPLT_OPT_PARAM_REMOVE_SILENCE:
131 state->options.parameter_remove_silence = *((int *)data);
132 break;
133 case SPLT_OPT_KEEP_SILENCE_LEFT:
134 state->options.keep_silence_left = *((float *)data);
135 break;
136 case SPLT_OPT_KEEP_SILENCE_RIGHT:
137 state->options.keep_silence_right = *((float *)data);
138 break;
139 case SPLT_OPT_CUE_SET_SPLITPOINT_NAMES_FROM_REM_NAME:
140 state->options.cue_set_splitpoint_names_from_rem_name = *((int *)data);
141 break;
142 case SPLT_OPT_CUE_DISABLE_CUE_FILE_CREATED_MESSAGE:
143 state->options.cue_disable_cue_file_created_message = *((int *)data);
144 break;
145 case SPLT_OPT_CUE_CDDB_ADD_TAGS_WITH_KEEP_ORIGINAL_TAGS:
146 state->options.cue_cddb_add_tags_with_keep_original_tags = *((int *)data);
147 break;
148 case SPLT_OPT_WARN_IF_NO_AUTO_ADJUST_FOUND:
149 state->options.warn_if_no_auto_adjust_found = *((int *)data);
150 break;
151 case SPLT_OPT_STOP_IF_NO_AUTO_ADJUST_FOUND:
152 state->options.stop_if_no_auto_adjust_found = *((int *)data);
153 break;
154 case SPLT_OPT_DECODE_AND_WRITE_FLAC_MD5SUM_FOR_CREATED_FILES:
155 state->options.decode_and_write_flac_md5sum = *((int *)data);
156 break;
157 case SPLT_OPT_HANDLE_BIT_RESERVOIR:
158 state->options.handle_bit_reservoir = *((int *)data);
159 break;
160 case SPLT_OPT_ID3V2_ENCODING:
161 state->options.id3v2_encoding = *((int *) data);
162 break;
163 case SPLT_OPT_INPUT_TAGS_ENCODING:
164 state->options.input_tags_encoding = *((int *) data);
165 break;
166 case SPLT_OPT_TIME_MINIMUM_THEORETICAL_LENGTH:
167 state->options.time_minimum_length = *((long *) data);
168 break;
169 case SPLT_OPT_PARAM_GAP:
170 state->options.parameter_gap = *((int *)data);
171 break;
172 case SPLT_OPT_ALL_REMAINING_TAGS_LIKE_X:
173 state->options.remaining_tags_like_x = *((int *)data);
174 break;
175 case SPLT_OPT_AUTO_INCREMENT_TRACKNUMBER_TAGS:
176 state->options.auto_increment_tracknumber_tags = *((int *)data);
177 break;
178 case SPLT_OPT_ENABLE_SILENCE_LOG:
179 state->options.enable_silence_log = *((int *)data);
180 break;
181 case SPLT_OPT_FORCE_TAGS_VERSION:
182 state->options.force_tags_version = *((int *)data);
183 break;
184 case SPLT_OPT_LENGTH_SPLIT_FILE_NUMBER:
185 state->options.length_split_file_number = *((int *)data);
186 break;
187 case SPLT_OPT_REPLACE_TAGS_IN_TAGS:
188 state->options.replace_tags_in_tags = *((int *)data);
189 break;
190 case SPLT_OPT_OVERLAP_TIME:
191 state->options.overlap_time = *((long *)data);
192 break;
193 case SPLT_OPT_SPLIT_TIME:
194 state->options.split_time = *((long *)data);
195 break;
196 case SPLT_OPT_PARAM_THRESHOLD:
197 state->options.parameter_threshold = *((float *)data);
198 break;
199 case SPLT_OPT_PARAM_OFFSET:
200 state->options.parameter_offset = *((float *)data);
201 break;
202 case SPLT_OPT_PARAM_MIN_LENGTH:
203 state->options.parameter_minimum_length = *((float *)data);
204 break;
205 case SPLT_OPT_PARAM_MIN_TRACK_LENGTH:
206 state->options.parameter_min_track_length = *((float *)data);
207 break;
208 case SPLT_OPT_PARAM_MIN_TRACK_JOIN:
209 state->options.parameter_min_track_join = *((float *)data);
210 break;
211 case SPLT_OPT_ARTIST_TAG_FORMAT:
212 state->options.artist_tag_format = *((int *)data);
213 break;
214 case SPLT_OPT_ALBUM_TAG_FORMAT:
215 state->options.album_tag_format = *((int *)data);
216 break;
217 case SPLT_OPT_TITLE_TAG_FORMAT:
218 state->options.title_tag_format = *((int *)data);
219 break;
220 case SPLT_OPT_COMMENT_TAG_FORMAT:
221 state->options.comment_tag_format = *((int *)data);
222 break;
223 case SPLT_OPT_REPLACE_UNDERSCORES_TAG_FORMAT:
224 state->options.replace_underscores_tag_format = *((int *)data);
225 break;
226 case SPLT_OPT_SET_FILE_FROM_CUE_IF_FILE_TAG_FOUND:
227 state->options.set_file_from_cue_if_file_tag_found = *((int *)data);
228 break;
229 default:
230 splt_e_error(SPLT_IERROR_INT,__func__, option_name, NULL);
231 break;
232 }
233 }
234
splt_o_set_int_option(splt_state * state,int option_name,int value)235 void splt_o_set_int_option(splt_state *state, int option_name, int value)
236 {
237 splt_o_set_option(state, option_name, &value);
238 }
239
splt_o_set_long_option(splt_state * state,int option_name,long value)240 void splt_o_set_long_option(splt_state *state, int option_name, long value)
241 {
242 splt_o_set_option(state, option_name, &value);
243 }
244
splt_o_set_float_option(splt_state * state,int option_name,float value)245 void splt_o_set_float_option(splt_state *state, int option_name, float value)
246 {
247 splt_o_set_option(state, option_name, &value);
248 }
249
splt_o_get_option(splt_state * state,int option_name)250 static void *splt_o_get_option(splt_state *state, int option_name)
251 {
252 switch (option_name)
253 {
254 case SPLT_OPT_QUIET_MODE:
255 return &state->options.quiet_mode;
256 case SPLT_OPT_PRETEND_TO_SPLIT:
257 return &state->options.pretend_to_split;
258 case SPLT_OPT_OUTPUT_FILENAMES:
259 return &state->options.output_filenames;
260 case SPLT_OPT_SPLIT_MODE:
261 return &state->options.split_mode;
262 case SPLT_OPT_TAGS:
263 return &state->options.tags;
264 case SPLT_OPT_XING:
265 return &state->options.xing;
266 case SPLT_OPT_CREATE_DIRS_FROM_FILENAMES:
267 return &state->options.create_dirs_from_filenames;
268 case SPLT_OPT_FRAME_MODE:
269 return &state->options.option_frame_mode;
270 case SPLT_OPT_AUTO_ADJUST:
271 return &state->options.option_auto_adjust;
272 case SPLT_OPT_INPUT_NOT_SEEKABLE:
273 return &state->options.option_input_not_seekable;
274 case SPLT_OPT_PARAM_NUMBER_TRACKS:
275 return &state->options.parameter_number_tracks;
276 case SPLT_OPT_PARAM_SHOTS:
277 return &state->options.parameter_shots;
278 case SPLT_OPT_PARAM_REMOVE_SILENCE:
279 return &state->options.parameter_remove_silence;
280 case SPLT_OPT_KEEP_SILENCE_LEFT:
281 return &state->options.keep_silence_left;
282 case SPLT_OPT_KEEP_SILENCE_RIGHT:
283 return &state->options.keep_silence_right;
284 case SPLT_OPT_CUE_SET_SPLITPOINT_NAMES_FROM_REM_NAME:
285 return &state->options.cue_set_splitpoint_names_from_rem_name;
286 case SPLT_OPT_CUE_DISABLE_CUE_FILE_CREATED_MESSAGE:
287 return &state->options.cue_disable_cue_file_created_message;
288 case SPLT_OPT_CUE_CDDB_ADD_TAGS_WITH_KEEP_ORIGINAL_TAGS:
289 return &state->options.cue_cddb_add_tags_with_keep_original_tags;
290 case SPLT_OPT_WARN_IF_NO_AUTO_ADJUST_FOUND:
291 return &state->options.warn_if_no_auto_adjust_found;
292 case SPLT_OPT_STOP_IF_NO_AUTO_ADJUST_FOUND:
293 return &state->options.stop_if_no_auto_adjust_found;
294 case SPLT_OPT_DECODE_AND_WRITE_FLAC_MD5SUM_FOR_CREATED_FILES:
295 return &state->options.decode_and_write_flac_md5sum;
296 case SPLT_OPT_HANDLE_BIT_RESERVOIR:
297 return &state->options.handle_bit_reservoir;
298 case SPLT_OPT_ID3V2_ENCODING:
299 return &state->options.id3v2_encoding;
300 case SPLT_OPT_INPUT_TAGS_ENCODING:
301 return &state->options.input_tags_encoding;
302 case SPLT_OPT_TIME_MINIMUM_THEORETICAL_LENGTH:
303 return &state->options.time_minimum_length;
304 case SPLT_OPT_PARAM_GAP:
305 return &state->options.parameter_gap;
306 case SPLT_OPT_ALL_REMAINING_TAGS_LIKE_X:
307 return &state->options.remaining_tags_like_x;
308 case SPLT_OPT_AUTO_INCREMENT_TRACKNUMBER_TAGS:
309 return &state->options.auto_increment_tracknumber_tags;
310 case SPLT_OPT_ENABLE_SILENCE_LOG:
311 return &state->options.enable_silence_log;
312 case SPLT_OPT_FORCE_TAGS_VERSION:
313 return &state->options.force_tags_version;
314 case SPLT_OPT_LENGTH_SPLIT_FILE_NUMBER:
315 return &state->options.length_split_file_number;
316 case SPLT_OPT_REPLACE_TAGS_IN_TAGS:
317 return &state->options.replace_tags_in_tags;
318 case SPLT_OPT_OVERLAP_TIME:
319 return &state->options.overlap_time;
320 case SPLT_OPT_SPLIT_TIME:
321 return &state->options.split_time;
322 case SPLT_OPT_PARAM_THRESHOLD:
323 return &state->options.parameter_threshold;
324 case SPLT_OPT_PARAM_OFFSET:
325 return &state->options.parameter_offset;
326 case SPLT_OPT_PARAM_MIN_LENGTH:
327 return &state->options.parameter_minimum_length;
328 case SPLT_OPT_PARAM_MIN_TRACK_LENGTH:
329 return &state->options.parameter_min_track_length;
330 case SPLT_OPT_PARAM_MIN_TRACK_JOIN:
331 return &state->options.parameter_min_track_join;
332 case SPLT_OPT_ARTIST_TAG_FORMAT:
333 return &state->options.artist_tag_format;
334 case SPLT_OPT_ALBUM_TAG_FORMAT:
335 return &state->options.album_tag_format;
336 case SPLT_OPT_TITLE_TAG_FORMAT:
337 return &state->options.title_tag_format;
338 case SPLT_OPT_COMMENT_TAG_FORMAT:
339 return &state->options.comment_tag_format;
340 case SPLT_OPT_REPLACE_UNDERSCORES_TAG_FORMAT:
341 return &state->options.replace_underscores_tag_format;
342 case SPLT_OPT_SET_FILE_FROM_CUE_IF_FILE_TAG_FOUND:
343 return &state->options.set_file_from_cue_if_file_tag_found;
344 default:
345 splt_e_error(SPLT_IERROR_INT,__func__, option_name, NULL);
346 break;
347 }
348
349 return NULL;
350 }
351
splt_o_get_int_option(splt_state * state,int option_name)352 int splt_o_get_int_option(splt_state *state, int option_name)
353 {
354 return *((int *)splt_o_get_option(state, option_name));
355 }
356
splt_o_get_long_option(splt_state * state,int option_name)357 long splt_o_get_long_option(splt_state *state, int option_name)
358 {
359 return *((long *)splt_o_get_option(state, option_name));
360 }
361
splt_o_get_float_option(splt_state * state,int option_name)362 float splt_o_get_float_option(splt_state *state, int option_name)
363 {
364 return *((float *)splt_o_get_option(state, option_name));
365 }
366
splt_o_set_ioptions_default_values(splt_state * state)367 void splt_o_set_ioptions_default_values(splt_state *state)
368 {
369 state->iopts.library_locked = SPLT_FALSE;
370 state->iopts.messages_locked = SPLT_FALSE;
371 state->iopts.current_refresh_rate = SPLT_DEFAULT_PROGRESS_RATE;
372 state->iopts.frame_mode_enabled = SPLT_FALSE;
373 state->iopts.new_filename_path = NULL;
374 }
375
splt_o_iopts_free(splt_state * state)376 void splt_o_iopts_free(splt_state *state)
377 {
378 if (state->iopts.new_filename_path)
379 {
380 free(state->iopts.new_filename_path);
381 state->iopts.new_filename_path = NULL;
382 }
383 }
384
splt_o_set_iopt(splt_state * state,int type,int value)385 void splt_o_set_iopt(splt_state *state, int type, int value)
386 {
387 switch (type)
388 {
389 case SPLT_INTERNAL_FRAME_MODE_ENABLED:
390 state->iopts.frame_mode_enabled = value;
391 break;
392 case SPLT_INTERNAL_PROGRESS_RATE:
393 state->iopts.current_refresh_rate = value;
394 break;
395 default:
396 break;
397 }
398 }
399
splt_o_get_iopt(splt_state * state,int type)400 int splt_o_get_iopt(splt_state *state, int type)
401 {
402 switch (type)
403 {
404 case SPLT_INTERNAL_FRAME_MODE_ENABLED:
405 return state->iopts.frame_mode_enabled;
406 break;
407 case SPLT_INTERNAL_PROGRESS_RATE:
408 return state->iopts.current_refresh_rate;
409 break;
410 default:
411 break;
412 }
413
414 return 0;
415 }
416
splt_o_set_default_iopts(splt_state * state)417 void splt_o_set_default_iopts(splt_state *state)
418 {
419 splt_o_set_iopt(state, SPLT_INTERNAL_FRAME_MODE_ENABLED,SPLT_FALSE);
420 splt_o_set_iopt(state, SPLT_INTERNAL_PROGRESS_RATE,0);
421 splt_t_set_new_filename_path(state, NULL, NULL);
422 }
423
splt_o_library_locked(splt_state * state)424 int splt_o_library_locked(splt_state *state)
425 {
426 return state->iopts.library_locked;
427 }
428
splt_o_lock_library(splt_state * state)429 void splt_o_lock_library(splt_state *state)
430 {
431 state->iopts.library_locked = SPLT_TRUE;
432 }
433
splt_o_unlock_library(splt_state * state)434 void splt_o_unlock_library(splt_state *state)
435 {
436 state->iopts.library_locked = SPLT_FALSE;
437 }
438
splt_o_messages_locked(splt_state * state)439 int splt_o_messages_locked(splt_state *state)
440 {
441 return state->iopts.messages_locked;
442 }
443
splt_o_lock_messages(splt_state * state)444 void splt_o_lock_messages(splt_state *state)
445 {
446 state->iopts.messages_locked = SPLT_TRUE;
447 }
448
splt_o_unlock_messages(splt_state * state)449 void splt_o_unlock_messages(splt_state *state)
450 {
451 state->iopts.messages_locked = SPLT_FALSE;
452 }
453
454