libmp3splt
src/options.c
00001 /**********************************************************
00002  *
00003  * libmp3splt -- library based on mp3splt,
00004  *               for mp3/ogg splitting without decoding
00005  *
00006  * Copyright (c) 2002-2005 M. Trotta - <mtrotta@users.sourceforge.net>
00007  * Copyright (c) 2005-2011 Alexandru Munteanu - io_fx@yahoo.fr
00008  *
00009  * http://mp3splt.sourceforge.net
00010  *
00011  *********************************************************/
00012 
00013 /**********************************************************
00014  *
00015  * This program is free software; you can redistribute it and/or
00016  * modify it under the terms of the GNU General Public License
00017  * as published by the Free Software Foundation; either version 2
00018  * of the License, or (at your option) any later version.
00019  *
00020  * This program is distributed in the hope that it will be useful,
00021  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00022  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00023  * GNU General Public License for more details.
00024  *
00025  * You should have received a copy of the GNU General Public License
00026  * along with this program; if not, write to the Free Software
00027  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
00028  * 02111-1307,
00029  * USA.
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_minimum_length = SPLT_DEFAULT_PARAM_MINIMUM_LENGTH;
00055 
00056   state->options.artist_tag_format = SPLT_NO_CONVERSION;
00057   state->options.album_tag_format = SPLT_NO_CONVERSION;
00058   state->options.title_tag_format = SPLT_NO_CONVERSION;
00059   state->options.comment_tag_format = SPLT_NO_CONVERSION;
00060   state->options.replace_underscores_tag_format = SPLT_FALSE;
00061   state->options.set_file_from_cue_if_file_tag_found = SPLT_FALSE;
00062 
00063   state->options.parameter_remove_silence = SPLT_FALSE;
00064   state->options.parameter_gap = SPLT_DEFAULT_PARAM_GAP;
00065   state->options.remaining_tags_like_x = -1;
00066   state->options.auto_increment_tracknumber_tags = 0;
00067   state->options.enable_silence_log = SPLT_FALSE;
00068   state->options.force_tags_version = 0;
00069   state->options.length_split_file_number = 1;
00070   state->options.replace_tags_in_tags = SPLT_FALSE;
00071 }
00072 
00073 void splt_o_set_option(splt_state *state, int option_name, const void *data)
00074 {
00075   switch (option_name)
00076   {
00077     case SPLT_OPT_DEBUG_MODE:
00078       global_debug = *((int *)data);
00079       break;
00080     case SPLT_OPT_QUIET_MODE:
00081       state->options.quiet_mode = *((int *)data);
00082       break;
00083     case SPLT_OPT_PRETEND_TO_SPLIT:
00084       state->options.pretend_to_split = *((int *)data);
00085       break;
00086     case SPLT_OPT_OUTPUT_FILENAMES:
00087       state->options.output_filenames = *((int *)data);
00088       break;
00089     case SPLT_OPT_SPLIT_MODE:
00090       state->options.split_mode = *((int *)data);
00091       break;
00092     case SPLT_OPT_TAGS:
00093       state->options.tags = *((int *)data);
00094       break;
00095     case SPLT_OPT_XING:
00096       state->options.xing = *((int *)data);
00097       break;
00098     case SPLT_OPT_CREATE_DIRS_FROM_FILENAMES:
00099       state->options.create_dirs_from_filenames = *((int *)data);
00100       break;
00101     case SPLT_OPT_FRAME_MODE:
00102       state->options.option_frame_mode = *((int *)data);
00103       break;
00104     case SPLT_OPT_AUTO_ADJUST:
00105       state->options.option_auto_adjust = *((int *)data);
00106       break;
00107     case SPLT_OPT_INPUT_NOT_SEEKABLE:
00108       state->options.option_input_not_seekable = *((int *)data);
00109       break;
00110     case SPLT_OPT_PARAM_NUMBER_TRACKS:
00111       state->options.parameter_number_tracks = *((int *)data);
00112       break;
00113     case SPLT_OPT_PARAM_REMOVE_SILENCE:
00114       state->options.parameter_remove_silence = *((int *)data);
00115       break;
00116     case SPLT_OPT_PARAM_GAP:
00117       state->options.parameter_gap = *((int *)data);
00118       break;
00119     case SPLT_OPT_ALL_REMAINING_TAGS_LIKE_X:
00120       state->options.remaining_tags_like_x = *((int *)data);
00121       break;
00122     case SPLT_OPT_AUTO_INCREMENT_TRACKNUMBER_TAGS:
00123       state->options.auto_increment_tracknumber_tags = *((int *)data);
00124       break;
00125     case SPLT_OPT_ENABLE_SILENCE_LOG:
00126       state->options.enable_silence_log = *((int *)data);
00127       break;
00128     case SPLT_OPT_FORCE_TAGS_VERSION:
00129       state->options.force_tags_version = *((int *)data);
00130       break;
00131     case SPLT_OPT_LENGTH_SPLIT_FILE_NUMBER:
00132       state->options.length_split_file_number = *((int *)data);
00133       break;
00134     case SPLT_OPT_REPLACE_TAGS_IN_TAGS:
00135       state->options.replace_tags_in_tags = *((int *)data);
00136       break;
00137 
00138     case SPLT_OPT_OVERLAP_TIME:
00139       state->options.overlap_time = *((long *)data);
00140       break;
00141 
00142     case SPLT_OPT_SPLIT_TIME:
00143       state->options.split_time = *((float *)data);
00144       break;
00145     case SPLT_OPT_PARAM_THRESHOLD:
00146       state->options.parameter_threshold = *((float *)data);
00147       break;
00148     case SPLT_OPT_PARAM_OFFSET:
00149       state->options.parameter_offset = *((float *)data);
00150       break;
00151     case SPLT_OPT_PARAM_MIN_LENGTH:
00152       state->options.parameter_minimum_length = *((float *)data);
00153       break;
00154     case SPLT_OPT_ARTIST_TAG_FORMAT:
00155       state->options.artist_tag_format = *((int *)data);
00156       break;
00157     case SPLT_OPT_ALBUM_TAG_FORMAT:
00158       state->options.album_tag_format = *((int *)data);
00159       break;
00160     case SPLT_OPT_TITLE_TAG_FORMAT:
00161       state->options.title_tag_format = *((int *)data);
00162       break;
00163     case SPLT_OPT_COMMENT_TAG_FORMAT:
00164       state->options.comment_tag_format = *((int *)data);
00165       break;
00166     case SPLT_OPT_REPLACE_UNDERSCORES_TAG_FORMAT:
00167       state->options.replace_underscores_tag_format = *((int *)data);
00168       break;
00169     case SPLT_OPT_SET_FILE_FROM_CUE_IF_FILE_TAG_FOUND:
00170       state->options.set_file_from_cue_if_file_tag_found = *((int *)data);
00171       break;
00172     default:
00173       splt_e_error(SPLT_IERROR_INT,__func__, option_name, NULL);
00174       break;
00175   }
00176 }
00177 
00178 void splt_o_set_int_option(splt_state *state, int option_name, int value)
00179 {
00180   splt_o_set_option(state, option_name, &value);
00181 }
00182 
00183 void splt_o_set_long_option(splt_state *state, int option_name, long value)
00184 {
00185   splt_o_set_option(state, option_name, &value);
00186 }
00187 
00188 void splt_o_set_float_option(splt_state *state, int option_name, float value)
00189 {
00190   splt_o_set_option(state, option_name, &value);
00191 }
00192 
00193 static void *splt_o_get_option(splt_state *state, int option_name)
00194 {
00195   switch (option_name)
00196   {
00197     case SPLT_OPT_QUIET_MODE:
00198       return &state->options.quiet_mode;
00199     case SPLT_OPT_PRETEND_TO_SPLIT:
00200       return &state->options.pretend_to_split;
00201     case SPLT_OPT_OUTPUT_FILENAMES:
00202       return &state->options.output_filenames;
00203     case SPLT_OPT_SPLIT_MODE:
00204       return &state->options.split_mode;
00205     case SPLT_OPT_TAGS:
00206       return &state->options.tags;
00207     case SPLT_OPT_XING:
00208       return &state->options.xing;
00209     case SPLT_OPT_CREATE_DIRS_FROM_FILENAMES:
00210       return &state->options.create_dirs_from_filenames;
00211     case SPLT_OPT_FRAME_MODE:
00212       return &state->options.option_frame_mode;
00213     case SPLT_OPT_AUTO_ADJUST:
00214       return &state->options.option_auto_adjust;
00215     case SPLT_OPT_INPUT_NOT_SEEKABLE:
00216       return &state->options.option_input_not_seekable;
00217     case SPLT_OPT_PARAM_NUMBER_TRACKS:
00218       return &state->options.parameter_number_tracks;
00219     case SPLT_OPT_PARAM_REMOVE_SILENCE:
00220       return &state->options.parameter_remove_silence;
00221     case SPLT_OPT_PARAM_GAP:
00222       return &state->options.parameter_gap;
00223     case SPLT_OPT_ALL_REMAINING_TAGS_LIKE_X:
00224       return &state->options.remaining_tags_like_x;
00225     case SPLT_OPT_AUTO_INCREMENT_TRACKNUMBER_TAGS:
00226       return &state->options.auto_increment_tracknumber_tags;
00227     case SPLT_OPT_ENABLE_SILENCE_LOG:
00228       return &state->options.enable_silence_log;
00229     case SPLT_OPT_FORCE_TAGS_VERSION:
00230       return &state->options.force_tags_version;
00231     case SPLT_OPT_LENGTH_SPLIT_FILE_NUMBER:
00232       return &state->options.length_split_file_number;
00233     case SPLT_OPT_REPLACE_TAGS_IN_TAGS:
00234       return &state->options.replace_tags_in_tags;
00235     case SPLT_OPT_OVERLAP_TIME:
00236       return &state->options.overlap_time;
00237     case SPLT_OPT_SPLIT_TIME:
00238       return &state->options.split_time;
00239     case SPLT_OPT_PARAM_THRESHOLD:
00240       return &state->options.parameter_threshold;
00241     case SPLT_OPT_PARAM_OFFSET:
00242       return &state->options.parameter_offset;
00243     case SPLT_OPT_PARAM_MIN_LENGTH:
00244       return &state->options.parameter_minimum_length;
00245     case SPLT_OPT_ARTIST_TAG_FORMAT:
00246       return &state->options.artist_tag_format;
00247     case SPLT_OPT_ALBUM_TAG_FORMAT:
00248       return &state->options.album_tag_format;
00249     case SPLT_OPT_TITLE_TAG_FORMAT:
00250       return &state->options.title_tag_format;
00251     case SPLT_OPT_COMMENT_TAG_FORMAT:
00252       return &state->options.comment_tag_format;
00253     case SPLT_OPT_REPLACE_UNDERSCORES_TAG_FORMAT:
00254       return &state->options.replace_underscores_tag_format;
00255     case SPLT_OPT_SET_FILE_FROM_CUE_IF_FILE_TAG_FOUND:
00256       return &state->options.set_file_from_cue_if_file_tag_found;
00257     default:
00258       splt_e_error(SPLT_IERROR_INT,__func__, option_name, NULL);
00259       break;
00260   }
00261 
00262   return NULL;
00263 }
00264 
00265 int splt_o_get_int_option(splt_state *state, int option_name)
00266 {
00267   return *((int *)splt_o_get_option(state, option_name));
00268 }
00269 
00270 long splt_o_get_long_option(splt_state *state, int option_name)
00271 {
00272   return *((long *)splt_o_get_option(state, option_name));
00273 }
00274 
00275 float splt_o_get_float_option(splt_state *state, int option_name)
00276 {
00277   return *((float *)splt_o_get_option(state, option_name));
00278 }
00279 
00280 void splt_o_set_ioptions_default_values(splt_state *state)
00281 {
00282   state->iopts.library_locked = SPLT_FALSE;
00283   state->iopts.messages_locked = SPLT_FALSE;
00284   state->iopts.current_refresh_rate = SPLT_DEFAULT_PROGRESS_RATE;
00285   state->iopts.frame_mode_enabled = SPLT_FALSE;
00286   state->iopts.new_filename_path = NULL;
00287 }
00288 
00289 void splt_o_iopts_free(splt_state *state)
00290 {
00291   if (state->iopts.new_filename_path)
00292   {
00293     free(state->iopts.new_filename_path);
00294     state->iopts.new_filename_path = NULL;
00295   }
00296 }
00297 
00298 void splt_o_set_iopt(splt_state *state, int type, int value)
00299 {
00300   switch (type)
00301   {
00302     case SPLT_INTERNAL_FRAME_MODE_ENABLED:
00303       state->iopts.frame_mode_enabled = value;
00304       break;
00305     case SPLT_INTERNAL_PROGRESS_RATE:
00306       state->iopts.current_refresh_rate = value;
00307       break;
00308     default:
00309       break;
00310   }
00311 }
00312 
00313 int splt_o_get_iopt(splt_state *state, int type)
00314 {
00315   switch (type)
00316   {
00317     case SPLT_INTERNAL_FRAME_MODE_ENABLED:
00318       return state->iopts.frame_mode_enabled;
00319       break;
00320     case SPLT_INTERNAL_PROGRESS_RATE:
00321       return state->iopts.current_refresh_rate;
00322       break;
00323     default:
00324       break;
00325   }
00326 
00327   return 0;
00328 }
00329 
00330 void splt_o_set_default_iopts(splt_state *state)
00331 {
00332   splt_o_set_iopt(state, SPLT_INTERNAL_FRAME_MODE_ENABLED,SPLT_FALSE);
00333   splt_o_set_iopt(state, SPLT_INTERNAL_PROGRESS_RATE,0);
00334   splt_t_set_new_filename_path(state, NULL, NULL);
00335 }
00336 
00337 int splt_o_library_locked(splt_state *state)
00338 {
00339   return state->iopts.library_locked;
00340 }
00341 
00342 void splt_o_lock_library(splt_state *state)
00343 {
00344   state->iopts.library_locked = SPLT_TRUE;
00345 }
00346 
00347 void splt_o_unlock_library(splt_state *state)
00348 {
00349   state->iopts.library_locked = SPLT_FALSE;
00350 }
00351 
00352 int splt_o_messages_locked(splt_state *state)
00353 {
00354   return state->iopts.messages_locked;
00355 }
00356 
00357 void splt_o_lock_messages(splt_state *state)
00358 {
00359   state->iopts.messages_locked = SPLT_TRUE;
00360 }
00361 
00362 void splt_o_unlock_messages(splt_state *state)
00363 {
00364   state->iopts.messages_locked = SPLT_FALSE;
00365 }
00366