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
00033 #include "splt.h"
00034
00035 extern int global_debug;
00036
00037 void splt_o_set_options_default_values(splt_state *state)
00038 {
00039 state->options.split_mode = SPLT_OPTION_NORMAL_MODE;
00040 state->options.tags = SPLT_CURRENT_TAGS;
00041 state->options.xing = SPLT_TRUE;
00042 state->options.output_filenames = SPLT_OUTPUT_DEFAULT;
00043 state->options.quiet_mode = SPLT_FALSE;
00044 state->options.pretend_to_split = SPLT_FALSE;
00045 state->options.option_frame_mode = SPLT_FALSE;
00046 state->options.split_time = 6000;
00047 state->options.overlap_time = 0;
00048 state->options.option_auto_adjust = SPLT_FALSE;
00049 state->options.option_input_not_seekable = SPLT_FALSE;
00050 state->options.create_dirs_from_filenames = SPLT_FALSE;
00051 state->options.parameter_threshold = SPLT_DEFAULT_PARAM_THRESHOLD;
00052 state->options.parameter_offset = SPLT_DEFAULT_PARAM_OFFSET;
00053 state->options.parameter_number_tracks = SPLT_DEFAULT_PARAM_TRACKS;
00054 state->options.parameter_shots = SPLT_DEFAULT_PARAM_SHOTS;
00055 state->options.parameter_minimum_length = SPLT_DEFAULT_PARAM_MINIMUM_LENGTH;
00056 state->options.parameter_min_track_length = SPLT_DEFAULT_PARAM_MINIMUM_TRACK_LENGTH;
00057
00058 state->options.artist_tag_format = SPLT_NO_CONVERSION;
00059 state->options.album_tag_format = SPLT_NO_CONVERSION;
00060 state->options.title_tag_format = SPLT_NO_CONVERSION;
00061 state->options.comment_tag_format = SPLT_NO_CONVERSION;
00062 state->options.replace_underscores_tag_format = SPLT_FALSE;
00063 state->options.set_file_from_cue_if_file_tag_found = SPLT_FALSE;
00064
00065 state->options.parameter_remove_silence = SPLT_FALSE;
00066 state->options.parameter_gap = SPLT_DEFAULT_PARAM_GAP;
00067 state->options.remaining_tags_like_x = -1;
00068 state->options.auto_increment_tracknumber_tags = 0;
00069 state->options.enable_silence_log = SPLT_FALSE;
00070 state->options.force_tags_version = 0;
00071 state->options.length_split_file_number = 1;
00072 state->options.replace_tags_in_tags = SPLT_FALSE;
00073 }
00074
00075 void splt_o_set_option(splt_state *state, int option_name, const void *data)
00076 {
00077 switch (option_name)
00078 {
00079 case SPLT_OPT_DEBUG_MODE:
00080 global_debug = *((int *)data);
00081 break;
00082 case SPLT_OPT_QUIET_MODE:
00083 state->options.quiet_mode = *((int *)data);
00084 break;
00085 case SPLT_OPT_PRETEND_TO_SPLIT:
00086 state->options.pretend_to_split = *((int *)data);
00087 break;
00088 case SPLT_OPT_OUTPUT_FILENAMES:
00089 state->options.output_filenames = *((int *)data);
00090 break;
00091 case SPLT_OPT_SPLIT_MODE:
00092 state->options.split_mode = *((int *)data);
00093 break;
00094 case SPLT_OPT_TAGS:
00095 state->options.tags = *((int *)data);
00096 break;
00097 case SPLT_OPT_XING:
00098 state->options.xing = *((int *)data);
00099 break;
00100 case SPLT_OPT_CREATE_DIRS_FROM_FILENAMES:
00101 state->options.create_dirs_from_filenames = *((int *)data);
00102 break;
00103 case SPLT_OPT_FRAME_MODE:
00104 state->options.option_frame_mode = *((int *)data);
00105 break;
00106 case SPLT_OPT_AUTO_ADJUST:
00107 state->options.option_auto_adjust = *((int *)data);
00108 break;
00109 case SPLT_OPT_INPUT_NOT_SEEKABLE:
00110 state->options.option_input_not_seekable = *((int *)data);
00111 break;
00112 case SPLT_OPT_PARAM_NUMBER_TRACKS:
00113 state->options.parameter_number_tracks = *((int *)data);
00114 break;
00115 case SPLT_OPT_PARAM_SHOTS:
00116 state->options.parameter_shots = *((int *)data);
00117 break;
00118 case SPLT_OPT_PARAM_REMOVE_SILENCE:
00119 state->options.parameter_remove_silence = *((int *)data);
00120 break;
00121 case SPLT_OPT_PARAM_GAP:
00122 state->options.parameter_gap = *((int *)data);
00123 break;
00124 case SPLT_OPT_ALL_REMAINING_TAGS_LIKE_X:
00125 state->options.remaining_tags_like_x = *((int *)data);
00126 break;
00127 case SPLT_OPT_AUTO_INCREMENT_TRACKNUMBER_TAGS:
00128 state->options.auto_increment_tracknumber_tags = *((int *)data);
00129 break;
00130 case SPLT_OPT_ENABLE_SILENCE_LOG:
00131 state->options.enable_silence_log = *((int *)data);
00132 break;
00133 case SPLT_OPT_FORCE_TAGS_VERSION:
00134 state->options.force_tags_version = *((int *)data);
00135 break;
00136 case SPLT_OPT_LENGTH_SPLIT_FILE_NUMBER:
00137 state->options.length_split_file_number = *((int *)data);
00138 break;
00139 case SPLT_OPT_REPLACE_TAGS_IN_TAGS:
00140 state->options.replace_tags_in_tags = *((int *)data);
00141 break;
00142
00143 case SPLT_OPT_OVERLAP_TIME:
00144 state->options.overlap_time = *((long *)data);
00145 break;
00146
00147 case SPLT_OPT_SPLIT_TIME:
00148 state->options.split_time = *((float *)data);
00149 break;
00150 case SPLT_OPT_PARAM_THRESHOLD:
00151 state->options.parameter_threshold = *((float *)data);
00152 break;
00153 case SPLT_OPT_PARAM_OFFSET:
00154 state->options.parameter_offset = *((float *)data);
00155 break;
00156 case SPLT_OPT_PARAM_MIN_LENGTH:
00157 state->options.parameter_minimum_length = *((float *)data);
00158 break;
00159 case SPLT_OPT_PARAM_MIN_TRACK_LENGTH:
00160 state->options.parameter_min_track_length = *((float *)data);
00161 break;
00162 case SPLT_OPT_ARTIST_TAG_FORMAT:
00163 state->options.artist_tag_format = *((int *)data);
00164 break;
00165 case SPLT_OPT_ALBUM_TAG_FORMAT:
00166 state->options.album_tag_format = *((int *)data);
00167 break;
00168 case SPLT_OPT_TITLE_TAG_FORMAT:
00169 state->options.title_tag_format = *((int *)data);
00170 break;
00171 case SPLT_OPT_COMMENT_TAG_FORMAT:
00172 state->options.comment_tag_format = *((int *)data);
00173 break;
00174 case SPLT_OPT_REPLACE_UNDERSCORES_TAG_FORMAT:
00175 state->options.replace_underscores_tag_format = *((int *)data);
00176 break;
00177 case SPLT_OPT_SET_FILE_FROM_CUE_IF_FILE_TAG_FOUND:
00178 state->options.set_file_from_cue_if_file_tag_found = *((int *)data);
00179 break;
00180 default:
00181 splt_e_error(SPLT_IERROR_INT,__func__, option_name, NULL);
00182 break;
00183 }
00184 }
00185
00186 void splt_o_set_int_option(splt_state *state, int option_name, int value)
00187 {
00188 splt_o_set_option(state, option_name, &value);
00189 }
00190
00191 void splt_o_set_long_option(splt_state *state, int option_name, long value)
00192 {
00193 splt_o_set_option(state, option_name, &value);
00194 }
00195
00196 void splt_o_set_float_option(splt_state *state, int option_name, float value)
00197 {
00198 splt_o_set_option(state, option_name, &value);
00199 }
00200
00201 static void *splt_o_get_option(splt_state *state, int option_name)
00202 {
00203 switch (option_name)
00204 {
00205 case SPLT_OPT_QUIET_MODE:
00206 return &state->options.quiet_mode;
00207 case SPLT_OPT_PRETEND_TO_SPLIT:
00208 return &state->options.pretend_to_split;
00209 case SPLT_OPT_OUTPUT_FILENAMES:
00210 return &state->options.output_filenames;
00211 case SPLT_OPT_SPLIT_MODE:
00212 return &state->options.split_mode;
00213 case SPLT_OPT_TAGS:
00214 return &state->options.tags;
00215 case SPLT_OPT_XING:
00216 return &state->options.xing;
00217 case SPLT_OPT_CREATE_DIRS_FROM_FILENAMES:
00218 return &state->options.create_dirs_from_filenames;
00219 case SPLT_OPT_FRAME_MODE:
00220 return &state->options.option_frame_mode;
00221 case SPLT_OPT_AUTO_ADJUST:
00222 return &state->options.option_auto_adjust;
00223 case SPLT_OPT_INPUT_NOT_SEEKABLE:
00224 return &state->options.option_input_not_seekable;
00225 case SPLT_OPT_PARAM_NUMBER_TRACKS:
00226 return &state->options.parameter_number_tracks;
00227 case SPLT_OPT_PARAM_SHOTS:
00228 return &state->options.parameter_shots;
00229 case SPLT_OPT_PARAM_REMOVE_SILENCE:
00230 return &state->options.parameter_remove_silence;
00231 case SPLT_OPT_PARAM_GAP:
00232 return &state->options.parameter_gap;
00233 case SPLT_OPT_ALL_REMAINING_TAGS_LIKE_X:
00234 return &state->options.remaining_tags_like_x;
00235 case SPLT_OPT_AUTO_INCREMENT_TRACKNUMBER_TAGS:
00236 return &state->options.auto_increment_tracknumber_tags;
00237 case SPLT_OPT_ENABLE_SILENCE_LOG:
00238 return &state->options.enable_silence_log;
00239 case SPLT_OPT_FORCE_TAGS_VERSION:
00240 return &state->options.force_tags_version;
00241 case SPLT_OPT_LENGTH_SPLIT_FILE_NUMBER:
00242 return &state->options.length_split_file_number;
00243 case SPLT_OPT_REPLACE_TAGS_IN_TAGS:
00244 return &state->options.replace_tags_in_tags;
00245 case SPLT_OPT_OVERLAP_TIME:
00246 return &state->options.overlap_time;
00247 case SPLT_OPT_SPLIT_TIME:
00248 return &state->options.split_time;
00249 case SPLT_OPT_PARAM_THRESHOLD:
00250 return &state->options.parameter_threshold;
00251 case SPLT_OPT_PARAM_OFFSET:
00252 return &state->options.parameter_offset;
00253 case SPLT_OPT_PARAM_MIN_LENGTH:
00254 return &state->options.parameter_minimum_length;
00255 case SPLT_OPT_PARAM_MIN_TRACK_LENGTH:
00256 return &state->options.parameter_min_track_length;
00257 case SPLT_OPT_ARTIST_TAG_FORMAT:
00258 return &state->options.artist_tag_format;
00259 case SPLT_OPT_ALBUM_TAG_FORMAT:
00260 return &state->options.album_tag_format;
00261 case SPLT_OPT_TITLE_TAG_FORMAT:
00262 return &state->options.title_tag_format;
00263 case SPLT_OPT_COMMENT_TAG_FORMAT:
00264 return &state->options.comment_tag_format;
00265 case SPLT_OPT_REPLACE_UNDERSCORES_TAG_FORMAT:
00266 return &state->options.replace_underscores_tag_format;
00267 case SPLT_OPT_SET_FILE_FROM_CUE_IF_FILE_TAG_FOUND:
00268 return &state->options.set_file_from_cue_if_file_tag_found;
00269 default:
00270 splt_e_error(SPLT_IERROR_INT,__func__, option_name, NULL);
00271 break;
00272 }
00273
00274 return NULL;
00275 }
00276
00277 int splt_o_get_int_option(splt_state *state, int option_name)
00278 {
00279 return *((int *)splt_o_get_option(state, option_name));
00280 }
00281
00282 long splt_o_get_long_option(splt_state *state, int option_name)
00283 {
00284 return *((long *)splt_o_get_option(state, option_name));
00285 }
00286
00287 float splt_o_get_float_option(splt_state *state, int option_name)
00288 {
00289 return *((float *)splt_o_get_option(state, option_name));
00290 }
00291
00292 void splt_o_set_ioptions_default_values(splt_state *state)
00293 {
00294 state->iopts.library_locked = SPLT_FALSE;
00295 state->iopts.messages_locked = SPLT_FALSE;
00296 state->iopts.current_refresh_rate = SPLT_DEFAULT_PROGRESS_RATE;
00297 state->iopts.frame_mode_enabled = SPLT_FALSE;
00298 state->iopts.new_filename_path = NULL;
00299 }
00300
00301 void splt_o_iopts_free(splt_state *state)
00302 {
00303 if (state->iopts.new_filename_path)
00304 {
00305 free(state->iopts.new_filename_path);
00306 state->iopts.new_filename_path = NULL;
00307 }
00308 }
00309
00310 void splt_o_set_iopt(splt_state *state, int type, int value)
00311 {
00312 switch (type)
00313 {
00314 case SPLT_INTERNAL_FRAME_MODE_ENABLED:
00315 state->iopts.frame_mode_enabled = value;
00316 break;
00317 case SPLT_INTERNAL_PROGRESS_RATE:
00318 state->iopts.current_refresh_rate = value;
00319 break;
00320 default:
00321 break;
00322 }
00323 }
00324
00325 int splt_o_get_iopt(splt_state *state, int type)
00326 {
00327 switch (type)
00328 {
00329 case SPLT_INTERNAL_FRAME_MODE_ENABLED:
00330 return state->iopts.frame_mode_enabled;
00331 break;
00332 case SPLT_INTERNAL_PROGRESS_RATE:
00333 return state->iopts.current_refresh_rate;
00334 break;
00335 default:
00336 break;
00337 }
00338
00339 return 0;
00340 }
00341
00342 void splt_o_set_default_iopts(splt_state *state)
00343 {
00344 splt_o_set_iopt(state, SPLT_INTERNAL_FRAME_MODE_ENABLED,SPLT_FALSE);
00345 splt_o_set_iopt(state, SPLT_INTERNAL_PROGRESS_RATE,0);
00346 splt_t_set_new_filename_path(state, NULL, NULL);
00347 }
00348
00349 int splt_o_library_locked(splt_state *state)
00350 {
00351 return state->iopts.library_locked;
00352 }
00353
00354 void splt_o_lock_library(splt_state *state)
00355 {
00356 state->iopts.library_locked = SPLT_TRUE;
00357 }
00358
00359 void splt_o_unlock_library(splt_state *state)
00360 {
00361 state->iopts.library_locked = SPLT_FALSE;
00362 }
00363
00364 int splt_o_messages_locked(splt_state *state)
00365 {
00366 return state->iopts.messages_locked;
00367 }
00368
00369 void splt_o_lock_messages(splt_state *state)
00370 {
00371 state->iopts.messages_locked = SPLT_TRUE;
00372 }
00373
00374 void splt_o_unlock_messages(splt_state *state)
00375 {
00376 state->iopts.messages_locked = SPLT_FALSE;
00377 }
00378