diff options
Diffstat (limited to 'audio/TiMidity++/patches/other.diff')
| -rw-r--r-- | audio/TiMidity++/patches/other.diff | 1008 |
1 files changed, 1008 insertions, 0 deletions
diff --git a/audio/TiMidity++/patches/other.diff b/audio/TiMidity++/patches/other.diff new file mode 100644 index 0000000000..7ca3e39645 --- /dev/null +++ b/audio/TiMidity++/patches/other.diff @@ -0,0 +1,1008 @@ +diff --git a/ChangeLog b/ChangeLog +index d7d211d..ad57852 100644 +--- a/ChangeLog ++++ b/ChangeLog +@@ -1,3 +1,29 @@ ++2004-10-21 Henrique de Moraes Holschuh <hmh@debian.org> ++ ++ * timidity/mod2midi.c (Voice_Play,Voice_SetPeriod): ++ improve the code path when period2note returns -1 ++ ++2004-10-21 Eric A. Welsh <ewelsh@ccb.wustl.edu> ++ ++ * timidity/mod2midi.c (period2note): ++ initialize *finetune when returning a bad period ++ * timidity/mod2midi.c (load_module_samples): ++ samples without names were causing NULL pointer reads ++ * timidity/mod2midi.c (period2note): ++ delete extra \n ++ ++2004-10-18 Eric A. Welsh <ewelsh@ccb.wustl.edu> ++ ++ * libunimod/mlutil.c (getAmigaPeriod): Avoid division by zero ++ * timidity/mod2midi.c: Change all VERB_NORMAL and VERB_VERBOSE ++ messages to VERB_NOISY. ++ ++2004-10-17 URABE Shyouhei <shyouhei@ice.uec.ac.jp> ++ ++ * libunimod/mloader.c (SL_LoadSamples): too many arguments to ++ function `FreeSampleList' ++ * timidity/aq.c: fix wrong prototype (int -> void) ++ + 2004-10-03 URABE Shyouhei <shyouhei@ice.uec.ac.jp> + + * NEWS: Add new entry for 2.13.2 +diff --git a/interface/alsaseq_c.c b/interface/alsaseq_c.c +index ac7b918..8d608a7 100644 +--- a/interface/alsaseq_c.c ++++ b/interface/alsaseq_c.c +@@ -500,6 +500,7 @@ static void stop_playing(void) + + static void doit(struct seq_context *ctxp) + { ++ int err, timeout_val = 10; + for (;;) { + while (snd_seq_event_input_pending(ctxp->handle, 1)) { + if (do_sequencer(ctxp)) +@@ -532,10 +533,20 @@ static void doit(struct seq_context *ctxp) + struct timeval timeout; + FD_ZERO(&rfds); + FD_SET(ctxp->fd, &rfds); +- timeout.tv_sec = 0; +- timeout.tv_usec = 10000; /* 10ms */ +- if (select(ctxp->fd + 1, &rfds, NULL, NULL, &timeout) < 0) ++ timeout.tv_sec = (timeout_val / 1000); ++ timeout.tv_usec = (timeout_val % 1000) * 1000; ++ err = select(ctxp->fd + 1, &rfds, NULL, NULL, timeout_val < 0 ? NULL : &timeout); ++ if (err < 0) { + goto __done; ++ } else if (err == 0) { ++ if (timeout_val < 1024) { ++ timeout_val+=timeout_val; ++ } else { ++ timeout_val = -1; ++ } ++ } else { ++ timeout_val = 10; ++ } + } + } + +diff --git a/interface/xaw_i.c b/interface/xaw_i.c +index 7efd6dd..84b6885 100644 +--- a/interface/xaw_i.c ++++ b/interface/xaw_i.c +@@ -261,7 +261,7 @@ int amplitude = DEFAULT_AMPLIFICATION; + String bitmapdir = XAW_BITMAP_DIR; + Boolean arrangetitle,savelist; + static char **current_flist = NULL; +-static int voices = 0, last_voice = 0, voices_num_width; ++static last_voice = 0, voices_num_width; + static int maxentry_on_a_menu = 0,submenu_n = 0; + #define OPTIONS_WINDOW 1 + #define FLIST_WINDOW 2 +diff --git a/libunimod/mloader.c b/libunimod/mloader.c +index 943b307..bea58df 100644 +--- a/libunimod/mloader.c ++++ b/libunimod/mloader.c +@@ -636,14 +636,14 @@ SL_LoadSamples (void) + s->sample->flags = (s->sample->flags & ~SF_FORMATMASK) | s->outfmt; + if (s->sample->data == NULL) + { +- FreeSampleList (musiclist); ++ FreeSampleList (); + return 1; + } + } + s = s->next; + } + +- FreeSampleList (musiclist); ++ FreeSampleList (); + return 0; + } + +diff --git a/libunimod/mlutil.c b/libunimod/mlutil.c +index 3008a53..e147e8a 100644 +--- a/libunimod/mlutil.c ++++ b/libunimod/mlutil.c +@@ -321,6 +321,7 @@ ULONG getAmigaPeriod (UBYTE flags, ULONG period) + if (flags & UF_LINEAR) + { + period = lintab[period % 768] >> (period / 768); ++ if (period < 1) period = 1; + period = (8363L * 1712L) / period; + } + +diff --git a/timidity/aRts_a.c b/timidity/aRts_a.c +index 0140a47..6bacce3 100644 +--- a/timidity/aRts_a.c ++++ b/timidity/aRts_a.c +@@ -56,6 +56,8 @@ + #include "playmidi.h" + #include "miditrace.h" + ++static int arts_init_state = 0; /* 0=no init, 1=arts_init, 2=arts_free */ ++static int arts_atexit = 0; /* 1=atexit handler has been installed */ + static arts_stream_t stream = 0; + static int server_buffer = 0; + static int output_count = 0; +@@ -64,9 +66,11 @@ static int open_output(void); /* 0=success, 1=warning, -1=fatal error */ + static void close_output(void); + static int output_data(char *buf, int32 nbytes); + static int acntl(int request, void *arg); +-static int detect(void); + +-/* export the playback mode */ ++/* export the playback mode. aRts cannot support auto-detection properly ++ * see TiMidity bug report #35 on Kagemai. Do not add any functionality ++ * that would require TiMidity to call arts_init() again after an ++ * arts_free(), it will blow up */ + + #define dpm arts_play_mode + +@@ -82,17 +86,16 @@ PlayMode dpm = { + open_output, + close_output, + output_data, +- acntl, +- detect ++ acntl + }; + +-static int detect(void) ++static void arts_shutdown(void) + { +- if (arts_init() == 0) { +- arts_free(); +- return 1; /* ok, found */ ++ if(arts_init_state == 1) { ++ close_output(); ++ arts_free(); ++ arts_init_state = 2; /* paranoia */ + } +- return 0; + } + + /*************************************************************************/ +@@ -114,10 +117,23 @@ static int open_output(void) + channels = (dpm.encoding & PE_MONO) ? 1 : 2; + + /* Open the audio device */ +- if((i = arts_init()) != 0) +- { +- ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: %s", +- dpm.name, arts_error_text(i)); ++ switch (arts_init_state) { ++ case 0: ++ if((i = arts_init()) != 0) ++ { ++ ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: %s", ++ dpm.name, arts_error_text(i)); ++ return -1; ++ } ++ arts_init_state = 1; ++ if (!arts_atexit) { ++ atexit(arts_shutdown); ++ arts_atexit = 1; ++ } ++ break; ++ case 2: ++ ctl->cmsg(CMSG_ERROR, VERB_NORMAL, ++ "TiMidity aRts bug: open_output() after close_output() not supported"); + return -1; + } + stream = arts_play_stream(dpm.rate, +@@ -186,7 +202,6 @@ static void close_output(void) + if(stream == 0) + return; + arts_close_stream(stream); +- arts_free(); + stream = 0; + } + +@@ -197,7 +212,6 @@ static int acntl(int request, void *arg) + { + case PM_REQ_DISCARD: /* Discard stream */ + arts_close_stream(stream); +- arts_free(); + stream=NULL; + return 0; + case PM_REQ_RATE: /* Change sample rate */ +diff --git a/timidity/aq.c b/timidity/aq.c +index af2f603..bedd737 100644 +--- a/timidity/aq.c ++++ b/timidity/aq.c +@@ -87,7 +87,7 @@ static int32 estimate_queue_size(void); + + /* effect.c */ + extern void init_effect(void); +-extern int do_effect(int32* buf, int32 count); ++extern void do_effect(int32* buf, int32 count); + + int aq_calc_fragsize(void) + { +diff --git a/timidity/common.c b/timidity/common.c +index 2fd5ea1..1ff7445 100644 +--- a/timidity/common.c ++++ b/timidity/common.c +@@ -27,10 +27,16 @@ + #include <stdio.h> + #include <stdlib.h> + #include <stdarg.h> +-#include <time.h> +-#ifdef HAVE_SYS_TIME_H +-#include <sys/time.h> +-#endif /* HAVE_SYS_TIME_H */ ++#if TIME_WITH_SYS_TIME ++# include <sys/time.h> ++# include <time.h> ++#else ++# if HAVE_SYS_TIME_H ++# include <sys/time.h> ++# else ++# include <time.h> ++# endif ++#endif /* TIME_WITH_SYS_TIME */ + #ifdef HAVE_SYS_TYPES_H + #include <sys/types.h> + #endif /* HAVE_SYS_TYPES_H */ +@@ -405,7 +411,8 @@ struct timidity_file *open_file(char *name, int decompress, int noise_mode) + } + + /* First try the given name */ +- strncpy(current_filename, url_unexpand_home_dir(name), 1023); ++ /* strncpy(current_filename, url_unexpand_home_dir(name), 1023); */ ++ strncpy(current_filename, name, 1023); + current_filename[1023]='\0'; + + if(noise_mode) +diff --git a/timidity/flac_a.c b/timidity/flac_a.c +index 698fd29..e28acd6 100644 +--- a/timidity/flac_a.c ++++ b/timidity/flac_a.c +@@ -45,9 +45,6 @@ + #endif + + #include <FLAC/all.h> +-#ifdef AU_OGGFLAC +-#include <OggFLAC/stream_encoder.h> +-#endif + + #ifdef AU_FLAC_DLL + #include "w32_libFLAC_dll_g.h" +@@ -78,11 +75,7 @@ PlayMode dpm = { + DEFAULT_RATE, PE_SIGNED|PE_16BIT, PF_PCM_STREAM, + -1, + {0}, /* default: get all the buffer fragments you can */ +-#ifndef AU_OGGFLAC +- "FLAC", 'F', +-#else + "FLAC / OggFLAC", 'F', +-#endif /* AU_OGGFLAC */ + NULL, + open_output, + close_output, +@@ -100,28 +93,22 @@ typedef struct { + unsigned long out_bytes; + union { + FLAC__StreamEncoderState flac; +- FLAC__SeekableStreamEncoderState s_flac; +-#ifdef AU_OGGFLAC +- OggFLAC__StreamEncoderState ogg; +-#endif ++ FLAC__StreamEncoderState s_flac; ++ FLAC__StreamEncoderState ogg; + } state; + union { + union { + FLAC__StreamEncoder *stream; +- FLAC__SeekableStreamEncoder *s_stream; ++ FLAC__StreamEncoder *s_stream; + } flac; +-#ifdef AU_OGGFLAC + union { +- OggFLAC__StreamEncoder *stream; ++ FLAC__StreamEncoder *stream; + } ogg; +-#endif + } encoder; + } FLAC_ctx; + + typedef struct { +-#ifdef AU_OGGFLAC + int isogg; +-#endif + int verify; + int padding; + int blocksize; +@@ -138,9 +125,7 @@ typedef struct { + + /* default compress level is 5 */ + FLAC_options flac_options = { +-#ifdef AU_OGGFLAC + 0, /* isogg */ +-#endif + 0, /* verify */ + 4096, /* padding */ + 4608, /* blocksize */ +@@ -158,13 +143,11 @@ FLAC_options flac_options = { + static long serial_number = 0; + FLAC_ctx *flac_ctx = NULL; + +-#ifdef AU_OGGFLAC + static FLAC__StreamEncoderWriteStatus +-ogg_stream_encoder_write_callback(const OggFLAC__StreamEncoder *encoder, ++ogg_stream_encoder_write_callback(const FLAC__StreamEncoder *encoder, + const FLAC__byte buffer[], + unsigned bytes, unsigned samples, + unsigned current_frame, void *client_data); +-#endif + static FLAC__StreamEncoderWriteStatus + flac_stream_encoder_write_callback(const FLAC__StreamEncoder *encoder, + const FLAC__byte buffer[], +@@ -174,13 +157,10 @@ static void flac_stream_encoder_metadata_callback(const FLAC__StreamEncoder *enc + const FLAC__StreamMetadata *metadata, + void *client_data); + static FLAC__StreamEncoderWriteStatus +-flac_seekable_stream_encoder_write_callback(const FLAC__SeekableStreamEncoder *encoder, ++flac_stream_encoder_write_callback(const FLAC__StreamEncoder *encoder, + const FLAC__byte buffer[], + unsigned bytes, unsigned samples, + unsigned current_frame, void *client_data); +-static void flac_seekable_stream_encoder_metadata_callback(const FLAC__SeekableStreamEncoder *encoder, +- const FLAC__StreamMetadata *metadata, +- void *client_data); + + /* preset */ + void flac_set_compression_level(int compression_level) +@@ -278,12 +258,10 @@ void flac_set_option_verify(int verify) + { + flac_options.verify = verify; + } +-#ifdef AU_OGGFLAC + void flac_set_option_oggflac(int isogg) + { + flac_options.isogg = isogg; + } +-#endif + + static int flac_session_close() + { +@@ -295,19 +273,17 @@ static int flac_session_close() + dpm.fd = -1; + + if (ctx != NULL) { +-#ifdef AU_OGGFLAC + if (flac_options.isogg) { + if (ctx->encoder.ogg.stream) { +- OggFLAC__stream_encoder_finish(ctx->encoder.ogg.stream); +- OggFLAC__stream_encoder_delete(ctx->encoder.ogg.stream); ++ FLAC__stream_encoder_finish(ctx->encoder.ogg.stream); ++ FLAC__stream_encoder_delete(ctx->encoder.ogg.stream); + } + } + else +-#endif /* AU_OGGFLAC */ + if (flac_options.seekable) { + if (ctx->encoder.flac.s_stream) { +- FLAC__seekable_stream_encoder_finish(ctx->encoder.flac.s_stream); +- FLAC__seekable_stream_encoder_delete(ctx->encoder.flac.s_stream); ++ FLAC__stream_encoder_finish(ctx->encoder.flac.s_stream); ++ FLAC__stream_encoder_delete(ctx->encoder.flac.s_stream); + } + } + else +@@ -371,17 +347,16 @@ static int flac_output_open(const char *fname, const char *comment) + metadata[num_metadata++] = &padding; + } + +-#ifdef AU_OGGFLAC + if (flac_options.isogg) { +- if ((ctx->encoder.ogg.stream = OggFLAC__stream_encoder_new()) == NULL) { ++ if ((ctx->encoder.ogg.stream = FLAC__stream_encoder_new()) == NULL) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create OggFLAC stream"); + flac_session_close(); + return -1; + } + +- OggFLAC__stream_encoder_set_channels(ctx->encoder.ogg.stream, nch); ++ FLAC__stream_encoder_set_channels(ctx->encoder.ogg.stream, nch); + /* 16bps only */ +- OggFLAC__stream_encoder_set_bits_per_sample(ctx->encoder.ogg.stream, 16); ++ FLAC__stream_encoder_set_bits_per_sample(ctx->encoder.ogg.stream, 16); + + /* set sequential number for serial */ + serial_number++; +@@ -389,9 +364,9 @@ static int flac_output_open(const char *fname, const char *comment) + srand(time(NULL)); + serial_number = rand(); + } +- OggFLAC__stream_encoder_set_serial_number(ctx->encoder.ogg.stream, serial_number); ++ FLAC__stream_encoder_set_ogg_serial_number(ctx->encoder.ogg.stream, serial_number); + +- OggFLAC__stream_encoder_set_verify(ctx->encoder.ogg.stream, flac_options.verify); ++ FLAC__stream_encoder_set_verify(ctx->encoder.ogg.stream, flac_options.verify); + + if (!FLAC__format_sample_rate_is_valid(dpm.rate)) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "invalid sampling rate %d", +@@ -399,53 +374,52 @@ static int flac_output_open(const char *fname, const char *comment) + flac_session_close(); + return -1; + } +- OggFLAC__stream_encoder_set_sample_rate(ctx->encoder.ogg.stream, dpm.rate); ++ FLAC__stream_encoder_set_sample_rate(ctx->encoder.ogg.stream, dpm.rate); + +- OggFLAC__stream_encoder_set_qlp_coeff_precision(ctx->encoder.ogg.stream, flac_options.qlp_coeff_precision); ++ FLAC__stream_encoder_set_qlp_coeff_precision(ctx->encoder.ogg.stream, flac_options.qlp_coeff_precision); + /* expensive! */ +- OggFLAC__stream_encoder_set_do_qlp_coeff_prec_search(ctx->encoder.ogg.stream, flac_options.qlp_coeff_precision_search); ++ FLAC__stream_encoder_set_do_qlp_coeff_prec_search(ctx->encoder.ogg.stream, flac_options.qlp_coeff_precision_search); + + if (nch == 2) { +- OggFLAC__stream_encoder_set_do_mid_side_stereo(ctx->encoder.ogg.stream, flac_options.mid_side); +- OggFLAC__stream_encoder_set_loose_mid_side_stereo(ctx->encoder.ogg.stream, flac_options.adaptive_mid_side); ++ FLAC__stream_encoder_set_do_mid_side_stereo(ctx->encoder.ogg.stream, flac_options.mid_side); ++ FLAC__stream_encoder_set_loose_mid_side_stereo(ctx->encoder.ogg.stream, flac_options.adaptive_mid_side); + } + +- OggFLAC__stream_encoder_set_max_lpc_order(ctx->encoder.ogg.stream, flac_options.max_lpc_order); +- OggFLAC__stream_encoder_set_min_residual_partition_order(ctx->encoder.ogg.stream, flac_options.min_residual_partition_order); +- OggFLAC__stream_encoder_set_max_residual_partition_order(ctx->encoder.ogg.stream, flac_options.max_residual_partition_order); +- +- OggFLAC__stream_encoder_set_blocksize(ctx->encoder.ogg.stream, flac_options.blocksize); ++ FLAC__stream_encoder_set_max_lpc_order(ctx->encoder.ogg.stream, flac_options.max_lpc_order); ++ FLAC__stream_encoder_set_min_residual_partition_order(ctx->encoder.ogg.stream, flac_options.min_residual_partition_order); ++ FLAC__stream_encoder_set_max_residual_partition_order(ctx->encoder.ogg.stream, flac_options.max_residual_partition_order); + +- OggFLAC__stream_encoder_set_client_data(ctx->encoder.ogg.stream, ctx); ++ FLAC__stream_encoder_set_blocksize(ctx->encoder.ogg.stream, flac_options.blocksize); + + if (0 < num_metadata) +- OggFLAC__stream_encoder_set_metadata(ctx->encoder.ogg.stream, metadata, num_metadata); +- +- /* set callback */ +- OggFLAC__stream_encoder_set_write_callback(ctx->encoder.ogg.stream, ogg_stream_encoder_write_callback); +- +- ctx->state.ogg = OggFLAC__stream_encoder_init(ctx->encoder.ogg.stream); +- if (ctx->state.ogg != OggFLAC__STREAM_ENCODER_OK) { ++ FLAC__stream_encoder_set_metadata(ctx->encoder.ogg.stream, metadata, num_metadata); ++ ++ ctx->state.ogg = FLAC__stream_encoder_init_ogg_stream(ctx->encoder.ogg.stream, ++ 0, ++ ogg_stream_encoder_write_callback, ++ 0, 0, 0, ++ ctx); ++ if (ctx->state.ogg != FLAC__STREAM_ENCODER_OK) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create OggFLAC state (%s)", +- OggFLAC__StreamEncoderStateString[ctx->state.ogg]); ++ FLAC__StreamEncoderStateString[ctx->state.ogg]); + flac_session_close(); + return -1; + } + } + else +-#endif /* AU_OGGFLAC */ + if (flac_options.seekable) { +- if ((ctx->encoder.flac.s_stream = FLAC__seekable_stream_encoder_new()) == NULL) { ++ /* FLAC SEEKABLE STREAM */ ++ if ((ctx->encoder.flac.s_stream = FLAC__stream_encoder_new()) == NULL) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create FLAC stream"); + flac_session_close(); + return -1; + } + +- FLAC__seekable_stream_encoder_set_channels(ctx->encoder.flac.s_stream, nch); ++ FLAC__stream_encoder_set_channels(ctx->encoder.flac.s_stream, nch); + /* 16bps only */ +- FLAC__seekable_stream_encoder_set_bits_per_sample(ctx->encoder.flac.s_stream, 16); ++ FLAC__stream_encoder_set_bits_per_sample(ctx->encoder.flac.s_stream, 16); + +- FLAC__seekable_stream_encoder_set_verify(ctx->encoder.flac.s_stream, flac_options.verify); ++ FLAC__stream_encoder_set_verify(ctx->encoder.flac.s_stream, flac_options.verify); + + if (!FLAC__format_sample_rate_is_valid(dpm.rate)) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "invalid sampling rate %d", +@@ -453,44 +427,40 @@ static int flac_output_open(const char *fname, const char *comment) + flac_session_close(); + return -1; + } +- FLAC__seekable_stream_encoder_set_sample_rate(ctx->encoder.flac.s_stream, dpm.rate); ++ FLAC__stream_encoder_set_sample_rate(ctx->encoder.flac.s_stream, dpm.rate); + +- FLAC__seekable_stream_encoder_set_qlp_coeff_precision(ctx->encoder.flac.s_stream, flac_options.qlp_coeff_precision); ++ FLAC__stream_encoder_set_qlp_coeff_precision(ctx->encoder.flac.s_stream, flac_options.qlp_coeff_precision); + /* expensive! */ +- FLAC__seekable_stream_encoder_set_do_qlp_coeff_prec_search(ctx->encoder.flac.s_stream, flac_options.qlp_coeff_precision_search); ++ FLAC__stream_encoder_set_do_qlp_coeff_prec_search(ctx->encoder.flac.s_stream, flac_options.qlp_coeff_precision_search); + + if (nch == 2) { +- FLAC__seekable_stream_encoder_set_do_mid_side_stereo(ctx->encoder.flac.s_stream, flac_options.mid_side); +- FLAC__seekable_stream_encoder_set_loose_mid_side_stereo(ctx->encoder.flac.s_stream, flac_options.adaptive_mid_side); ++ FLAC__stream_encoder_set_do_mid_side_stereo(ctx->encoder.flac.s_stream, flac_options.mid_side); ++ FLAC__stream_encoder_set_loose_mid_side_stereo(ctx->encoder.flac.s_stream, flac_options.adaptive_mid_side); + } + +- FLAC__seekable_stream_encoder_set_max_lpc_order(ctx->encoder.flac.s_stream, flac_options.max_lpc_order); +- FLAC__seekable_stream_encoder_set_min_residual_partition_order(ctx->encoder.flac.s_stream, flac_options.min_residual_partition_order); +- FLAC__seekable_stream_encoder_set_max_residual_partition_order(ctx->encoder.flac.s_stream, flac_options.max_residual_partition_order); ++ FLAC__stream_encoder_set_max_lpc_order(ctx->encoder.flac.s_stream, flac_options.max_lpc_order); ++ FLAC__stream_encoder_set_min_residual_partition_order(ctx->encoder.flac.s_stream, flac_options.min_residual_partition_order); ++ FLAC__stream_encoder_set_max_residual_partition_order(ctx->encoder.flac.s_stream, flac_options.max_residual_partition_order); + +- FLAC__seekable_stream_encoder_set_blocksize(ctx->encoder.flac.s_stream, flac_options.blocksize); +- FLAC__seekable_stream_encoder_set_client_data(ctx->encoder.flac.s_stream, ctx); ++ FLAC__stream_encoder_set_blocksize(ctx->encoder.flac.s_stream, flac_options.blocksize); + + if (0 < num_metadata) +- FLAC__seekable_stream_encoder_set_metadata(ctx->encoder.flac.s_stream, metadata, num_metadata); ++ FLAC__stream_encoder_set_metadata(ctx->encoder.flac.s_stream, metadata, num_metadata); + +- /* set callback */ +-/* FLAC__seekable_stream_encoder_set_metadata_callback(ctx->encoder.flac.s_stream, flac_seekable_stream_encoder_metadata_callback); /* */ +-#ifndef __BORLANDC__ +- FLAC__stream_encoder_set_metadata_callback(ctx->encoder.flac.s_stream, flac_seekable_stream_encoder_metadata_callback); /* */ +-#endif +- FLAC__seekable_stream_encoder_set_write_callback(ctx->encoder.flac.s_stream, flac_seekable_stream_encoder_write_callback); ++ ctx->state.s_flac = FLAC__stream_encoder_init_stream( ++ ctx->encoder.flac.s_stream, ++ flac_stream_encoder_write_callback, ++ 0, 0, 0, ++ ctx); + +- ctx->state.s_flac = FLAC__seekable_stream_encoder_init(ctx->encoder.flac.s_stream); +- if (ctx->state.s_flac != FLAC__SEEKABLE_STREAM_ENCODER_OK) { ++ if (ctx->state.s_flac != FLAC__STREAM_ENCODER_OK) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create FLAC state (%s)", +- FLAC__SeekableStreamEncoderStateString[ctx->state.s_flac]); ++ FLAC__StreamEncoderStateString[ctx->state.s_flac]); + flac_session_close(); + return -1; + } +- } +- else +- { ++ } else { ++ /* NON SEEKABLE STREAM */ + if ((ctx->encoder.flac.stream = FLAC__stream_encoder_new()) == NULL) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create FLAC stream"); + flac_session_close(); +@@ -525,16 +495,16 @@ static int flac_output_open(const char *fname, const char *comment) + FLAC__stream_encoder_set_max_residual_partition_order(ctx->encoder.flac.stream, flac_options.max_residual_partition_order); + + FLAC__stream_encoder_set_blocksize(ctx->encoder.flac.stream, flac_options.blocksize); +- FLAC__stream_encoder_set_client_data(ctx->encoder.flac.stream, ctx); + + if (0 < num_metadata) + FLAC__stream_encoder_set_metadata(ctx->encoder.flac.stream, metadata, num_metadata); + +- /* set callback */ +- FLAC__stream_encoder_set_metadata_callback(ctx->encoder.flac.stream, flac_stream_encoder_metadata_callback); +- FLAC__stream_encoder_set_write_callback(ctx->encoder.flac.stream, flac_stream_encoder_write_callback); +- +- ctx->state.flac = FLAC__stream_encoder_init(ctx->encoder.flac.stream); ++ ctx->state.flac = FLAC__stream_encoder_init_stream(ctx->encoder.flac.stream, ++ flac_stream_encoder_write_callback, ++ 0, ++ 0, ++ flac_stream_encoder_metadata_callback, ++ ctx); + if (ctx->state.flac != FLAC__STREAM_ENCODER_OK) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot create FLAC state (%s)", + FLAC__StreamEncoderStateString[ctx->state.flac]); +@@ -550,7 +520,6 @@ static int auto_flac_output_open(const char *input_filename, const char *title) + { + char *output_filename; + +-#ifdef AU_OGGFLAC + if (flac_options.isogg) { + #ifndef __W32G__ + output_filename = create_auto_output_name(input_filename, "ogg", NULL, 0); +@@ -559,7 +528,6 @@ static int auto_flac_output_open(const char *input_filename, const char *title) + #endif + } + else +-#endif /* AU_OGGFLAC */ + { + #ifndef __W32G__ + output_filename = create_auto_output_name(input_filename, "flac", NULL, 0); +@@ -608,12 +576,10 @@ static int open_output(void) + exclude_enc |= PE_BYTESWAP | PE_24BIT; + dpm.encoding = validate_encoding(dpm.encoding, include_enc, exclude_enc); + +-#ifdef AU_OGGFLAC + if (flac_options.isogg) { + ctl->cmsg(CMSG_WARNING, VERB_NORMAL, "*** cannot write back seekpoints when encoding to Ogg yet ***"); + ctl->cmsg(CMSG_WARNING, VERB_NORMAL, "*** and stream end will not be written. ***"); + } +-#endif + + #ifndef __W32G__ + if(dpm.name == NULL) { +@@ -638,9 +604,8 @@ static int open_output(void) + return 0; + } + +-#ifdef AU_OGGFLAC + static FLAC__StreamEncoderWriteStatus +-ogg_stream_encoder_write_callback(const OggFLAC__StreamEncoder *encoder, ++ogg_stream_encoder_write_callback(const FLAC__StreamEncoder *encoder, + const FLAC__byte buffer[], + unsigned bytes, unsigned samples, + unsigned current_frame, void *client_data) +@@ -654,7 +619,6 @@ ogg_stream_encoder_write_callback(const OggFLAC__StreamEncoder *encoder, + else + return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; + } +-#endif + static FLAC__StreamEncoderWriteStatus + flac_stream_encoder_write_callback(const FLAC__StreamEncoder *encoder, + const FLAC__byte buffer[], +@@ -675,26 +639,6 @@ static void flac_stream_encoder_metadata_callback(const FLAC__StreamEncoder *enc + void *client_data) + { + } +-static FLAC__StreamEncoderWriteStatus +-flac_seekable_stream_encoder_write_callback(const FLAC__SeekableStreamEncoder *encoder, +- const FLAC__byte buffer[], +- unsigned bytes, unsigned samples, +- unsigned current_frame, void *client_data) +-{ +- FLAC_ctx *ctx = (FLAC_ctx *)client_data; +- +- ctx->out_bytes += bytes; +- +- if (write(dpm.fd, buffer, bytes) == bytes) +- return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; +- else +- return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR; +-} +-static void flac_seekable_stream_encoder_metadata_callback(const FLAC__SeekableStreamEncoder *encoder, +- const FLAC__StreamMetadata *metadata, +- void *client_data) +-{ +-} + + static int output_data(char *buf, int32 nbytes) + { +@@ -723,21 +667,18 @@ static int output_data(char *buf, int32 nbytes) + oggbuf[i] = *s++; + } + +-#ifdef AU_OGGFLAC + if (flac_options.isogg) { +- ctx->state.ogg = OggFLAC__stream_encoder_get_state(ctx->encoder.ogg.stream); +- if (ctx->state.ogg != OggFLAC__STREAM_ENCODER_OK) { +- if (ctx->state.ogg == OggFLAC__STREAM_ENCODER_FLAC_STREAM_ENCODER_ERROR) { ++ ctx->state.ogg = FLAC__stream_encoder_get_state(ctx->encoder.ogg.stream); ++ if (ctx->state.ogg != FLAC__STREAM_ENCODER_OK) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "FLAC stream verify error (%s)", +- FLAC__StreamDecoderStateString[OggFLAC__stream_encoder_get_verify_decoder_state(ctx->encoder.ogg.stream)]); +- } ++ FLAC__StreamEncoderStateString[FLAC__stream_encoder_get_verify_decoder_state(ctx->encoder.ogg.stream)]); + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot encode OggFLAC stream (%s)", +- OggFLAC__StreamEncoderStateString[ctx->state.ogg]); ++ FLAC__StreamEncoderStateString[ctx->state.ogg]); + flac_session_close(); + return -1; + } + +- if (!OggFLAC__stream_encoder_process_interleaved(ctx->encoder.ogg.stream, oggbuf, ++ if (!FLAC__stream_encoder_process_interleaved(ctx->encoder.ogg.stream, oggbuf, + nbytes / nch / 2)) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot encode OggFLAC stream"); + flac_session_close(); +@@ -745,24 +686,23 @@ static int output_data(char *buf, int32 nbytes) + } + } + else +-#endif /* AU_OGGFLAC */ + if (flac_options.seekable) { +- ctx->state.s_flac = FLAC__seekable_stream_encoder_get_state(ctx->encoder.flac.s_stream); ++ ctx->state.s_flac = FLAC__stream_encoder_get_state(ctx->encoder.flac.s_stream); + if (ctx->state.s_flac != FLAC__STREAM_ENCODER_OK) { + if (ctx->state.s_flac == FLAC__STREAM_ENCODER_VERIFY_DECODER_ERROR | + FLAC__STREAM_ENCODER_VERIFY_MISMATCH_IN_AUDIO_DATA) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "FLAC stream verify error (%s)", +- FLAC__SeekableStreamDecoderStateString[FLAC__seekable_stream_encoder_get_verify_decoder_state(ctx->encoder.flac.s_stream)]); ++ FLAC__StreamDecoderStateString[FLAC__stream_encoder_get_verify_decoder_state(ctx->encoder.flac.s_stream)]); + } + else { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot encode FLAC stream (%s)", +- FLAC__SeekableStreamEncoderStateString[ctx->state.s_flac]); ++ FLAC__StreamEncoderStateString[ctx->state.s_flac]); + } + flac_session_close(); + return -1; + } + +- if (!FLAC__seekable_stream_encoder_process_interleaved(ctx->encoder.flac.s_stream, oggbuf, ++ if (!FLAC__stream_encoder_process_interleaved(ctx->encoder.flac.s_stream, oggbuf, + nbytes / nch / 2 )) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "cannot encode FLAC stream"); + flac_session_close(); +@@ -814,19 +754,17 @@ static void close_output(void) + } + + if (flac_options.isogg) { +-#ifdef AU_OGGFLAC +- if ((ctx->state.ogg = OggFLAC__stream_encoder_get_state(ctx->encoder.ogg.stream)) != OggFLAC__STREAM_ENCODER_OK) { ++ if ((ctx->state.ogg = FLAC__stream_encoder_get_state(ctx->encoder.ogg.stream)) != FLAC__STREAM_ENCODER_OK) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "OggFLAC stream encoder is invalid (%s)", +- OggFLAC__StreamEncoderStateString[ctx->state.ogg]); ++ FLAC__StreamEncoderStateString[ctx->state.ogg]); + /* fall through */ + } + } + else +-#endif /* AU_OGGFLAC */ + if (flac_options.seekable) { +- if ((ctx->state.s_flac = FLAC__seekable_stream_encoder_get_state(ctx->encoder.flac.s_stream)) != FLAC__SEEKABLE_STREAM_ENCODER_OK) { ++ if ((ctx->state.s_flac = FLAC__stream_encoder_get_state(ctx->encoder.flac.s_stream)) != FLAC__STREAM_ENCODER_OK) { + ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "FLAC stream encoder is invalid (%s)", +- FLAC__SeekableStreamEncoderStateString[ctx->state.s_flac]); ++ FLAC__StreamEncoderStateString[ctx->state.s_flac]); + /* fall through */ + } + } +diff --git a/timidity/mod2midi.c b/timidity/mod2midi.c +index 72c0293..2f86cf3 100644 +--- a/timidity/mod2midi.c ++++ b/timidity/mod2midi.c +@@ -195,7 +195,8 @@ period2note (int period, int *finetune) + + if (period < 14 || period > 13696) + { +- ctl->cmsg(CMSG_WARNING, VERB_NORMAL, "BAD period %d\n", period); ++ ctl->cmsg(CMSG_WARNING, VERB_NOISY, "BAD period %d", period); ++ *finetune = 0; + return -1; + } + +@@ -266,11 +267,13 @@ Voice_SetPeriod (UBYTE v, ULONG period) + return; + + new_noteon = period2note (ModV[v].period, &bend); ++ if (new_noteon >= 0) { + #ifndef TRACE_SLIDE_NOTES +- bend += (new_noteon - ModV[v].noteon) << 13; +- new_noteon = ModV[v].noteon; ++ bend += (new_noteon - ModV[v].noteon) << 13; ++ new_noteon = ModV[v].noteon; + #endif +- bend = WHEEL_VALUE(bend); ++ bend = WHEEL_VALUE(bend); ++ } + + if (ModV[v].noteon != new_noteon) + { +@@ -278,7 +281,7 @@ Voice_SetPeriod (UBYTE v, ULONG period) + + if (new_noteon < 0) + { +- ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, ++ ctl->cmsg(CMSG_WARNING, VERB_NOISY, + "Strange period %d", + ModV[v].period); + return; +@@ -330,13 +333,13 @@ Voice_Play (UBYTE v, SAMPLE * s, ULONG start) + Voice_Stop (v); + + new_noteon = period2note (ModV[v].period, &bend); +- bend = WHEEL_VALUE(bend); + if (new_noteon < 0) { +- ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, ++ ctl->cmsg(CMSG_WARNING, VERB_NOISY, + "Strange period %d", + ModV[v].period); + return; + } ++ bend = WHEEL_VALUE(bend); + + ModV[v].noteon = new_noteon; + ModV[v].time = at; +@@ -590,9 +593,13 @@ void load_module_samples (SAMPLE * s, int numsamples, int ntsc) + special_patch[i]->sample = sp = + (Sample *)safe_malloc(sizeof(Sample)); + memset(sp, 0, sizeof(Sample)); +- strncpy(name, s->samplename, 22); +- name[22] = '\0'; +- code_convert(name, NULL, 23, NULL, "ASCII"); ++ memset(name, 0, 23 * sizeof(char)); ++ if (s->samplename != NULL) ++ { ++ strncpy(name, s->samplename, 22); ++ name[22] = '\0'; ++ code_convert(name, NULL, 23, NULL, "ASCII"); ++ } + if(name[0] == '\0') + special_patch[i]->name = NULL; + else +diff --git a/timidity/reverb.c b/timidity/reverb.c +index 2bc8dea..a5b4c06 100644 +--- a/timidity/reverb.c ++++ b/timidity/reverb.c +@@ -1624,8 +1624,8 @@ static void do_ch_reverb_panning_delay(int32 *buf, int32 count, InfoDelay3 *info + buf[i] += r; + buf[++i] += l; + +- if (++index0 == buf_size) {index0 = 0;} +- if (++buf_index == buf_size) {buf_index = 0;} ++ if (index0++ == buf_size) {index0 = 0;} ++ if (buf_index++ == buf_size) {buf_index = 0;} + } + memset(reverb_effect_buffer, 0, sizeof(int32) * count); + info->index[0] = index0; +diff --git a/timidity/tables.c b/timidity/tables.c +index bb37994..9f55f54 100644 +--- a/timidity/tables.c ++++ b/timidity/tables.c +@@ -1682,4 +1682,4 @@ float lofi_sampling_freq_table_xg[] = + 420.0, 416.0, 412.0, 408.0, 405.0, 401.0, 397.0, 394.0, + 390.0, 387.0, 383.0, 380.0, 377.0, 374.0, 371.0, 368.0, + 364.0, 361.0, 359.0, 356.0, 353.0, 350.0, 347.0, 345.0, +-}; +\ No newline at end of file ++}; +diff --git a/timidity/timidity.c b/timidity/timidity.c +index a53a367..e443b4c 100644 +--- a/timidity/timidity.c ++++ b/timidity/timidity.c +@@ -40,31 +40,21 @@ + #ifdef HAVE_UNISTD_H + #include <unistd.h> + #endif /* HAVE_UNISTD_H */ ++#if TIME_WITH_SYS_TIME ++# include <sys/time.h> ++# include <time.h> ++#else ++# if HAVE_SYS_TIME_H ++# include <sys/time.h> ++# else ++# include <time.h> ++# endif ++#endif /* TIME_WITH_SYS_TIME */ + #ifdef HAVE_SYS_STAT_H + #include <sys/stat.h> + #endif /* NAVE_SYS_STAT_H */ + #include <fcntl.h> /* for open */ + +-#ifdef HAVE_STDBOOL_H +-#include <stdbool.h> +-#endif +- +-#ifndef __bool_true_false_are_defined +-# ifdef bool +-# undef bool +-# endif +-# ifdef ture +-# undef ture +-# endif +-# ifdef false +-# undef false +-# endif +-# define bool int +-# define false ((bool)0) +-# define true (!false) +-# define __bool_true_false_are_defined true +-#endif /* C99 _Bool hack */ +- + #ifdef BORLANDC_EXCEPTION + #include <excpt.h> + #endif /* BORLANDC_EXCEPTION */ +@@ -311,9 +301,7 @@ static const struct option longopts[] = { + { "flac-verify", no_argument, NULL, TIM_OPT_FLAC_VERIFY }, + { "flac-padding", required_argument, NULL, TIM_OPT_FLAC_PADDING }, + { "flac-complevel", required_argument, NULL, TIM_OPT_FLAC_COMPLEVEL }, +-#ifdef AU_OGGFLAC + { "oggflac", no_argument, NULL, TIM_OPT_FLAC_OGGFLAC }, +-#endif /* AU_OGGFLAC */ + #endif /* AU_FLAC */ + #ifdef AU_SPEEX + { "speex-quality", required_argument, NULL, TIM_OPT_SPEEX_QUALITY }, +@@ -449,9 +437,7 @@ static inline int parse_opt_output_swab(const char *); + static inline int parse_opt_flac_verify(const char *); + static inline int parse_opt_flac_padding(const char *); + static inline int parse_opt_flac_complevel(const char *); +-#ifdef AU_OGGFLAC + static inline int parse_opt_flac_oggflac(const char *); +-#endif /* AU_OGGFLAC */ + #endif /* AU_FLAC */ + #ifdef AU_SPEEX + static inline int parse_opt_speex_quality(const char *); +@@ -2789,10 +2775,8 @@ MAIN_INTERFACE int set_tim_opt_long(int c, char *optarg, int index) + return parse_opt_flac_padding(arg); + case TIM_OPT_FLAC_COMPLEVEL: + return parse_opt_flac_complevel(arg); +-#ifdef AU_OGGFLAC + case TIM_OPT_FLAC_OGGFLAC: + return parse_opt_flac_oggflac(arg); +-#endif /* AU_OGGFLAC */ + #endif /* AU_FLAC */ + #ifdef AU_SPEEX + case TIM_OPT_SPEEX_QUALITY: +@@ -3642,10 +3626,8 @@ static inline int parse_opt_h(const char *arg) + " Write a PADDING block of length n", + " --flac-complevel=n (for Ogg FLAC only)", + " Set compression level n:[0..8]", +-#ifdef AU_OGGFLAC + " --oggflac (for Ogg FLAC only)", + " Output OggFLAC stream (experimental)", +-#endif /* AU_OGGFLAC */ + #endif /* AU_FLAC */ + #ifdef AU_SPEEX + " --speex-quality=n (for Ogg Speex only)", +@@ -4381,7 +4363,6 @@ static inline int parse_opt_flac_complevel(const char *arg) + return 0; + } + +-#ifdef AU_OGGFLAC + extern void flac_set_option_oggflac(int); + + static inline int parse_opt_flac_oggflac(const char *arg) +@@ -4389,7 +4370,6 @@ static inline int parse_opt_flac_oggflac(const char *arg) + flac_set_option_oggflac(1); + return 0; + } +-#endif /* AU_OGGFLAC */ + #endif /* AU_FLAC */ + + #ifdef AU_SPEEX +@@ -5466,14 +5446,14 @@ extern int volatile save_playlist_once_before_exit_flag; + static int CoInitializeOK = 0; + #endif + +-static inline bool directory_p(const char* path) ++static inline int directory_p(const char* path) + { + #if defined ( IA_W32GUI ) || defined ( IA_W32G_SYN ) + return is_directory(path); + #else + struct stat st; + if(stat(path, &st) != -1) return S_ISDIR(st.st_mode); +- return false; ++ return 0; + #endif + } + +@@ -5649,11 +5629,11 @@ int main(int argc, char **argv) + } + + ctl->cmsg(CMSG_FATAL, VERB_NORMAL, +- "%s: Can't read any configuration file.\nPlease check " ++ "%s: Error reading configuration file.\nPlease check " + "%s or %s", program_name, config1, config2); + #else + ctl->cmsg(CMSG_FATAL, VERB_NORMAL, +- "%s: Can't read any configuration file.\nPlease check " ++ "%s: Error reading configuration file.\nPlease check " + CONFIG_FILE, program_name); + #endif /* __W32__ */ + } +diff --git a/timidity/wrd.h b/timidity/wrd.h +index 0815aa7..fd7fbb3 100644 +--- a/timidity/wrd.h ++++ b/timidity/wrd.h +@@ -148,6 +148,7 @@ static inline void print_ecmd(char*, int*, int); + #endif + #include <limits.h> + #include "mblock.h" ++#include "common.h" + #include "controls.h" + static inline void print_ecmd(char *cmd, int *args, int narg) + { +diff --git a/timidity/wrd_read.c b/timidity/wrd_read.c +index e7ae7f8..c824f49 100644 +--- a/timidity/wrd_read.c ++++ b/timidity/wrd_read.c +@@ -1765,7 +1765,10 @@ static char *wrd_name_string(int cmd) + + #ifdef ENABLE_SHERRY + /*******************************************************************************/ ++#if 0 ++/* for mac only */ + #pragma mark - ++#endif + + static int sherry_started; /* 0 - before start command 0x01*/ + /* 1 - after start command 0x01*/ |