include/libmp3splt/mp3splt.h

Go to the documentation of this file.

/**********************************************************
 *
 * libmp3splt -- library based on mp3splt,
 *               for mp3/ogg splitting without decoding
 *
 * Copyright (c) 2002-2005 M. Trotta - <mtrotta@users.sourceforge.net>
 * Copyright (c) 2005-2011 Alexandru Munteanu - io_fx@yahoo.fr
 *
 * http://mp3splt.sourceforge.net
 *
 *********************************************************/

/**********************************************************
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307,
 * USA.
 *
 *********************************************************/

#ifndef MP3SPLT_MP3SPLT_H

#include <sys/types.h>
#include <stdlib.h>
#include <stdio.h>

//libtool 1.4e is buggy on mingw if we include ltdl.h
#ifndef __WIN32__
#include <ltdl.h>
#endif

#define SPLT_TRUE 1

#define SPLT_FALSE 0

/******************************/
/* Structures for the freedb  */

typedef struct {
  char *name;
  int id;
  int revision_number;
  int *revisions;
} splt_freedb_one_result;

typedef struct {
  splt_freedb_one_result *results;
  int number;
} splt_freedb_results;

#define SPLT_MAXCD 512

//maximum length of the disc id
#define SPLT_DISCIDLEN 8

//structure for the freedb search
struct splt_cd {
  char discid[SPLT_DISCIDLEN+1];
  char category[20];
};

typedef struct {
  struct splt_cd discs[SPLT_MAXCD];
  int foundcd;
} splt_cd_state;

//structure containing everything used for the
//freedb search
typedef struct {
  //we stock here the results of the freedb search
  splt_freedb_results *search_results;
  //we stock the state of the CD
  //(for the freedb search)
  splt_cd_state *cdstate;
} splt_freedb;

/******************************/
/* Structures for the wrap    */

typedef struct {
  int wrap_files_num;
  char **wrap_files;
} splt_wrap;

/************************************/
/* Structures for the syncerrors    */

typedef struct {
  off_t *serrors_points;
  long int serrors_points_num;
} splt_syncerrors;

/***************************************/
/* Structures for the output format    */

#define SPLT_MAXOLEN 255
#define SPLT_OUTNUM  20

//structure defining the output format
typedef struct {
  //format as @n_@t.. as a string
  char *format_string;
  //when we have @n option on output format
  char output_format_digits;
  int output_alpha_format_digits;
  //format for the cddb cue output
  char format[SPLT_OUTNUM+1][SPLT_MAXOLEN];
} splt_oformat;

/***************************/
/* Structures for the tags */

typedef struct {
  char *title;
  char *artist;
  char *album;
  char *performer;
  char *year;
  char *comment;
  int track;
  char *genre;

  /*
   * @brief tags version (for mp3): 1 or 2 or 1 & 2
   */
  int tags_version;

  int set_original_tags;
} splt_tags;

typedef struct {
  splt_tags tags;
  void *all_original_tags;
} splt_original_tags;

typedef struct {
  long value;
  char *name;
  int type;
} splt_point;

/*****************************/
/* Structure for the silence */

struct splt_ssplit {
  double begin_position;
  double end_position;
  long len;
  struct splt_ssplit *next;
};

/**********************************/
/* Structure for the split        */

typedef struct splt_progres {
  int progress_text_max_char;
  char filename_shorted[512];
  float percent_progress;
  int current_split;
  int max_splits;
  int progress_type;
  int silence_found_tracks;
  float silence_db_level;
  int user_data;
  void (*progress)(struct splt_progres*);
} splt_progress;

typedef struct {
  int use_proxy;
  char hostname[256];
  int port;
  int authentification;
  char user[256];
  char password[256];
} splt_proxy;

typedef enum {
  SPLT_MESSAGE_INFO,
  SPLT_MESSAGE_DEBUG
} splt_message_type;

typedef struct {
  long total_time;
  int current_split;
  int current_split_file_number;
  int splitnumber;
  int real_splitnumber;
  void (*file_split)(const char *,int);
  splt_progress *p_bar;
  void (*get_silence_level)(long time, float level, void *user_data);
  void *silence_level_client_data;
  void (*put_message)(const char *, splt_message_type );
  splt_point *points;
  int real_tagsnumber;
  splt_tags *tags;
  splt_tags tags_like_x;
} splt_struct;

/**********************************/
/* Options structure              */

typedef enum {
  SPLT_OPTION_NORMAL_MODE,
  SPLT_OPTION_WRAP_MODE,
  SPLT_OPTION_SILENCE_MODE,
  SPLT_OPTION_TRIM_SILENCE_MODE,
  SPLT_OPTION_ERROR_MODE,
  SPLT_OPTION_TIME_MODE,
  SPLT_OPTION_LENGTH_MODE,
} splt_split_mode_options;

typedef enum {
  SPLT_OUTPUT_FORMAT,
  SPLT_OUTPUT_DEFAULT,
  SPLT_OUTPUT_CUSTOM
} splt_output_filenames_options;

#define SPLT_DEFAULT_PARAM_THRESHOLD -48.0

#define SPLT_DEFAULT_PARAM_OFFSET 0.8

#define SPLT_DEFAULT_PARAM_MINIMUM_LENGTH 0.0

#define SPLT_DEFAULT_PARAM_MINIMUM_TRACK_LENGTH 0.0

#define SPLT_DEFAULT_PARAM_GAP 30

#define SPLT_DEFAULT_PARAM_TRACKS 0

typedef enum {
  SPLT_TAGS_ORIGINAL_FILE,
  SPLT_CURRENT_TAGS,
  SPLT_NO_TAGS,
  SPLT_TAGS_FROM_FILENAME_REGEX,
} splt_tags_options;

#define SPLT_ORIGINAL_TAGS_DEFAULT "%[@o,@N=1]"

#define SPLT_DEFAULT_OUTPUT "@f_@mm_@ss_@hh__@Mm_@Ss_@Hh"

#define SPLT_DEFAULT_CDDB_CUE_OUTPUT "@A - @n - @t"

#define SPLT_DEFAULT_SYNCERROR_OUTPUT "@f_error_@n"

#define SPLT_DEFAULT_SILENCE_OUTPUT "@f_silence_@n"

#define SPLT_DEFAULT_TRIM_SILENCE_OUTPUT "@f_trimmed"

typedef struct {
  splt_split_mode_options split_mode;

  splt_tags_options tags;

  int xing;

  splt_output_filenames_options output_filenames;

  int quiet_mode;

  int pretend_to_split;

  int option_frame_mode;
  float split_time;
  long overlap_time;
  int option_auto_adjust;
  int option_input_not_seekable;

  int create_dirs_from_filenames;

  //PARAMETERS---------------------------------------
  //PARAMETERS for option_auto_adjust and option_silence_mode:
  float parameter_threshold;
  float parameter_offset;

  //PARAMETERS for option_silence_mode:
  int parameter_number_tracks;
  float parameter_minimum_length;
  float parameter_min_track_length;

  int artist_tag_format;
  int album_tag_format;
  int title_tag_format;
  int comment_tag_format;

  int replace_underscores_tag_format;

  int set_file_from_cue_if_file_tag_found;

  int parameter_remove_silence;

  //PARAMETERS for option_auto_adjust:
  int parameter_gap;

  int remaining_tags_like_x;

  int auto_increment_tracknumber_tags;

  int enable_silence_log;

  int force_tags_version;
  int length_split_file_number;
  int replace_tags_in_tags;
} splt_options;

/**********************************/
/* Main structure                 */

//internal structures
typedef struct
{
  int frame_mode_enabled;
  int current_refresh_rate;
  int messages_locked;
  int library_locked;
  char *new_filename_path;
} splt_internal;

typedef struct
{
  float version;
  char *name;
  char *extension;
  char *upper_extension;
} splt_plugin_info;

typedef struct {
  int (*check_plugin_is_for_file)(void *state, int *error);
  void (*set_plugin_info)(splt_plugin_info *info, int *error);
  void (*search_syncerrors)(void *state, int *error);
  void (*dewrap)(void *state, int listonly, const char *dir, int *error);
  void (*set_total_time)(void *state, int *error);
  int (*simple_split)(void *state, const char *output_fname, off_t begin, off_t end);
  double (*split)(void *state, const char *final_fname, double begin_point,
      double end_point, int *error, int save_end_point);
  int (*scan_silence)(void *state, int *error);
  int (*scan_trim_silence)(void *state, int *error);
  void (*set_original_tags)(void *state, int *error);
  void (*clear_original_tags)(splt_original_tags *original_tags);
  void (*init)(void *state, int *error);
  void (*end)(void *state, int *error);
} splt_plugin_func;

typedef struct
{
  splt_plugin_info info;
  char *plugin_filename;
  void *plugin_handle;
  splt_plugin_func *func;
} splt_plugin_data;

typedef struct
{
  char **plugins_scan_dirs;
  int number_of_dirs_to_scan;
  int number_of_plugins_found;
  splt_plugin_data *data;
} splt_plugins;

typedef struct
{
  char *error_data;
  char *strerror_msg;
} splt_error;

typedef struct {

  int cancel_split;
  char *fname_to_split;
  char *path_of_split;

  //if this is non null, we write a m3u from the split files
  char *m3u_filename;
  
  char *input_fname_regex;

  char *default_comment_tag;
  char *default_genre_tag;

  splt_original_tags original_tags;

  splt_options options;
  splt_struct split;
  splt_oformat oformat;
  splt_wrap *wrap;
  splt_syncerrors *serrors;
  unsigned long syncerrors;
  splt_freedb fdb;

  splt_internal iopts;

  struct splt_ssplit *silence_list;

  //proxy infos
  //splt_proxy proxy;

  void *codec;

  splt_error err;

  splt_plugins *plug;
  int current_plugin;

  char *silence_log_fname;
} splt_state;

/*****************************************/
/* Confirmations, errors and messages    */

typedef enum {
  SPLT_OK = 0,

  SPLT_OK_SPLIT = 1,
  SPLT_SPLITPOINT_BIGGER_THAN_LENGTH = 4,
  SPLT_SILENCE_OK = 5,
  SPLT_TIME_SPLIT_OK = 6,
  SPLT_NO_SILENCE_SPLITPOINTS_FOUND = 7,
  SPLT_OK_SPLIT_EOF = 8,
  SPLT_LENGTH_SPLIT_OK = 9,
  SPLT_TRIM_SILENCE_OK = 10,

  SPLT_FREEDB_OK = 100,
  SPLT_FREEDB_FILE_OK = 101,
  SPLT_CDDB_OK = 102,
  SPLT_CUE_OK = 103,
  SPLT_FREEDB_MAX_CD_REACHED = 104,
  SPLT_AUDACITY_OK = 105,

  SPLT_DEWRAP_OK = 200,

  SPLT_SYNC_OK = 300,
  SPLT_MIGHT_BE_VBR = 301,

  SPLT_ERR_SYNC = -300,
  SPLT_ERR_NO_SYNC_FOUND = -301,
  SPLT_ERR_TOO_MANY_SYNC_ERR = -302,

  SPLT_OUTPUT_FORMAT_OK = 400,
  SPLT_OUTPUT_FORMAT_AMBIGUOUS = 401,

  SPLT_REGEX_OK = 800,

  SPLT_ERROR_SPLITPOINTS = -1,
  SPLT_ERROR_CANNOT_OPEN_FILE = -2,
  SPLT_ERROR_INVALID = -3,
  SPLT_ERROR_EQUAL_SPLITPOINTS = -5,
  SPLT_ERROR_SPLITPOINTS_NOT_IN_ORDER = -6,
  SPLT_ERROR_NEGATIVE_SPLITPOINT = -7,
  SPLT_ERROR_INCORRECT_PATH = -8,
  SPLT_ERROR_INCOMPATIBLE_OPTIONS = -10,
  SPLT_ERROR_INPUT_OUTPUT_SAME_FILE = -12,
  SPLT_ERROR_CANNOT_ALLOCATE_MEMORY = -15,
  SPLT_ERROR_CANNOT_OPEN_DEST_FILE = -16,
  SPLT_ERROR_CANT_WRITE_TO_OUTPUT_FILE = -17,
  SPLT_ERROR_WHILE_READING_FILE = -18,
  SPLT_ERROR_SEEKING_FILE = -19,
  SPLT_ERROR_BEGIN_OUT_OF_FILE = -20,
  SPLT_ERROR_INEXISTENT_FILE = -21,
  SPLT_SPLIT_CANCELLED = -22,
  SPLT_ERROR_LIBRARY_LOCKED = -24,
  SPLT_ERROR_STATE_NULL = -25,
  SPLT_ERROR_NEGATIVE_TIME_SPLIT = -26,
  SPLT_ERROR_CANNOT_CREATE_DIRECTORY = -27,
  SPLT_ERROR_CANNOT_CLOSE_FILE = -28,
  SPLT_ERROR_NO_PLUGIN_FOUND = -29,
  SPLT_ERROR_CANNOT_INIT_LIBLTDL = -30,
  SPLT_ERROR_CRC_FAILED = -31,
  SPLT_ERROR_NO_PLUGIN_FOUND_FOR_FILE = -32,
  SPLT_ERROR_PLUGIN_ERROR = -33,
  SPLT_ERROR_TIME_SPLIT_VALUE_INVALID = -34,
  SPLT_ERROR_LENGTH_SPLIT_VALUE_INVALID = -35,
  SPLT_ERROR_CANNOT_GET_TOTAL_TIME = -36,
  SPLT_ERROR_LIBID3 = -37,

  SPLT_FREEDB_ERROR_INITIALISE_SOCKET = -101,
  SPLT_FREEDB_ERROR_CANNOT_GET_HOST = -102,
  SPLT_FREEDB_ERROR_CANNOT_OPEN_SOCKET = -103,
  SPLT_FREEDB_ERROR_CANNOT_CONNECT = -104,
  SPLT_FREEDB_ERROR_CANNOT_SEND_MESSAGE = -105,
  SPLT_FREEDB_ERROR_INVALID_SERVER_ANSWER = -106,
  SPLT_FREEDB_ERROR_SITE_201 = -107,
  SPLT_FREEDB_ERROR_SITE_200 = -108,
  SPLT_FREEDB_ERROR_BAD_COMMUNICATION = -109,
  SPLT_FREEDB_ERROR_GETTING_INFOS = -110,
  SPLT_FREEDB_NO_CD_FOUND = -111,
  SPLT_FREEDB_ERROR_CANNOT_RECV_MESSAGE = -112,
  SPLT_INVALID_CUE_FILE = -115,
  SPLT_INVALID_CDDB_FILE = -116,
  SPLT_FREEDB_NO_SUCH_CD_IN_DATABASE = -118,
  SPLT_FREEDB_ERROR_SITE = -119,
  SPLT_FREEDB_ERROR_CANNOT_DISCONNECT = -120,

  SPLT_DEWRAP_ERR_FILE_LENGTH = -200,
  SPLT_DEWRAP_ERR_VERSION_OLD = -201,
  SPLT_DEWRAP_ERR_NO_FILE_OR_BAD_INDEX = -202,
  SPLT_DEWRAP_ERR_FILE_DAMAGED_INCOMPLETE = -203,
  SPLT_DEWRAP_ERR_FILE_NOT_WRAPED_DAMAGED = -204,

  SPLT_OUTPUT_FORMAT_ERROR = -400,

  SPLT_ERROR_INEXISTENT_SPLITPOINT = -500,

  SPLT_PLUGIN_ERROR_UNSUPPORTED_FEATURE = -600,

  SPLT_INVALID_AUDACITY_FILE = -700,

  SPLT_INVALID_REGEX = -800,
  SPLT_REGEX_NO_MATCH = -801,
} splt_code;

//internal
#define SPLT_INTERNAL_PROGRESS_RATE 1
#define SPLT_INTERNAL_FRAME_MODE_ENABLED 2

//progress messages
typedef enum {
  SPLT_PROGRESS_PREPARE,
  SPLT_PROGRESS_CREATE,
  SPLT_PROGRESS_SEARCH_SYNC,
  SPLT_PROGRESS_SCAN_SILENCE
} splt_progress_messages;

typedef enum {
  SPLT_OPT_PRETEND_TO_SPLIT,
  /*
   * If quiet; we don't do CRC check or human interaction
   */
  SPLT_OPT_QUIET_MODE,
  SPLT_OPT_DEBUG_MODE,
  SPLT_OPT_SPLIT_MODE,
  SPLT_OPT_TAGS,
  SPLT_OPT_XING,
  SPLT_OPT_CREATE_DIRS_FROM_FILENAMES,
  SPLT_OPT_OUTPUT_FILENAMES,
  SPLT_OPT_FRAME_MODE,
  SPLT_OPT_AUTO_ADJUST,
  SPLT_OPT_INPUT_NOT_SEEKABLE,
  SPLT_OPT_PARAM_NUMBER_TRACKS,
  SPLT_OPT_PARAM_REMOVE_SILENCE,
  SPLT_OPT_PARAM_GAP,
  SPLT_OPT_ALL_REMAINING_TAGS_LIKE_X,
  SPLT_OPT_AUTO_INCREMENT_TRACKNUMBER_TAGS,
  SPLT_OPT_ENABLE_SILENCE_LOG,
  SPLT_OPT_FORCE_TAGS_VERSION,
  SPLT_OPT_LENGTH_SPLIT_FILE_NUMBER,
  SPLT_OPT_REPLACE_TAGS_IN_TAGS,
  SPLT_OPT_OVERLAP_TIME,
  SPLT_OPT_SPLIT_TIME,
  SPLT_OPT_PARAM_THRESHOLD,
  SPLT_OPT_PARAM_OFFSET,
  SPLT_OPT_PARAM_MIN_LENGTH,
  SPLT_OPT_PARAM_MIN_TRACK_LENGTH,
  SPLT_OPT_ARTIST_TAG_FORMAT,
  SPLT_OPT_ALBUM_TAG_FORMAT,
  SPLT_OPT_TITLE_TAG_FORMAT,
  SPLT_OPT_COMMENT_TAG_FORMAT,
  SPLT_OPT_REPLACE_UNDERSCORES_TAG_FORMAT,
  SPLT_OPT_SET_FILE_FROM_CUE_IF_FILE_TAG_FOUND,
} splt_int_options;

typedef enum {
  SPLT_NO_CONVERSION,
  SPLT_TO_LOWERCASE,
  SPLT_TO_UPPERCASE,
  SPLT_TO_FIRST_UPPERCASE,
  SPLT_TO_WORD_FIRST_UPPERCASE
} splt_str_format;

typedef enum {
  /* a regular splitpoint */
  SPLT_SPLITPOINT,
  /* a skippoint */
  SPLT_SKIPPOINT,
} splt_type_of_splitpoint;


#define SPLT_UNDEFINED_GENRE "Other"

#define SPLT_ID3V1_NUMBER_OF_GENRES 127

static const char splt_id3v1_genres[SPLT_ID3V1_NUMBER_OF_GENRES][25] = {
  {"Blues"},
  {"Classic Rock"}, {"Country"}, {"Dance"}, 
  {"Disco"},{"Funk"},{"Grunge"},{"Hip-Hop"},{"Jazz"},
  {"Metal"},{"New Age"},{"Oldies"}, {"Other"}, {"Pop"},
  {"R&B"}, {"Rap"}, {"Reggae"}, {"Rock"}, {"Techno"},
  {"Industrial"}, {"Alternative"}, {"Ska"}, {"Death metal"},
  {"Pranks"}, {"Soundtrack"}, {"Euro-Techno"},
  {"Ambient"}, {"Trip-hop"}, {"Vocal"}, {"Jazz+Funk"},
  {"Fusion"}, {"Trance"}, {"Classical"}, {"Instrumental"},
  {"Acid"}, {"House"}, {"Game"}, {"Sound clip"}, {"Gospel"},
  {"Noise"}, {"Alt. Rock"}, {"Bass"}, {"Soul"}, {"Punk"}, 
  {"Space"}, {"Meditative"}, {"Instrumental pop"}, 
  {"Instrumental rock"}, {"Ethnic"}, {"Gothic"},{"Darkwave"},
  {"Techno-Industrial"},{"Electronic"},{"Pop-Folk"},{"Eurodance"},
  {"Dream"},{"Southern Rock"},{"Comedy"}, {"Cult"},{"Gangsta"},
  {"Top 40"},{"Christian Rap"},{"Pop/Funk"}, {"Jungle"},
  {"Native American"},{"Cabaret"},{"New Wave"}, {"Psychedelic"},
  {"Rave"},{"Showtunes"},{"Trailer"}, {"Lo-Fi"},{"Tribal"},
  {"Acid Punk"},{"Acid Jazz"}, {"Polka"}, {"Retro"},
  {"Musical"},{"Rock & Roll"},{"Hard Rock"},

  {"Folk"}, {"Folk-Rock"}, {"National Folk"}, {"Swing"},
  {"Fast Fusion"}, {"Bebob"}, {"Latin"}, {"Revival"},
  {"Celtic"}, {"Bluegrass"}, {"Avantgarde"}, {"Gothic Rock"},
  {"Progressive Rock"}, {"Psychedelic Rock"}, {"Symphonic Rock"},
  {"Slow Rock"}, {"Big Band"}, {"Chorus"}, {"Easy Listening"},
  {"Acoustic"}, {"Humour"}, {"Speech"}, {"Chanson"}, {"Opera"},
  {"Chamber Music"}, {"Sonata"}, {"Symphony"}, {"Booty Bass"},
  {"Primus"}, {"Porn Groove"}, {"Satire"}, {"Slow Jam"},
  {"Club"}, {"Tango"}, {"Samba"}, {"Folklore"}, {"Ballad"},
  {"Power Ballad"}, {"Rhythmic Soul"}, {"Freestyle"}, {"Duet"},
  {"Punk Rock"}, {"Drum Solo"}, {"A capella"}, {"Euro-House"},
  {"Dance Hall"},

  {"misc"},
};

/*
 * freedb2 search type
 */
#define SPLT_FREEDB_SEARCH_TYPE_CDDB_CGI 1
/*
 * freedb search type
 */
#define SPLT_FREEDB_SEARCH_TYPE_CDDB 2
/*
 * freedb get file type
 * we retrieve the file by using the cddb.cgi script
 * (usually on port 80)
 */
#define SPLT_FREEDB_GET_FILE_TYPE_CDDB_CGI 3
/*
 * we retrieve the file by using the freedb cddb protocol 
 * (usually on port 8880)
 */
#define SPLT_FREEDB_GET_FILE_TYPE_CDDB 4

#define SPLT_FREEDB_CDDB_CGI_PORT 80

#define SPLT_FREEDB_CDDB_PORT 8880

#define SPLT_FREEDB_CGI_SITE "freedb.org/~cddb/cddb.cgi"
#define SPLT_FREEDB2_CGI_SITE "tracktype.org/~cddb/cddb.cgi"

//package information constants
#ifndef SPLT_PACKAGE_NAME

#define SPLT_PACKAGE_NAME "libmp3splt"
#endif
#ifndef SPLT_PACKAGE_VERSION

#define SPLT_PACKAGE_VERSION "0.7.1"
#endif

#define SPLT_AUTHOR "Matteo Trotta | Munteanu Alexandru"
#define SPLT_EMAIL "<mtrotta@users.sourceforge.net> | <io_fx@yahoo.fr>"

#define SPLT_WEBSITE "http://mp3splt.sourceforge.net"

/* other useful variables */

#define MP3SPLT_LIB_GETTEXT_DOMAIN "libmp3splt"

//backslash character
#ifndef SPLT_DIRCHAR
#ifdef __WIN32__
#define SPLT_DIRCHAR '\\'
#define SPLT_DIRSTR "\\"
#define SPLT_NDIRCHAR '/'
#else
#define SPLT_DIRCHAR '/'
#define SPLT_DIRSTR "/"
#define SPLT_NDIRCHAR '\\'
#endif
#endif

splt_state *mp3splt_new_state(int *error);

//find plugins
int mp3splt_find_plugins(splt_state *state);

//this function frees the left variables in the library
//don't forget to call this function ONLY at the end of the program
//returns possible error
void mp3splt_free_state(splt_state *state, int *error);

/************************************/
int mp3splt_set_path_of_split(splt_state *state, const char *path);

int mp3splt_set_filename_to_split(splt_state *state, const char *filename);

char *mp3splt_get_filename_to_split(splt_state *state);

int mp3splt_set_m3u_filename(splt_state *state, const char *filename);
int mp3splt_set_silence_log_filename(splt_state *state, const char *filename);

int mp3splt_set_input_filename_regex(splt_state *state, const char *regex);

int mp3splt_set_default_comment_tag(splt_state *state, const char *default_comment_tag);

int mp3splt_set_default_genre_tag(splt_state *state, const char *default_genre_tag);


/************************************/
int mp3splt_set_message_function(splt_state *state, 
    void (*message_cb)(const char *, splt_message_type));

int mp3splt_set_split_filename_function(splt_state *state,
    void (*file_cb)(const char *,int));

int mp3splt_set_progress_function(splt_state *state,
    void (*progress_cb)(splt_progress *p_bar));

int mp3splt_set_silence_level_function(splt_state *state,
  void (*get_silence_cb)(long time, float level, void *user_data),
  void *user_data);


/************************************/
int mp3splt_append_splitpoint(splt_state *state,
    long split_value, const char *name, int type);

const splt_point *mp3splt_get_splitpoints(splt_state *state,
    int *splitpoints_number, int *error);

void mp3splt_erase_all_splitpoints(splt_state *state,
    int *error);

/************************************/
/* Tags                             */

//puts a tag
int mp3splt_append_tags(splt_state *state, 
    const char *title, const char *artist,
    const char *album, const char *performer,
    const char *year, const char *comment,
    int track, const char *genre);

//returns a pointer to all the current tags
const splt_tags *mp3splt_get_tags(splt_state *state,
    int *tags_number, int *error);

//puts tags from a string
int mp3splt_put_tags_from_string(splt_state *state, const char *tags,
    int *error);

void mp3splt_erase_all_tags(splt_state *state,
    int *error);

/************************************/
/* Options                          */

int mp3splt_set_int_option(splt_state *state, int option_name, int value);
int mp3splt_set_long_option(splt_state *state, int option_name, long value);
int mp3splt_set_float_option(splt_state *state, int option_name, float value);

int mp3splt_get_int_option(splt_state *state, int option_name, int *error);
long mp3splt_get_long_option(splt_state *state, int option_name, int *error);
float mp3splt_get_float_option(splt_state *state, int option_name, int *error);

/************************************/
/* Split functions                  */

//split a ogg or mp3 file
//returns possible error
int mp3splt_split(splt_state *state);

//cancel split function
//returns possible error
void mp3splt_stop_split(splt_state *state,
    int *error);

/************************************/
/*    Cddb and Cue functions        */

//get the cue splitpoints from a file and puts them in the state
void mp3splt_put_cue_splitpoints_from_file(splt_state *state,
    const char *cue_file, int *error);

//read cddb splitpoints from file and puts them in the state
void mp3splt_put_cddb_splitpoints_from_file(splt_state *state,
    const char *cddb_file, int *error);

void mp3splt_put_audacity_labels_splitpoints_from_file(splt_state *state,
    const char *file, int *error);

/************************************/
/*    Freedb functions              */

//returns the freedb results and possible eerror
const splt_freedb_results *mp3splt_get_freedb_search(splt_state *state,
    const char *searched_string,
    int *error,
    int search_type,
    const char *search_server,
    int port);

void mp3splt_write_freedb_file_result(splt_state *state,
    int disc_id,
    const char *cddb_file,
    int *error,
    int cddb_get_type,
    const char *cddb_get_server,
    int port);

void mp3splt_export_to_cue(splt_state *state, const char *out_file,
    short stop_at_total_time, int *error);

void mp3splt_set_oformat(splt_state *state,
    const char *format_string, int *error);

/************************************/
/* Other utilities                  */

//counts the number of tracks found with silence detection
int mp3splt_count_silence_points(splt_state *state, int *error);

int mp3splt_set_silence_points(splt_state *state, int *error);
void mp3splt_set_trim_silence_points(splt_state *state, int *error);

//returns the version of libmp3splt
void mp3splt_get_version(char *version);

//result must be freed
char *mp3splt_get_strerror(splt_state *state, int error_code);

//returns the number of syncerrors
//puts possible error in error variable
const splt_syncerrors *mp3splt_get_syncerrors(splt_state *state,
    int *error);

//returns the wrapped files found
const splt_wrap *mp3splt_get_wrap_files(splt_state *state, int *error);

int mp3splt_append_plugins_scan_dir(splt_state *state, char *dir);

#ifdef __WIN32__
char *mp3splt_win32_utf16_to_utf8(const wchar_t *source);
#endif

char **mp3splt_find_filenames(splt_state *state, const char *filename,
    int *num_of_files_found, int *error);

int mp3splt_u_check_if_directory(const char *fname);

void mp3splt_free_one_tag(splt_tags *tags);
splt_tags *mp3splt_parse_filename_regex(splt_state *state, int *error);

#define MP3SPLT_MP3SPLT_H

#endif

---