include/libmp3splt/mp3splt.h

Go to the documentation of this file.
00001 /**********************************************************
00002  *
00003  * libmp3splt -- library based on mp3splt v2.1c,
00004  *               for mp3/ogg splitting without decoding
00005  *
00006  * Copyright (c) 2002-2005 M. Trotta - <mtrotta@users.sourceforge.net>
00007  * Copyright (c) 2005-2013 Alexandru Munteanu - m@ioalex.net
00008  *
00009  * And others ... see the AUTHORS file provided with libmp3splt source.
00010  *
00011  * http://mp3splt.sourceforge.net
00012  *
00013  *********************************************************/
00014 
00015 /**********************************************************
00016  *
00017  * This program is free software; you can redistribute it and/or
00018  * modify it under the terms of the GNU General Public License
00019  * as published by the Free Software Foundation; either version 2
00020  * of the License, or (at your option) any later version.
00021  *
00022  * This program is distributed in the hope that it will be useful,
00023  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00024  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00025  * GNU General Public License for more details.
00026  *
00027  * You should have received a copy of the GNU General Public License
00028  * along with this program; if not, write to the Free Software
00029  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
00030  * USA.
00031  *
00032  *********************************************************/
00033 
00080 #ifndef MP3SPLT_MP3SPLT_H
00081 
00082 #include <sys/types.h>
00083 
00084 #include "version.h"
00085 
00089 #define SPLT_TRUE 1
00090 
00093 #define SPLT_FALSE 0
00094 
00106 typedef enum {
00107   SPLT_OK = 0,
00108 
00109   SPLT_OK_SPLIT = 1,
00110   SPLT_SPLITPOINT_BIGGER_THAN_LENGTH = 4,
00111   SPLT_SILENCE_OK = 5,
00112   SPLT_TIME_SPLIT_OK = 6,
00113   SPLT_NO_SILENCE_SPLITPOINTS_FOUND = 7,
00114   SPLT_OK_SPLIT_EOF = 8,
00115   SPLT_LENGTH_SPLIT_OK = 9,
00116   SPLT_TRIM_SILENCE_OK = 10,
00117 
00118   SPLT_FREEDB_OK = 100,
00119   SPLT_FREEDB_FILE_OK = 101,
00120   SPLT_CDDB_OK = 102,
00121   SPLT_CUE_OK = 103,
00122   SPLT_FREEDB_MAX_CD_REACHED = 104,
00123   SPLT_AUDACITY_OK = 105,
00124 
00125   SPLT_DEWRAP_OK = 200,
00126 
00127   SPLT_SYNC_OK = 300,
00128   SPLT_MIGHT_BE_VBR = 301,
00129 
00130   SPLT_ERR_SYNC = -300,
00131   SPLT_ERR_NO_SYNC_FOUND = -301,
00132   SPLT_ERR_TOO_MANY_SYNC_ERR = -302,
00133 
00134   SPLT_OUTPUT_FORMAT_OK = 400,
00135   SPLT_OUTPUT_FORMAT_AMBIGUOUS = 401,
00136 
00137   SPLT_REGEX_OK = 800,
00138 
00139   SPLT_ERROR_SPLITPOINTS = -1,
00140   SPLT_ERROR_CANNOT_OPEN_FILE = -2,
00141   SPLT_ERROR_INVALID = -3,
00142   SPLT_ERROR_EQUAL_SPLITPOINTS = -5,
00143   SPLT_ERROR_SPLITPOINTS_NOT_IN_ORDER = -6,
00144   SPLT_ERROR_NEGATIVE_SPLITPOINT = -7,
00145   SPLT_ERROR_INCORRECT_PATH = -8,
00146   SPLT_ERROR_INCOMPATIBLE_OPTIONS = -10,
00147   SPLT_ERROR_INPUT_OUTPUT_SAME_FILE = -12,
00148   SPLT_ERROR_CANNOT_ALLOCATE_MEMORY = -15,
00149   SPLT_ERROR_CANNOT_OPEN_DEST_FILE = -16,
00150   SPLT_ERROR_CANT_WRITE_TO_OUTPUT_FILE = -17,
00151   SPLT_ERROR_WHILE_READING_FILE = -18,
00152   SPLT_ERROR_SEEKING_FILE = -19,
00153   SPLT_ERROR_BEGIN_OUT_OF_FILE = -20,
00154   SPLT_ERROR_INEXISTENT_FILE = -21,
00155   SPLT_SPLIT_CANCELLED = -22,
00156   SPLT_ERROR_LIBRARY_LOCKED = -24,
00157   SPLT_ERROR_STATE_NULL = -25,
00158   SPLT_ERROR_NEGATIVE_TIME_SPLIT = -26,
00159   SPLT_ERROR_CANNOT_CREATE_DIRECTORY = -27,
00160   SPLT_ERROR_CANNOT_CLOSE_FILE = -28,
00161   SPLT_ERROR_NO_PLUGIN_FOUND = -29,
00162   SPLT_ERROR_CANNOT_INIT_LIBLTDL = -30,
00163   SPLT_ERROR_CRC_FAILED = -31,
00164   SPLT_ERROR_NO_PLUGIN_FOUND_FOR_FILE = -32,
00165   SPLT_ERROR_PLUGIN_ERROR = -33,
00166   SPLT_ERROR_TIME_SPLIT_VALUE_INVALID = -34,
00167   SPLT_ERROR_LENGTH_SPLIT_VALUE_INVALID = -35,
00168   SPLT_ERROR_CANNOT_GET_TOTAL_TIME = -36,
00169   SPLT_ERROR_LIBID3 = -37,
00170 
00171   SPLT_FREEDB_ERROR_INITIALISE_SOCKET = -101,
00172   SPLT_FREEDB_ERROR_CANNOT_GET_HOST = -102,
00173   SPLT_FREEDB_ERROR_CANNOT_OPEN_SOCKET = -103,
00174   SPLT_FREEDB_ERROR_CANNOT_CONNECT = -104,
00175   SPLT_FREEDB_ERROR_CANNOT_SEND_MESSAGE = -105,
00176   SPLT_FREEDB_ERROR_INVALID_SERVER_ANSWER = -106,
00177   SPLT_FREEDB_ERROR_SITE_201 = -107,
00178   SPLT_FREEDB_ERROR_SITE_200 = -108,
00179   SPLT_FREEDB_ERROR_BAD_COMMUNICATION = -109,
00180   SPLT_FREEDB_ERROR_GETTING_INFOS = -110,
00181   SPLT_FREEDB_NO_CD_FOUND = -111,
00182   SPLT_FREEDB_ERROR_CANNOT_RECV_MESSAGE = -112,
00183   SPLT_INVALID_CUE_FILE = -115,
00184   SPLT_INVALID_CDDB_FILE = -116,
00185   SPLT_FREEDB_NO_SUCH_CD_IN_DATABASE = -118,
00186   SPLT_FREEDB_ERROR_SITE = -119,
00187   SPLT_FREEDB_ERROR_CANNOT_DISCONNECT = -120,
00188   SPLT_FREEDB_ERROR_PROXY_NOT_SUPPORTED = -121,
00189 
00190   SPLT_DEWRAP_ERR_FILE_LENGTH = -200,
00191   SPLT_DEWRAP_ERR_VERSION_OLD = -201,
00192   SPLT_DEWRAP_ERR_NO_FILE_OR_BAD_INDEX = -202,
00193   SPLT_DEWRAP_ERR_FILE_DAMAGED_INCOMPLETE = -203,
00194   SPLT_DEWRAP_ERR_FILE_NOT_WRAPED_DAMAGED = -204,
00195 
00196   SPLT_OUTPUT_FORMAT_ERROR = -400,
00197 
00198   SPLT_ERROR_INEXISTENT_SPLITPOINT = -500,
00199 
00200   SPLT_PLUGIN_ERROR_UNSUPPORTED_FEATURE = -600,
00201 
00202   SPLT_INVALID_AUDACITY_FILE = -700,
00203 
00204   SPLT_INVALID_REGEX = -800,
00205   SPLT_REGEX_NO_MATCH = -801,
00206   SPLT_REGEX_UNAVAILABLE = -802,
00207 } splt_code;
00208 
00210 
00215 
00223 typedef struct _splt_state splt_state;
00224 
00235 splt_state *mp3splt_new_state(splt_code *error);
00236 
00245 splt_code mp3splt_free_state(splt_state *state);
00246 
00256 splt_code mp3splt_append_plugins_scan_dir(splt_state *state, const char *directory);
00257 
00267 splt_code mp3splt_find_plugins(splt_state *state);
00268 
00270 
00285 char *mp3splt_get_strerror(splt_state *state, splt_code error);
00286 
00288 
00304 typedef enum {
00313   SPLT_OPT_PRETEND_TO_SPLIT = 1,
00321   SPLT_OPT_QUIET_MODE,
00329   SPLT_OPT_DEBUG_MODE,
00337   SPLT_OPT_SPLIT_MODE,
00345   SPLT_OPT_TAGS,
00353   SPLT_OPT_XING,
00365   SPLT_OPT_CREATE_DIRS_FROM_FILENAMES,
00373   SPLT_OPT_OUTPUT_FILENAMES,
00384   SPLT_OPT_FRAME_MODE,
00392   SPLT_OPT_AUTO_ADJUST,
00402   SPLT_OPT_INPUT_NOT_SEEKABLE,
00411   SPLT_OPT_PARAM_NUMBER_TRACKS,
00423   SPLT_OPT_PARAM_SHOTS,
00431   SPLT_OPT_PARAM_REMOVE_SILENCE,
00440   SPLT_OPT_PARAM_GAP,
00449   SPLT_OPT_ENABLE_SILENCE_LOG,
00459   SPLT_OPT_FORCE_TAGS_VERSION,
00468   SPLT_OPT_LENGTH_SPLIT_FILE_NUMBER,
00478   SPLT_OPT_REPLACE_TAGS_IN_TAGS,
00487   SPLT_OPT_OVERLAP_TIME,
00496   SPLT_OPT_SPLIT_TIME,
00507   SPLT_OPT_PARAM_THRESHOLD,
00517   SPLT_OPT_PARAM_OFFSET,
00526   SPLT_OPT_PARAM_MIN_LENGTH,
00535   SPLT_OPT_PARAM_MIN_TRACK_LENGTH,
00546   SPLT_OPT_PARAM_MIN_TRACK_JOIN,
00555   SPLT_OPT_ARTIST_TAG_FORMAT,
00564   SPLT_OPT_ALBUM_TAG_FORMAT,
00573   SPLT_OPT_TITLE_TAG_FORMAT,
00582   SPLT_OPT_COMMENT_TAG_FORMAT,
00591   SPLT_OPT_REPLACE_UNDERSCORES_TAG_FORMAT,
00600   SPLT_OPT_SET_FILE_FROM_CUE_IF_FILE_TAG_FOUND,
00610   SPLT_OPT_KEEP_SILENCE_LEFT,
00620   SPLT_OPT_KEEP_SILENCE_RIGHT,
00629   SPLT_OPT_CUE_SET_SPLITPOINT_NAMES_FROM_REM_NAME,
00637   SPLT_OPT_CUE_DISABLE_CUE_FILE_CREATED_MESSAGE,
00646   SPLT_OPT_CUE_CDDB_ADD_TAGS_WITH_KEEP_ORIGINAL_TAGS,
00654   SPLT_OPT_ID3V2_ENCODING,
00662   SPLT_OPT_INPUT_TAGS_ENCODING,
00673   SPLT_OPT_TIME_MINIMUM_THEORETICAL_LENGTH,
00674 } splt_options;
00675 
00679 typedef enum {
00683   SPLT_OPTION_NORMAL_MODE,
00688   SPLT_OPTION_WRAP_MODE,
00693   SPLT_OPTION_SILENCE_MODE,
00698   SPLT_OPTION_TRIM_SILENCE_MODE,
00703   SPLT_OPTION_ERROR_MODE,
00708   SPLT_OPTION_TIME_MODE,
00712   SPLT_OPTION_LENGTH_MODE,
00713 } splt_split_mode_options;
00714 
00718 typedef enum {
00722   SPLT_ID3V2_LATIN1,
00726   SPLT_ID3V2_UTF8,
00730   SPLT_ID3V2_UTF16,
00731 } splt_id3v2_encoding;
00732 
00736 typedef enum {
00740   SPLT_OUTPUT_FORMAT,
00748   SPLT_OUTPUT_DEFAULT,
00753   SPLT_OUTPUT_CUSTOM
00754 } splt_output_filenames_options;
00755 
00759 #define SPLT_DEFAULT_PARAM_THRESHOLD -48.0
00760 
00763 #define SPLT_DEFAULT_PARAM_OFFSET 0.8
00764 
00767 #define SPLT_DEFAULT_PARAM_MINIMUM_LENGTH 0.0
00768 
00771 #define SPLT_DEFAULT_PARAM_MINIMUM_TRACK_LENGTH 0.0
00772 
00775 #define SPLT_DEFAULT_PARAM_MIN_TRACK_JOIN 0.0
00776 
00779 #define SPLT_DEFAULT_PARAM_GAP 30
00780 
00783 #define SPLT_DEFAULT_PARAM_TRACKS 0
00784 
00787 #define SPLT_DEFAULT_PARAM_SHOTS 25
00788 
00791 #define SPLT_DEFAULT_KEEP_SILENCE_LEFT 0
00792 
00795 #define SPLT_DEFAULT_KEEP_SILENCE_RIGHT 0
00796 
00800 typedef enum {
00804   SPLT_TAGS_ORIGINAL_FILE,
00808   SPLT_CURRENT_TAGS,
00812   SPLT_NO_TAGS,
00816   SPLT_TAGS_FROM_FILENAME_REGEX,
00817 } splt_tags_options;
00818 
00823 #define SPLT_DEFAULT_OUTPUT "@f_@mm_@ss_@h0h__@Mm_@Ss_@H0h"
00824 
00829 #define SPLT_DEFAULT_CDDB_CUE_OUTPUT "@A - @n - @t"
00830 
00834 #define SPLT_DEFAULT_SYNCERROR_OUTPUT "@f_error_@n"
00835 
00839 #define SPLT_DEFAULT_SILENCE_OUTPUT "@f_silence_@n"
00840 
00844 #define SPLT_DEFAULT_TRIM_SILENCE_OUTPUT "@f_trimmed"
00845 
00851 typedef enum {
00855   SPLT_NO_CONVERSION,
00859   SPLT_TO_LOWERCASE,
00863   SPLT_TO_UPPERCASE,
00867   SPLT_TO_FIRST_UPPERCASE,
00871   SPLT_TO_WORD_FIRST_UPPERCASE
00872 } splt_str_format;
00873 
00882 splt_code mp3splt_set_int_option(splt_state *state, splt_options option, int value);
00883 
00892 splt_code mp3splt_set_long_option(splt_state *state, splt_options option, long value);
00893 
00902 splt_code mp3splt_set_float_option(splt_state *state, splt_options option, float value);
00903 
00912 int mp3splt_get_int_option(splt_state *state, splt_options option, splt_code *error);
00913 
00922 long mp3splt_get_long_option(splt_state *state, splt_options option, splt_code *error);
00923 
00932 float mp3splt_get_float_option(splt_state *state, splt_options option, splt_code *error);
00933 
00941 splt_code mp3splt_set_oformat(splt_state *state, const char *format);
00942 
00944 
00958 splt_code mp3splt_set_filename_to_split(splt_state *state, const char *filename);
00959 
00967 splt_code mp3splt_set_path_of_split(splt_state *state, const char *path_of_split);
00968 
00980 const char *mp3splt_get_filename_to_split(splt_state *state);
00981 
00994 splt_code mp3splt_set_m3u_filename(splt_state *state, const char *m3u_filename);
00995 
01021 splt_code mp3splt_set_silence_log_filename(splt_state *state, const char *filename);
01022 
01055 splt_code mp3splt_set_silence_full_log_filename(splt_state *state, const char *filename);
01056 
01058 
01070 typedef enum {
01074   SPLT_MESSAGE_INFO,
01078   SPLT_MESSAGE_DEBUG
01079 } splt_message_type;
01080 
01097 splt_code mp3splt_set_message_function(splt_state *state, 
01098     void (*message_cb)(const char *message, splt_message_type type, void *cb_data), void *cb_data);
01099 
01113 splt_code mp3splt_set_split_filename_function(splt_state *state,
01114     void (*file_cb)(const char *filename, void *cb_data),
01115     void *cb_data);
01116 
01137 splt_code mp3splt_set_pretend_to_split_write_function(splt_state *state,
01138     void (*write_cb)(const void *ptr, size_t size, size_t nmemb, void *cb_data),
01139     void *cb_data);
01140 
01145 typedef enum {
01149   SPLT_PROGRESS_PREPARE,
01153   SPLT_PROGRESS_CREATE,
01157   SPLT_PROGRESS_SEARCH_SYNC,
01162   SPLT_PROGRESS_SCAN_SILENCE
01163 } splt_progress_messages;
01164 
01180 typedef struct splt_progres splt_progress;
01181 
01195 splt_code mp3splt_set_progress_function(splt_state *state,
01196     void (*progress_cb)(splt_progress *p_bar, void *cb_data), void *cb_data);
01197 
01201 int mp3splt_progress_get_type(const splt_progress *p_bar);
01202 
01206 char *mp3splt_progress_get_filename_shorted(const splt_progress *p_bar);
01207 
01211 int mp3splt_progress_get_current_split(const splt_progress *p_bar);
01212 
01216 int mp3splt_progress_get_max_splits(const splt_progress *p_bar);
01217 
01221 int mp3splt_progress_get_silence_found_tracks(const splt_progress *p_bar);
01222 
01226 float mp3splt_progress_get_silence_db_level(const splt_progress *p_bar);
01227 
01231 float mp3splt_progress_get_percent_progress(const splt_progress *p_bar);
01232 
01248 splt_code mp3splt_set_silence_level_function(splt_state *state,
01249   void (*get_silence_cb)(long time, float level, void *user_data),
01250   void *user_data);
01251 
01253 
01264 typedef enum {
01268   SPLT_SPLITPOINT,
01273   SPLT_SKIPPOINT,
01274 } splt_type_of_splitpoint;
01275 
01284 typedef struct _splt_point splt_point;
01285 
01299 splt_point *mp3splt_point_new(long splitpoint_value, splt_code *error);
01300 
01308 splt_code mp3splt_point_set_name(splt_point *splitpoint, const char *name);
01309 
01317 splt_code mp3splt_point_set_type(splt_point *splitpoint, splt_type_of_splitpoint type);
01318 
01328 splt_code mp3splt_append_splitpoint(splt_state *state, splt_point *splitpoint);
01329 
01337 typedef struct _splt_points splt_points;
01338 
01349 splt_points *mp3splt_get_splitpoints(splt_state *state, splt_code *error);
01350 
01358 void mp3splt_points_init_iterator(splt_points *splitpoints);
01359 
01370 const splt_point *mp3splt_points_next(splt_points *splitpoints);
01371 
01380 long mp3splt_point_get_value(const splt_point *point);
01381 
01391 splt_type_of_splitpoint mp3splt_point_get_type(const splt_point *point);
01392 
01401 char *mp3splt_point_get_name(const splt_point *point);
01402 
01409 splt_code mp3splt_erase_all_splitpoints(splt_state *state);
01410 
01412 
01422 #define SPLT_UNDEFINED_GENRE "Other"
01423 
01428 #define SPLT_ID3V1_NUMBER_OF_GENRES 127
01429 
01433 extern const char splt_id3v1_genres[SPLT_ID3V1_NUMBER_OF_GENRES][25];
01434 
01438 typedef enum {
01439   SPLT_TAGS_TITLE = 1,
01440   SPLT_TAGS_ARTIST = 2,
01441   SPLT_TAGS_ALBUM = 3,
01442   SPLT_TAGS_YEAR = 4,
01443   SPLT_TAGS_COMMENT = 5,
01444   SPLT_TAGS_TRACK = 6,
01445   SPLT_TAGS_GENRE = 7,
01446   SPLT_TAGS_PERFORMER = 8,
01451   SPLT_TAGS_ORIGINAL = 900
01452 } splt_tag_key;
01453 
01463 typedef struct _splt_tags splt_tags;
01464 
01474 splt_tags *mp3splt_tags_new(splt_code *error);
01475 
01495 splt_code mp3splt_tags_set(splt_tags *tags, ...);
01496 
01509 splt_code mp3splt_append_tags(splt_state *state, splt_tags *tags);
01510 
01515 typedef struct _splt_tags_group splt_tags_group;
01516 
01527 splt_tags_group *mp3splt_get_tags_group(splt_state *state, splt_code *error);
01528 
01535 splt_code mp3splt_remove_tags_of_skippoints(splt_state *state);
01536 
01544 void mp3splt_tags_group_init_iterator(splt_tags_group *tags_group);
01545 
01554 splt_tags *mp3splt_tags_group_next(splt_tags_group *tags_group);
01555 
01559 char *mp3splt_tags_get(splt_tags *tags, splt_tag_key key);
01560 
01589 int mp3splt_put_tags_from_string(splt_state *state, const char *tags, splt_code *error);
01590 
01599 splt_code mp3splt_read_original_tags(splt_state *state);
01600 
01607 splt_code mp3splt_erase_all_tags(splt_state *state);
01608 
01622 splt_code mp3splt_set_input_filename_regex(splt_state *state, const char *regex);
01623 
01633 splt_code mp3splt_set_default_comment_tag(splt_state *state, const char *default_comment_tag);
01634 
01644 splt_code mp3splt_set_default_genre_tag(splt_state *state, const char *default_genre_tag);
01645 
01658 splt_tags *mp3splt_parse_filename_regex(splt_state *state, splt_code *error);
01659 
01667 void mp3splt_free_one_tag(splt_tags *tags);
01668 
01670 
01689 splt_code mp3splt_split(splt_state *state);
01690 
01699 splt_code mp3splt_stop_split(splt_state *state);
01700 
01712 char **mp3splt_find_filenames(splt_state *state, const char *filename,
01713     int *num_of_files_found, splt_code *error);
01714 
01716 
01728 typedef enum {
01729   CUE_IMPORT,
01730   CDDB_IMPORT,
01731   AUDACITY_LABELS_IMPORT
01732 } splt_import_type;
01733 
01744 splt_code mp3splt_import(splt_state *state, splt_import_type type, const char *file);
01745 
01751 #define SPLT_FREEDB_SEARCH_TYPE_CDDB_CGI 1
01752 
01758 #define SPLT_FREEDB_GET_FILE_TYPE_CDDB_CGI 3
01759 
01765 #define SPLT_FREEDB_GET_FILE_TYPE_CDDB 4
01766 
01773 #define SPLT_FREEDB_CDDB_CGI_PORT 80
01774 
01782 #define SPLT_FREEDB2_CGI_SITE "tracktype.org/~cddb/cddb.cgi"
01783 
01792 typedef struct _splt_freedb_results splt_freedb_results;
01793 
01801 typedef struct _splt_freedb_one_result splt_freedb_one_result;
01802 
01811 splt_code mp3splt_use_proxy(splt_state *state, const char *proxy_address, int proxy_port);
01812 
01824 splt_code mp3splt_use_base64_authentification(splt_state *state, 
01825     const char *base64_authentification);
01826 
01837 char *mp3splt_encode_in_base64(splt_state *state, const char *input, int *error);
01838 
01845 void mp3splt_clear_proxy(splt_state *state);
01846 
01863 splt_freedb_results *mp3splt_get_freedb_search(splt_state *state,
01864     const char *searched_string, splt_code *error,
01865     int search_type, const char *search_server, int port);
01866 
01874 void mp3splt_freedb_init_iterator(splt_freedb_results *freedb_results);
01875 
01886 const splt_freedb_one_result *mp3splt_freedb_next(splt_freedb_results *freedb_results);
01887 
01892 int mp3splt_freedb_get_id(const splt_freedb_one_result *result);
01893 
01897 const char *mp3splt_freedb_get_name(const splt_freedb_one_result *result);
01898 
01902 int mp3splt_freedb_get_number_of_revisions(const splt_freedb_one_result *result);
01903 
01920 splt_code mp3splt_write_freedb_file_result(splt_state *state,
01921     int disc_id, const char *output_file,
01922     int cddb_get_type, const char *cddb_get_server, int port);
01923 
01925 
01937 typedef enum {
01938   CUE_EXPORT
01939 } splt_export_type;
01940 
01951 splt_code mp3splt_export(splt_state *state, splt_export_type type, 
01952     const char *file, int stop_at_total_time);
01953 
01955 
01970 typedef struct _splt_wrap splt_wrap;
01971 
01978 typedef struct _splt_one_wrap splt_one_wrap;
01979 
01991 splt_wrap *mp3splt_get_wrap_files(splt_state *state, splt_code *error);
01992 
02000 void mp3splt_wrap_init_iterator(splt_wrap *wrap);
02001 
02010 const splt_one_wrap *mp3splt_wrap_next(splt_wrap *wrap);
02011 
02015 char *mp3splt_wrap_get_wrapped_file(const splt_one_wrap *one_wrap);
02016 
02018 
02032 int mp3splt_set_silence_points(splt_state *state, splt_code *error);
02033 
02040 splt_code mp3splt_set_trim_silence_points(splt_state *state);
02041 
02045 char *mp3splt_get_version();
02046 
02047 #ifdef __WIN32__
02048 
02051 char *mp3splt_win32_utf16_to_utf8(const wchar_t *source);
02052 #endif
02053 
02057 int mp3splt_check_if_directory(const char *filename);
02058 
02059 #ifndef SPLT_DIRCHAR
02060 #ifdef __WIN32__
02061 #define SPLT_DIRCHAR '\\'
02062 #define SPLT_DIRSTR "\\"
02063 #else
02064 
02067 #define SPLT_DIRCHAR '/'
02068 
02071 #define SPLT_DIRSTR "/"
02072 #endif
02073 #endif
02074 
02076 
02085 typedef struct {
02089   float version;
02093   char *name;
02097   char *extension;
02101   char *upper_extension;
02102 } splt_plugin_info;
02103 
02107 typedef struct _splt_original_tags splt_original_tags;
02108 
02123 typedef struct {
02133   void (*splt_pl_init)(splt_state *state, splt_code *error);
02142   void (*splt_pl_end)(splt_state *state, splt_code *error);
02152   int (*splt_pl_check_plugin_is_for_file)(splt_state *state, splt_code *error);
02161   void (*splt_pl_set_plugin_info)(splt_plugin_info *information, splt_code *error);
02175   double (*splt_pl_split)(splt_state *state, const char *final_fname, double begin_point,
02176       double end_point, splt_code *error, int save_end_point);
02188   void (*splt_pl_set_original_tags)(splt_state *state, splt_code *error);
02197   void (*splt_pl_clear_original_tags)(splt_original_tags *original_tags);
02209   int (*splt_pl_scan_silence)(splt_state *state, splt_code *error);
02221   int (*splt_pl_scan_trim_silence)(splt_state *state, splt_code *error);
02230   void (*splt_pl_search_syncerrors)(splt_state *state, splt_code *error);
02242   int (*splt_pl_offset_split)(splt_state *state, const char *output_fname, off_t begin, off_t end);
02254   void (*splt_pl_dewrap)(splt_state *state, int listonly, const char *dir, splt_code *error);
02255 } splt_plugin_func;
02256 
02258 
02262 #define MP3SPLT_MP3SPLT_H
02263 #endif
02264