OSDN > Pesquisar Software > Multimedia > Sound/Audio > MIDI > TiMidity++ 41 version > SCM > git > timidity41 > Commit

TiMidity++ 41 version
Fork

R/O
HTTP
SSH
HTTPS

timidity41: Commit

Commit MetaInfo

Revisão	391fc0745926422325e2c2c9f6c917bb073aef97 (tree)
Hora	2019-01-17 01:16:23
Autor	Starg <starg@user...>
Commiter	Starg

Mensagem de Log

Import UnkoTim223

Mudança Sumário

modified: interface/w32g.h (diff)
modified: interface/w32g_ini.c (diff)
modified: interface/w32g_pref.c (diff)
modified: interface/w32g_res.h (diff)
modified: interface/w32g_res.rc (diff)
modified: interface/w32g_syn.c (diff)
modified: interface/w32g_utl.c (diff)
modified: timidity/effect.c (diff)
modified: timidity/effect.h (diff)
modified: timidity/instrum.c (diff)
modified: timidity/instrum.h (diff)
modified: timidity/int_synth.c (diff)
modified: timidity/int_synth.h (diff)
modified: timidity/loadsndfontini.h (diff)
modified: timidity/mix.c (diff)
modified: timidity/playmidi.c (diff)
modified: timidity/playmidi.h (diff)
modified: timidity/sndfontini.c (diff)
modified: timidity/sndfontini.h (diff)
modified: timidity/thread_effect.c (diff)
modified: timidity/timidity.c (diff)
modified: timidity/timidity.h (diff)
modified: timidity/voice_effect.c (diff)
modified: timw32g/timw32g.vcxproj (diff)
modified: twsyng/twsyng.vcxproj (diff)

Diff

--- a/interface/w32g.h

+++ b/interface/w32g.h

		@@ -1,6 +1,6 @@
1	1	/*
2	2	TiMidity++ -- MIDI to WAVE converter and player
3		- Copyright (C) 1999-2018 Masanao Izumo <iz@onicos.co.jp>
	3	+ Copyright (C) 1999-2002 Masanao Izumo <mo@goice.co.jp>
4	4	Copyright (C) 1995 Tuukka Toivonen <tt@cgs.fi>
5	5
6	6	This program is free software; you can redistribute it and/or modify

		@@ -33,10 +33,10 @@
33	33	#ifdef RC_NONE
34	34	#undef RC_NONE
35	35	#endif
36		-#define RC_NONE 0
	36	+#define RC_NONE 0
37	37
38		-#define LANGUAGE_JAPANESE 0x0001
39		-#define LANGUAGE_ENGLISH 0x0002
	38	+#define LANGUAGE_JAPANESE 0x0001
	39	+#define LANGUAGE_ENGLISH 0x0002
40	40	extern int PlayerLanguage;
41	41	extern int PlayerMode;
42	42

		@@ -48,15 +48,15 @@ extern int PlayerMode;
48	48	#define _midi_play_mode midi_play_mode
49	49
50	50	typedef struct argc_argv_t_ {
51		- int argc;
52		- char **argv;
	51	+ int argc;
	52	+ char **argv;
53	53	} argc_argv_t;
54	54
55	55	#if defined(_MSC_VER) \|\| defined(__WATCOMC__)
56		-//typedef void (__cdecl MSVC_BEGINTHREAD_START_ADDRESS)(void);
	56	+//typedef void (__cdecl MSVC_BEGINTHREAD_START_ADDRESS)(void );
57	57	typedef LPTHREAD_START_ROUTINE MSVC_BEGINTHREAD_START_ADDRESS;
58	58	#elif defined(_BORLANDC_)
59		-// typedef _USERENTRY (BCC_BEGINTHREAD_START_ADDRESS)(void);
	59	+// typedef _USERENTRY (BCC_BEGINTHREAD_START_ADDRESS)(void );
60	60	typedef LPTHREAD_START_ROUTINE BCC_BEGINTHREAD_START_ADDRESS;
61	61	#endif
62	62

		@@ -65,25 +65,25 @@ typedef LPTHREAD_START_ROUTINE BCC_BEGINTHREAD_START_ADDRESS;
65	65	// HANDLE crt_beginthread(LPTHREAD_START_ROUTINE start_address, DWORD stack_size, LPVOID arglist);
66	66	#if defined(_MSC_VER) \|\| defined(__WATCOMC__)
67	67	#define crt_beginthread(start_address,stack_size,arglist) \
68		-(HANDLE) _beginthread((MSVC_BEGINTHREAD_START_ADDRESS) start_address,(unsigned) stack_size,(void*) arglist)
	68	+(HANDLE)_beginthread((MSVC_BEGINTHREAD_START_ADDRESS)start_address,(unsigned)stack_size,(void *)arglist)
69	69	#elif defined(_BORLANDC_)
70	70	#define crt_beginthread(start_address,stack_size,arglist) \
71		-(HANDLE) _beginthread((BCC_BEGINTHREAD_START_ADDRESS) start_address,(unsigned) stack_size,(void*) arglist)
	71	+(HANDLE)_beginthread((BCC_BEGINTHREAD_START_ADDRESS)start_address,(unsigned)stack_size,(void *)arglist)
72	72	#else
73	73	#define crt_beginthread(start_address,stack_size,arglist) \
74		-(HANDLE) CreateThread(NULL,(DWORD) stack_size,(LPTHREAD_START_ROUTINE) start_address,(LPVOID) arglist,0,&dwTmp)
	74	+(HANDLE)CreateThread(NULL,(DWORD)stack_size,(LPTHREAD_START_ROUTINE)start_address,(LPVOID)arglist,0,&dwTmp)
75	75	#endif
76	76
77		-// (HANDLE) crt_beginthreadex(LPSECURITY_ATTRIBUTES security, DWORD stack_size, LPTHREAD_START_ROUTINE start_address, LPVOID arglist, DWORD initflag, LPDWORD thrdaddr );
	77	+// (HANDLE)crt_beginthreadex(LPSECURITY_ATTRIBUTES security, DWORD stack_size, LPTHREAD_START_ROUTINE start_address, LPVOID arglist, DWORD initflag, LPDWORD thrdaddr );
78	78	#if defined(_MSC_VER) \|\| defined(__WATCOMC__)
79	79	#define crt_beginthreadex(security,stack_size,start_address,arglist,initflag,thrdaddr ) \
80		-(HANDLE) _beginthreadex((void) security,(unsigned) stack_size,start_address,(void) arglist,(unsigned) initflag,(unsigned*) thrdaddr)
	80	+(HANDLE)_beginthreadex((void )security,(unsigned)stack_size,start_address,(void )arglist,(unsigned)initflag,(unsigned *)thrdaddr)
81	81	#elif defined(_BORLANDC_)
82	82	#define crt_beginthreadex(security,stack_size,start_address,arglist,initflag,thrdaddr ) \
83		-(HANDLE) _beginthreadNT((BCC_BEGINTHREAD_START_ADDRESS) start_address,(unsigned) stack_size,(void) arglist,(void) security_attrib,(unsigned long) create_flags,(unsigned long*) thread_id)
	83	+(HANDLE)_beginthreadNT((BCC_BEGINTHREAD_START_ADDRESS)start_address,(unsigned)stack_size,(void )arglist,(void )security_attrib,(unsigned long)create_flags,(unsigned long *)thread_id)
84	84	#else
85	85	#define crt_beginthreadex(security,stack_size,start_address,arglist,initflag,thrdaddr ) \
86		-(HANDLE) CreateThread((LPSECURITY_ATTRIBUTES) security,(DWORD) stack_size,(LPTHREAD_START_ROUTINE) start_address,(LPVOID) arglist,(DWORD) initflag,(LPDWORD) thrdaddr)
	86	+(HANDLE)CreateThread((LPSECURITY_ATTRIBUTES)security,(DWORD)stack_size,(LPTHREAD_START_ROUTINE)start_address,(LPVOID)arglist,(DWORD)initflag,(LPDWORD)thrdaddr)
87	87	#endif
88	88
89	89	#if defined(_MSC_VER) \|\| defined(__WATCOMC__)

		@@ -114,7 +114,7 @@ enum {
114	114	RC_EXT_CLEAR_PLAYLIST,
115	115	RC_EXT_OPEN_DOC,
116	116	RC_EXT_RESTART_GUI,
117		- RC_EXT_LOAD_FILES_AND_PLAY,
	117	+ RC_EXT_LOAD_FILES_AND_PLAY,
118	118	///r
119	119	RC_EXT_PLAYLIST_CTRL,
120	120	RC_EXT_COPYCUT_PLAYLIST,

		@@ -122,121 +122,121 @@ enum {
122	122	RC_EXT_PLAYLIST_CTRL_UPDATE,
123	123	};
124	124	///r
125		-#define MAX_W32G_MIDI_CHANNELS MAX_CHANNELS
	125	+#define MAX_W32G_MIDI_CHANNELS MAX_CHANNELS
126	126
127	127
128	128	// Toolbar Macros
129		-#define IDM_STOP 2501
130		-#define IDM_PAUSE 2502
131		-#define IDM_PREV 2503
132		-#define IDM_FOREWARD 2504
133		-#define IDM_PLAY 2505
134		-#define IDM_BACKWARD 2506
135		-#define IDM_NEXT 2507
136		-
137		-#define IDM_CONSOLE 2511
138		-#define IDM_LIST 2512
139		-#define IDM_TRACER 2513
140		-#define IDM_DOC 2514
141		-#define IDM_WRD 2515
142		-#define IDM_SOUNDSPEC 2516
	129	+#define IDM_STOP 2501
	130	+#define IDM_PAUSE 2502
	131	+#define IDM_PREV 2503
	132	+#define IDM_FOREWARD 2504
	133	+#define IDM_PLAY 2505
	134	+#define IDM_BACKWARD 2506
	135	+#define IDM_NEXT 2507
	136	+
	137	+#define IDM_CONSOLE 2511
	138	+#define IDM_LIST 2512
	139	+#define IDM_TRACER 2513
	140	+#define IDM_DOC 2514
	141	+#define IDM_WRD 2515
	142	+#define IDM_SOUNDSPEC 2516
143	143	///r
144		-#define IDM_VSTMGR 2517
	144	+#define IDM_VSTMGR 2517
145	145
146		-#define FLAG_NOTE_OFF 1
147		-#define FLAG_NOTE_ON 2
	146	+#define FLAG_NOTE_OFF 1
	147	+#define FLAG_NOTE_ON 2
148	148
149		-#define FLAG_BANK 0x0001
150		-#define FLAG_PROG 0x0002
151		-#define FLAG_PAN 0x0004
152		-#define FLAG_SUST 0x0008
	149	+#define FLAG_BANK 0x0001
	150	+#define FLAG_PROG 0x0002
	151	+#define FLAG_PAN 0x0004
	152	+#define FLAG_SUST 0x0008
153	153
154		-#define FLAG_NOTE_OFF 1
155		-#define FLAG_NOTE_ON 2
	154	+#define FLAG_NOTE_OFF 1
	155	+#define FLAG_NOTE_ON 2
156	156
157		-#define FLAG_BANK 0x0001
158		-#define FLAG_PROG 0x0002
159		-#define FLAG_PAN 0x0004
160		-#define FLAG_SUST 0x0008
	157	+#define FLAG_BANK 0x0001
	158	+#define FLAG_PROG 0x0002
	159	+#define FLAG_PAN 0x0004
	160	+#define FLAG_SUST 0x0008
161	161
162	162	typedef struct {
163		- int reset_panel;
164		- int wait_reset;
165		- int multi_part;
166		-
167		- char v_flags[MAX_W32G_MIDI_CHANNELS];
168		- int16 cnote[MAX_W32G_MIDI_CHANNELS];
169		- int16 cvel[MAX_W32G_MIDI_CHANNELS];
170		- int16 ctotal[MAX_W32G_MIDI_CHANNELS];
171		- char c_flags[MAX_W32G_MIDI_CHANNELS];
172		- Channel channel[MAX_W32G_MIDI_CHANNELS];
173		-
174		- int32 total_time;
175		- int total_time_h;
176		- int total_time_m;
177		- int total_time_s;
178		- int total_time_ss;
179		- int32 cur_time;
180		- int cur_time_h;
181		- int cur_time_m;
182		- int cur_time_s;
183		- int cur_time_ss;
184		- int cur_voices;
185		- int voices;
186		- int upper_voices;
187		- char filename[FILEPATH_MAX];
188		- char titlename[FILEPATH_MAX];
189		- int filename_setflag;
190		- int titlename_setflag;
191		- int32 master_volume;
192		- int32 master_volume_max;
193		- int meas;
194		- int beat;
195		- char keysig[7];
196		- int key_offset;
197		- int tempo;
198		- int tempo_ratio;
199		- int invalid_flag;
200		-
201		- int32 xnote[MAX_W32G_MIDI_CHANNELS][4];
202		- int aq_ratio;
203		-
204		- int changed;
205		- char dummy[1024];
206		-
207		- int8 GSLCD[20][16];
208		- double gslcd_last_display_time;
209		- int8 gslcd_displayed_flag;
	163	+ int reset_panel;
	164	+ int wait_reset;
	165	+ int multi_part;
	166	+
	167	+ char v_flags[MAX_W32G_MIDI_CHANNELS];
	168	+ int16 cnote[MAX_W32G_MIDI_CHANNELS];
	169	+ int16 cvel[MAX_W32G_MIDI_CHANNELS];
	170	+ int16 ctotal[MAX_W32G_MIDI_CHANNELS];
	171	+ char c_flags[MAX_W32G_MIDI_CHANNELS];
	172	+ Channel channel[MAX_W32G_MIDI_CHANNELS];
	173	+
	174	+ int32 total_time;
	175	+ int total_time_h;
	176	+ int total_time_m;
	177	+ int total_time_s;
	178	+ int total_time_ss;
	179	+ int32 cur_time;
	180	+ int cur_time_h;
	181	+ int cur_time_m;
	182	+ int cur_time_s;
	183	+ int cur_time_ss;
	184	+ int cur_voices;
	185	+ int voices;
	186	+ int upper_voices;
	187	+ char filename[FILEPATH_MAX];
	188	+ char titlename[FILEPATH_MAX];
	189	+ int filename_setflag;
	190	+ int titlename_setflag;
	191	+ int32 master_volume;
	192	+ int32 master_volume_max;
	193	+ int meas;
	194	+ int beat;
	195	+ char keysig[7];
	196	+ int key_offset;
	197	+ int tempo;
	198	+ int tempo_ratio;
	199	+ int invalid_flag;
	200	+
	201	+ int32 xnote[MAX_W32G_MIDI_CHANNELS][4];
	202	+ int aq_ratio;
	203	+
	204	+ int changed;
	205	+ char dummy[1024];
	206	+
	207	+ int8 GSLCD[20][16];
	208	+ double gslcd_last_display_time;
	209	+ int8 gslcd_displayed_flag;
210	210	} PanelInfo;
211	211	extern PanelInfo *Panel;
212	212
213		-#define PANELRESET_TIME 0x0001
214		-#define PANELRESET_CHANNEL 0x0002
215		-#define PANELRESET_MIDIINFO 0x0004
216		-#define PANELRESET_MISC 0x0008
217		-#define PANELRESET_EFFECT 0x0010
	213	+#define PANELRESET_TIME 0x0001
	214	+#define PANELRESET_CHANNEL 0x0002
	215	+#define PANELRESET_MIDIINFO 0x0004
	216	+#define PANELRESET_MISC 0x0008
	217	+#define PANELRESET_EFFECT 0x0010
218	218
219	219
220		-#define CANVAS_MODE_GSLCD 0x0001
221		-#define CANVAS_MODE_MAP16 0x0002
222		-#define CANVAS_MODE_MAP32 0x0003
223		-#define CANVAS_MODE_MAP64 0x0004
224		-#define CANVAS_MODE_KBD_A 0x0005
225		-#define CANVAS_MODE_KBD_B 0x0006
226		-#define CANVAS_MODE_KBD_C 0x0007
227		-#define CANVAS_MODE_KBD_D 0x0008
228		-#define CANVAS_MODE_SLEEP 0x0009
	220	+#define CANVAS_MODE_GSLCD 0x0001
	221	+#define CANVAS_MODE_MAP16 0x0002
	222	+#define CANVAS_MODE_MAP32 0x0003
	223	+#define CANVAS_MODE_MAP64 0x0004
	224	+#define CANVAS_MODE_KBD_A 0x0005
	225	+#define CANVAS_MODE_KBD_B 0x0006
	226	+#define CANVAS_MODE_KBD_C 0x0007
	227	+#define CANVAS_MODE_KBD_D 0x0008
	228	+#define CANVAS_MODE_SLEEP 0x0009
229	229
230	230	#if 0
231		-#define TMCCC_BLACK RGB(0x00,0x00,0x00)
232		-#define TMCCC_WHITE RGB(0xff,0xff,0xff)
233		-#define TMCCC_RED RGB(0xff,0x00,0x00)
	231	+#define TMCCC_BLACK RGB(0x00,0x00,0x00)
	232	+#define TMCCC_WHITE RGB(0xff,0xff,0xff)
	233	+#define TMCCC_RED RGB(0xff,0x00,0x00)
234	234
235		-#define TMCCC_FORE TMCCC_BLACK // Aliased
236		-#define TMCCC_BACK RGB(0x00, 0xf0, 0x00)
237		-#define TMCCC_LOW RGB(0x80, 0xd0, 0x00)
238		-#define TMCCC_MIDDLE RGB(0xb0, 0xb0, 0x00)
239		-#define TMCCC_HIGH RGB(0xe0, 0x00, 0x00)
	235	+#define TMCCC_FORE TMCCC_BLACK // Aliased
	236	+#define TMCCC_BACK RGB(0x00, 0xf0, 0x00)
	237	+#define TMCCC_LOW RGB(0x80, 0xd0, 0x00)
	238	+#define TMCCC_MIDDLE RGB(0xb0, 0xb0, 0x00)
	239	+#define TMCCC_HIGH RGB(0xe0, 0x00, 0x00)
240	240
241	241	enum {
242	242	TMCC_BLACK, // Aliased FORE

		@@ -270,7 +270,7 @@ extern int w32g_get_rc(ptr_size_t *value, int wait_if_empty);
270	270	extern void w32g_lock(void);
271	271	extern void w32g_unlock(void);
272	272	extern void MainWndScrollbarProgressUpdate(int sec);
273		-extern void PutsConsoleWnd(const char *str);
	273	+extern void PutsConsoleWnd(char *str);
274	274	extern void w32g_ctle_play_start(int sec);
275	275	extern void SettingWndApply(void);
276	276	extern int w32g_lock_open_file;

		@@ -278,14 +278,14 @@ extern void w32g_i_init(void);
278	278	extern void CanvasChange(int mode);
279	279	extern HINSTANCE hInst;
280	280	extern void w32g_show_console(void);
281		-extern void MPanelStartLoad(const char *filename);
	281	+extern void MPanelStartLoad(char *filename);
282	282
283	283
284	284	/* w32g_utl.c */
285	285
286	286	/* w32g_playlist.c */
287	287	extern int w32g_add_playlist(int nfiles, char **files, int expand_flag,
288		- int autouniq, int autorefine);
	288	+ int autouniq, int autorefine);
289	289	extern char *w32g_get_playlist(int idx);
290	290	extern int w32g_next_playlist(int skip_invalid_file);
291	291	extern int w32g_prev_playlist(int skip_invalid_file);

		@@ -328,7 +328,7 @@ extern void w32g_paste_playlist(int uniq, int refine);
328	328	#if 0
329	329	/* w32g_panel.c */
330	330	extern void w32g_init_panel(HWND hwnd);
331		-extern void TmPanelStartToLoad(const char *filename);
	331	+extern void TmPanelStartToLoad(char *filename);
332	332	extern void TmPanelStartToPlay(int total_sec);
333	333	extern void TmPanelSetVoices(int v);
334	334	//extern void TmPanelInit(HWND hwnd);

		@@ -421,18 +421,9 @@ extern int gdi_lock(void);
421	421	extern int gdi_unlock(void);
422	422	#define GDI_SAFETY(command) (gdi_lock(),(command),gdi_unlock);
423	423
424		-// use twsyng32.ini or timpp32g.ini ??
425		-#if defined(TIMDRVINI)
426		-#define TIMW32_INITFILE_NAME "timdrv.ini"
427		-#elif defined(TWSYNG32INI)
428		-#define TIMW32_INITFILE_NAME "twsyng32.ini"
429		-#else
430		-#define TIMW32_INITFILE_NAME "timpp32g.ini"
431		-#endif
432		-
433	424	#define W32G_RANDOM_IS_SHUFFLE
434	425
435		-#ifndef BELOW_NORMAL_PRIORITY_CLASS /* VC6.0 doesn't support them. */
	426	+#ifndef BELOW_NORMAL_PRIORITY_CLASS /* VC6.0 doesn't support them. */
436	427	#define BELOW_NORMAL_PRIORITY_CLASS 0x4000
437	428	#define ABOVE_NORMAL_PRIORITY_CLASS 0x8000
438	429	#endif /* BELOW_NORMAL_PRIORITY_CLASS */

--- a/interface/w32g_ini.c

+++ b/interface/w32g_ini.c

		@@ -1,6 +1,6 @@
1	1	/*
2	2	TiMidity++ -- MIDI to WAVE converter and player
3		- Copyright (C) 1999-2018 Masanao Izumo <iz@onicos.co.jp>
	3	+ Copyright (C) 1999-2002 Masanao Izumo <mo@goice.co.jp>
4	4	Copyright (C) 1995 Tuukka Toivonen <toivonen@clinet.fi>
5	5
6	6	This program is free software; you can redistribute it and/or modify

		@@ -18,7 +18,7 @@
18	18	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	19
20	20	w32g_ini.c: written by Daisuke Aoki <dai@y7.net>
21		- Masanao Izumo <iz@onicos.co.jp>
	21	+ Masanao Izumo <mo@goice.co.jp>
22	22	*/
23	23
24	24	#ifdef HAVE_CONFIG_H

		@@ -55,241 +55,244 @@
55	55	#pragma comment(lib, "shlwapi.lib")
56	56	#include <shlwapi.h>
57	57
58		-void OverrideSFSettingSave(void)
	58	+void OverrideSFSettingSave()
59	59	{
60		- INIDATA ini = { 0 };
61		- LPINISEC sec = NULL;
62		- const char sndfontini[] = SNDFNT_INITFILE_NAME;
63		-
64		- char fn[FILEPATH_MAX] = "";
65		- char *p = NULL;
	60	+ INIDATA ini = {0};
	61	+ LPINISEC sec = NULL;
	62	+ char fn[FILEPATH_MAX] = "";
	63	+ char *p = NULL;
66	64
67	65	#if defined(WINDRV)
68		- GetWindowsDirectoryA(fn, FILEPATH_MAX - strlen(sndfontini) - 1);
69		- if (is_last_path_sep(fn))
70		- fn[strlen(fn) - 1] = 0;
71		- strlcat(fn, PATH_STRING, FILEPATH_MAX);
	66	+ GetWindowsDirectory(fn, FILEPATH_MAX - 1);
	67	+ if (IS_PATH_SEP(fn[strlen(fn) - 1]))
	68	+ fn[strlen(fn) - 1] = 0;
	69	+ strlcat(fn, "\\", FILEPATH_MAX);
	70	+ strlcat(fn, "timdrv_soundfont.ini", FILEPATH_MAX);
72	71	#else
73		- if (GetModuleFileNameA(GetModuleHandle(0), fn, FILEPATH_MAX - strlen(sndfontini) - 1 - 1)) {
74		- PathRemoveFileSpecA(fn);
75		- strcat(fn, PATH_STRING);
76		- } else {
77		- fn[0] = '.';
78		- fn[1] = PATH_SEP;
79		- fn[2] = '\0';
	72	+ if(GetModuleFileName(GetModuleHandle(0), fn, FILEPATH_MAX - 1)){
	73	+ PathRemoveFileSpec(fn);
	74	+ strcat(fn,"\\");
	75	+ }else{
	76	+ fn[0] = '.';
	77	+ fn[1] = PATH_SEP;
	78	+ fn[2] = '\0';
80	79	}
	80	+ strcat(fn,"soundfont.ini");
81	81	#endif
82		- strlcat(fn, sndfontini, FILEPATH_MAX);
83	82	///r
84		- //if (otd.vibrato_cent == 0 && otd.vibrato_delay == 0) {
85		- // OverrideSFSettingLoad();
86		- //}
87		-
88		- MyIni_Load(&ini, fn);
89		- sec = MyIni_GetSection(&ini, "param", TRUE);
90		-
91		- MyIni_SetInt32(sec, "VibratoDelay", OverrideSample.vibrato_delay);
92		- MyIni_SetInt32(sec, "VibratoDepth", OverrideSample.vibrato_to_pitch);
93		- MyIni_SetInt32(sec, "VibratoSweep", OverrideSample.vibrato_sweep);
94		-
95		- MyIni_SetInt32(sec, "VelToFc", OverrideSample.vel_to_fc);
96		- MyIni_SetInt32(sec, "VelToFcThr", OverrideSample.vel_to_fc_threshold);
97		- MyIni_SetInt32(sec, "VelToRes", OverrideSample.vel_to_resonance);
98		-
99		- MyIni_SetInt32(sec, "TremoloDelay", OverrideSample.tremolo_delay);
100		- MyIni_SetInt32(sec, "TremoloDepth", OverrideSample.tremolo_to_amp);
101		- MyIni_SetInt32(sec, "TremoloToFc", OverrideSample.tremolo_to_fc);
102		- MyIni_SetInt32(sec, "TremoloToPitch", OverrideSample.tremolo_to_pitch);
103		- MyIni_SetInt32(sec, "Res", OverrideSample.resonance);
104		- MyIni_SetInt32(sec, "CutoffFreq", OverrideSample.cutoff_freq);
105		-
106		- MyIni_SetInt32(sec, "EnvDelay", OverrideSample.envelope_delay);
107		-
108		- MyIni_SetInt32(sec, "ModEnvDelay", OverrideSample.modenv_delay);
109		- MyIni_SetInt32(sec, "ModEnvToFc", OverrideSample.modenv_to_fc);
110		- MyIni_SetInt32(sec, "ModEnvToPitch", OverrideSample.modenv_to_pitch);
111		-
112		- MyIni_SetInt8(sec, "Attenuation_Neg", sf_attenuation_neg);
113		- MyIni_SetFloat64(sec, "Attenuation_Pow", sf_attenuation_pow);
114		- MyIni_SetFloat64(sec, "Attenuation_Mul", sf_attenuation_mul);
115		- MyIni_SetFloat64(sec, "Attenuation_Add", sf_attenuation_add);
116		-
117		- MyIni_SetInt32(sec, "Limit_VolEnv_Attack", sf_limit_volenv_attack);
118		- MyIni_SetInt32(sec, "Limit_ModEnv_Attack", sf_limit_modenv_attack);
119		- MyIni_SetInt32(sec, "Limit_ModEnv_Fc", sf_limit_modenv_fc);
120		- MyIni_SetInt32(sec, "Limit_ModEnv_Pitch", sf_limit_modenv_pitch);
121		- MyIni_SetInt32(sec, "Limit_ModLfo_Fc", sf_limit_modlfo_fc);
122		- MyIni_SetInt32(sec, "Limit_ModLfo_Pitch", sf_limit_modlfo_pitch);
123		- MyIni_SetInt32(sec, "Limit_VibLfo_Pitch", sf_limit_viblfo_pitch);
124		- MyIni_SetInt32(sec, "Limit_ModLfo_Freq", sf_limit_modlfo_freq);
125		- MyIni_SetInt32(sec, "Limit_VibLfo_Freq", sf_limit_viblfo_freq);
126		-
127		- MyIni_SetInt32(sec, "Default_ModLfo_Freq", sf_default_modlfo_freq);
128		- MyIni_SetInt32(sec, "Default_VibLfo_Freq", sf_default_viblfo_freq);
129		-
130		- MyIni_SetInt8(sec, "Config_LFO_Swap", sf_config_lfo_swap);
131		- MyIni_SetInt8(sec, "Config_Addrs_Offset", sf_config_addrs_offset);
132		-
133		- MyIni_SetInt8(sec, "_SF2ChorusSend", otd.chorus_send);
134		- MyIni_SetInt8(sec, "_SF2ReverbSend", otd.reverb_send);
135		-
136		- MyIni_SetInt32(sec, "_VibratoRate", otd.vibrato_rate);
137		- MyIni_SetInt32(sec, "_VibratoCent", otd.vibrato_cent);
138		- MyIni_SetInt32(sec, "_VibratoDelay", otd.vibrato_delay);
139		- MyIni_SetInt32(sec, "_FilterFreq", otd.filter_freq);
140		- MyIni_SetInt32(sec, "_FilterReso", otd.filter_reso);
141		-
142		- MyIni_SetFloat64(sec, "VoiceFilter_Reso", voice_filter_reso);
143		- MyIni_SetFloat64(sec, "VoiceFilter_Gain", voice_filter_gain);
144		-
145		- sec = MyIni_GetSection(&ini, "envelope", TRUE);
146		- MyIni_SetFloat64(sec, "GS_ENV_Attack", gs_env_attack_calc);
147		- MyIni_SetFloat64(sec, "GS_ENV_Decay", gs_env_decay_calc);
148		- MyIni_SetFloat64(sec, "GS_ENV_Release", gs_env_release_calc);
149		- MyIni_SetFloat64(sec, "XG_ENV_Attack", xg_env_attack_calc);
150		- MyIni_SetFloat64(sec, "XG_ENV_Decay", xg_env_decay_calc);
151		- MyIni_SetFloat64(sec, "XG_ENV_Release", xg_env_release_calc);
152		- MyIni_SetFloat64(sec, "GM2_ENV_Attack", gm2_env_attack_calc);
153		- MyIni_SetFloat64(sec, "GM2_ENV_Decay", gm2_env_decay_calc);
154		- MyIni_SetFloat64(sec, "GM2_ENV_Release", gm2_env_release_calc);
155		- MyIni_SetFloat64(sec, "GM_ENV_Attack", gm_env_attack_calc);
156		- MyIni_SetFloat64(sec, "GM_ENV_Decay", gm_env_decay_calc);
157		- MyIni_SetFloat64(sec, "GM_ENV_Release", gm_env_release_calc);
158		- MyIni_SetFloat64(sec, "ENV_Add_Offdelay", env_add_offdelay_time);
159		-
160		- sec = MyIni_GetSection(&ini, "main", TRUE);
161		- MyIni_SetUint32(sec, "ver", 101);
162		- MyIni_SetBool(sec, "OverWriteVibrato", otd.overwriteMode & EOWM_ENABLE_VIBRATO);
163		- MyIni_SetBool(sec, "OverWriteTremolo", otd.overwriteMode & EOWM_ENABLE_TREMOLO);
164		- MyIni_SetBool(sec, "OverWriteCutoff", otd.overwriteMode & EOWM_ENABLE_CUTOFF);
165		- MyIni_SetBool(sec, "OverWriteVel", otd.overwriteMode & EOWM_ENABLE_VEL);
166		- MyIni_SetBool(sec, "OverWriteModEnv", otd.overwriteMode & EOWM_ENABLE_MOD);
167		- MyIni_SetBool(sec, "OverWriteEnv", otd.overwriteMode & EOWM_ENABLE_ENV);
168		-
169		- sec = MyIni_GetSection(&ini, "chorus", TRUE);
170		- MyIni_SetFloat64(sec, "Ext_Level", ext_chorus_level);
171		- MyIni_SetFloat64(sec, "Ext_Feedback", ext_chorus_feedback);
172		- MyIni_SetFloat64(sec, "Ext_Depth", ext_chorus_depth);
173		- MyIni_SetInt32(sec, "Ext_EX_Phase", ext_chorus_ex_phase);
174		- MyIni_SetInt32(sec, "Ext_EX_Lite", ext_chorus_ex_lite);
175		- MyIni_SetInt32(sec, "Ext_EX_OV", ext_chorus_ex_ov);
	83	+ //if (otd.vibrato_cent == 0 && otd.vibrato_delay == 0) {
	84	+ // OverrideSFSettingLoad();
	85	+ //}
	86	+
	87	+ MyIni_Load(&ini, fn);
	88	+ sec = MyIni_GetSection(&ini, "param", TRUE);
	89	+
	90	+ MyIni_SetInt32(sec, "VibratoDelay", OverrideSample.vibrato_delay);
	91	+ MyIni_SetInt32(sec, "VibratoDepth", OverrideSample.vibrato_to_pitch);
	92	+ MyIni_SetInt32(sec, "VibratoSweep", OverrideSample.vibrato_sweep);
	93	+
	94	+ MyIni_SetInt32(sec, "VelToFc", OverrideSample.vel_to_fc);
	95	+ MyIni_SetInt32(sec, "VelToFcThr", OverrideSample.vel_to_fc_threshold);
	96	+ MyIni_SetInt32(sec, "VelToRes", OverrideSample.vel_to_resonance);
	97	+
	98	+ MyIni_SetInt32(sec, "TremoloDelay", OverrideSample.tremolo_delay);
	99	+ MyIni_SetInt32(sec, "TremoloDepth", OverrideSample.tremolo_to_amp);
	100	+ MyIni_SetInt32(sec, "TremoloToFc", OverrideSample.tremolo_to_fc);
	101	+ MyIni_SetInt32(sec, "TremoloToPitch", OverrideSample.tremolo_to_pitch);
	102	+ MyIni_SetInt32(sec, "Res", OverrideSample.resonance);
	103	+ MyIni_SetInt32(sec, "CutoffFreq", OverrideSample.cutoff_freq);
	104	+
	105	+ MyIni_SetInt32(sec, "EnvDelay", OverrideSample.envelope_delay);
	106	+
	107	+ MyIni_SetInt32(sec, "ModEnvDelay", OverrideSample.modenv_delay);
	108	+ MyIni_SetInt32(sec, "ModEnvToFc", OverrideSample.modenv_to_fc);
	109	+ MyIni_SetInt32(sec, "ModEnvToPitch", OverrideSample.modenv_to_pitch);
	110	+
	111	+ MyIni_SetInt8(sec, "Attenuation_Neg", sf_attenuation_neg);
	112	+ MyIni_SetFloat64(sec, "Attenuation_Pow", sf_attenuation_pow);
	113	+ MyIni_SetFloat64(sec, "Attenuation_Mul", sf_attenuation_mul);
	114	+ MyIni_SetFloat64(sec, "Attenuation_Add", sf_attenuation_add);
	115	+
	116	+ MyIni_SetInt32(sec, "Limit_VolEnv_Attack", sf_limit_volenv_attack);
	117	+ MyIni_SetInt32(sec, "Limit_ModEnv_Attack", sf_limit_modenv_attack);
	118	+ MyIni_SetInt32(sec, "Limit_ModEnv_Fc", sf_limit_modenv_fc);
	119	+ MyIni_SetInt32(sec, "Limit_ModEnv_Pitch", sf_limit_modenv_pitch);
	120	+ MyIni_SetInt32(sec, "Limit_ModLfo_Fc", sf_limit_modlfo_fc);
	121	+ MyIni_SetInt32(sec, "Limit_ModLfo_Pitch", sf_limit_modlfo_pitch);
	122	+ MyIni_SetInt32(sec, "Limit_VibLfo_Pitch", sf_limit_viblfo_pitch);
	123	+ MyIni_SetInt32(sec, "Limit_ModLfo_Freq", sf_limit_modlfo_freq);
	124	+ MyIni_SetInt32(sec, "Limit_VibLfo_Freq", sf_limit_viblfo_freq);
	125	+
	126	+ MyIni_SetInt32(sec, "Default_ModLfo_Freq", sf_default_modlfo_freq);
	127	+ MyIni_SetInt32(sec, "Default_VibLfo_Freq", sf_default_viblfo_freq);
	128	+
	129	+ MyIni_SetInt8(sec, "Config_LFO_Swap", sf_config_lfo_swap);
	130	+ MyIni_SetInt8(sec, "Config_Addrs_Offset", sf_config_addrs_offset);
	131	+
	132	+ MyIni_SetInt8(sec, "_SF2ChorusSend", otd.chorus_send);
	133	+ MyIni_SetInt8(sec, "_SF2ReverbSend", otd.reverb_send);
	134	+
	135	+ MyIni_SetInt32(sec, "_VibratoRate", otd.vibrato_rate);
	136	+ MyIni_SetInt32(sec, "_VibratoCent", otd.vibrato_cent);
	137	+ MyIni_SetInt32(sec, "_VibratoDelay", otd.vibrato_delay);
	138	+ MyIni_SetInt32(sec, "_FilterFreq", otd.filter_freq);
	139	+ MyIni_SetInt32(sec, "_FilterReso", otd.filter_reso);
	140	+
	141	+ MyIni_SetFloat64(sec, "VoiceFilter_Reso", voice_filter_reso);
	142	+ MyIni_SetFloat64(sec, "VoiceFilter_Gain", voice_filter_gain);
	143	+
	144	+ sec = MyIni_GetSection(&ini, "envelope", TRUE);
	145	+ MyIni_SetFloat64(sec, "GS_ENV_Attack", gs_env_attack_calc);
	146	+ MyIni_SetFloat64(sec, "GS_ENV_Decay", gs_env_decay_calc);
	147	+ MyIni_SetFloat64(sec, "GS_ENV_Release", gs_env_release_calc);
	148	+ MyIni_SetFloat64(sec, "XG_ENV_Attack", xg_env_attack_calc);
	149	+ MyIni_SetFloat64(sec, "XG_ENV_Decay", xg_env_decay_calc);
	150	+ MyIni_SetFloat64(sec, "XG_ENV_Release", xg_env_release_calc);
	151	+ MyIni_SetFloat64(sec, "GM2_ENV_Attack", gm2_env_attack_calc);
	152	+ MyIni_SetFloat64(sec, "GM2_ENV_Decay", gm2_env_decay_calc);
	153	+ MyIni_SetFloat64(sec, "GM2_ENV_Release", gm2_env_release_calc);
	154	+ MyIni_SetFloat64(sec, "GM_ENV_Attack", gm_env_attack_calc);
	155	+ MyIni_SetFloat64(sec, "GM_ENV_Decay", gm_env_decay_calc);
	156	+ MyIni_SetFloat64(sec, "GM_ENV_Release", gm_env_release_calc);
	157	+ MyIni_SetFloat64(sec, "ENV_Add_Offdelay", env_add_offdelay_time);
	158	+
	159	+ sec = MyIni_GetSection(&ini, "main", TRUE);
	160	+ MyIni_SetUint32(sec, "ver", 101);
	161	+ MyIni_SetBool(sec, "OverWriteVibrato", otd.overwriteMode & EOWM_ENABLE_VIBRATO);
	162	+ MyIni_SetBool(sec, "OverWriteTremolo", otd.overwriteMode & EOWM_ENABLE_TREMOLO);
	163	+ MyIni_SetBool(sec, "OverWriteCutoff", otd.overwriteMode & EOWM_ENABLE_CUTOFF);
	164	+ MyIni_SetBool(sec, "OverWriteVel", otd.overwriteMode & EOWM_ENABLE_VEL);
	165	+ MyIni_SetBool(sec, "OverWriteModEnv", otd.overwriteMode & EOWM_ENABLE_MOD);
	166	+ MyIni_SetBool(sec, "OverWriteEnv", otd.overwriteMode & EOWM_ENABLE_ENV);
	167	+
	168	+ sec = MyIni_GetSection(&ini, "chorus", TRUE);
	169	+ MyIni_SetFloat64(sec, "Ext_Level", ext_chorus_level);
	170	+ MyIni_SetFloat64(sec, "Ext_Feedback", ext_chorus_feedback);
	171	+ MyIni_SetFloat64(sec, "Ext_Depth", ext_chorus_depth);
	172	+ MyIni_SetInt32(sec, "Ext_EX_Phase", ext_chorus_ex_phase);
	173	+ MyIni_SetInt32(sec, "Ext_EX_Lite", ext_chorus_ex_lite);
	174	+ MyIni_SetInt32(sec, "Ext_EX_OV", ext_chorus_ex_ov);
176	175
177	176	#ifdef CUSTOMIZE_CHORUS_PARAM
178		- MyIni_SetInt8(sec, "PreLPF", otd.chorus_param.pre_lpf);
179		- MyIni_SetInt8(sec, "Level", otd.chorus_param.level);
180		- MyIni_SetInt8(sec, "Feedback", otd.chorus_param.feedback);
181		- MyIni_SetInt8(sec, "Delay", otd.chorus_param.delay);
182		- MyIni_SetInt8(sec, "Rate", otd.chorus_param.rate);
183		- MyIni_SetInt8(sec, "Depth", otd.chorus_param.depth);
184		- MyIni_SetInt8(sec, "SendReverb", otd.chorus_param.send_reverb);
185		- MyIni_SetInt8(sec, "SendDelay", otd.chorus_param.send_delay);
	177	+ MyIni_SetInt8(sec, "PreLPF", otd.chorus_param.pre_lpf);
	178	+ MyIni_SetInt8(sec, "Level", otd.chorus_param.level);
	179	+ MyIni_SetInt8(sec, "Feedback", otd.chorus_param.feedback);
	180	+ MyIni_SetInt8(sec, "Delay", otd.chorus_param.delay);
	181	+ MyIni_SetInt8(sec, "Rate", otd.chorus_param.rate);
	182	+ MyIni_SetInt8(sec, "Depth", otd.chorus_param.depth);
	183	+ MyIni_SetInt8(sec, "SendReverb", otd.chorus_param.send_reverb);
	184	+ MyIni_SetInt8(sec, "SendDelay", otd.chorus_param.send_delay);
186	185	#endif
187	186
188	187	///r
189		- sec = MyIni_GetSection(&ini, "efx", 1);
190		- MyIni_SetFloat64(sec, "GS_OD_Level", otd.gsefx_CustomODLv);
191		- MyIni_SetFloat64(sec, "GS_OD_Drive", otd.gsefx_CustomODDrive);
192		- MyIni_SetFloat64(sec, "GS_OD_Freq", otd.gsefx_CustomODFreq);
193		- MyIni_SetFloat64(sec, "XG_OD_Drive", otd.xgefx_CustomODDrive);
194		- MyIni_SetFloat64(sec, "XG_OD_Level", otd.xgefx_CustomODLv);
195		- MyIni_SetFloat64(sec, "XG_OD_Freq", otd.xgefx_CustomODFreq);
196		- MyIni_SetFloat64(sec, "SD_OD_Drive", otd.sdefx_CustomODDrive);
197		- MyIni_SetFloat64(sec, "SD_OD_Level", otd.sdefx_CustomODLv);
198		- MyIni_SetFloat64(sec, "SD_OD_Freq", otd.sdefx_CustomODFreq);
199		-
200		- MyIni_SetFloat64(sec, "GS_LF_In_Level", otd.gsefx_CustomLFLvIn);
201		- MyIni_SetFloat64(sec, "GS_LF_Out_Level", otd.gsefx_CustomLFLvOut);
202		- MyIni_SetFloat64(sec, "XG_LF_In_Level", otd.xgefx_CustomLFLvIn);
203		- MyIni_SetFloat64(sec, "XG_LF_Out_Level", otd.xgefx_CustomLFLvOut);
204		- MyIni_SetFloat64(sec, "SD_LF_In_Level", otd.sdefx_CustomLFLvIn);
205		- MyIni_SetFloat64(sec, "SD_LF_Out_Level", otd.sdefx_CustomLFLvOut);
206		-
207		- MyIni_SetFloat64(sec, "Hmn_In_Level", otd.efx_CustomHmnLvIn);
208		- MyIni_SetFloat64(sec, "Hmn_Out_Level", otd.efx_CustomHmnLvOut);
209		-
210		- MyIni_SetFloat64(sec, "Lmt_In_Level", otd.efx_CustomLmtLvIn);
211		- MyIni_SetFloat64(sec, "Lmt_Out_Level", otd.efx_CustomLmtLvOut);
212		-
213		- MyIni_SetFloat64(sec, "Cmp_In_Level", otd.efx_CustomCmpLvIn);
214		- MyIni_SetFloat64(sec, "Cmp_Out_Level", otd.efx_CustomCmpLvOut);
215		-
216		- MyIni_SetFloat64(sec, "Wah_In_Level", otd.efx_CustomWahLvIn);
217		- MyIni_SetFloat64(sec, "Wah_Out_Level", otd.efx_CustomWahLvOut);
218		-
219		- MyIni_SetFloat64(sec, "GRev_In_Level", otd.efx_CustomGRevLvIn);
220		- MyIni_SetFloat64(sec, "GRev_Out_Level", otd.efx_CustomGRevLvOut);
221		-
222		- MyIni_SetFloat64(sec, "Enh_In_Level", otd.efx_CustomEnhLvIn);
223		- MyIni_SetFloat64(sec, "Enh_Out_Level", otd.efx_CustomEnhLvOut);
224		-
225		- MyIni_SetFloat64(sec, "Rot_Out_Level", otd.efx_CustomRotLvOut);
226		-
227		- MyIni_SetFloat64(sec, "PS_Out_Level", otd.efx_CustomPSLvOut);
228		-
229		- MyIni_SetFloat64(sec, "RM_Out_Level", otd.efx_CustomRMLvOut);
230		-
231		- MyIni_SetInt32(sec, "Rev_Type", otd.efx_CustomRevType);
232		-
233		- sec = MyIni_GetSection(&ini, "compressor", 1);
234		- MyIni_SetBool(sec, "enable", otd.timRunMode & EOWM_USE_COMPRESSOR);
235		- MyIni_SetFloat32(sec, "threshold", otd.compThr);
236		- MyIni_SetFloat32(sec, "slope", otd.compSlope);
237		- MyIni_SetFloat32(sec, "lookahead", otd.compLook);
238		- MyIni_SetFloat32(sec, "window", otd.compWTime);
239		- MyIni_SetFloat32(sec, "attack", otd.compATime);
240		- MyIni_SetFloat32(sec, "release", otd.compRTime);
	188	+ sec = MyIni_GetSection(&ini, "efx", 1);
	189	+ MyIni_SetFloat64(sec, "GS_OD_Level", otd.gsefx_CustomODLv);
	190	+ MyIni_SetFloat64(sec, "GS_OD_Drive", otd.gsefx_CustomODDrive);
	191	+ MyIni_SetFloat64(sec, "GS_OD_Freq", otd.gsefx_CustomODFreq);
	192	+ MyIni_SetFloat64(sec, "XG_OD_Drive", otd.xgefx_CustomODDrive);
	193	+ MyIni_SetFloat64(sec, "XG_OD_Level", otd.xgefx_CustomODLv);
	194	+ MyIni_SetFloat64(sec, "XG_OD_Freq", otd.xgefx_CustomODFreq);
	195	+ MyIni_SetFloat64(sec, "SD_OD_Drive", otd.sdefx_CustomODDrive);
	196	+ MyIni_SetFloat64(sec, "SD_OD_Level", otd.sdefx_CustomODLv);
	197	+ MyIni_SetFloat64(sec, "SD_OD_Freq", otd.sdefx_CustomODFreq);
	198	+
	199	+ MyIni_SetFloat64(sec, "GS_LF_In_Level", otd.gsefx_CustomLFLvIn);
	200	+ MyIni_SetFloat64(sec, "GS_LF_Out_Level", otd.gsefx_CustomLFLvOut);
	201	+ MyIni_SetFloat64(sec, "XG_LF_In_Level", otd.xgefx_CustomLFLvIn);
	202	+ MyIni_SetFloat64(sec, "XG_LF_Out_Level", otd.xgefx_CustomLFLvOut);
	203	+ MyIni_SetFloat64(sec, "SD_LF_In_Level", otd.sdefx_CustomLFLvIn);
	204	+ MyIni_SetFloat64(sec, "SD_LF_Out_Level", otd.sdefx_CustomLFLvOut);
	205	+
	206	+ MyIni_SetFloat64(sec, "Hmn_In_Level", otd.efx_CustomHmnLvIn);
	207	+ MyIni_SetFloat64(sec, "Hmn_Out_Level", otd.efx_CustomHmnLvOut);
	208	+
	209	+ MyIni_SetFloat64(sec, "Lmt_In_Level", otd.efx_CustomLmtLvIn);
	210	+ MyIni_SetFloat64(sec, "Lmt_Out_Level", otd.efx_CustomLmtLvOut);
	211	+
	212	+ MyIni_SetFloat64(sec, "Cmp_In_Level", otd.efx_CustomCmpLvIn);
	213	+ MyIni_SetFloat64(sec, "Cmp_Out_Level", otd.efx_CustomCmpLvOut);
	214	+
	215	+ MyIni_SetFloat64(sec, "Wah_In_Level", otd.efx_CustomWahLvIn);
	216	+ MyIni_SetFloat64(sec, "Wah_Out_Level", otd.efx_CustomWahLvOut);
	217	+
	218	+ MyIni_SetFloat64(sec, "GRev_In_Level", otd.efx_CustomGRevLvIn);
	219	+ MyIni_SetFloat64(sec, "GRev_Out_Level", otd.efx_CustomGRevLvOut);
	220	+
	221	+ MyIni_SetFloat64(sec, "Enh_In_Level", otd.efx_CustomEnhLvIn);
	222	+ MyIni_SetFloat64(sec, "Enh_Out_Level", otd.efx_CustomEnhLvOut);
	223	+
	224	+ MyIni_SetFloat64(sec, "Rot_Out_Level", otd.efx_CustomRotLvOut);
	225	+
	226	+ MyIni_SetFloat64(sec, "PS_Out_Level", otd.efx_CustomPSLvOut);
	227	+
	228	+ MyIni_SetFloat64(sec, "RM_Out_Level", otd.efx_CustomRMLvOut);
	229	+
	230	+ MyIni_SetInt32(sec, "Rev_Type", otd.efx_CustomRevType);
	231	+
	232	+ sec = MyIni_GetSection(&ini, "compressor", 1);
	233	+ MyIni_SetBool(sec, "enable", otd.timRunMode & EOWM_USE_COMPRESSOR);
	234	+ MyIni_SetFloat32(sec, "threshold", otd.compThr);
	235	+ MyIni_SetFloat32(sec, "slope", otd.compSlope);
	236	+ MyIni_SetFloat32(sec, "lookahead", otd.compLook);
	237	+ MyIni_SetFloat32(sec, "window", otd.compWTime);
	238	+ MyIni_SetFloat32(sec, "attack", otd.compATime);
	239	+ MyIni_SetFloat32(sec, "release", otd.compRTime);
241	240
242	241	///r
243		- sec = MyIni_GetSection(&ini, "reverb", 1);
244		- // freeverb
245		- MyIni_SetFloat32(sec, "scalewet", scalewet);
246		- MyIni_SetFloat32(sec, "scaleroom", freeverb_scaleroom);
247		- MyIni_SetFloat32(sec, "offsetroom", freeverb_offsetroom);
248		- MyIni_SetFloat32(sec, "fixedgain", fixedgain);
249		- MyIni_SetFloat32(sec, "combfbk", combfbk);
250		- MyIni_SetFloat32(sec, "timediff", time_rt_diff);
251		- MyIni_SetInt32(sec, "numcombs", numcombs);
252		- // reverb ex
253		- MyIni_SetFloat32(sec, "Ext_EX_Time", ext_reverb_ex_time);
254		- MyIni_SetFloat32(sec, "Ext_EX_Level", ext_reverb_ex_level);
255		- MyIni_SetFloat32(sec, "Ext_EX_ER_Level", ext_reverb_ex_er_level);
256		- MyIni_SetFloat32(sec, "Ext_EX_RV_Level", ext_reverb_ex_rv_level);
257		- MyIni_SetInt32(sec, "Ext_EX_RV_Num", ext_reverb_ex_rv_num);
258		- MyIni_SetInt32(sec, "Ext_EX_AP_Num", ext_reverb_ex_ap_num);
259		- //MyIni_SetInt32(sec, "Ext_EX_Lite", ext_reverb_ex_lite);
260		- //MyIni_SetInt32(sec, "Ext_EX_Mode", ext_reverb_ex_mode);
261		- //MyIni_SetInt32(sec, "Ext_EX_ER_Num", ext_reverb_ex_er_num);
262		- //MyIni_SetInt32(sec, "Ext_EX_RV_Type", ext_reverb_ex_rv_type);
263		- //MyIni_SetInt32(sec, "Ext_EX_AP_Type", ext_reverb_ex_ap_type);
264		- MyIni_SetInt32(sec, "Ext_EX_Mod", ext_reverb_ex_mod);
265		- // plate reverb
266		- MyIni_SetFloat32(sec, "Ext_Plate_Level", ext_plate_reverb_level);
267		- MyIni_SetFloat32(sec, "Ext_Plate_Time", ext_plate_reverb_time);
268		-
269		- sec = MyIni_GetSection(&ini, "delay", 1);
270		- MyIni_SetFloat32(sec, "delay", otd.delay_param.delay);
271		- MyIni_SetFloat64(sec, "level", otd.delay_param.level);
272		- MyIni_SetFloat64(sec, "feedback", otd.delay_param.feedback);
273		-
274		- sec = MyIni_GetSection(&ini, "filter", 1);
275		- MyIni_SetFloat64(sec, "Ext_Shelving_Gain", ext_filter_shelving_gain);
276		- MyIni_SetFloat64(sec, "Ext_Shelving_Reduce", ext_filter_shelving_reduce);
277		- MyIni_SetFloat64(sec, "Ext_Shelving_Q", ext_filter_shelving_q);
278		- MyIni_SetFloat64(sec, "Ext_Peaking_Gain", ext_filter_peaking_gain);
279		- MyIni_SetFloat64(sec, "Ext_Peaking_Reduce", ext_filter_peaking_reduce);
280		- MyIni_SetFloat64(sec, "Ext_Peaking_Q", ext_filter_peaking_q);
281		-
282		- sec = MyIni_GetSection(&ini, "effect", 1);
283		- //MyIni_SetFloat64(sec, "XG_System_Return_Level", xg_system_return_level);
284		- MyIni_SetFloat64(sec, "XG_Reverb_Return_Level", xg_reverb_return_level);
285		- MyIni_SetFloat64(sec, "XG_Chorus_Return_Level", xg_chorus_return_level);
286		- MyIni_SetFloat64(sec, "XG_Variation_Return_Level", xg_variation_return_level);
287		- MyIni_SetFloat64(sec, "XG_Chorus_Send_Reverb", xg_chorus_send_reverb);
288		- MyIni_SetFloat64(sec, "XG_Variation_Send_Reverb", xg_variation_send_reverb);
289		- MyIni_SetFloat64(sec, "XG_Variation_Send_Chorus", xg_variation_send_chorus);
290		-
291		- MyIni_Save(&ini, fn);
292		- MyIni_SectionAllClear(&ini);
	242	+ sec = MyIni_GetSection(&ini, "reverb", 1);
	243	+ // freeverb
	244	+ MyIni_SetFloat32(sec, "scalewet", scalewet);
	245	+ MyIni_SetFloat32(sec, "scaleroom", freeverb_scaleroom);
	246	+ MyIni_SetFloat32(sec, "offsetroom", freeverb_offsetroom);
	247	+ MyIni_SetFloat32(sec, "fixedgain", fixedgain);
	248	+ MyIni_SetFloat32(sec, "combfbk", combfbk);
	249	+ MyIni_SetFloat32(sec, "timediff", time_rt_diff);
	250	+ MyIni_SetInt32(sec, "numcombs", numcombs);
	251	+ // reverb ex
	252	+ MyIni_SetFloat32(sec, "Ext_EX_Time", ext_reverb_ex_time);
	253	+ MyIni_SetFloat32(sec, "Ext_EX_Level", ext_reverb_ex_level);
	254	+ MyIni_SetFloat32(sec, "Ext_EX_ER_Level", ext_reverb_ex_er_level);
	255	+ MyIni_SetFloat32(sec, "Ext_EX_RV_Level", ext_reverb_ex_rv_level);
	256	+ MyIni_SetInt32(sec, "Ext_EX_RV_Num", ext_reverb_ex_rv_num);
	257	+ MyIni_SetInt32(sec, "Ext_EX_AP_Num", ext_reverb_ex_ap_num);
	258	+ //MyIni_SetInt32(sec, "Ext_EX_Lite", ext_reverb_ex_lite);
	259	+ //MyIni_SetInt32(sec, "Ext_EX_Mode", ext_reverb_ex_mode);
	260	+ //MyIni_SetInt32(sec, "Ext_EX_ER_Num", ext_reverb_ex_er_num);
	261	+ //MyIni_SetInt32(sec, "Ext_EX_RV_Type", ext_reverb_ex_rv_type);
	262	+ //MyIni_SetInt32(sec, "Ext_EX_AP_Type", ext_reverb_ex_ap_type);
	263	+ MyIni_SetInt32(sec, "Ext_EX_Mod", ext_reverb_ex_mod);
	264	+ // reverb ex2
	265	+ MyIni_SetFloat32(sec, "Ext_SR_Level", ext_reverb_ex2_level);
	266	+ MyIni_SetInt32(sec, "Ext_SR_RS_Mode", ext_reverb_ex2_rsmode);
	267	+ MyIni_SetInt32(sec, "Ext_SR_FFT_Mode", ext_reverb_ex2_fftmode);
	268	+ // plate reverb
	269	+ MyIni_SetFloat32(sec, "Ext_Plate_Level", ext_plate_reverb_level);
	270	+ MyIni_SetFloat32(sec, "Ext_Plate_Time", ext_plate_reverb_time);
	271	+
	272	+ sec = MyIni_GetSection(&ini, "delay", 1);
	273	+ MyIni_SetFloat32(sec, "delay", otd.delay_param.delay);
	274	+ MyIni_SetFloat64(sec, "level", otd.delay_param.level);
	275	+ MyIni_SetFloat64(sec, "feedback", otd.delay_param.feedback);
	276	+
	277	+ sec = MyIni_GetSection(&ini, "filter", 1);
	278	+ MyIni_SetFloat64(sec, "Ext_Shelving_Gain", ext_filter_shelving_gain);
	279	+ MyIni_SetFloat64(sec, "Ext_Shelving_Reduce", ext_filter_shelving_reduce);
	280	+ MyIni_SetFloat64(sec, "Ext_Shelving_Q", ext_filter_shelving_q);
	281	+ MyIni_SetFloat64(sec, "Ext_Peaking_Gain", ext_filter_peaking_gain);
	282	+ MyIni_SetFloat64(sec, "Ext_Peaking_Reduce", ext_filter_peaking_reduce);
	283	+ MyIni_SetFloat64(sec, "Ext_Peaking_Q", ext_filter_peaking_q);
	284	+
	285	+ sec = MyIni_GetSection(&ini, "effect", 1);
	286	+ //MyIni_SetFloat64(sec, "XG_System_Return_Level", xg_system_return_level);
	287	+ MyIni_SetFloat64(sec, "XG_Reverb_Return_Level", xg_reverb_return_level);
	288	+ MyIni_SetFloat64(sec, "XG_Chorus_Return_Level", xg_chorus_return_level);
	289	+ MyIni_SetFloat64(sec, "XG_Variation_Return_Level", xg_variation_return_level);
	290	+ MyIni_SetFloat64(sec, "XG_Chorus_Send_Reverb", xg_chorus_send_reverb);
	291	+ MyIni_SetFloat64(sec, "XG_Variation_Send_Reverb", xg_variation_send_reverb);
	292	+ MyIni_SetFloat64(sec, "XG_Variation_Send_Chorus", xg_variation_send_chorus);
	293	+
	294	+ MyIni_Save(&ini, fn);
	295	+ MyIni_SectionAllClear(&ini);
293	296	}
294	297
295	298

		@@ -297,20 +300,13 @@ extern void IniFlush(void);
297	300
298	301	int w32g_has_ini_file;
299	302
300		-static int32 str2size(const char *str)
	303	+static int32 str2size(char *str)
301	304	{
302		- int len;
303		- if (!str)
304		- return 0;
305		- len = strlen(str);
306		- if (!len)
307		- return 0;
308		- if (str[len - 1] == 'k' \|\| str[len - 1] == 'K')
309		- return (int32)(1024. * atof(str));
310		- if (str[len - 1] == 'm' \|\| str[len - 1] == 'M')
311		- return (int32)(1024. * 1024 * atof(str));
312		- if (str[len - 1] == 'g' \|\| str[len - 1] == 'G')
313		- return (int32)(1024. * 1024 * 1024 * atof(str));
	305	+ int len = strlen(str);
	306	+ if(str[len - 1] == 'k' \|\| str[len - 1] == 'K')
	307	+ return (int32)(1024.0 * atof(str));
	308	+ if(str[len - 1] == 'm' \|\| str[len - 1] == 'M')
	309	+ return (int32)(1024 * 1024 * atof(str));
314	310	return atoi(str);
315	311	}
316	312

		@@ -338,10 +334,9 @@ void LoadIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
338	334	IniGetKeyInt(INI_SEC_PLAYER,"PlaylistMax",&(sp->PlaylistMax));
339	335	IniGetKeyInt(INI_SEC_PLAYER,"ConsoleClearFlag",&(sp->ConsoleClearFlag));
340	336	IniGetKeyStringN(INI_SEC_PLAYER,"ConfigFile",sp->ConfigFile,FILEPATH_MAX);
341		- if (!sp->ConfigFile[0]) {
342		- const char timiditycfg[] = CONFIG_FILE_NAME_P;
343		- GetWindowsDirectory(sp->ConfigFile, sizeof(sp->ConfigFile) - 14);
344		- strlcat(sp->ConfigFile, timiditycfg, FILEPATH_MAX);
	337	+ if(!sp->ConfigFile[0]) {
	338	+ GetWindowsDirectory(sp->ConfigFile, sizeof(sp->ConfigFile) - 14);
	339	+ strcat(sp->ConfigFile, "\\TIMIDITY.CFG");
345	340	}
346	341	IniGetKeyStringN(INI_SEC_PLAYER,"PlaylistFile",sp->PlaylistFile,FILEPATH_MAX);
347	342	IniGetKeyStringN(INI_SEC_PLAYER,"PlaylistHistoryFile",sp->PlaylistHistoryFile,FILEPATH_MAX);

		@@ -383,26 +378,27 @@ void LoadIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
383	378	IniGetKeyInt(INI_SEC_TIMIDITY,"antialiasing_allowed",&(st->antialiasing_allowed));
384	379	///r
385	380	IniGetKeyInt(INI_SEC_TIMIDITY,"buffer_fragments",&(st->buffer_fragments));
386		- if (st->buffer_fragments > 4096 \|\| st->buffer_fragments < 2)
387		- st->buffer_fragments = 64;
	381	+ if(st->buffer_fragments > 4096 \|\| st->buffer_fragments < 2)
	382	+ st->buffer_fragments = 64;
388	383	IniGetKeyInt(INI_SEC_TIMIDITY,"audio_buffer_bits",&(st->audio_buffer_bits));
389		- if (st->audio_buffer_bits > AUDIO_BUFFER_BITS \|\| st->audio_buffer_bits < 5)
390		- st->audio_buffer_bits = AUDIO_BUFFER_BITS;
	384	+ if(st->audio_buffer_bits > AUDIO_BUFFER_BITS \|\| st->audio_buffer_bits < 5)
	385	+ st->audio_buffer_bits = AUDIO_BUFFER_BITS;
391	386	IniGetKeyInt(INI_SEC_TIMIDITY,"compute_buffer_bits",&(st->compute_buffer_bits));
392		- if (st->compute_buffer_bits > 10 \|\| st->compute_buffer_bits < -5)
393		- st->compute_buffer_bits = 6;
	387	+ if(st->compute_buffer_bits > 10 \|\| st->compute_buffer_bits < -5){
	388	+ st->compute_buffer_bits = 6;
	389	+ }
394	390	IniGetKeyInt32(INI_SEC_TIMIDITY,"control_ratio",&(st->control_ratio));
395	391	///r
396	392	#if MAX_CHANNELS > 32
397	393	// ChannelBitMask int32[8]
398		- IniGetKeyInt32Array(INI_SEC_TIMIDITY,"default_drumchannels",(int32*) &(st->default_drumchannels), CHANNEL_ARRAY_ENABLE);
399		- IniGetKeyInt32Array(INI_SEC_TIMIDITY,"default_drumchannel_mask",(int32*) &(st->default_drumchannel_mask), CHANNEL_ARRAY_ENABLE);
400		- IniGetKeyInt32Array(INI_SEC_TIMIDITY,"quietchannels",(int32*) &(st->quietchannels), CHANNEL_ARRAY_ENABLE);
	394	+ IniGetKeyInt32Array(INI_SEC_TIMIDITY,"default_drumchannels",(int32 *)&(st->default_drumchannels), CHANNEL_ARRAY_ENABLE);
	395	+ IniGetKeyInt32Array(INI_SEC_TIMIDITY,"default_drumchannel_mask",(int32 *)&(st->default_drumchannel_mask), CHANNEL_ARRAY_ENABLE);
	396	+ IniGetKeyInt32Array(INI_SEC_TIMIDITY,"quietchannels",(int32 *)&(st->quietchannels), CHANNEL_ARRAY_ENABLE);
401	397	#else
402	398	// ChannelBitMask uint32
403		- IniGetKeyInt32(INI_SEC_TIMIDITY,"default_drumchannels",(int32*) &(st->default_drumchannels));
404		- IniGetKeyInt32(INI_SEC_TIMIDITY,"default_drumchannel_mask",(int32*) &(st->default_drumchannel_mask));
405		- IniGetKeyInt32(INI_SEC_TIMIDITY,"quietchannels",(int32*) &(st->quietchannels));
	399	+ IniGetKeyInt32(INI_SEC_TIMIDITY,"default_drumchannels",(int32 *)&(st->default_drumchannels));
	400	+ IniGetKeyInt32(INI_SEC_TIMIDITY,"default_drumchannel_mask",(int32 *)&(st->default_drumchannel_mask));
	401	+ IniGetKeyInt32(INI_SEC_TIMIDITY,"quietchannels",(int32 *)&(st->quietchannels));
406	402	#endif
407	403	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_modulation_wheel",&(st->opt_modulation_wheel));
408	404	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_portamento",&(st->opt_portamento));

		@@ -411,63 +407,63 @@ void LoadIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
411	407	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_trace_text_meta_event",&(st->opt_trace_text_meta_event));
412	408	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_overlap_voice_allow",&(st->opt_overlap_voice_allow));
413	409	///r
414		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_overlap_voice_count",&(st->opt_overlap_voice_count));
415		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_max_channel_voices",&(st->opt_max_channel_voices));
	410	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_overlap_voice_count",&(st->opt_overlap_voice_count));
	411	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_max_channel_voices",&(st->opt_max_channel_voices));
416	412	///r
417		-// IniGetKeyStringN(INI_SEC_TIMIDITY,"opt_default_mid",buff,sizeof(buff) -1);
	413	+// IniGetKeyStringN(INI_SEC_TIMIDITY,"opt_default_mid",buff,sizeof(buff)-1);
418	414	// st->opt_default_mid = str2mID(buff);
419	415	// st->opt_default_mid = atoi(buff);
420		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_default_mid",&(st->opt_default_mid));
	416	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_default_mid",&(st->opt_default_mid));
421	417	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_system_mid",&(st->opt_system_mid));
422	418	IniGetKeyInt(INI_SEC_TIMIDITY,"default_tonebank",&(st->default_tonebank));
423	419	IniGetKeyInt(INI_SEC_TIMIDITY,"special_tonebank",&(st->special_tonebank));
424	420	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_reverb_control",&(st->opt_reverb_control));
425	421	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_chorus_control",&(st->opt_chorus_control));
426		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_surround_chorus",&(st->opt_surround_chorus));
427		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_normal_chorus_plus",&(st->opt_normal_chorus_plus));
428		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_tva_attack",&(st->opt_tva_attack));
429		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_tva_decay",&(st->opt_tva_decay));
430		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_tva_release",&(st->opt_tva_release));
431		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_delay_control",&(st->opt_delay_control));
432		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_default_module",&(st->opt_default_module));
433		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_lpf_def",&(st->opt_lpf_def));
434		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_hpf_def",&(st->opt_hpf_def));
435		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_drum_effect",&(st->opt_drum_effect));
436		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_modulation_envelope",&(st->opt_modulation_envelope));
437		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_eq_control",&(st->opt_eq_control));
438		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_insertion_effect",&(st->opt_insertion_effect));
439		- IniGetKeyInt(INI_SEC_TIMIDITY,"noise_sharp_type",&(st->noise_sharp_type));
	422	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_surround_chorus",&(st->opt_surround_chorus));
	423	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_normal_chorus_plus",&(st->opt_normal_chorus_plus));
	424	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_tva_attack",&(st->opt_tva_attack));
	425	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_tva_decay",&(st->opt_tva_decay));
	426	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_tva_release",&(st->opt_tva_release));
	427	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_delay_control",&(st->opt_delay_control));
	428	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_default_module",&(st->opt_default_module));
	429	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_lpf_def",&(st->opt_lpf_def));
	430	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_hpf_def",&(st->opt_hpf_def));
	431	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_drum_effect",&(st->opt_drum_effect));
	432	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_modulation_envelope",&(st->opt_modulation_envelope));
	433	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_eq_control",&(st->opt_eq_control));
	434	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_insertion_effect",&(st->opt_insertion_effect));
	435	+ IniGetKeyInt(INI_SEC_TIMIDITY,"noise_sharp_type",&(st->noise_sharp_type));
440	436	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_evil_mode",&(st->opt_evil_mode));
441	437	IniGetKeyInt(INI_SEC_TIMIDITY,"adjust_panning_immediately",&(st->adjust_panning_immediately));
442	438	IniGetKeyInt(INI_SEC_TIMIDITY,"fast_decay",&(st->opt_fast_decay));
443	439	IniGetKeyInt(INI_SEC_TIMIDITY,"min_sustain_time",&(st->min_sustain_time));
444	440	#ifdef SUPPORT_SOUNDSPEC
445	441	IniGetKeyInt(INI_SEC_TIMIDITY,"view_soundspec_flag",&(st->view_soundspec_flag));
446		- v_float = 0.0;
	442	+ v_float = 0.0;
447	443	IniGetKeyFloat(INI_SEC_TIMIDITY,"spectrogram_update_sec",&v_float);
448	444	st->spectrogram_update_sec = v_float;
449	445	#endif
450	446	IniGetKeyIntArray(INI_SEC_TIMIDITY,"default_program",st->default_program,MAX_CHANNELS);
451	447	IniGetKeyIntArray(INI_SEC_TIMIDITY,"special_program",st->special_program,MAX_CHANNELS);
452		- IniGetKeyStringN(INI_SEC_TIMIDITY,"opt_ctl",st->opt_ctl,sizeof(st->opt_ctl) -1);
453		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_print_fontname",&(st->opt_print_fontname));
454		- IniGetKeyInt32(INI_SEC_TIMIDITY,"opt_drum_power",&(st->opt_drum_power));
455		- IniGetKeyInt32(INI_SEC_TIMIDITY,"opt_amp_compensation",&(st->opt_amp_compensation));
	448	+ IniGetKeyStringN(INI_SEC_TIMIDITY,"opt_ctl",st->opt_ctl,sizeof(st->opt_ctl)-1);
	449	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_print_fontname",&(st->opt_print_fontname));
	450	+ IniGetKeyInt32(INI_SEC_TIMIDITY,"opt_drum_power",&(st->opt_drum_power));
	451	+ IniGetKeyInt32(INI_SEC_TIMIDITY,"opt_amp_compensation",&(st->opt_amp_compensation));
456	452	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_realtime_playing",&(st->opt_realtime_playing));
457	453	///r
458		- IniGetKeyStringN(INI_SEC_TIMIDITY,"reduce_voice_threshold",st->reduce_voice_threshold,sizeof(st->reduce_voice_threshold) -1);
459		- IniGetKeyStringN(INI_SEC_TIMIDITY,"reduce_quality_threshold",st->reduce_quality_threshold,sizeof(st->reduce_quality_threshold) -1);
460		- IniGetKeyStringN(INI_SEC_TIMIDITY,"reduce_polyphony_threshold",st->reduce_polyphony_threshold,sizeof(st->reduce_polyphony_threshold) -1);
	454	+ IniGetKeyStringN(INI_SEC_TIMIDITY,"reduce_voice_threshold",st->reduce_voice_threshold,sizeof(st->reduce_voice_threshold)-1);
	455	+ IniGetKeyStringN(INI_SEC_TIMIDITY,"reduce_quality_threshold",st->reduce_quality_threshold,sizeof(st->reduce_quality_threshold)-1);
	456	+ IniGetKeyStringN(INI_SEC_TIMIDITY,"reduce_polyphony_threshold",st->reduce_polyphony_threshold,sizeof(st->reduce_polyphony_threshold)-1);
461	457
462		- IniGetKeyStringN(INI_SEC_TIMIDITY,"opt_playmode",st->opt_playmode,sizeof(st->opt_playmode) -1);
463		- IniGetKeyStringN(INI_SEC_TIMIDITY,"OutputName",st->OutputName,sizeof(st->OutputName) -1);
464		- IniGetKeyStringN(INI_SEC_TIMIDITY,"OutputDirName",st->OutputDirName,sizeof(st->OutputDirName) -1);
	458	+ IniGetKeyStringN(INI_SEC_TIMIDITY,"opt_playmode",st->opt_playmode,sizeof(st->opt_playmode)-1);
	459	+ IniGetKeyStringN(INI_SEC_TIMIDITY,"OutputName",st->OutputName,sizeof(st->OutputName)-1);
	460	+ IniGetKeyStringN(INI_SEC_TIMIDITY,"OutputDirName",st->OutputDirName,sizeof(st->OutputDirName)-1);
465	461	IniGetKeyInt(INI_SEC_TIMIDITY,"auto_output_mode",&(st->auto_output_mode));
466	462	IniGetKeyInt(INI_SEC_TIMIDITY,"voices",&(st->voices));
467	463	IniGetKeyInt(INI_SEC_TIMIDITY,"auto_reduce_polyphony",&(st->auto_reduce_polyphony));
468		- IniGetKeyInt(INI_SEC_TIMIDITY,"temper_type_mute",&(st->temper_type_mute));
	464	+ IniGetKeyInt(INI_SEC_TIMIDITY,"temper_type_mute",&(st->temper_type_mute));
469	465	#if !(defined(IA_W32G_SYN) \|\| defined(WINDRV_SETUP))
470		- IniGetKeyStringN(INI_SEC_TIMIDITY,"opt_qsize",st->opt_qsize,sizeof(st->opt_qsize) -1);
	466	+ IniGetKeyStringN(INI_SEC_TIMIDITY,"opt_qsize",st->opt_qsize,sizeof(st->opt_qsize)-1);
471	467	#endif
472	468	IniGetKeyInt32(INI_SEC_TIMIDITY,"modify_release",&(st->modify_release));
473	469	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_resample_type",&(st->opt_resample_type));

		@@ -475,20 +471,20 @@ void LoadIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
475	471	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_resample_filter",&(st->opt_resample_filter));
476	472	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_resample_over_sampling",&(st->opt_resample_over_sampling));
477	473	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_pre_resamplation",&(st->opt_pre_resamplation));
478		- IniGetKeyStringN(INI_SEC_TIMIDITY,"allocate_cache_size",buff,sizeof(buff) -1);
	474	+ IniGetKeyStringN(INI_SEC_TIMIDITY,"allocate_cache_size",buff,sizeof(buff)-1);
479	475	st->allocate_cache_size = str2size(buff);
480		- IniGetKeyInt(INI_SEC_TIMIDITY,"key_adjust",&(st->key_adjust));
481		- IniGetKeyInt8(INI_SEC_TIMIDITY,"opt_force_keysig",&(st->opt_force_keysig));
482		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_pure_intonation",&(st->opt_pure_intonation));
483		- IniGetKeyInt8(INI_SEC_TIMIDITY,"opt_init_keysig",&(st->opt_init_keysig));
	476	+ IniGetKeyInt(INI_SEC_TIMIDITY,"key_adjust",&(st->key_adjust));
	477	+ IniGetKeyInt8(INI_SEC_TIMIDITY,"opt_force_keysig",&(st->opt_force_keysig));
	478	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_pure_intonation",&(st->opt_pure_intonation));
	479	+ IniGetKeyInt8(INI_SEC_TIMIDITY,"opt_init_keysig",&(st->opt_init_keysig));
484	480	IniGetKeyInt(INI_SEC_TIMIDITY,"output_rate",&(st->output_rate));
485		- IniGetKeyStringN(INI_SEC_TIMIDITY,"output_text_code",st->output_text_code,sizeof(st->output_text_code) -1);
	481	+ IniGetKeyStringN(INI_SEC_TIMIDITY,"output_text_code",st->output_text_code,sizeof(st->output_text_code)-1);
486	482	IniGetKeyInt(INI_SEC_TIMIDITY,"free_instruments_afterwards",&(st->free_instruments_afterwards));
487	483	///r
488		- v_float = 0.0;
	484	+ v_float = 0.0;
489	485	IniGetKeyFloat(INI_SEC_TIMIDITY,"opt_user_volume_curve",&v_float);
490	486	st->opt_user_volume_curve = v_float;
491		- IniGetKeyStringN(INI_SEC_TIMIDITY,"out_wrd",st->opt_wrd,sizeof(st->opt_wrd) -1);
	487	+ IniGetKeyStringN(INI_SEC_TIMIDITY,"out_wrd",st->opt_wrd,sizeof(st->opt_wrd)-1);
492	488	///r
493	489	#ifdef AU_W32
494	490	IniGetKeyInt32(INI_SEC_TIMIDITY,"wmme_device_id",&st->wmme_device_id);

		@@ -496,61 +492,61 @@ void LoadIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
496	492	#endif
497	493	#ifdef AU_WASAPI
498	494	IniGetKeyInt32(INI_SEC_TIMIDITY,"opt_wasapi_device_id",&st->wasapi_device_id);
499		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_latency",&st->wasapi_latency);
500		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_format_ext",&st->wasapi_format_ext);
501		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_exclusive",&st->wasapi_exclusive);
502		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_polling",&st->wasapi_polling);
503		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_priority",&st->wasapi_priority);
	495	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_latency",&st->wasapi_latency);
	496	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_format_ext",&st->wasapi_format_ext);
	497	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_exclusive",&st->wasapi_exclusive);
	498	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_polling",&st->wasapi_polling);
	499	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_priority",&st->wasapi_priority);
504	500	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_stream_category",&st->wasapi_stream_category);
505		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_stream_option",&st->wasapi_stream_option);
	501	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_stream_option",&st->wasapi_stream_option);
506	502	#endif
507	503	#ifdef AU_WDMKS
508	504	IniGetKeyInt32(INI_SEC_TIMIDITY,"opt_wdmks_device_id",&st->wdmks_device_id);
509		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_latency",&st->wdmks_latency);
510		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_format_ext",&st->wdmks_format_ext);
511		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_polling",&st->wdmks_polling);
512		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_thread__priority",&st->wdmks_thread_priority);
513		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_pin_priority",&st->wdmks_pin_priority);
514		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_rt_priority",&st->wdmks_rt_priority);
	505	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_latency",&st->wdmks_latency);
	506	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_format_ext",&st->wdmks_format_ext);
	507	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_polling",&st->wdmks_polling);
	508	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_thread__priority",&st->wdmks_thread_priority);
	509	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_pin_priority",&st->wdmks_pin_priority);
	510	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_rt_priority",&st->wdmks_rt_priority);
515	511	#endif
516	512	#ifdef AU_PORTAUDIO
517	513	IniGetKeyInt32(INI_SEC_TIMIDITY,"pa_wmme_device_id",&st->pa_wmme_device_id);
518		- IniGetKeyInt32(INI_SEC_TIMIDITY,"pa_ds_device_id",&st->pa_ds_device_id);
519		- IniGetKeyInt32(INI_SEC_TIMIDITY,"pa_asio_device_id",&st->pa_asio_device_id);
520		- IniGetKeyInt32(INI_SEC_TIMIDITY,"pa_wdmks_device_id",&st->pa_wdmks_device_id);
521		- IniGetKeyInt32(INI_SEC_TIMIDITY,"pa_wasapi_device_id",&st->pa_wasapi_device_id);
522		- IniGetKeyInt(INI_SEC_TIMIDITY,"pa_wasapi_flag",&st->pa_wasapi_flag);
	514	+ IniGetKeyInt32(INI_SEC_TIMIDITY,"pa_ds_device_id",&st->pa_ds_device_id);
	515	+ IniGetKeyInt32(INI_SEC_TIMIDITY,"pa_asio_device_id",&st->pa_asio_device_id);
	516	+ IniGetKeyInt32(INI_SEC_TIMIDITY,"pa_wdmks_device_id",&st->pa_wdmks_device_id);
	517	+ IniGetKeyInt32(INI_SEC_TIMIDITY,"pa_wasapi_device_id",&st->pa_wasapi_device_id);
	518	+ IniGetKeyInt(INI_SEC_TIMIDITY,"pa_wasapi_flag",&st->pa_wasapi_flag);
523	519	IniGetKeyInt(INI_SEC_TIMIDITY,"pa_wasapi_stream_category",&st->pa_wasapi_stream_category);
524		- IniGetKeyInt(INI_SEC_TIMIDITY,"pa_wasapi_stream_option",&st->pa_wasapi_stream_option);
	520	+ IniGetKeyInt(INI_SEC_TIMIDITY,"pa_wasapi_stream_option",&st->pa_wasapi_stream_option);
525	521	#endif
526		- IniGetKeyInt(INI_SEC_TIMIDITY,"add_play_time",&(st->add_play_time));
527		- IniGetKeyInt(INI_SEC_TIMIDITY,"add_silent_time",&(st->add_silent_time));
528		- IniGetKeyInt(INI_SEC_TIMIDITY,"emu_delay_time",&(st->emu_delay_time));
529		-
	522	+ IniGetKeyInt(INI_SEC_TIMIDITY,"add_play_time",&(st->add_play_time));
	523	+ IniGetKeyInt(INI_SEC_TIMIDITY,"add_silent_time",&(st->add_silent_time));
	524	+ IniGetKeyInt(INI_SEC_TIMIDITY,"emu_delay_time",&(st->emu_delay_time));
	525	+
530	526	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_mix_envelope",&st->opt_mix_envelope);
531	527	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_modulation_update",&(st->opt_modulation_update));
532	528	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_cut_short_time",&st->opt_cut_short_time);
533		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_limiter",&st->opt_limiter);
	529	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_limiter",&st->opt_limiter);
534	530	IniGetKeyInt(INI_SEC_TIMIDITY, "opt_use_midi_loop_repeat", &st->opt_use_midi_loop_repeat);
535	531	IniGetKeyInt(INI_SEC_TIMIDITY, "opt_midi_loop_repeat", &st->opt_midi_loop_repeat);
536	532
537	533	#if defined(__W32__) && defined(SMFCONV)
538	534	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_rcpcv_dll",&(st->opt_rcpcv_dll));
539	535	#endif
540		-// IniGetKeyInt(INI_SEC_TIMIDITY,"data_block_bits",&(st->data_block_bits));
541		-// if (st->data_block_bits > AUDIO_BUFFER_BITS)
	536	+// IniGetKeyInt(INI_SEC_TIMIDITY,"data_block_bits",&(st->data_block_bits));
	537	+// if(st->data_block_bits > AUDIO_BUFFER_BITS)
542	538	// st->data_block_bits = AUDIO_BUFFER_BITS;
543		-// IniGetKeyInt(INI_SEC_TIMIDITY,"data_block_num",&(st->data_block_num));
544		-
	539	+// IniGetKeyInt(INI_SEC_TIMIDITY,"data_block_num",&(st->data_block_num));
	540	+
545	541	#if defined(WINDRV_SETUP)
546	542	IniGetKeyInt(INI_SEC_TIMIDITY,"processPriority",&(st->processPriority));
547		- IniGetKeyInt(INI_SEC_TIMIDITY,"syn_ThreadPriority",&(st->syn_ThreadPriority));
	543	+ IniGetKeyInt(INI_SEC_TIMIDITY,"syn_ThreadPriority",&(st->syn_ThreadPriority));
548	544	IniGetKeyInt(INI_SEC_TIMIDITY,"SynShTime",&(st->SynShTime));
549		- if ( st->SynShTime < 0 ) st->SynShTime = 0;
	545	+ if ( st->SynShTime < 0 ) st->SynShTime = 0;
550	546	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_rtsyn_latency",&(st->opt_rtsyn_latency));
551	547	if ( st->opt_rtsyn_latency < 1 ) st->opt_rtsyn_latency = 1;
552		- if ( st->opt_rtsyn_latency > 1000 ) st->opt_rtsyn_latency = 1000;
553		- IniGetKeyInt(INI_SEC_TIMIDITY,"opt_rtsyn_skip_aq",&(st->opt_rtsyn_skip_aq));
	548	+ if ( st->opt_rtsyn_latency > 1000 ) st->opt_rtsyn_latency = 1000;
	549	+ IniGetKeyInt(INI_SEC_TIMIDITY,"opt_rtsyn_skip_aq",&(st->opt_rtsyn_skip_aq));
554	550	#elif defined(IA_W32G_SYN)
555	551	IniGetKeyIntArray(INI_SEC_TIMIDITY,"SynIDPort",st->SynIDPort,MAX_PORT);
556	552	IniGetKeyInt(INI_SEC_TIMIDITY,"syn_AutoStart",&(st->syn_AutoStart));

		@@ -558,7 +554,7 @@ void LoadIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
558	554	IniGetKeyInt(INI_SEC_TIMIDITY,"syn_ThreadPriority",&(st->syn_ThreadPriority));
559	555	IniGetKeyInt(INI_SEC_TIMIDITY,"SynPortNum",&(st->SynPortNum));
560	556	IniGetKeyInt(INI_SEC_TIMIDITY,"SynShTime",&(st->SynShTime));
561		- if ( st->SynShTime < 0 ) st->SynShTime = 0;
	557	+ if ( st->SynShTime < 0 ) st->SynShTime = 0;
562	558	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_rtsyn_latency",&(st->opt_rtsyn_latency));
563	559	if ( st->opt_rtsyn_latency < 1 ) st->opt_rtsyn_latency = 1;
564	560	if ( st->opt_rtsyn_latency > 1000 ) st->opt_rtsyn_latency = 1000;

		@@ -568,12 +564,12 @@ void LoadIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
568	564	IniGetKeyInt(INI_SEC_TIMIDITY,"processPriority",&(st->processPriority));
569	565	#endif
570	566	IniGetKeyInt(INI_SEC_TIMIDITY,"compute_thread_num",&(st->compute_thread_num));
571		-
	567	+
572	568	IniGetKeyInt(INI_SEC_TIMIDITY,"trace_mode_update_time",&(st->trace_mode_update_time));
573	569	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_load_all_instrument",&(st->opt_load_all_instrument));
574		-
	570	+
575	571	IniGetKeyInt(INI_SEC_TIMIDITY,"opt_load_all_instrument",&(st->opt_load_all_instrument));
576		-
	572	+
577	573	/* for INT_SYNTH */
578	574	IniGetKeyInt32(INI_SEC_TIMIDITY,"opt_int_synth_sine",&(st->opt_int_synth_sine));
579	575	IniGetKeyInt32(INI_SEC_TIMIDITY,"opt_int_synth_rate",&(st->opt_int_synth_rate));

		@@ -649,14 +645,14 @@ SaveIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
649	645	///r
650	646	#if MAX_CHANNELS > 32
651	647	// ChannelBitMask uint32[8]
652		- IniPutKeyInt32Array(INI_SEC_TIMIDITY,"default_drumchannels",(int32*) &st->default_drumchannels, CHANNEL_ARRAY_ENABLE);
653		- IniPutKeyInt32Array(INI_SEC_TIMIDITY,"default_drumchannel_mask",(int32*) &st->default_drumchannel_mask, CHANNEL_ARRAY_ENABLE);
654		- IniPutKeyInt32Array(INI_SEC_TIMIDITY,"quietchannels",(int32*) &(st->quietchannels), CHANNEL_ARRAY_ENABLE);
	648	+ IniPutKeyInt32Array(INI_SEC_TIMIDITY,"default_drumchannels",(int32 *)&st->default_drumchannels, CHANNEL_ARRAY_ENABLE);
	649	+ IniPutKeyInt32Array(INI_SEC_TIMIDITY,"default_drumchannel_mask",(int32 *)&st->default_drumchannel_mask, CHANNEL_ARRAY_ENABLE);
	650	+ IniPutKeyInt32Array(INI_SEC_TIMIDITY,"quietchannels",(int32 *)&(st->quietchannels), CHANNEL_ARRAY_ENABLE);
655	651	#else
656	652	// ChannelBitMask uint32
657		- IniPutKeyInt32(INI_SEC_TIMIDITY,"default_drumchannels",(int32*) &st->default_drumchannels);
658		- IniPutKeyInt32(INI_SEC_TIMIDITY,"default_drumchannel_mask",(int32*) &st->default_drumchannel_mask);
659		- IniPutKeyInt32(INI_SEC_TIMIDITY,"quietchannels",(int32*) &(st->quietchannels));
	653	+ IniPutKeyInt32(INI_SEC_TIMIDITY,"default_drumchannels",(int32 *)&st->default_drumchannels);
	654	+ IniPutKeyInt32(INI_SEC_TIMIDITY,"default_drumchannel_mask",(int32 *)&st->default_drumchannel_mask);
	655	+ IniPutKeyInt32(INI_SEC_TIMIDITY,"quietchannels",(int32 *)&(st->quietchannels));
660	656	#endif
661	657	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_modulation_wheel",&(st->opt_modulation_wheel));
662	658	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_portamento",&(st->opt_portamento));

		@@ -673,19 +669,19 @@ SaveIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
673	669	IniPutKeyInt(INI_SEC_TIMIDITY,"special_tonebank",&(st->special_tonebank));
674	670	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_reverb_control",&(st->opt_reverb_control));
675	671	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_chorus_control",&(st->opt_chorus_control));
676		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_surround_chorus",&(st->opt_surround_chorus));
677		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_normal_chorus_plus",&(st->opt_normal_chorus_plus));
678		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_tva_attack",&(st->opt_tva_attack));
679		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_tva_decay",&(st->opt_tva_decay));
680		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_tva_release",&(st->opt_tva_release));
681		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_delay_control",&(st->opt_delay_control));
682		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_default_module",&(st->opt_default_module));
683		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_lpf_def",&(st->opt_lpf_def));
684		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_hpf_def",&(st->opt_hpf_def));
685		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_drum_effect",&(st->opt_drum_effect));
686		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_modulation_envelope",&(st->opt_modulation_envelope));
687		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_eq_control",&(st->opt_eq_control));
688		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_insertion_effect",&(st->opt_insertion_effect));
	672	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_surround_chorus",&(st->opt_surround_chorus));
	673	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_normal_chorus_plus",&(st->opt_normal_chorus_plus));
	674	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_tva_attack",&(st->opt_tva_attack));
	675	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_tva_decay",&(st->opt_tva_decay));
	676	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_tva_release",&(st->opt_tva_release));
	677	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_delay_control",&(st->opt_delay_control));
	678	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_default_module",&(st->opt_default_module));
	679	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_lpf_def",&(st->opt_lpf_def));
	680	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_hpf_def",&(st->opt_hpf_def));
	681	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_drum_effect",&(st->opt_drum_effect));
	682	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_modulation_envelope",&(st->opt_modulation_envelope));
	683	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_eq_control",&(st->opt_eq_control));
	684	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_insertion_effect",&(st->opt_insertion_effect));
689	685	IniPutKeyInt(INI_SEC_TIMIDITY,"noise_sharp_type",&(st->noise_sharp_type));
690	686	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_evil_mode",&(st->opt_evil_mode));
691	687	IniPutKeyInt(INI_SEC_TIMIDITY,"adjust_panning_immediately",&(st->adjust_panning_immediately));

		@@ -700,7 +696,7 @@ SaveIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
700	696	IniPutKeyStringN(INI_SEC_TIMIDITY,"opt_ctl",st->opt_ctl,sizeof(st->opt_ctl));
701	697	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_print_fontname",&(st->opt_print_fontname));
702	698	IniPutKeyInt32(INI_SEC_TIMIDITY,"opt_drum_power",&(st->opt_drum_power));
703		- IniPutKeyInt32(INI_SEC_TIMIDITY,"opt_amp_compensation",&(st->opt_amp_compensation));
	699	+ IniPutKeyInt32(INI_SEC_TIMIDITY,"opt_amp_compensation",&(st->opt_amp_compensation));
704	700	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_realtime_playing",&(st->opt_realtime_playing));
705	701	///r
706	702	IniPutKeyStringN(INI_SEC_TIMIDITY,"reduce_voice_threshold",st->reduce_voice_threshold,sizeof(st->reduce_voice_threshold));

		@@ -713,7 +709,7 @@ SaveIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
713	709	IniPutKeyInt(INI_SEC_TIMIDITY,"auto_output_mode",&(st->auto_output_mode));
714	710	IniPutKeyInt(INI_SEC_TIMIDITY,"voices",&(st->voices));
715	711	IniPutKeyInt(INI_SEC_TIMIDITY,"auto_reduce_polyphony",&(st->auto_reduce_polyphony));
716		- IniPutKeyInt(INI_SEC_TIMIDITY,"temper_type_mute",&(st->temper_type_mute));
	712	+ IniPutKeyInt(INI_SEC_TIMIDITY,"temper_type_mute",&(st->temper_type_mute));
717	713	#if !(defined(IA_W32G_SYN) \|\| defined(WINDRV_SETUP))
718	714	IniPutKeyStringN(INI_SEC_TIMIDITY,"opt_qsize",st->opt_qsize,sizeof(st->opt_qsize));
719	715	#endif

		@@ -723,43 +719,43 @@ SaveIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
723	719	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_resample_filter",&(st->opt_resample_filter));
724	720	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_resample_over_sampling",&(st->opt_resample_over_sampling));
725	721	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_pre_resamplation",&(st->opt_pre_resamplation));
726		-
	722	+
727	723	IniPutKeyInt32(INI_SEC_TIMIDITY,"allocate_cache_size",&(st->allocate_cache_size));
728		- IniPutKeyInt(INI_SEC_TIMIDITY,"key_adjust",&(st->key_adjust));
729		- IniPutKeyInt8(INI_SEC_TIMIDITY,"opt_force_keysig",&(st->opt_force_keysig));
730		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_pure_intonation",&(st->opt_pure_intonation));
731		- IniPutKeyInt8(INI_SEC_TIMIDITY,"opt_init_keysig",&(st->opt_init_keysig));
	724	+ IniPutKeyInt(INI_SEC_TIMIDITY,"key_adjust",&(st->key_adjust));
	725	+ IniPutKeyInt8(INI_SEC_TIMIDITY,"opt_force_keysig",&(st->opt_force_keysig));
	726	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_pure_intonation",&(st->opt_pure_intonation));
	727	+ IniPutKeyInt8(INI_SEC_TIMIDITY,"opt_init_keysig",&(st->opt_init_keysig));
732	728	IniPutKeyInt(INI_SEC_TIMIDITY,"output_rate",&(st->output_rate));
733		- if (st->output_rate == 0)
734		- st->output_rate = play_mode->rate;
	729	+ if(st->output_rate == 0)
	730	+ st->output_rate = play_mode->rate;
735	731	IniPutKeyStringN(INI_SEC_TIMIDITY,"output_text_code",st->output_text_code,sizeof(st->output_text_code));
736	732	///r
737		- IniPutKeyFloat(INI_SEC_TIMIDITY,"opt_user_volume_curve",st->opt_user_volume_curve);
	733	+ IniPutKeyFloat(INI_SEC_TIMIDITY,"opt_user_volume_curve",st->opt_user_volume_curve);
738	734	IniPutKeyInt(INI_SEC_TIMIDITY,"free_instruments_afterwards",&(st->free_instruments_afterwards));
739	735	IniPutKeyStringN(INI_SEC_TIMIDITY,"out_wrd",st->opt_wrd,sizeof(st->opt_wrd));
740	736	///r
741	737	#ifdef AU_W32
742	738	IniPutKeyInt32(INI_SEC_TIMIDITY,"wmme_device_id",&st->wmme_device_id);
743		- IniPutKeyInt(INI_SEC_TIMIDITY,"wave_format_ext",&st->wave_format_ext);
	739	+ IniPutKeyInt(INI_SEC_TIMIDITY,"wave_format_ext",&st->wave_format_ext);
744	740	#endif
745	741	#ifdef AU_WASAPI
746	742	IniPutKeyInt32(INI_SEC_TIMIDITY,"opt_wasapi_device_id",&st->wasapi_device_id);
747		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_latency",&st->wasapi_latency);
748		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_format_ext",&st->wasapi_format_ext);
749		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_exclusive",&st->wasapi_exclusive);
750		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_polling",&st->wasapi_polling);
751		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_priority",&st->wasapi_priority);
	743	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_latency",&st->wasapi_latency);
	744	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_format_ext",&st->wasapi_format_ext);
	745	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_exclusive",&st->wasapi_exclusive);
	746	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_polling",&st->wasapi_polling);
	747	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_priority",&st->wasapi_priority);
752	748	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_stream_category",&st->wasapi_stream_category);
753		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_stream_option",&st->wasapi_stream_option);
	749	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wasapi_stream_option",&st->wasapi_stream_option);
754	750	#endif
755	751	#ifdef AU_WDMKS
756	752	IniPutKeyInt32(INI_SEC_TIMIDITY,"opt_wdmks_device_id",&st->wdmks_device_id);
757		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_latency",&st->wdmks_latency);
758		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_format_ext",&st->wdmks_format_ext);
759		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_polling",&st->wdmks_polling);
760		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_thread_priority",&st->wdmks_thread_priority);
761		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_pin_priority",&st->wdmks_pin_priority);
762		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_rt_priority",&st->wdmks_rt_priority);
	753	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_latency",&st->wdmks_latency);
	754	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_format_ext",&st->wdmks_format_ext);
	755	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_polling",&st->wdmks_polling);
	756	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_thread_priority",&st->wdmks_thread_priority);
	757	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_pin_priority",&st->wdmks_pin_priority);
	758	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_wdmks_rt_priority",&st->wdmks_rt_priority);
763	759	#endif
764	760	#ifdef AU_PORTAUDIO
765	761	IniPutKeyInt32(INI_SEC_TIMIDITY,"pa_wmme_device_id",&st->pa_wmme_device_id);

		@@ -771,18 +767,20 @@ SaveIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
771	767	IniPutKeyInt(INI_SEC_TIMIDITY,"pa_wasapi_stream_category",&st->pa_wasapi_stream_category);
772	768	IniPutKeyInt(INI_SEC_TIMIDITY,"pa_wasapi_stream_option",&st->pa_wasapi_stream_option);
773	769	#endif
774		-
775		- IniPutKeyInt(INI_SEC_TIMIDITY,"add_play_time",&(st->add_play_time));
776		- IniPutKeyInt(INI_SEC_TIMIDITY,"add_silent_time",&(st->add_silent_time));
777		- IniPutKeyInt(INI_SEC_TIMIDITY,"emu_delay_time",&(st->emu_delay_time));
778		-
	770	+
	771	+ IniPutKeyInt(INI_SEC_TIMIDITY,"add_play_time",&(st->add_play_time));
	772	+ IniPutKeyInt(INI_SEC_TIMIDITY,"add_silent_time",&(st->add_silent_time));
	773	+ IniPutKeyInt(INI_SEC_TIMIDITY,"emu_delay_time",&(st->emu_delay_time));
	774	+
779	775	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_mix_envelope",&st->opt_mix_envelope);
780	776	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_modulation_update",&(st->opt_modulation_update));
781	777	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_cut_short_time",&st->opt_cut_short_time);
782		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_limiter",&st->opt_limiter);
	778	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_limiter",&st->opt_limiter);
	779	+ if (st->opt_use_midi_loop_repeat)
	780	+ st->opt_use_midi_loop_repeat = 1;
783	781	IniPutKeyInt(INI_SEC_TIMIDITY, "opt_use_midi_loop_repeat", &st->opt_use_midi_loop_repeat);
784	782	IniPutKeyInt(INI_SEC_TIMIDITY, "opt_midi_loop_repeat", &st->opt_midi_loop_repeat);
785		-
	783	+
786	784	#if defined(__W32__) && defined(SMFCONV)
787	785	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_rcpcv_dll",&(st->opt_rcpcv_dll));
788	786	#endif

		@@ -790,13 +788,13 @@ SaveIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
790	788	// IniPutKeyInt(INI_SEC_TIMIDITY,"data_block_num",&(st->data_block_num));
791	789	// IniPutKeyInt(INI_SEC_TIMIDITY,"wmme_buffer_bits",&(st->wmme_buffer_bits));
792	790	// IniPutKeyInt(INI_SEC_TIMIDITY,"wmme_buffer_num",&(st->wmme_buffer_num));
793		-
	791	+
794	792	#if defined(WINDRV_SETUP)
795	793	IniPutKeyInt(INI_SEC_TIMIDITY,"processPriority",&(st->processPriority));
796		- IniPutKeyInt(INI_SEC_TIMIDITY,"syn_ThreadPriority",&(st->syn_ThreadPriority));
	794	+ IniPutKeyInt(INI_SEC_TIMIDITY,"syn_ThreadPriority",&(st->syn_ThreadPriority));
797	795	IniPutKeyInt(INI_SEC_TIMIDITY,"SynShTime",&(st->SynShTime));
798		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_rtsyn_latency",&(st->opt_rtsyn_latency));
799		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_rtsyn_skip_aq",&(st->opt_rtsyn_skip_aq));
	796	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_rtsyn_latency",&(st->opt_rtsyn_latency));
	797	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_rtsyn_skip_aq",&(st->opt_rtsyn_skip_aq));
800	798	#elif defined(IA_W32G_SYN)
801	799	IniPutKeyIntArray(INI_SEC_TIMIDITY,"SynIDPort",st->SynIDPort,MAX_PORT);
802	800	IniPutKeyInt(INI_SEC_TIMIDITY,"syn_AutoStart",&(st->syn_AutoStart));

		@@ -804,26 +802,26 @@ SaveIniFile(SETTING_PLAYER sp, SETTING_TIMIDITY st)
804	802	IniPutKeyInt(INI_SEC_TIMIDITY,"syn_ThreadPriority",&(st->syn_ThreadPriority));
805	803	IniPutKeyInt(INI_SEC_TIMIDITY,"SynPortNum",&(st->SynPortNum));
806	804	IniPutKeyInt(INI_SEC_TIMIDITY,"SynShTime",&(st->SynShTime));
807		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_rtsyn_latency",&(st->opt_rtsyn_latency));
808		- IniPutKeyInt(INI_SEC_TIMIDITY,"opt_rtsyn_skip_aq",&(st->opt_rtsyn_skip_aq));
	805	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_rtsyn_latency",&(st->opt_rtsyn_latency));
	806	+ IniPutKeyInt(INI_SEC_TIMIDITY,"opt_rtsyn_skip_aq",&(st->opt_rtsyn_skip_aq));
809	807	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_use_twsyn_bridge",&(st->opt_use_twsyn_bridge));
810	808	#else
811	809	IniPutKeyInt(INI_SEC_TIMIDITY,"processPriority",&(st->processPriority));
812	810	#endif
813	811	IniPutKeyInt(INI_SEC_TIMIDITY,"compute_thread_num",&(st->compute_thread_num));
814		-
	812	+
815	813	IniPutKeyInt(INI_SEC_TIMIDITY,"trace_mode_update_time",&(st->trace_mode_update_time));
816	814	IniPutKeyInt(INI_SEC_TIMIDITY,"opt_load_all_instrument",&(st->opt_load_all_instrument));
817		-
	815	+
818	816	/* for INT_SYNTH */
819	817	IniPutKeyInt32(INI_SEC_TIMIDITY,"opt_int_synth_sine",&(st->opt_int_synth_sine));
820	818	IniPutKeyInt32(INI_SEC_TIMIDITY,"opt_int_synth_rate",&(st->opt_int_synth_rate));
821	819	IniPutKeyInt32(INI_SEC_TIMIDITY,"opt_int_synth_update",&(st->opt_int_synth_update));
822	820
823		- IniFlush();
824		- w32g_has_ini_file = 1;
	821	+ IniFlush();
	822	+ w32g_has_ini_file = 1;
825	823
826		- OverrideSFSettingSave();
	824	+ OverrideSFSettingSave();
827	825	}
828	826
829	827	// When Start TiMidity in WinMain()

		@@ -831,34 +829,39 @@ extern int SecondMode;
831	829	static char S_IniFile[FILEPATH_MAX];
832	830	void FirstLoadIniFile(void)
833	831	{
834		- const char timini[] = TIMW32_INITFILE_NAME;
835		- char buffer[FILEPATH_MAX];
836		- char *prevIniFile = IniFile;
837		- char *p;
838		- IniFile = S_IniFile;
839		- if (GetModuleFileNameA(GetModuleHandle(NULL), buffer, FILEPATH_MAX))
	832	+ char buffer[FILEPATH_MAX];
	833	+ char *prevIniFile = IniFile;
	834	+ char *p;
	835	+ IniFile = S_IniFile;
	836	+ if(GetModuleFileName(GetModuleHandle(0), buffer, FILEPATH_MAX))
840	837	{
841		- if ((p = pathsep_strrchr(buffer)) != NULL)
842		- {
843		- p++;
844		- *p = '\0';
845		- }
846		- else
847		- {
848		- buffer[0] = '.';
849		- buffer[1] = PATH_SEP;
850		- buffer[2] = '\0';
851		- }
	838	+ if((p = pathsep_strrchr(buffer)) != NULL)
	839	+ {
	840	+ p++;
	841	+ *p = '\0';
	842	+ }
	843	+ else
	844	+ {
	845	+ buffer[0] = '.';
	846	+ buffer[1] = PATH_SEP;
	847	+ buffer[2] = '\0';
	848	+ }
852	849	}
853	850	else
854	851	{
855		- buffer[0] = '.';
856		- buffer[1] = PATH_SEP;
857		- buffer[2] = '\0';
	852	+ buffer[0] = '.';
	853	+ buffer[1] = PATH_SEP;
	854	+ buffer[2] = '\0';
858	855	}
859	856	strncpy(IniFile, buffer, FILEPATH_MAX);
860	857	IniFile[FILEPATH_MAX - 1] = '\0';
861		- strlcat(IniFile, timini, FILEPATH_MAX);
862		- IniGetKeyInt(INI_SEC_PLAYER, "SecondMode", &(SecondMode));
863		- IniFile = prevIniFile;
	858	+#if defined(TIMDRVINI)
	859	+ strcat(IniFile,"timdrv.ini");
	860	+#elif defined(TWSYNG32INI)
	861	+ strcat(IniFile,"twsyng32.ini");
	862	+#else
	863	+ strcat(IniFile,"timpp32g.ini");
	864	+#endif
	865	+ IniGetKeyInt(INI_SEC_PLAYER,"SecondMode",&(SecondMode));
	866	+ IniFile = prevIniFile;
864	867	}

--- a/interface/w32g_pref.c

+++ b/interface/w32g_pref.c

		@@ -583,9 +583,9 @@ void PrefWndCreate(HWND hwnd, UINT cid)
583	583	DialogBox ( hInst, MAKEINTRESOURCE(IDD_DIALOG_PREF_EN), hwnd, PrefWndDialogProc );
584	584	break;
585	585	}
586		-#endif
587	586	hPrefWnd = NULL;
588	587	CurrentPlayerLanguage = -1;
	588	+#endif
589	589	PrefWndSetOK = 0;
590	590	PrefWndDoing = 0;
591	591	return;

		@@ -2126,16 +2126,8 @@ static const TCHAR *cb_info_IDC_COMBO_REVERB_en[] = {
2126	2126	TEXT("Global New Reverb 1"),
2127	2127	TEXT("Standard Reverb EX"),
2128	2128	TEXT("Global Reverb EX"),
2129		-#if 0
2130		- TEXT("Standard Reverb EX2"),
2131		- TEXT("Global Reverb EX2")
2132		-#elif 0
2133	2129	TEXT("Sampling Reverb"),
2134	2130	TEXT("Global Sampling Reverb"),
2135		-#else
2136		- TEXT("Ignore"),
2137		- TEXT("Ignore"),
2138		-#endif
2139	2131	TEXT("Reverb VST"),
2140	2132	TEXT("Global Reverb VST"),
2141	2133	TEXT("Channel VST"),

		@@ -2149,16 +2141,8 @@ static const TCHAR *cb_info_IDC_COMBO_REVERB_jp[] = {
2149	2141	TEXT("新リバーブ (グローバル)"),
2150	2142	TEXT("標準リバーブ EX"),
2151	2143	TEXT("標準リバーブ EX (グローバル)"),
2152		-#if 0
2153		- TEXT("標準リバーブ EX2"),
2154		- TEXT("標準リバーブ EX2 (グローバル)"),
2155		-#elif 0
2156	2144	TEXT("サンプリングリバーブ"),
2157	2145	TEXT("サンプリングリバーブ (グローバル)"),
2158		-#else
2159		- TEXT("無効"),
2160		- TEXT("無効"),
2161		-#endif
2162	2146	TEXT("リバーブ VST"),
2163	2147	TEXT("リバーブ VST (グローバル)"),
2164	2148	TEXT("チャンネル VST"),

		@@ -3402,10 +3386,9 @@ PrefTiMidity1DialogProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam)
3402	3386
3403	3387	RANGE(st_temp->voices, 1, MAX_VOICES); /* 1..1024 */
3404	3388	if (st_temp->voices > max_voices) {
3405		- free_voices();
3406		- safe_free(voice);
	3389	+ free_voice_pointer();
3407	3390	max_voices = st_temp->voices;
3408		- voice = (Voice*) safe_calloc(max_voices, sizeof(Voice));
	3391	+ init_voice_pointer();
3409	3392	}
3410	3393
3411	3394	st_temp->output_amplification = GetDlgItemInt(hwnd,IDC_EDIT_OUTPUT_AMP,NULL,FALSE);

		@@ -5121,90 +5104,41 @@ static const TCHAR *cb_info_IDC_COMBO_REVC_EX_AP_NUM[] = {
5121	5104	TEXT("8"),
5122	5105	};
5123	5106
5124		-#if 0
5125		-// IDC_COMBO_REVC_EX_ER_NUM
5126		-static int cb_info_IDC_COMBO_REVC_EX_ER_NUM_num[] = {
5127		- 2,
5128		- 3,
5129		- 4,
5130		- 6,
5131		- 8,
5132		- 12,
5133		- 16,
5134		- 20,
5135		- 24,
5136		- 32,
5137		- 40,
5138		- 48,
5139		- 56,
5140		- 64,
5141		-};
5142		-static const TCHAR *cb_info_IDC_COMBO_REVC_EX_ER_NUM[] = {
5143		- TEXT("2"),
5144		- TEXT("3"),
5145		- TEXT("4"),
5146		- TEXT("6"),
5147		- TEXT("8"),
5148		- TEXT("12"),
5149		- TEXT("16"),
5150		- TEXT("20"),
5151		- TEXT("24"),
5152		- TEXT("32"),
5153		- TEXT("40"),
5154		- TEXT("48"),
5155		- TEXT("56"),
5156		- TEXT("64"),
5157		-};
5158		-
5159		-// IDC_COMBO_REVC_EX_RV_TYPE
5160		-static int cb_info_IDC_COMBO_REVC_EX_RV_TYPE_num[] = {
	5107	+// IDC_SFOW_EFX_REV_TYPE
	5108	+static int cb_info_IDC_SFOW_EFX_REV_TYPE_num[] = {
5161	5109	0,
5162	5110	1,
5163		- 2,
5164		- 3,
5165	5111	};
5166	5112
5167		-static const TCHAR *cb_info_IDC_COMBO_REVC_EX_RV_TYPE[] = {
5168		- TEXT("comb2"),
5169		- TEXT("mod_comb2"),
5170		- TEXT("net_comb"),
5171		- TEXT("net_comb2"),
	5113	+static const TCHAR *cb_info_IDC_SFOW_EFX_REV_TYPE[] = {
	5114	+ TEXT("Freeverb"),
	5115	+ TEXT("ReverbEX"),
5172	5116	};
5173	5117
5174		-// IDC_COMBO_REVC_EX_AP_TYPE
5175		-static int cb_info_IDC_COMBO_REVC_EX_AP_TYPE_num[] = {
	5118	+// IDC_COMBO_REVC_SR_RS_MODE
	5119	+static int cb_info_IDC_COMBO_REVC_SR_RS_MODE_num[] = {
5176	5120	0,
5177	5121	1,
5178	5122	2,
	5123	+ 3,
5179	5124	};
5180		-
5181		-static const TCHAR *cb_info_IDC_COMBO_REVC_EX_AP_TYPE[] = {
5182		- TEXT("none"),
5183		- TEXT("allpass2"),
5184		- TEXT("mod_allpass2"),
5185		-};
5186		-
5187		-// IDC_COMBO_REVC_EX_MODE
5188		-static int cb_info_IDC_COMBO_REVC_EX_MODE_num[] = {
5189		- 0,
5190		- 1,
5191		-};
5192		-
5193		-static const TCHAR *cb_info_IDC_COMBO_REVC_EX_MODE[] = {
5194		- TEXT("2ch"),
5195		- TEXT("3ch"),
	5125	+static const TCHAR *cb_info_IDC_COMBO_REVC_SR_RS_MODE[] = {
	5126	+ TEXT("OFF"),
	5127	+ TEXT("SR1/2"),
	5128	+ TEXT("SR1/4"),
	5129	+ TEXT("SR1/8"),
5196	5130	};
5197		-#endif
5198	5131
5199		-// IDC_SFOW_EFX_REV_TYPE
5200		-static int cb_info_IDC_SFOW_EFX_REV_TYPE_num[] = {
	5132	+// IDC_COMBO_REVC_SR_FFT_MODE
	5133	+static int cb_info_IDC_COMBO_REVC_SR_FFT_MODE_num[] = {
5201	5134	0,
5202	5135	1,
	5136	+ 2,
5203	5137	};
5204		-
5205		-static const TCHAR *cb_info_IDC_SFOW_EFX_REV_TYPE[] = {
5206		- TEXT("Freeverb"),
5207		- TEXT("ReverbEX"),
	5138	+static const TCHAR *cb_info_IDC_COMBO_REVC_SR_FFT_MODE[] = {
	5139	+ TEXT("OFF"),
	5140	+ TEXT("Zero Latency"),
	5141	+ TEXT("Large Latency"),
5208	5142	};
5209	5143
5210	5144	// IDC_CHOC_EX_PHASE_NUM

		@@ -5559,7 +5493,14 @@ static LRESULT APIENTRY CALLBACK PrefCustom1DialogProc(HWND hwnd, UINT uMess, WP
5559	5493	for (i = 0; i < CB_NUM(cb_info_IDC_SFOW_EFX_REV_TYPE_num); i++)
5560	5494	CB_INSSTR(IDC_SFOW_EFX_REV_TYPE, cb_info_IDC_SFOW_EFX_REV_TYPE[i]);
5561	5495	CB_SET(IDC_SFOW_EFX_REV_TYPE, CB_FIND(cb_info_IDC_SFOW_EFX_REV_TYPE_num, otd.efx_CustomRevType, 5));
5562		-
	5496	+ // reverb ex2
	5497	+ SetDlgItemFloat(hwnd, IDC_REVC_SR_LEVEL, ext_reverb_ex2_level);
	5498	+ for (i = 0; i < CB_NUM(cb_info_IDC_COMBO_REVC_SR_RS_MODE_num); i++)
	5499	+ CB_INSSTR(IDC_COMBO_REVC_SR_RS_MODE, cb_info_IDC_COMBO_REVC_SR_RS_MODE[i]);
	5500	+ CB_SET(IDC_COMBO_REVC_SR_RS_MODE, CB_FIND(cb_info_IDC_COMBO_REVC_SR_RS_MODE_num, ext_reverb_ex2_rsmode, 3));
	5501	+ for (i = 0; i < CB_NUM(cb_info_IDC_COMBO_REVC_SR_FFT_MODE_num); i++)
	5502	+ CB_INSSTR(IDC_COMBO_REVC_SR_FFT_MODE, cb_info_IDC_COMBO_REVC_SR_FFT_MODE[i]);
	5503	+ CB_SET(IDC_COMBO_REVC_SR_FFT_MODE, CB_FIND(cb_info_IDC_COMBO_REVC_SR_FFT_MODE_num, ext_reverb_ex2_fftmode, 0));
5563	5504	// ch chorus
5564	5505	SetDlgItemFloat(hwnd, IDC_CHOC_EXT_LEVEL, ext_chorus_level);
5565	5506	SetDlgItemFloat(hwnd, IDC_CHOC_EXT_FEEDBACK, ext_chorus_feedback);

		@@ -5635,6 +5576,11 @@ static LRESULT APIENTRY CALLBACK PrefCustom1DialogProc(HWND hwnd, UINT uMess, WP
5635	5576	//ext_reverb_ex_ap_type = cb_info_IDC_COMBO_REVC_EX_AP_TYPE_num[CB_GETS(IDC_COMBO_REVC_EX_AP_TYPE, 0)];
5636	5577	//ext_reverb_ex_mode = cb_info_IDC_COMBO_REVC_EX_MODE_num[CB_GETS(IDC_COMBO_REVC_EX_MODE, 0)];
5637	5578	DLG_CHECKBUTTON_TO_FLAG(hwnd, IDC_REVC_EX_MOD, ext_reverb_ex_mod);
	5579	+ // reverb ex2
	5580	+ ext_reverb_ex2_level = GetDlgItemFloat(hwnd, IDC_REVC_SR_LEVEL);
	5581	+ CHECKRANGE_SFINI_PARAM(ext_reverb_ex2_level, 0.001, 16.000);
	5582	+ ext_reverb_ex2_rsmode = cb_info_IDC_COMBO_REVC_SR_RS_MODE_num[CB_GETS(IDC_COMBO_REVC_SR_RS_MODE, 3)];
	5583	+ ext_reverb_ex2_fftmode = cb_info_IDC_COMBO_REVC_SR_FFT_MODE_num[CB_GETS(IDC_COMBO_REVC_SR_FFT_MODE, 0)];
5638	5584	// plate reverb
5639	5585	ext_plate_reverb_level = GetDlgItemFloat(hwnd, IDC_REVC_PLATE_LEVEL);
5640	5586	ext_plate_reverb_time = GetDlgItemFloat(hwnd, IDC_REVC_PLATE_TIME);

--- a/interface/w32g_res.h

+++ b/interface/w32g_res.h

		@@ -616,9 +616,13 @@
616	616	#define IDC_COMBO_REVC_EX_RV_NUM 7716
617	617	#define IDC_COMBO_REVC_EX_AP_NUM 7717
618	618	#define IDC_REVC_EX_MOD 7718
	619	+// reverb ex2
	620	+#define IDC_REVC_SR_LEVEL 7720
	621	+#define IDC_COMBO_REVC_SR_RS_MODE 7721
	622	+#define IDC_COMBO_REVC_SR_FFT_MODE 7722
619	623	// plate reverb
620		-#define IDC_REVC_PLATE_LEVEL 7720
621		-#define IDC_REVC_PLATE_TIME 7721
	624	+#define IDC_REVC_PLATE_LEVEL 7730
	625	+#define IDC_REVC_PLATE_TIME 7731
622	626	// chorus
623	627	#define IDC_CHOC_EXT_LEVEL 7770
624	628	#define IDC_CHOC_EXT_FEEDBACK 7771

--- a/interface/w32g_res.rc

+++ b/interface/w32g_res.rc

		@@ -2422,87 +2422,94 @@ IDD_PREF_CUSTOM1 DIALOGEX 0, 0, 350, 290
2422	2422	STYLE DS_CONTROL \| DS_SETFONT \| WS_CHILDWINDOW
2423	2423	FONT 9, "MS UI Gothic", 0, 0, 1
2424	2424	{
2425		- GROUPBOX "EFX/SYS Freeverb", IDC_STATIC, 5, 5, 110, 120, WS_GROUP
2426		- LTEXT "wet", IDC_STATIC, 10, 20, 30, 8, SS_LEFT \| SS_CENTERIMAGE
2427		- EDITTEXT IDC_REVC_EDWET, 80, 17, 30, 12, ES_AUTOHSCROLL
2428		- LTEXT "scale room", IDC_STATIC, 10, 35, 36, 8, SS_LEFT \| SS_CENTERIMAGE
2429		- EDITTEXT IDC_REVC_EDSCALEROOM, 80, 32, 30, 12, ES_AUTOHSCROLL
2430		- LTEXT "offset room", IDC_STATIC, 10, 50, 33, 8, SS_LEFT \| SS_CENTERIMAGE
2431		- EDITTEXT IDC_REVC_EDOFFSETROOM, 80, 47, 30, 12, ES_AUTOHSCROLL
2432		- LTEXT "time", IDC_STATIC, 10, 65, 26, 8, SS_LEFT \| SS_CENTERIMAGE
2433		- EDITTEXT IDC_REVC_EDTIME, 80, 62, 30, 12, ES_AUTOHSCROLL
2434		- LTEXT "fixed gain", IDC_STATIC, 10, 80, 32, 8, SS_LEFT \| SS_CENTERIMAGE
2435		- EDITTEXT IDC_REVC_EDFIXGAIN, 80, 77, 30, 12, ES_AUTOHSCROLL
2436		- LTEXT "combfbk", IDC_STATIC, 10, 95, 30, 8, SS_LEFT \| SS_CENTERIMAGE
2437		- EDITTEXT IDC_REVC_EDCOMBFBK, 80, 92, 30, 12, ES_AUTOHSCROLL
2438		- LTEXT "numcombs", IDC_STATIC, 10, 110, 32, 8, SS_LEFT \| SS_CENTERIMAGE
2439		- GROUPBOX "SYS Delay (GS)", IDC_STATIC, 120, 120, 110, 60, WS_GROUP
2440		- LTEXT "Delay Time", IDC_STATIC, 125, 135, 34, 8, SS_LEFT \| SS_CENTERIMAGE
2441		- EDITTEXT IDC_DELAY_EDDELAY, 195, 132, 30, 12, ES_AUTOHSCROLL
2442		- COMBOBOX IDC_COMBO_REVC_EDNUMCOMBS, 80, 107, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
2443		- GROUPBOX "EFX/SYS Chorus", IDC_STATIC, 120, 5, 110, 60, WS_GROUP
2444		- LTEXT "Ext Level", IDC_STATIC, 125, 20, 58, 8, SS_LEFT
2445		- LTEXT "Ext Feedback", IDC_STATIC, 125, 35, 61, 8, SS_LEFT
2446		- EDITTEXT IDC_CHOC_EXT_LEVEL, 195, 17, 30, 12, ES_AUTOHSCROLL
2447		- EDITTEXT IDC_CHOC_EXT_FEEDBACK, 195, 32, 30, 12, ES_AUTOHSCROLL
2448		- GROUPBOX "EFX/SYS EQ", IDC_STATIC, 235, 5, 110, 105, WS_GROUP
2449		- LTEXT "Ext_Shelving_Gain", IDC_STATIC, 240, 20, 60, 8, SS_LEFT
2450		- LTEXT "Ext_Peaking_Gain", IDC_STATIC, 240, 65, 58, 8, SS_LEFT
2451		- EDITTEXT IDC_FLTC_EXT_SHELVING_GAIN, 310, 17, 30, 12, ES_AUTOHSCROLL
2452		- EDITTEXT IDC_FLTC_EXT_PEAKING_GAIN, 310, 62, 30, 12, ES_AUTOHSCROLL
2453		- LTEXT "Ext_Shelving_Reduce", IDC_STATIC, 240, 35, 62, 8, SS_LEFT
2454		- EDITTEXT IDC_FLTC_EXT_SHELVING_REDUCE, 310, 32, 30, 12, ES_AUTOHSCROLL
2455		- LTEXT "Ext_Peaking_Reduce", IDC_STATIC, 240, 80, 60, 8, SS_LEFT
2456		- EDITTEXT IDC_FLTC_EXT_PEAKING_REDUCE, 310, 77, 30, 12, ES_AUTOHSCROLL
2457		- LTEXT "Ext EX Phase (GS)", IDC_STATIC, 125, 83, 56, 8, SS_LEFT \| SS_CENTERIMAGE
2458		- COMBOBOX IDC_CHOC_EX_PHASE_NUM, 195, 80, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
2459		- AUTOCHECKBOX "Ext EX Over Sampling", IDC_CHOC_EX_OV, 125, 98, 81, 8
2460		- LTEXT "Ext EX Level", IDC_STATIC, 10, 160, 39, 8, SS_LEFT \| SS_CENTERIMAGE
2461		- EDITTEXT IDC_REVC_EX_LEVEL, 80, 158, 30, 12, ES_AUTOHSCROLL
2462		- LTEXT "Ext EX Time", IDC_STATIC, 10, 145, 38, 8, SS_LEFT \| SS_CENTERIMAGE
2463		- EDITTEXT IDC_REVC_EX_TIME, 80, 143, 30, 12, ES_AUTOHSCROLL
2464		- GROUPBOX "EFX/SYS Reverb EX", IDC_STATIC, 5, 130, 110, 120, WS_GROUP
2465		- LTEXT "Delay Level", IDC_STATIC, 125, 150, 35, 8, SS_LEFT \| SS_CENTERIMAGE
2466		- EDITTEXT IDC_DELAY_EDLEVEL, 195, 147, 30, 12, ES_AUTOHSCROLL
2467		- LTEXT "Feedback", IDC_STATIC, 125, 165, 29, 8, SS_LEFT \| SS_CENTERIMAGE
2468		- EDITTEXT IDC_DELAY_EDFEEDBACK, 195, 162, 30, 12, ES_AUTOHSCROLL
2469		- LTEXT "Ext Depth", IDC_STATIC, 125, 50, 30, 8, SS_LEFT
2470		- EDITTEXT IDC_CHOC_EXT_DEPTH, 195, 47, 30, 12, ES_AUTOHSCROLL
2471		- GROUPBOX "EFX/SYS Chorus EX", IDC_STATIC, 120, 70, 110, 45, WS_GROUP
2472		- LTEXT "Ext Plate Level", IDC_STATIC, 125, 250, 48, 8, SS_LEFT \| SS_CENTERIMAGE
2473		- EDITTEXT IDC_REVC_PLATE_LEVEL, 195, 247, 30, 12, ES_AUTOHSCROLL
2474		- EDITTEXT IDC_REVC_PLATE_TIME, 195, 262, 30, 12, ES_AUTOHSCROLL
2475		- LTEXT "Ext Plate Time", IDC_STATIC, 125, 265, 46, 8, SS_LEFT \| SS_CENTERIMAGE
2476		- GROUPBOX "EFX/SYS Plate Reverb", IDC_STATIC, 120, 235, 110, 45, WS_GROUP
2477		- LTEXT "Ext EX ER Level", IDC_STATIC, 10, 175, 51, 8, SS_LEFT \| SS_CENTERIMAGE
2478		- EDITTEXT IDC_REVC_EX_ER_LEVEL, 80, 172, 30, 12, ES_AUTOHSCROLL
2479		- LTEXT "Ext EX RV_Level", IDC_STATIC, 10, 190, 53, 8, SS_LEFT \| SS_CENTERIMAGE
2480		- EDITTEXT IDC_REVC_EX_RV_LEVEL, 80, 187, 30, 12, ES_AUTOHSCROLL
2481		- LTEXT "Ext EX RV Num", IDC_STATIC, 10, 205, 48, 8, SS_LEFT \| SS_CENTERIMAGE
2482		- COMBOBOX IDC_COMBO_REVC_EX_RV_NUM, 80, 202, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
2483		- GROUPBOX "XG System Effect", IDC_STATIC, 235, 175, 110, 105, WS_GROUP
2484		- LTEXT "Rev Return Level", IDC_STATIC, 240, 190, 56, 8, SS_LEFT
2485		- EDITTEXT IDC_EFX_XG_REV_RETURN_LEVEL, 310, 187, 30, 12, ES_AUTOHSCROLL
2486		- LTEXT "Cho Return Level", IDC_STATIC, 240, 205, 56, 8, SS_LEFT
2487		- EDITTEXT IDC_EFX_XG_CHO_RETURN_LEVEL, 310, 202, 30, 12, ES_AUTOHSCROLL
2488		- LTEXT "Var Return Level", IDC_STATIC, 240, 220, 54, 8, SS_LEFT
2489		- EDITTEXT IDC_EFX_XG_VAR_RETURN_LEVEL, 310, 217, 30, 12, ES_AUTOHSCROLL
2490		- LTEXT "Ext EX AP Num", IDC_STATIC, 10, 220, 48, 8, SS_LEFT \| SS_CENTERIMAGE
2491		- COMBOBOX IDC_COMBO_REVC_EX_AP_NUM, 80, 217, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
2492		- LTEXT "Ext_Shelving_Q", IDC_STATIC, 240, 50, 63, 8, SS_LEFT
2493		- EDITTEXT IDC_FLTC_EXT_SHELVING_Q, 310, 47, 30, 12, ES_AUTOHSCROLL
2494		- LTEXT "Ext_Peaking_Q", IDC_STATIC, 240, 95, 62, 8, SS_LEFT
2495		- EDITTEXT IDC_FLTC_EXT_PEAKING_Q, 310, 92, 30, 12, ES_AUTOHSCROLL
2496		- LTEXT "Cho Send Reverb", IDC_STATIC, 240, 235, 57, 8, SS_LEFT
2497		- EDITTEXT IDC_EFX_XG_CHO_SEND_REVERB, 310, 232, 30, 12, ES_AUTOHSCROLL
2498		- LTEXT "Var Send Reverb", IDC_STATIC, 240, 250, 55, 8, SS_LEFT
2499		- EDITTEXT IDC_EFX_XG_VAR_SEND_REVERB, 310, 247, 30, 12, ES_AUTOHSCROLL
2500		- LTEXT "Var Send Chorus", IDC_STATIC, 240, 265, 54, 8, SS_LEFT
2501		- EDITTEXT IDC_EFX_XG_VAR_SEND_CHORUS, 310, 262, 30, 12, ES_AUTOHSCROLL
2502		- AUTOCHECKBOX "Ext EX Modulation", IDC_REVC_EX_MOD, 10, 235, 70, 8
2503		- GROUPBOX "EFX Reverb", IDC_STATIC, 120, 190, 110, 30, WS_GROUP
2504		- LTEXT "Reverb Type", IDC_STATIC, 125, 203, 49, 8, SS_LEFT \| SS_CENTERIMAGE
2505		- COMBOBOX IDC_SFOW_EFX_REV_TYPE, 185, 200, 40, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2425	+ GROUPBOX "EFX/SYS Freeverb", IDC_STATIC, 5, 5, 110, 115, WS_GROUP
	2426	+ LTEXT "wet", IDC_STATIC, 10, 17, 30, 8, SS_LEFT \| SS_CENTERIMAGE
	2427	+ EDITTEXT IDC_REVC_EDWET, 80, 14, 30, 12, ES_AUTOHSCROLL
	2428	+ LTEXT "scale room", IDC_STATIC, 10, 32, 36, 8, SS_LEFT \| SS_CENTERIMAGE
	2429	+ EDITTEXT IDC_REVC_EDSCALEROOM, 80, 29, 30, 12, ES_AUTOHSCROLL
	2430	+ LTEXT "offset room", IDC_STATIC, 10, 47, 33, 8, SS_LEFT \| SS_CENTERIMAGE
	2431	+ EDITTEXT IDC_REVC_EDOFFSETROOM, 80, 44, 30, 12, ES_AUTOHSCROLL
	2432	+ LTEXT "time", IDC_STATIC, 10, 62, 26, 8, SS_LEFT \| SS_CENTERIMAGE
	2433	+ EDITTEXT IDC_REVC_EDTIME, 80, 59, 30, 12, ES_AUTOHSCROLL
	2434	+ LTEXT "fixed gain", IDC_STATIC, 10, 77, 32, 8, SS_LEFT \| SS_CENTERIMAGE
	2435	+ EDITTEXT IDC_REVC_EDFIXGAIN, 80, 74, 30, 12, ES_AUTOHSCROLL
	2436	+ LTEXT "combfbk", IDC_STATIC, 10, 92, 30, 8, SS_LEFT \| SS_CENTERIMAGE
	2437	+ EDITTEXT IDC_REVC_EDCOMBFBK, 80, 89, 30, 12, ES_AUTOHSCROLL
	2438	+ LTEXT "numcombs", IDC_STATIC, 10, 107, 32, 8, SS_LEFT \| SS_CENTERIMAGE
	2439	+ GROUPBOX "SYS Delay (GS)", IDC_STATIC, 235, 5, 110, 55, WS_GROUP
	2440	+ LTEXT "Delay Time", IDC_STATIC, 240, 17, 34, 8, SS_LEFT \| SS_CENTERIMAGE
	2441	+ EDITTEXT IDC_DELAY_EDDELAY, 310, 14, 30, 12, ES_AUTOHSCROLL
	2442	+ COMBOBOX IDC_COMBO_REVC_EDNUMCOMBS, 80, 104, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2443	+ GROUPBOX "EFX/SYS Chorus", IDC_STATIC, 120, 180, 110, 55, WS_GROUP
	2444	+ LTEXT "Ext Level", IDC_STATIC, 125, 192, 58, 8, SS_LEFT
	2445	+ LTEXT "Ext Feedback", IDC_STATIC, 125, 207, 61, 8, SS_LEFT
	2446	+ EDITTEXT IDC_CHOC_EXT_LEVEL, 195, 189, 30, 12, ES_AUTOHSCROLL
	2447	+ EDITTEXT IDC_CHOC_EXT_FEEDBACK, 195, 204, 30, 12, ES_AUTOHSCROLL
	2448	+ GROUPBOX "EFX/SYS EQ", IDC_STATIC, 235, 75, 110, 100, WS_GROUP
	2449	+ LTEXT "Ext_Shelving_Gain", IDC_STATIC, 240, 87, 60, 8, SS_LEFT
	2450	+ LTEXT "Ext_Peaking_Gain", IDC_STATIC, 240, 132, 58, 8, SS_LEFT
	2451	+ EDITTEXT IDC_FLTC_EXT_SHELVING_GAIN, 310, 84, 30, 12, ES_AUTOHSCROLL
	2452	+ EDITTEXT IDC_FLTC_EXT_PEAKING_GAIN, 310, 129, 30, 12, ES_AUTOHSCROLL
	2453	+ LTEXT "Ext_Shelving_Reduce", IDC_STATIC, 240, 102, 62, 8, SS_LEFT
	2454	+ EDITTEXT IDC_FLTC_EXT_SHELVING_REDUCE, 310, 99, 30, 12, ES_AUTOHSCROLL
	2455	+ LTEXT "Ext_Peaking_Reduce", IDC_STATIC, 240, 147, 60, 8, SS_LEFT
	2456	+ EDITTEXT IDC_FLTC_EXT_PEAKING_REDUCE, 310, 144, 30, 12, ES_AUTOHSCROLL
	2457	+ LTEXT "Ext EX Phase (GS)", IDC_STATIC, 125, 253, 56, 8, SS_LEFT \| SS_CENTERIMAGE
	2458	+ COMBOBOX IDC_CHOC_EX_PHASE_NUM, 195, 250, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2459	+ AUTOCHECKBOX "Ext EX Over Sampling", IDC_CHOC_EX_OV, 125, 268, 81, 8
	2460	+ LTEXT "Ext EX Level", IDC_STATIC, 10, 152, 39, 8, SS_LEFT \| SS_CENTERIMAGE
	2461	+ EDITTEXT IDC_REVC_EX_LEVEL, 80, 150, 30, 12, ES_AUTOHSCROLL
	2462	+ LTEXT "Ext EX Time", IDC_STATIC, 10, 137, 38, 8, SS_LEFT \| SS_CENTERIMAGE
	2463	+ EDITTEXT IDC_REVC_EX_TIME, 80, 135, 30, 12, ES_AUTOHSCROLL
	2464	+ GROUPBOX "EFX/SYS Reverb EX", IDC_STATIC, 5, 125, 110, 115, WS_GROUP
	2465	+ LTEXT "Delay Level", IDC_STATIC, 240, 32, 35, 8, SS_LEFT \| SS_CENTERIMAGE
	2466	+ EDITTEXT IDC_DELAY_EDLEVEL, 310, 29, 30, 12, ES_AUTOHSCROLL
	2467	+ LTEXT "Feedback", IDC_STATIC, 240, 47, 29, 8, SS_LEFT \| SS_CENTERIMAGE
	2468	+ EDITTEXT IDC_DELAY_EDFEEDBACK, 310, 44, 30, 12, ES_AUTOHSCROLL
	2469	+ LTEXT "Ext Depth", IDC_STATIC, 125, 222, 30, 8, SS_LEFT
	2470	+ EDITTEXT IDC_CHOC_EXT_DEPTH, 195, 219, 30, 12, ES_AUTOHSCROLL
	2471	+ GROUPBOX "EFX/SYS Chorus EX", IDC_STATIC, 120, 240, 110, 40, WS_GROUP
	2472	+ LTEXT "Ext Plate Level", IDC_STATIC, 125, 77, 48, 8, SS_LEFT \| SS_CENTERIMAGE
	2473	+ EDITTEXT IDC_REVC_PLATE_LEVEL, 195, 74, 30, 12, ES_AUTOHSCROLL
	2474	+ EDITTEXT IDC_REVC_PLATE_TIME, 195, 89, 30, 12, ES_AUTOHSCROLL
	2475	+ LTEXT "Ext Plate Time", IDC_STATIC, 125, 92, 46, 8, SS_LEFT \| SS_CENTERIMAGE
	2476	+ GROUPBOX "EFX/SYS Plate Reverb", IDC_STATIC, 120, 65, 110, 40, WS_GROUP
	2477	+ LTEXT "Ext EX ER Level", IDC_STATIC, 10, 167, 51, 8, SS_LEFT \| SS_CENTERIMAGE
	2478	+ EDITTEXT IDC_REVC_EX_ER_LEVEL, 80, 164, 30, 12, ES_AUTOHSCROLL
	2479	+ LTEXT "Ext EX RV_Level", IDC_STATIC, 10, 182, 53, 8, SS_LEFT \| SS_CENTERIMAGE
	2480	+ EDITTEXT IDC_REVC_EX_RV_LEVEL, 80, 179, 30, 12, ES_AUTOHSCROLL
	2481	+ LTEXT "Ext EX RV Num", IDC_STATIC, 10, 197, 48, 8, SS_LEFT \| SS_CENTERIMAGE
	2482	+ COMBOBOX IDC_COMBO_REVC_EX_RV_NUM, 80, 194, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2483	+ GROUPBOX "XG System Effect", IDC_STATIC, 235, 180, 110, 100, WS_GROUP
	2484	+ LTEXT "Rev Return Level", IDC_STATIC, 240, 192, 56, 8, SS_LEFT
	2485	+ EDITTEXT IDC_EFX_XG_REV_RETURN_LEVEL, 310, 189, 30, 12, ES_AUTOHSCROLL
	2486	+ LTEXT "Cho Return Level", IDC_STATIC, 240, 207, 56, 8, SS_LEFT
	2487	+ EDITTEXT IDC_EFX_XG_CHO_RETURN_LEVEL, 310, 204, 30, 12, ES_AUTOHSCROLL
	2488	+ LTEXT "Var Return Level", IDC_STATIC, 240, 222, 54, 8, SS_LEFT
	2489	+ EDITTEXT IDC_EFX_XG_VAR_RETURN_LEVEL, 310, 219, 30, 12, ES_AUTOHSCROLL
	2490	+ LTEXT "Ext EX AP Num", IDC_STATIC, 10, 212, 48, 8, SS_LEFT \| SS_CENTERIMAGE
	2491	+ COMBOBOX IDC_COMBO_REVC_EX_AP_NUM, 80, 209, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2492	+ LTEXT "Ext_Shelving_Q", IDC_STATIC, 240, 117, 63, 8, SS_LEFT
	2493	+ EDITTEXT IDC_FLTC_EXT_SHELVING_Q, 310, 114, 30, 12, ES_AUTOHSCROLL
	2494	+ LTEXT "Ext_Peaking_Q", IDC_STATIC, 240, 162, 62, 8, SS_LEFT
	2495	+ EDITTEXT IDC_FLTC_EXT_PEAKING_Q, 310, 159, 30, 12, ES_AUTOHSCROLL
	2496	+ LTEXT "Cho Send Reverb", IDC_STATIC, 240, 237, 57, 8, SS_LEFT
	2497	+ EDITTEXT IDC_EFX_XG_CHO_SEND_REVERB, 310, 234, 30, 12, ES_AUTOHSCROLL
	2498	+ LTEXT "Var Send Reverb", IDC_STATIC, 240, 252, 55, 8, SS_LEFT
	2499	+ EDITTEXT IDC_EFX_XG_VAR_SEND_REVERB, 310, 249, 30, 12, ES_AUTOHSCROLL
	2500	+ LTEXT "Var Send Chorus", IDC_STATIC, 240, 267, 54, 8, SS_LEFT
	2501	+ EDITTEXT IDC_EFX_XG_VAR_SEND_CHORUS, 310, 264, 30, 12, ES_AUTOHSCROLL
	2502	+ AUTOCHECKBOX "Ext EX Modulation", IDC_REVC_EX_MOD, 10, 227, 70, 8
	2503	+ GROUPBOX "EFX Reverb", IDC_STATIC, 5, 250, 110, 30, WS_GROUP
	2504	+ LTEXT "Reverb Type", IDC_STATIC, 10, 263, 49, 8, SS_LEFT \| SS_CENTERIMAGE
	2505	+ COMBOBOX IDC_SFOW_EFX_REV_TYPE, 60, 260, 50, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2506	+ GROUPBOX "SYS Sampling Reverb", IDC_STATIC, 120, 5, 110, 55, WS_GROUP
	2507	+ LTEXT "Ext Level", IDC_STATIC, 125, 17, 58, 8, SS_LEFT
	2508	+ EDITTEXT IDC_REVC_SR_LEVEL, 195, 14, 30, 12, ES_AUTOHSCROLL
	2509	+ LTEXT "RS Mode", IDC_STATIC, 125, 32, 27, 8, SS_LEFT \| SS_CENTERIMAGE
	2510	+ COMBOBOX IDC_COMBO_REVC_SR_RS_MODE, 175, 29, 50, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2511	+ LTEXT "FFT Mode", IDC_STATIC, 125, 47, 31, 8, SS_LEFT \| SS_CENTERIMAGE
	2512	+ COMBOBOX IDC_COMBO_REVC_SR_FFT_MODE, 175, 44, 50, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
2506	2513	}
2507	2514
2508	2515

		@@ -2512,87 +2519,94 @@ IDD_PREF_CUSTOM1_EN DIALOGEX 0, 0, 350, 290
2512	2519	STYLE DS_CONTROL \| DS_SETFONT \| WS_CHILDWINDOW
2513	2520	FONT 8, "Tahoma", 0, 0, 1
2514	2521	{
2515		- GROUPBOX "EFX/SYS Freeverb", IDC_STATIC, 5, 5, 110, 120, WS_GROUP
2516		- LTEXT "wet", IDC_STATIC, 10, 20, 50, 8, SS_LEFT \| SS_CENTERIMAGE
2517		- EDITTEXT IDC_REVC_EDWET, 80, 17, 30, 12, ES_AUTOHSCROLL
2518		- LTEXT "scale room", IDC_STATIC, 10, 35, 36, 8, SS_LEFT \| SS_CENTERIMAGE
2519		- EDITTEXT IDC_REVC_EDSCALEROOM, 80, 32, 30, 12, ES_AUTOHSCROLL
2520		- LTEXT "offset room", IDC_STATIC, 10, 50, 37, 8, SS_LEFT \| SS_CENTERIMAGE
2521		- EDITTEXT IDC_REVC_EDOFFSETROOM, 80, 47, 30, 12, ES_AUTOHSCROLL
2522		- LTEXT "time", IDC_STATIC, 10, 65, 39, 8, SS_LEFT \| SS_CENTERIMAGE
2523		- EDITTEXT IDC_REVC_EDTIME, 80, 62, 30, 12, ES_AUTOHSCROLL
2524		- LTEXT "fixed gain", IDC_STATIC, 10, 80, 32, 8, SS_LEFT \| SS_CENTERIMAGE
2525		- EDITTEXT IDC_REVC_EDFIXGAIN, 80, 77, 30, 12, ES_AUTOHSCROLL
2526		- LTEXT "combfbk", IDC_STATIC, 10, 95, 30, 8, SS_LEFT \| SS_CENTERIMAGE
2527		- EDITTEXT IDC_REVC_EDCOMBFBK, 80, 92, 30, 12, ES_AUTOHSCROLL
2528		- LTEXT "numcombs", IDC_STATIC, 10, 110, 34, 8, SS_LEFT \| SS_CENTERIMAGE
2529		- GROUPBOX "SYS Delay (GS)", IDC_STATIC, 120, 120, 110, 60, WS_GROUP
2530		- LTEXT "Delay Time", IDC_STATIC, 125, 135, 36, 8, SS_LEFT \| SS_CENTERIMAGE
2531		- EDITTEXT IDC_DELAY_EDDELAY, 195, 132, 30, 12, ES_AUTOHSCROLL
2532		- COMBOBOX IDC_COMBO_REVC_EDNUMCOMBS, 80, 107, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
2533		- GROUPBOX "EFX/SYS Chorus", IDC_STATIC, 120, 5, 110, 60, WS_GROUP
2534		- LTEXT "Ext Level", IDC_STATIC, 125, 20, 55, 8, SS_LEFT
2535		- LTEXT "Ext Feedback", IDC_STATIC, 125, 35, 57, 8, SS_LEFT
2536		- EDITTEXT IDC_CHOC_EXT_LEVEL, 195, 17, 30, 12, ES_AUTOHSCROLL
2537		- EDITTEXT IDC_CHOC_EXT_FEEDBACK, 195, 32, 30, 12, ES_AUTOHSCROLL
2538		- GROUPBOX "EFX/SYS EQ", IDC_STATIC, 235, 5, 110, 105, WS_GROUP
2539		- LTEXT "Ext_Shelving_Gain", IDC_STATIC, 240, 20, 63, 8, SS_LEFT
2540		- LTEXT "Ext_Peaking_Gain", IDC_STATIC, 240, 65, 65, 8, SS_LEFT
2541		- EDITTEXT IDC_FLTC_EXT_SHELVING_GAIN, 310, 17, 30, 12, ES_AUTOHSCROLL
2542		- EDITTEXT IDC_FLTC_EXT_PEAKING_GAIN, 310, 62, 30, 12, ES_AUTOHSCROLL
2543		- LTEXT "Ext_Shelving_Reduce", IDC_STATIC, 240, 35, 69, 8, SS_LEFT
2544		- EDITTEXT IDC_FLTC_EXT_SHELVING_REDUCE, 310, 32, 30, 12, ES_AUTOHSCROLL
2545		- LTEXT "Ext_Peaking_Reduce", IDC_STATIC, 240, 80, 68, 8, SS_LEFT
2546		- EDITTEXT IDC_FLTC_EXT_PEAKING_REDUCE, 310, 77, 30, 12, ES_AUTOHSCROLL
2547		- LTEXT "Ext EX Phase (GS)", IDC_STATIC, 125, 85, 59, 8, SS_LEFT \| SS_CENTERIMAGE
2548		- COMBOBOX IDC_CHOC_EX_PHASE_NUM, 195, 82, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
2549		- AUTOCHECKBOX "Ext EX Over Sampling", IDC_CHOC_EX_OV, 125, 100, 85, 8
2550		- LTEXT "Ext EX Level", IDC_STATIC, 10, 160, 39, 8, SS_LEFT \| SS_CENTERIMAGE
2551		- EDITTEXT IDC_REVC_EX_LEVEL, 80, 157, 30, 12, ES_AUTOHSCROLL
2552		- EDITTEXT IDC_REVC_EX_TIME, 80, 142, 30, 12, ES_AUTOHSCROLL
2553		- LTEXT "Ext EX Time", IDC_STATIC, 10, 145, 38, 8, SS_LEFT \| SS_CENTERIMAGE
2554		- GROUPBOX "EFX/SYS Reverb EX", IDC_STATIC, 5, 130, 110, 120, WS_GROUP
2555		- LTEXT "Delay Level", IDC_STATIC, 125, 150, 35, 8, SS_LEFT \| SS_CENTERIMAGE
2556		- EDITTEXT IDC_DELAY_EDLEVEL, 195, 147, 30, 12, ES_AUTOHSCROLL
2557		- EDITTEXT IDC_DELAY_EDFEEDBACK, 195, 162, 30, 12, ES_AUTOHSCROLL
2558		- LTEXT "Feedback", IDC_STATIC, 125, 165, 29, 8, SS_LEFT \| SS_CENTERIMAGE
2559		- LTEXT "Ext Depth", IDC_STATIC, 125, 50, 49, 8, SS_LEFT
2560		- EDITTEXT IDC_CHOC_EXT_DEPTH, 195, 47, 30, 12, ES_AUTOHSCROLL
2561		- GROUPBOX "EFX/SYS Chorus EX", IDC_STATIC, 120, 70, 110, 45, WS_GROUP
2562		- LTEXT "Ext Plate Level", IDC_STATIC, 125, 250, 48, 8, SS_LEFT \| SS_CENTERIMAGE
2563		- EDITTEXT IDC_REVC_PLATE_LEVEL, 195, 247, 30, 12, ES_AUTOHSCROLL
2564		- EDITTEXT IDC_REVC_PLATE_TIME, 195, 262, 30, 12, ES_AUTOHSCROLL
2565		- LTEXT "Ext Plate Time", IDC_STATIC, 125, 265, 46, 8, SS_LEFT \| SS_CENTERIMAGE
2566		- GROUPBOX "EFX/SYS Plate Reverb", IDC_STATIC, 120, 235, 110, 45, WS_GROUP
2567		- LTEXT "Ext EX ER Level", IDC_STATIC, 10, 175, 51, 8, SS_LEFT \| SS_CENTERIMAGE
2568		- EDITTEXT IDC_REVC_EX_ER_LEVEL, 80, 172, 30, 12, ES_AUTOHSCROLL
2569		- LTEXT "Ext EX RV_Level", IDC_STATIC, 10, 190, 53, 8, SS_LEFT \| SS_CENTERIMAGE
2570		- EDITTEXT IDC_REVC_EX_RV_LEVEL, 80, 187, 30, 12, ES_AUTOHSCROLL
2571		- LTEXT "Ext EX RV Num", IDC_STATIC, 10, 205, 48, 8, SS_LEFT \| SS_CENTERIMAGE
2572		- COMBOBOX IDC_COMBO_REVC_EX_RV_NUM, 80, 202, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
2573		- GROUPBOX "XG System Effect", IDC_STATIC, 235, 175, 110, 105, WS_GROUP
2574		- LTEXT "Rev Return Level", IDC_STATIC, 240, 190, 56, 8, SS_LEFT
2575		- EDITTEXT IDC_EFX_XG_REV_RETURN_LEVEL, 310, 187, 30, 12, ES_AUTOHSCROLL
2576		- LTEXT "Cho Return Level", IDC_STATIC, 240, 205, 56, 8, SS_LEFT
2577		- EDITTEXT IDC_EFX_XG_CHO_RETURN_LEVEL, 310, 202, 30, 12, ES_AUTOHSCROLL
2578		- LTEXT "Var Return Level", IDC_STATIC, 240, 220, 54, 8, SS_LEFT
2579		- EDITTEXT IDC_EFX_XG_VAR_RETURN_LEVEL, 310, 217, 30, 12, ES_AUTOHSCROLL
2580		- COMBOBOX IDC_COMBO_REVC_EX_AP_NUM, 80, 217, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
2581		- LTEXT "Ext EX AP Num", IDC_STATIC, 10, 220, 48, 8, SS_LEFT \| SS_CENTERIMAGE
2582		- LTEXT "Ext_Shelving_Q", IDC_STATIC, 240, 50, 63, 8, SS_LEFT
2583		- EDITTEXT IDC_FLTC_EXT_SHELVING_Q, 310, 47, 30, 12, ES_AUTOHSCROLL
2584		- LTEXT "Ext_Peaking_Q", IDC_STATIC, 240, 95, 65, 8, SS_LEFT
2585		- EDITTEXT IDC_FLTC_EXT_PEAKING_Q, 310, 92, 30, 12, ES_AUTOHSCROLL
2586		- LTEXT "Cho Send Reverb", IDC_STATIC, 240, 235, 57, 8, SS_LEFT
2587		- EDITTEXT IDC_EFX_XG_CHO_SEND_REVERB, 310, 232, 30, 12, ES_AUTOHSCROLL
2588		- EDITTEXT IDC_EFX_XG_VAR_SEND_REVERB, 310, 247, 30, 12, ES_AUTOHSCROLL
2589		- LTEXT "Var Send Reverb", IDC_STATIC, 240, 250, 55, 8, SS_LEFT
2590		- LTEXT "Var Send Chorus", IDC_STATIC, 240, 265, 54, 8, SS_LEFT
2591		- EDITTEXT IDC_EFX_XG_VAR_SEND_CHORUS, 310, 262, 30, 12, ES_AUTOHSCROLL
2592		- AUTOCHECKBOX "Ext EX Modulation", IDC_REVC_EX_MOD, 10, 235, 70, 8
2593		- GROUPBOX "EFX Reverb", IDC_STATIC, 120, 190, 110, 30, WS_GROUP
2594		- LTEXT "Reverb Type", IDC_STATIC, 125, 203, 51, 8, SS_LEFT \| SS_CENTERIMAGE
2595		- COMBOBOX IDC_SFOW_EFX_REV_TYPE, 185, 200, 40, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2522	+ GROUPBOX "EFX/SYS Freeverb", IDC_STATIC, 5, 5, 110, 115, WS_GROUP
	2523	+ LTEXT "wet", IDC_STATIC, 10, 17, 50, 8, SS_LEFT \| SS_CENTERIMAGE
	2524	+ EDITTEXT IDC_REVC_EDWET, 80, 14, 30, 12, ES_AUTOHSCROLL
	2525	+ LTEXT "scale room", IDC_STATIC, 10, 32, 36, 8, SS_LEFT \| SS_CENTERIMAGE
	2526	+ EDITTEXT IDC_REVC_EDSCALEROOM, 80, 29, 30, 12, ES_AUTOHSCROLL
	2527	+ LTEXT "offset room", IDC_STATIC, 10, 47, 37, 8, SS_LEFT \| SS_CENTERIMAGE
	2528	+ EDITTEXT IDC_REVC_EDOFFSETROOM, 80, 44, 30, 12, ES_AUTOHSCROLL
	2529	+ LTEXT "time", IDC_STATIC, 10, 62, 39, 8, SS_LEFT \| SS_CENTERIMAGE
	2530	+ EDITTEXT IDC_REVC_EDTIME, 80, 59, 30, 12, ES_AUTOHSCROLL
	2531	+ LTEXT "fixed gain", IDC_STATIC, 10, 77, 32, 8, SS_LEFT \| SS_CENTERIMAGE
	2532	+ EDITTEXT IDC_REVC_EDFIXGAIN, 80, 74, 30, 12, ES_AUTOHSCROLL
	2533	+ LTEXT "combfbk", IDC_STATIC, 10, 92, 30, 8, SS_LEFT \| SS_CENTERIMAGE
	2534	+ EDITTEXT IDC_REVC_EDCOMBFBK, 80, 89, 30, 12, ES_AUTOHSCROLL
	2535	+ LTEXT "numcombs", IDC_STATIC, 10, 107, 34, 8, SS_LEFT \| SS_CENTERIMAGE
	2536	+ GROUPBOX "SYS Delay (GS)", IDC_STATIC, 235, 5, 110, 55, WS_GROUP
	2537	+ LTEXT "Delay Time", IDC_STATIC, 240, 17, 36, 8, SS_LEFT \| SS_CENTERIMAGE
	2538	+ EDITTEXT IDC_DELAY_EDDELAY, 310, 14, 30, 12, ES_AUTOHSCROLL
	2539	+ COMBOBOX IDC_COMBO_REVC_EDNUMCOMBS, 80, 104, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2540	+ GROUPBOX "EFX/SYS Chorus", IDC_STATIC, 120, 180, 110, 55, WS_GROUP
	2541	+ LTEXT "Ext Level", IDC_STATIC, 125, 192, 55, 8, SS_LEFT
	2542	+ LTEXT "Ext Feedback", IDC_STATIC, 125, 207, 57, 8, SS_LEFT
	2543	+ EDITTEXT IDC_CHOC_EXT_LEVEL, 195, 189, 30, 12, ES_AUTOHSCROLL
	2544	+ EDITTEXT IDC_CHOC_EXT_FEEDBACK, 195, 204, 30, 12, ES_AUTOHSCROLL
	2545	+ GROUPBOX "EFX/SYS EQ", IDC_STATIC, 235, 75, 110, 100, WS_GROUP
	2546	+ LTEXT "Ext_Shelving_Gain", IDC_STATIC, 240, 87, 63, 8, SS_LEFT
	2547	+ LTEXT "Ext_Peaking_Gain", IDC_STATIC, 240, 132, 65, 8, SS_LEFT
	2548	+ EDITTEXT IDC_FLTC_EXT_SHELVING_GAIN, 310, 84, 30, 12, ES_AUTOHSCROLL
	2549	+ EDITTEXT IDC_FLTC_EXT_PEAKING_GAIN, 310, 129, 30, 12, ES_AUTOHSCROLL
	2550	+ LTEXT "Ext_Shelving_Reduce", IDC_STATIC, 240, 102, 69, 8, SS_LEFT
	2551	+ EDITTEXT IDC_FLTC_EXT_SHELVING_REDUCE, 310, 99, 30, 12, ES_AUTOHSCROLL
	2552	+ LTEXT "Ext_Peaking_Reduce", IDC_STATIC, 240, 147, 68, 8, SS_LEFT
	2553	+ EDITTEXT IDC_FLTC_EXT_PEAKING_REDUCE, 310, 144, 30, 12, ES_AUTOHSCROLL
	2554	+ LTEXT "Ext EX Phase (GS)", IDC_STATIC, 125, 252, 59, 8, SS_LEFT \| SS_CENTERIMAGE
	2555	+ COMBOBOX IDC_CHOC_EX_PHASE_NUM, 195, 249, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2556	+ AUTOCHECKBOX "Ext EX Over Sampling", IDC_CHOC_EX_OV, 125, 267, 85, 8
	2557	+ LTEXT "Ext EX Level", IDC_STATIC, 10, 152, 39, 8, SS_LEFT \| SS_CENTERIMAGE
	2558	+ EDITTEXT IDC_REVC_EX_LEVEL, 80, 149, 30, 12, ES_AUTOHSCROLL
	2559	+ EDITTEXT IDC_REVC_EX_TIME, 80, 134, 30, 12, ES_AUTOHSCROLL
	2560	+ LTEXT "Ext EX Time", IDC_STATIC, 10, 137, 38, 8, SS_LEFT \| SS_CENTERIMAGE
	2561	+ GROUPBOX "EFX/SYS Reverb EX", IDC_STATIC, 5, 125, 110, 110, WS_GROUP
	2562	+ LTEXT "Delay Level", IDC_STATIC, 240, 32, 35, 8, SS_LEFT \| SS_CENTERIMAGE
	2563	+ EDITTEXT IDC_DELAY_EDLEVEL, 310, 29, 30, 12, ES_AUTOHSCROLL
	2564	+ EDITTEXT IDC_DELAY_EDFEEDBACK, 310, 44, 30, 12, ES_AUTOHSCROLL
	2565	+ LTEXT "Feedback", IDC_STATIC, 240, 47, 29, 8, SS_LEFT \| SS_CENTERIMAGE
	2566	+ LTEXT "Ext Depth", IDC_STATIC, 125, 222, 49, 8, SS_LEFT
	2567	+ EDITTEXT IDC_CHOC_EXT_DEPTH, 195, 219, 30, 12, ES_AUTOHSCROLL
	2568	+ GROUPBOX "EFX/SYS Chorus EX", IDC_STATIC, 120, 240, 110, 40, WS_GROUP
	2569	+ LTEXT "Ext Plate Level", IDC_STATIC, 125, 77, 48, 8, SS_LEFT \| SS_CENTERIMAGE
	2570	+ EDITTEXT IDC_REVC_PLATE_LEVEL, 195, 74, 30, 12, ES_AUTOHSCROLL
	2571	+ EDITTEXT IDC_REVC_PLATE_TIME, 195, 89, 30, 12, ES_AUTOHSCROLL
	2572	+ LTEXT "Ext Plate Time", IDC_STATIC, 125, 92, 46, 8, SS_LEFT \| SS_CENTERIMAGE
	2573	+ GROUPBOX "EFX/SYS Plate Reverb", IDC_STATIC, 120, 65, 110, 40, WS_GROUP
	2574	+ LTEXT "Ext EX ER Level", IDC_STATIC, 10, 167, 51, 8, SS_LEFT \| SS_CENTERIMAGE
	2575	+ EDITTEXT IDC_REVC_EX_ER_LEVEL, 80, 164, 30, 12, ES_AUTOHSCROLL
	2576	+ LTEXT "Ext EX RV_Level", IDC_STATIC, 10, 182, 53, 8, SS_LEFT \| SS_CENTERIMAGE
	2577	+ EDITTEXT IDC_REVC_EX_RV_LEVEL, 80, 179, 30, 12, ES_AUTOHSCROLL
	2578	+ LTEXT "Ext EX RV Num", IDC_STATIC, 10, 197, 48, 8, SS_LEFT \| SS_CENTERIMAGE
	2579	+ COMBOBOX IDC_COMBO_REVC_EX_RV_NUM, 80, 194, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2580	+ GROUPBOX "XG System Effect", IDC_STATIC, 235, 180, 110, 100, WS_GROUP
	2581	+ LTEXT "Rev Return Level", IDC_STATIC, 240, 192, 56, 8, SS_LEFT
	2582	+ EDITTEXT IDC_EFX_XG_REV_RETURN_LEVEL, 310, 189, 30, 12, ES_AUTOHSCROLL
	2583	+ LTEXT "Cho Return Level", IDC_STATIC, 240, 207, 56, 8, SS_LEFT
	2584	+ EDITTEXT IDC_EFX_XG_CHO_RETURN_LEVEL, 310, 204, 30, 12, ES_AUTOHSCROLL
	2585	+ LTEXT "Var Return Level", IDC_STATIC, 240, 222, 54, 8, SS_LEFT
	2586	+ EDITTEXT IDC_EFX_XG_VAR_RETURN_LEVEL, 310, 219, 30, 12, ES_AUTOHSCROLL
	2587	+ COMBOBOX IDC_COMBO_REVC_EX_AP_NUM, 80, 209, 30, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2588	+ LTEXT "Ext EX AP Num", IDC_STATIC, 10, 212, 48, 8, SS_LEFT \| SS_CENTERIMAGE
	2589	+ LTEXT "Ext_Shelving_Q", IDC_STATIC, 240, 117, 63, 8, SS_LEFT
	2590	+ EDITTEXT IDC_FLTC_EXT_SHELVING_Q, 310, 114, 30, 12, ES_AUTOHSCROLL
	2591	+ LTEXT "Ext_Peaking_Q", IDC_STATIC, 240, 162, 65, 8, SS_LEFT
	2592	+ EDITTEXT IDC_FLTC_EXT_PEAKING_Q, 310, 159, 30, 12, ES_AUTOHSCROLL
	2593	+ LTEXT "Cho Send Reverb", IDC_STATIC, 240, 237, 57, 8, SS_LEFT
	2594	+ EDITTEXT IDC_EFX_XG_CHO_SEND_REVERB, 310, 234, 30, 12, ES_AUTOHSCROLL
	2595	+ EDITTEXT IDC_EFX_XG_VAR_SEND_REVERB, 310, 249, 30, 12, ES_AUTOHSCROLL
	2596	+ LTEXT "Var Send Reverb", IDC_STATIC, 240, 252, 55, 8, SS_LEFT
	2597	+ LTEXT "Var Send Chorus", IDC_STATIC, 240, 267, 54, 8, SS_LEFT
	2598	+ EDITTEXT IDC_EFX_XG_VAR_SEND_CHORUS, 310, 264, 30, 12, ES_AUTOHSCROLL
	2599	+ AUTOCHECKBOX "Ext EX Modulation", IDC_REVC_EX_MOD, 10, 227, 70, 8
	2600	+ GROUPBOX "EFX Reverb", IDC_STATIC, 5, 250, 110, 30, WS_GROUP
	2601	+ LTEXT "Reverb Type", IDC_STATIC, 10, 263, 51, 8, SS_LEFT \| SS_CENTERIMAGE
	2602	+ COMBOBOX IDC_SFOW_EFX_REV_TYPE, 60, 260, 50, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2603	+ GROUPBOX "SYS Sampling Reverb", IDC_STATIC, 120, 5, 110, 55, WS_GROUP
	2604	+ LTEXT "Ext Level", IDC_STATIC, 125, 17, 58, 8, SS_LEFT
	2605	+ EDITTEXT IDC_REVC_SR_LEVEL, 195, 14, 30, 12, ES_AUTOHSCROLL
	2606	+ LTEXT "RS Mode", IDC_STATIC, 125, 32, 27, 8, SS_LEFT \| SS_CENTERIMAGE
	2607	+ COMBOBOX IDC_COMBO_REVC_SR_RS_MODE, 175, 29, 50, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
	2608	+ LTEXT "FFT Mode", IDC_STATIC, 125, 47, 32, 8, SS_LEFT \| SS_CENTERIMAGE
	2609	+ COMBOBOX IDC_COMBO_REVC_SR_FFT_MODE, 175, 44, 50, 181, WS_TABSTOP \| WS_VSCROLL \| CBS_DROPDOWNLIST \| CBS_SORT
2596	2610	}
2597	2611
2598	2612

--- a/interface/w32g_syn.c

+++ b/interface/w32g_syn.c

		@@ -37,7 +37,11 @@
37	37	#undef RC_NONE
38	38	#include <shlobj.h>
39	39	#include <commctrl.h>
40		-#include "_string.h"
	40	+#ifndef NO_STRING_H
	41	+#include <string.h>
	42	+#else
	43	+#include <strings.h>
	44	+#endif
41	45	#include <shlobj.h>
42	46	#include <windowsx.h> /* There is no <windowsx.h> on CYGWIN.
43	47	* Edit_* and ListBox_* are defined in

		@@ -61,14 +65,9 @@
61	65	#include "output.h"
62	66	#include "controls.h"
63	67	#include "rtsyn.h"
64		-#include "timer2.h"
65		-
66		-#ifndef TWSYNSRV
67		-#include "soundspec.h"
68		-#endif /* !TWSYNSRV */
69	68
70	69	#ifdef WIN32GCC
71		-void WINAPI InitCommonControls(void);
	70	+WINAPI void InitCommonControls(void);
72	71	#endif
73	72
74	73	#include "w32g.h"

		@@ -76,7 +75,6 @@ void WINAPI InitCommonControls(void);
76	75	#include "w32g_pref.h"
77	76	#include "w32g_res.h"
78	77	#include "w32g_int_synth_editor.h"
79		-#include "vstwrapper.h"
80	78
81	79	#ifdef IA_W32G_SYN
82	80

		@@ -86,22 +84,22 @@ void WINAPI InitCommonControls(void);
86	84	#endif
87	85
88	86	typedef struct w32g_syn_t_ {
89		- UINT nid_uID;
	87	+ UINT nid_uID;
90	88	#ifndef TWSYNSRV
91		- HWND nid_hWnd;
92		- HICON hIcon;
93		- HICON hIconStart;
94		- HICON hIconPause;
	89	+ HWND nid_hWnd;
	90	+ HICON hIcon;
	91	+ HICON hIconStart;
	92	+ HICON hIconPause;
95	93	#endif /* !TWSYNSRV */
96		- int argc;
97		- char **argv;
98		- HANDLE gui_hThread;
99		- DWORD gui_dwThreadId;
100		- HANDLE syn_hThread;
101		- DWORD syn_dwThreadId;
102		-// int syn_ThreadPriority;
103		- HANDLE hMutex;
104		- int volatile quit_state;
	94	+ int argc;
	95	+ char **argv;
	96	+ HANDLE gui_hThread;
	97	+ DWORD gui_dwThreadId;
	98	+ HANDLE syn_hThread;
	99	+ DWORD syn_dwThreadId;
	100	+// int syn_ThreadPriority;
	101	+ HANDLE hMutex;
	102	+ int volatile quit_state;
105	103	} w32g_syn_t;
106	104	static w32g_syn_t w32g_syn;
107	105

		@@ -171,7 +169,7 @@ static void WINAPI syn_thread(void);
171	169
172	170	// Task tray version here
173	171
174		-static INT_PTR CALLBACK SynWinProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam);
	172	+static LRESULT CALLBACK SynWinProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam);
175	173	static void VersionWnd(HWND hParentWnd);
176	174	static void TiMidityWnd(HWND hParentWnd);
177	175

		@@ -233,7 +231,6 @@ void InitSoundSpecWnd(HWND hParentWnd);
233	231
234	232	static SERVICE_STATUS_HANDLE serviceStatusHandle;
235	233	static DWORD currentServiceStatus;
236		-
237	234	static const char *serviceName = "Timidity";
238	235	static const char *serviceDescription = "Realtime synthesize midi message";
239	236	static const char *regKeyTwSynSrv = "SYSTEM\\CurrentControlSet\\Services\\Timidity";

		@@ -242,7 +239,7 @@ static BOOL quietInstaller = FALSE;
242	239	static BOOL InstallService();
243	240	static BOOL UninstallService();
244	241
245		-#endif // !TWSYNSRV
	242	+#endif // !TWSYNSRV
246	243
247	244
248	245	#define W32G_SYN_NID_UID 12301

		@@ -250,9 +247,9 @@ static BOOL UninstallService();
250	247
251	248	#define W32G_SYN_MESSAGE_MAX 100
252	249	#define W32G_SYN_NONE 0
253		-#define W32G_SYN_QUIT 10
254		-#define W32G_SYN_START 11 // 演奏状態へ移行
255		-#define W32G_SYN_STOP 12 // 演奏停止状態へ移行
	250	+#define W32G_SYN_QUIT 10
	251	+#define W32G_SYN_START 11 // 演奏状態へ移行
	252	+#define W32G_SYN_STOP 12 // 演奏停止状態へ移行
256	253	///r
257	254	#define W32G_SYN_SYSTEM_RESET 15
258	255	#define W32G_SYN_SYSTEM_RESET_X 20 // IDM_SYSTEM_RESET_X と同じ並びであること

		@@ -265,7 +262,7 @@ static BOOL UninstallService();
265	262
266	263
267	264	typedef struct w32g_syn_message_t_ {
268		- int cmd;
	265	+ int cmd;
269	266	} w32g_syn_message_t;
270	267	static volatile enum { stop, run, quit, none } w32g_syn_status, w32g_syn_status_prev;
271	268	#ifndef MAX_PORT

		@@ -287,7 +284,7 @@ int syn_AutoStart; //
287	284	extern DWORD processPriority; // プロセスのプライオリティ
288	285	extern DWORD syn_ThreadPriority; // シンセスレッドのプライオリティ
289	286
290		-extern int volatile stream_max_compute; // play_event() の compute_data() で計算を許す最大時間。
	287	+extern int volatile stream_max_compute; // play_event() の compute_data() で計算を許す最大時間。
291	288
292	289	static int w32g_syn_main(void);
293	290	static int start_syn_thread(void);

		@@ -303,100 +300,91 @@ extern int w32g_syn_do_after_pref_apply(void);
303	300
304	301	/*
305	302	構造
306		- 　メインスレッド：GUIのメッセージループ
307		- 　シンセサイザースレッド：発音部分
	303	+ 　メインスレッド：GUIのメッセージループ
	304	+ 　シンセサイザースレッド：発音部分
308	305	*/
309	306	int WINAPI
310	307	WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
311		- LPSTR lpCmdLine, int nCmdShow)
	308	+ LPSTR lpCmdLine, int nCmdShow)
312	309	{
313		- HANDLE hMutex;
314		- int i;
315		-
316		- Sleep(100); // Restartで前プロセスの終了待機
	310	+ HANDLE hMutex;
	311	+ int i;
317	312
	313	+
	314	+ Sleep(100); // Restartで前プロセスの終了待機
318	315	#ifdef TIMIDITY_LEAK_CHECK
319		- _CrtSetDbgFlag(CRTDEBUGFLAGS);
	316	+ _CrtSetDbgFlag(CRTDEBUGFLAGS);
320	317	#endif
321	318
322		- // 今のところ２重起動はできないようにしとく。
323		- hMutex = OpenMutex(0, FALSE, W32G_MUTEX_NAME);
324		- if (hMutex) {
325		- CloseHandle(hMutex);
326		- return 0;
327		- }
328		- w32g_syn.hMutex = CreateMutex(NULL, TRUE, W32G_MUTEX_NAME);
329		- if (!w32g_syn.hMutex) {
330		- return 0;
331		- }
	319	+ // 今のところ２重起動はできないようにしとく。
	320	+ hMutex = OpenMutex(0, FALSE, W32G_MUTEX_NAME);
	321	+ if (hMutex) {
	322	+ CloseHandle(hMutex);
	323	+ return 0;
	324	+ }
	325	+ w32g_syn.hMutex = CreateMutex(NULL, TRUE, W32G_MUTEX_NAME);
	326	+ if (!w32g_syn.hMutex) {
	327	+ return 0;
	328	+ }
332	329
333		- CmdLineToArgv(lpCmdLine, &w32g_syn.argc, &w32g_syn.argv);
	330	+ CmdLineToArgv(lpCmdLine, &w32g_syn.argc, &w32g_syn.argv);
334	331
335	332	#ifdef TWSYNSRV
336		- // Service install and uninstall handling
337		- for (i = 1; i < w32g_syn.argc; i++)
338		- {
339		- if (!stricmp(w32g_syn.argv[i], "/QUIET"))
340		- {
341		- quietInstaller = TRUE;
342		- }
343		- else if (!stricmp(w32g_syn.argv[i], "/VERBOSE"))
344		- {
345		- quietInstaller = FALSE;
346		- }
347		- else if (!stricmp(w32g_syn.argv[i], "/INSTALL"))
348		- {
349		- InstallService();
	333	+ // Service install and uninstall handling
	334	+ for (i = 1; i < w32g_syn.argc; i++)
	335	+ {
	336	+ if (!stricmp(w32g_syn.argv[i], "/INSTALL"))
	337	+ {
	338	+ InstallService();
350	339
351		- ReleaseMutex(w32g_syn.hMutex);
352		- CloseHandle(w32g_syn.hMutex);
	340	+ ReleaseMutex(w32g_syn.hMutex);
	341	+ CloseHandle(w32g_syn.hMutex);
353	342
354		- return 0;
355		- }
356		- else if (!stricmp(w32g_syn.argv[i], "/UNINSTALL"))
357		- {
358		- UninstallService();
	343	+ return 0;
	344	+ }
	345	+ else if (!stricmp(w32g_syn.argv[i], "/UNINSTALL"))
	346	+ {
	347	+ UninstallService();
359	348
360		- ReleaseMutex(w32g_syn.hMutex);
361		- CloseHandle(w32g_syn.hMutex);
	349	+ ReleaseMutex(w32g_syn.hMutex);
	350	+ CloseHandle(w32g_syn.hMutex);
362	351
363		- return 0;
364		- }
365		- }
	352	+ return 0;
	353	+ }
	354	+ }
366	355	#endif /* TWSYNSRV */
367	356
368		-// wrdt = wrdt_list[0];
369		-
370		- hInst = hInstance;
371		- w32g_syn.gui_hThread = GetCurrentThread();
372		- w32g_syn.gui_dwThreadId = GetCurrentThreadId();
373		- w32g_syn.quit_state = 0;
374		-
375		- w32g_syn_main();
376		-
377		- for (i = 0; i < w32g_syn.argc; i++) {
378		- safe_free(w32g_syn.argv[i]);
379		- }
380		- safe_free(w32g_syn.argv);
381		- w32g_syn.argv = NULL;
382		- w32g_syn.argc = 0;
383		-
384		- ReleaseMutex(w32g_syn.hMutex);
385		- CloseHandle(w32g_syn.hMutex);
386		-
387		- if (RestartTimidity) {
388		- PROCESS_INFORMATION pi;
389		- STARTUPINFO si;
390		- CHAR path[FILEPATH_MAX];
391		- path[0] = '\0';
392		- RestartTimidity = 0;
393		- ZeroMemory(&si, sizeof(si));
394		- si.cb = sizeof(si);
395		- GetModuleFileNameA(hInstance, path, MAX_PATH);
396		- if (CreateProcessA(path, lpCmdLine, NULL, NULL, TRUE, CREATE_DEFAULT_ERROR_MODE, NULL, NULL, &si, &pi) == FALSE)
397		- MessageBox(NULL, TEXT("Restart Error."), TEXT("TiMidity++ Synth Win32GUI"), MB_OK \| MB_ICONEXCLAMATION);
398		- }
399		- return 0;
	357	+// wrdt = wrdt_list[0];
	358	+
	359	+ hInst = hInstance;
	360	+ w32g_syn.gui_hThread = GetCurrentThread();
	361	+ w32g_syn.gui_dwThreadId = GetCurrentThreadId();
	362	+ w32g_syn.quit_state = 0;
	363	+
	364	+ w32g_syn_main();
	365	+
	366	+ for (i = 0; i < w32g_syn.argc; i++) {
	367	+ safe_free(w32g_syn.argv[i]);
	368	+ }
	369	+ safe_free(w32g_syn.argv);
	370	+ w32g_syn.argv = NULL;
	371	+ w32g_syn.argc = 0;
	372	+
	373	+ ReleaseMutex(w32g_syn.hMutex);
	374	+ CloseHandle(w32g_syn.hMutex);
	375	+
	376	+ if(RestartTimidity){
	377	+ PROCESS_INFORMATION pi;
	378	+ STARTUPINFO si;
	379	+ CHAR path[FILEPATH_MAX] = "";
	380	+ RestartTimidity = 0;
	381	+ memset(&si, 0, sizeof(si));
	382	+ si.cb = sizeof(si);
	383	+ GetModuleFileName(hInstance, path, MAX_PATH);
	384	+ if(CreateProcess(path, lpCmdLine, NULL, NULL, TRUE, CREATE_DEFAULT_ERROR_MODE, NULL, NULL, &si, &pi) == FALSE)
	385	+ MessageBox(NULL, "Restart Error.", "TiMidity++ Synth Win32GUI", MB_OK \| MB_ICONEXCLAMATION);
	386	+ }
	387	+ return 0;
400	388	}
401	389
402	390	#ifndef TWSYNSRV

		@@ -405,29 +393,29 @@ WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
405	393
406	394	static int w32g_syn_create_win(void)
407	395	{
408		- WNDCLASSEX wndclass;
409		- wndclass.cbSize = sizeof(WNDCLASSEX);
410		- wndclass.style = CS_HREDRAW \| CS_VREDRAW;
411		- wndclass.lpfnWndProc = SynWinProc;
412		- wndclass.cbClsExtra = 0;
413		- wndclass.cbWndExtra = 0;
414		- wndclass.hInstance = hInst;
415		- wndclass.hIcon = w32g_syn.hIcon;
416		- wndclass.hIconSm = w32g_syn.hIcon;
417		- wndclass.hCursor = LoadCursor(0, IDC_ARROW);
418		- wndclass.hbrBackground = (HBRUSH)(COLOR_SCROLLBAR + 1);
419		- wndclass.lpszMenuName = NULL;
420		- wndclass.lpszClassName = W32G_SYNWIN_CLASSNAME;
421		- RegisterClassEx(&wndclass);
422		- w32g_syn.nid_hWnd = CreateWindowEx(WS_EX_TOOLWINDOW, W32G_SYNWIN_CLASSNAME, 0,
423		- WS_CLIPCHILDREN,
424		- CW_USEDEFAULT, 0, 10, 10, 0, 0, hInst, 0);
425		- if (!w32g_syn.nid_hWnd) {
426		- return -1;
427		- }
428		- ShowWindow(w32g_syn.nid_hWnd, SW_HIDE);
429		- UpdateWindow(w32g_syn.nid_hWnd); // 必要ないと思うんだけど。
430		- return 0;
	396	+ WNDCLASSEX wndclass;
	397	+ wndclass.cbSize = sizeof(WNDCLASSEX);
	398	+ wndclass.style = CS_HREDRAW \| CS_VREDRAW;
	399	+ wndclass.lpfnWndProc = SynWinProc;
	400	+ wndclass.cbClsExtra = 0;
	401	+ wndclass.cbWndExtra = 0;
	402	+ wndclass.hInstance = hInst;
	403	+ wndclass.hIcon = w32g_syn.hIcon;
	404	+ wndclass.hIconSm = w32g_syn.hIcon;
	405	+ wndclass.hCursor = LoadCursor(0, IDC_ARROW);
	406	+ wndclass.hbrBackground = (HBRUSH)(COLOR_SCROLLBAR + 1);
	407	+ wndclass.lpszMenuName = NULL;
	408	+ wndclass.lpszClassName = W32G_SYNWIN_CLASSNAME;
	409	+ RegisterClassEx(&wndclass);
	410	+ w32g_syn.nid_hWnd = CreateWindowEx(WS_EX_TOOLWINDOW, W32G_SYNWIN_CLASSNAME, 0,
	411	+ WS_CLIPCHILDREN,
	412	+ CW_USEDEFAULT, 0, 10, 10, 0, 0, hInst, 0);
	413	+ if (!w32g_syn.nid_hWnd) {
	414	+ return -1;
	415	+ }
	416	+ ShowWindow(w32g_syn.nid_hWnd, SW_HIDE);
	417	+ UpdateWindow(w32g_syn.nid_hWnd); // 必要ないと思うんだけど。
	418	+ return 0;
431	419	}
432	420
433	421	// return

		@@ -435,128 +423,119 @@ static int w32g_syn_create_win(void)
435	423	// -1 : FATAL ERROR
436	424	static int w32g_syn_main(void)
437	425	{
438		- int i;
439		- MSG msg;
440		-
441		- InitCommonControls();
442		-
443		- w32g_syn.nid_uID = W32G_SYN_NID_UID;
444		- w32g_syn.nid_hWnd = NULL;
445		- w32g_syn.hIcon = LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_TIMIDITY), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
446		- w32g_syn.hIconStart = LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_SERVER_START), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
447		- w32g_syn.hIconPause = LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_SERVER_PAUSE), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
448		-// processPriority = NORMAL_PRIORITY_CLASS;
449		-// syn_ThreadPriority = THREAD_PRIORITY_NORMAL;
450		- for (i = 0; i < MAX_PORT; i++) {
451		- w32g_syn_id_port[i] = i + 1;
452		- }
453		-
454		- if (w32g_syn_create_win()) {
455		- MessageBox(NULL, TEXT("Fatal Error"), TEXT("TWSYNG32 ERROR"), MB_OK);
456		- return -1;
457		- }
458		-
459		- while (GetMessage(&msg, NULL, 0, 0)) {
460		- if (msg.message == MYWM_QUIT) {
461		- if (w32g_syn.quit_state < 1) w32g_syn.quit_state = 1;
462		- if (hConsoleWnd) {
463		- DestroyWindow(hConsoleWnd);
464		- hConsoleWnd = NULL;
465		- }
466		- DestroyWindow(w32g_syn.nid_hWnd);
467		- w32g_syn.nid_hWnd = NULL;
468		- }
469		- TranslateMessage(&msg);
470		- DispatchMessage(&msg);
471		- }
472		-
473		- while (w32g_syn.quit_state < 2) {
474		- Sleep(300);
475		- }
476		-
477		- return 0;
	426	+ int i;
	427	+ MSG msg;
	428	+
	429	+ InitCommonControls();
	430	+
	431	+ w32g_syn.nid_uID = W32G_SYN_NID_UID;
	432	+ w32g_syn.nid_hWnd = NULL;
	433	+ w32g_syn.hIcon = LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_TIMIDITY), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
	434	+ w32g_syn.hIconStart = LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_SERVER_START), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
	435	+ w32g_syn.hIconPause = LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_SERVER_PAUSE), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
	436	+// processPriority = NORMAL_PRIORITY_CLASS;
	437	+// syn_ThreadPriority = THREAD_PRIORITY_NORMAL;
	438	+ for (i = 0; i < MAX_PORT; i++) {
	439	+ w32g_syn_id_port[i] = i + 1;
	440	+ }
	441	+
	442	+ if (w32g_syn_create_win()) {
	443	+ MessageBox(NULL, TEXT("Fatal Error"), TEXT("ERROR"), MB_OK);
	444	+ return -1;
	445	+ }
	446	+
	447	+ while (GetMessage(&msg, NULL, 0, 0)) {
	448	+ if (msg.message == MYWM_QUIT) {
	449	+ if (w32g_syn.quit_state < 1) w32g_syn.quit_state = 1;
	450	+ if (hConsoleWnd) {
	451	+ DestroyWindow(hConsoleWnd);
	452	+ hConsoleWnd = NULL;
	453	+ }
	454	+ DestroyWindow(w32g_syn.nid_hWnd);
	455	+ w32g_syn.nid_hWnd = NULL;
	456	+ }
	457	+ TranslateMessage(&msg);
	458	+ DispatchMessage(&msg);
	459	+ }
	460	+
	461	+ while (w32g_syn.quit_state < 2) {
	462	+ Sleep(300);
	463	+ }
	464	+
	465	+ return 0;
478	466	}
479	467
480	468	static VOID CALLBACK forced_exit(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime)
481	469	{
482		- exit(0);
	470	+ exit(0);
483	471	}
484	472
485	473	// Add the icon into the status area of the task bar.
486	474	BOOL AddTasktrayIcon(HWND hwnd)
487	475	{
488		- const int timeout = 5000;
489		- const int w = 200;
490		- const int c = timeout / w;
491		- BOOL bRes;
492		- NOTIFYICONDATAA nid;
493		- int i;
494		- nid.cbSize = sizeof(NOTIFYICONDATAA);
495		- nid.hWnd = w32g_syn.nid_hWnd = hwnd;
496		- nid.uID = w32g_syn.nid_uID;
497		- nid.uFlags = NIF_MESSAGE \| NIF_ICON \| NIF_TIP;
498		- nid.uCallbackMessage = MYWM_NOTIFYICON;
499		- nid.hIcon = w32g_syn_status == run ? w32g_syn.hIconStart : w32g_syn.hIconPause;
500		- strcpy(nid.szTip, W32G_SYN_TIP);
501		- for (i = 1; i <= c; i++) {
502		- bRes = Shell_NotifyIconA(NIM_ADD, &nid);
503		- if (bRes != FALSE \|\| GetLastError() != ERROR_TIMEOUT) {
504		- break;
505		- }
506		- if (Shell_NotifyIconA(NIM_MODIFY, &nid)) {
507		- break;
508		- }
509		- Sleep(w);
510		- }
511		- return bRes != FALSE;
	476	+ BOOL bRes;
	477	+ NOTIFYICONDATAA nid;
	478	+ int i;
	479	+ nid.cbSize = sizeof(NOTIFYICONDATAA);
	480	+ nid.hWnd = w32g_syn.nid_hWnd = hwnd;
	481	+ nid.uID = w32g_syn.nid_uID;
	482	+ nid.uFlags = NIF_MESSAGE \| NIF_ICON \| NIF_TIP;
	483	+ nid.uCallbackMessage = MYWM_NOTIFYICON;
	484	+ nid.hIcon = w32g_syn_status == run ? w32g_syn.hIconStart : w32g_syn.hIconPause;
	485	+ strcpy(nid.szTip, W32G_SYN_TIP);
	486	+ for (i = 1; i <= 20; i++) {
	487	+ bRes = Shell_NotifyIconA(NIM_ADD, &nid);
	488	+ if (bRes != FALSE \|\| GetLastError() != ERROR_TIMEOUT) {
	489	+ break;
	490	+ }
	491	+ if (Shell_NotifyIconA(NIM_MODIFY, &nid)) {
	492	+ break;
	493	+ }
	494	+ Sleep(100);
	495	+ }
	496	+ return bRes != FALSE;
512	497	}
513	498
514	499	// Delete the icon from the status area of the task bar.
515	500	void DeleteTasktrayIcon(HWND hwnd)
516	501	{
517		- const int timeout = 3000;
518		- const int w = 200;
519		- const int c = timeout / w;
520		- BOOL bRes;
521		- NOTIFYICONDATAA nid;
522		- int i;
523		- nid.cbSize = sizeof(NOTIFYICONDATAA);
524		- nid.hWnd = w32g_syn.nid_hWnd;
525		- nid.uID = w32g_syn.nid_uID;
526		- nid.uFlags = 0;
527		- for (i = 1; i <= c; i++) {
528		- bRes = Shell_NotifyIconA(NIM_DELETE, &nid);
529		- if (bRes == TRUE)
530		- break;
531		- Sleep(w);
532		- }
533		- if (i >= c) {
534		- MessageBox(NULL, TEXT("Fatal Error"), TEXT("TWSYNG32 ERROR"), MB_OK);
535		- }
	502	+ BOOL bRes;
	503	+ NOTIFYICONDATAA nid;
	504	+ int i;
	505	+ nid.cbSize = sizeof(NOTIFYICONDATAA);
	506	+ nid.hWnd = w32g_syn.nid_hWnd;
	507	+ nid.uID = w32g_syn.nid_uID;
	508	+ nid.uFlags = 0;
	509	+ for (i = 1; i <= 20; i++) {
	510	+ bRes = Shell_NotifyIconA(NIM_DELETE, &nid);
	511	+ if (bRes == TRUE)
	512	+ break;
	513	+ if (i >= 20) {
	514	+ MessageBox(NULL, TEXT("Fatal Error"), TEXT("ERROR"), MB_OK);
	515	+ }
	516	+ Sleep(100);
	517	+ }
536	518	}
537	519
538	520	void ChangeTasktrayIcon(HWND hwnd)
539	521	{
540		- const int timeout = 3000;
541		- const int w = 200;
542		- const int c = timeout / w;
543		- BOOL bRes;
544		- NOTIFYICONDATAA nid;
545		- int i;
546		- nid.cbSize = sizeof(NOTIFYICONDATAA);
547		- nid.hWnd = w32g_syn.nid_hWnd = hwnd;
548		- nid.uID = w32g_syn.nid_uID;
549		- nid.uFlags = NIF_ICON;
550		- nid.hIcon = w32g_syn_status == run ? w32g_syn.hIconStart : w32g_syn.hIconPause;
551		- strcpy(nid.szTip, W32G_SYN_TIP);
552		- for (i = 1; i <= c; i++) {
553		- bRes = Shell_NotifyIconA(NIM_MODIFY, &nid);
554		- if (bRes != FALSE \|\| GetLastError() != ERROR_TIMEOUT) {
555		- break;
556		- }
557		- Sleep(w);
558		- }
559		- return;
	522	+ BOOL bRes;
	523	+ NOTIFYICONDATAA nid;
	524	+ int i;
	525	+ nid.cbSize = sizeof(NOTIFYICONDATAA);
	526	+ nid.hWnd = w32g_syn.nid_hWnd = hwnd;
	527	+ nid.uID = w32g_syn.nid_uID;
	528	+ nid.uFlags = NIF_ICON;
	529	+ nid.hIcon = w32g_syn_status == run ? w32g_syn.hIconStart : w32g_syn.hIconPause;
	530	+ strcpy(nid.szTip, W32G_SYN_TIP);
	531	+ for (i = 1; i <= 20; i++) {
	532	+ bRes = Shell_NotifyIconA(NIM_MODIFY, &nid);
	533	+ if (bRes != FALSE \|\| GetLastError() != ERROR_TIMEOUT) {
	534	+ break;
	535	+ }
	536	+ Sleep(100);
	537	+ }
	538	+ return;
560	539	}
561	540
562	541	static const int system_mode_list_num = 8;

		@@ -648,7 +627,7 @@ static const int syn_thread_priority_num[] = {
648	627	THREAD_PRIORITY_TIME_CRITICAL
649	628	};
650	629	static const TCHAR *syn_thread_priority_name_jp[] = {
651		- TEXT("アイドル"),
	630	+ TEXT("アイドル"),
652	631	TEXT("低い"),
653	632	TEXT("少し低い"),
654	633	TEXT("普通"),

		@@ -657,7 +636,7 @@ static const TCHAR *syn_thread_priority_name_jp[] = {
657	636	TEXT("タイムクリティカル")
658	637	};
659	638	static const TCHAR *syn_thread_priority_name_en[] = {
660		- TEXT("idle"),
	639	+ TEXT("idle"),
661	640	TEXT("lowest"),
662	641	TEXT("below normal"),
663	642	TEXT("normal"),

		@@ -666,442 +645,413 @@ static const TCHAR *syn_thread_priority_name_en[] = {
666	645	TEXT("time critical")
667	646	};
668	647
669		-static INT_PTR CALLBACK
	648	+static LRESULT CALLBACK
670	649	SynWinProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam)
671	650	{
672		- static int have_popupmenu = 0;
673		- static UINT TaskbarCreatedMsg;
674		- switch (uMess) {
675		- case WM_CREATE:
676		- TaskbarCreatedMsg = RegisterWindowMessage(TEXT("TaskbarCreated"));
677		- if (AddTasktrayIcon(hwnd) == FALSE) {
678		- MessageBox(NULL, TEXT("Fatal Error"), TEXT("TWSYNG32 ERROR"), MB_OK);
679		- DestroyWindow(hwnd);
680		- PostQuitMessage(0);
681		- return -1;
682		- }
	651	+ static int have_popupmenu = 0;
	652	+ switch (uMess) {
	653	+ case WM_CREATE:
	654	+ if (AddTasktrayIcon(hwnd) == FALSE) {
	655	+ MessageBox(NULL, TEXT("Fatal Error"), TEXT("ERROR"), MB_OK);
	656	+ DestroyWindow(hwnd);
	657	+ PostQuitMessage(0);
	658	+ return -1;
	659	+ }
683	660	#ifdef USE_TWSYN_BRIDGE
684		- init_bridge();
	661	+ init_bridge();
685	662	#endif
686	663	#ifdef VST_LOADER_ENABLE
687		- if (!hVSTHost) {
688		- w32_reset_dll_directory();
689		- hVSTHost = LoadLibraryA(VST_LIBRARY_NAME);
690		- if (hVSTHost) {
691		- ((vst_open) GetProcAddress(hVSTHost, "vstOpen"))();
692		- //((vst_open_config_all) GetProcAddress(hVSTHost, "openEffectEditorAll"))(hwnd);
693		- }
694		- }
	664	+ if (!hVSTHost) {
	665	+#ifdef _WIN64
	666	+ hVSTHost = LoadLibrary(TEXT("timvstwrap_x64.dll"));
	667	+#else
	668	+ hVSTHost = LoadLibrary(TEXT("timvstwrap.dll"));
	669	+#endif
	670	+ if (hVSTHost) {
	671	+ ((vst_open) GetProcAddress(hVSTHost, "vstOpen"))();
	672	+ // ((vst_open_config_all) GetProcAddress(hVSTHost, "openEffectEditorAll"))(hwnd);
	673	+ }
	674	+ }
695	675	#endif /* VST_LOADER_ENABLE */
696		- start_syn_thread();
697		- break;
698		-
699		- case WM_DESTROY: {
700		- int i;
701		- terminate_syn_thread();
	676	+ start_syn_thread();
	677	+ break;
	678	+ case WM_DESTROY:
	679	+ {
	680	+ int i;
	681	+ terminate_syn_thread();
702	682	#ifndef NDEBUG
703		- while (!wait_for_termination_of_syn_thread());
	683	+ while(!wait_for_termination_of_syn_thread());
704	684	#else
705		- /* wait 16s (0.2s * 10loop * 8loop) */
706		- for (i = 0; i < 8; i++) {
707		- if (wait_for_termination_of_syn_thread())
708		- break;
709		- }
	685	+ /* wait 16s (0.2s * 10loop * 8loop) */
	686	+ for (i = 0; i < 8; i++) {
	687	+ if (wait_for_termination_of_syn_thread())
	688	+ break;
	689	+ }
710	690	#endif
711	691	#ifdef VST_LOADER_ENABLE
712		- if (hVSTHost != NULL) {
713		- ((vst_close) GetProcAddress(hVSTHost,"vstClose"))();
714		- FreeLibrary(hVSTHost);
715		- hVSTHost = NULL;
716		- }
	692	+ if (hVSTHost != NULL) {
	693	+ ((vst_close)GetProcAddress(hVSTHost,"vstClose"))();
	694	+ FreeLibrary(hVSTHost);
	695	+ hVSTHost = NULL;
	696	+ }
717	697	#endif
718	698	#ifdef USE_TWSYN_BRIDGE
719		- close_bridge();
	699	+ close_bridge();
720	700	#endif
721		- DeleteTasktrayIcon(hwnd);
722		- PostQuitMessage(0);
723		- break; }
724		-
725		- case MYWM_NOTIFYICON:
726		- if ((UINT) wParam == w32g_syn.nid_uID) {
727		- if ((UINT) lParam == WM_RBUTTONDOWN \|\| (UINT) lParam == WM_LBUTTONDOWN) {
728		- SetTimer(hwnd, (UINT_PTR) lParam, GetDoubleClickTime(), NULL);
729		- }
730		- else if ((UINT) lParam == WM_LBUTTONDBLCLK) {
731		- KillTimer(hwnd, WM_LBUTTONDOWN);
732		- PostMessage(hwnd, (WPARAM) lParam, 0, 0);
733		- }
734		- else if ((UINT) lParam == WM_RBUTTONDBLCLK) {
735		- KillTimer(hwnd, WM_RBUTTONDOWN);
736		- PostMessage(hwnd, (WPARAM) lParam, 0, 0);
737		- }
738		- }
739		- break;
740		-
741		- case WM_LBUTTONDBLCLK:
742		- PostMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDM_PREFERENCE, 0), 0);
743		- break;
744		-
745		- case WM_RBUTTONDBLCLK:
746		- break;
747		-
748		- case WM_TIMER:
749		- KillTimer(hwnd, (UINT_PTR) wParam);
750		- if ((UINT) wParam == WM_LBUTTONDOWN \|\| (UINT) wParam == WM_RBUTTONDOWN)
	701	+ DeleteTasktrayIcon(hwnd);
	702	+ PostQuitMessage(0);
	703	+ break;
	704	+ }
	705	+ case MYWM_NOTIFYICON:
	706	+ if ((UINT)wParam == w32g_syn.nid_uID) {
	707	+ if ((UINT)lParam == WM_RBUTTONDOWN \|\| (UINT)lParam == WM_LBUTTONDOWN) {
	708	+ SetTimer(hwnd, (UINT_PTR)lParam, GetDoubleClickTime(), NULL);
	709	+ }
	710	+ else if ((UINT)lParam == WM_LBUTTONDBLCLK) {
	711	+ KillTimer(hwnd, WM_LBUTTONDOWN);
	712	+ PostMessage(hwnd, (WPARAM)lParam, 0, 0);
	713	+ }
	714	+ else if ((UINT)lParam == WM_RBUTTONDBLCLK) {
	715	+ KillTimer(hwnd, WM_RBUTTONDOWN);
	716	+ PostMessage(hwnd, (WPARAM)lParam, 0, 0);
	717	+ }
	718	+ }
	719	+ break;
	720	+ case WM_LBUTTONDBLCLK:
	721	+ PostMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDM_PREFERENCE, 0), 0);
	722	+ break;
	723	+ case WM_RBUTTONDBLCLK:
	724	+ break;
	725	+ case WM_TIMER:
	726	+ KillTimer(hwnd, (UINT_PTR)wParam);
	727	+ if ((UINT)wParam == WM_LBUTTONDOWN \|\| (UINT)wParam == WM_RBUTTONDOWN)
751	728	///r
752		- {
753		- UINT uMess = (UINT) wParam;
754		- {
755		- int i, check, flag;
756		- POINT point;
757		- HMENU hMenu, hMenuModule, hMenuReset, hMenuChange, hMenuProcessPriority, hMenuSynPriority;
758		- GetCursorPos(&point);
759		-
760		- if (have_popupmenu)
761		- break;
762		- have_popupmenu = 1;
763		-
764		- hMenu = CreatePopupMenu();
765		- hMenuModule = CreateMenu();
766		- hMenuReset = CreateMenu();
767		- hMenuChange = CreateMenu();
768		- hMenuProcessPriority = CreateMenu();
769		- hMenuSynPriority = CreateMenu();
770		- if (PlayerLanguage == LANGUAGE_JAPANESE) {
771		- if (w32g_syn_status == run) {
772		- AppendMenu(hMenu, MF_STRING, IDM_STOP, TEXT("シンセ停止(&S)"));
773		- } else if (w32g_syn_status == stop) {
774		- AppendMenu(hMenu, MF_STRING, IDM_START, TEXT("シンセ開始(&S)"));
775		- } else if (w32g_syn_status == quit) {
776		- AppendMenu(hMenu, MF_STRING \| MF_GRAYED, IDM_START, TEXT("終了中……"));
777		- }
778		- AppendMenu(hMenu, MF_STRING, IDM_SYSTEM_RESET, TEXT("システムリセット(&R)"));
	729	+ {
	730	+ UINT uMess = (UINT)wParam;
	731	+ {
	732	+ int i, check, flag;
	733	+ POINT point;
	734	+ HMENU hMenu, hMenuModule, hMenuReset, hMenuChange, hMenuProcessPriority, hMenuSynPriority;
	735	+ GetCursorPos(&point);
	736	+
	737	+ if (have_popupmenu)
	738	+ break;
	739	+ have_popupmenu = 1;
	740	+
	741	+ hMenu = CreatePopupMenu();
	742	+ hMenuModule = CreateMenu();
	743	+ hMenuReset = CreateMenu();
	744	+ hMenuChange = CreateMenu();
	745	+ hMenuProcessPriority = CreateMenu();
	746	+ hMenuSynPriority = CreateMenu();
	747	+ if (PlayerLanguage == LANGUAGE_JAPANESE) {
	748	+ if (w32g_syn_status == run) {
	749	+ AppendMenu(hMenu, MF_STRING, IDM_STOP, TEXT("シンセ停止(&S)"));
	750	+ } else if (w32g_syn_status == stop) {
	751	+ AppendMenu(hMenu, MF_STRING, IDM_START, TEXT("シンセ開始(&S)"));
	752	+ } else if (w32g_syn_status == quit) {
	753	+ AppendMenu(hMenu, MF_STRING \| MF_GRAYED, IDM_START, TEXT("終了中……"));
	754	+ }
	755	+ AppendMenu(hMenu, MF_STRING, IDM_SYSTEM_RESET, TEXT("システムリセット(&R)"));
779	756	///r
780		- for (i = 0; i < module_list_num && module_list[i].name; i++) {
781		- flag = MF_STRING;
782		- flag \|= (i > 0 && i % (module_list_num / 2) == 0) ? MF_MENUBARBREAK : 0;
783		- check = opt_default_module == module_list[i].num ? MF_CHECKED : 0;
784		- AppendMenuA(hMenuModule, flag \| check, IDM_MODULE + i, module_list[i].name);
785		- }
786		-
787		- for (i = 0; i < system_mode_list_num; i++) {
788		- check = rtsyn_system_mode == system_mode_num[i] ? MF_CHECKED : 0;
789		- if (i < system_mode_list_num - 1)
790		- AppendMenu(hMenuReset, MF_STRING \| check, IDM_SYSTEM_RESET_X + i, system_mode_name_reset_jp[i]);
791		- AppendMenu(hMenuChange, MF_STRING \| check, IDM_CHANGE_SYSTEM_X + i, system_mode_name_change_jp[i]);
792		- }
793		-
794		- for (i = 0; i < process_priority_list_num; i++) {
795		- check = processPriority == process_priority_num[i] ? MF_CHECKED : 0;
796		- AppendMenu(hMenuProcessPriority, MF_STRING \| check, IDM_PROCESS_PRIORITY + i, process_priority_name_jp[i]);
797		- if (i == 4)
798		- AppendMenu(hMenuProcessPriority, MF_SEPARATOR, 0, 0);
799		- }
800		-
801		- for (i = 0; i < syn_thread_priority_list_num; i++) {
802		- check = syn_ThreadPriority == syn_thread_priority_num[i] ? MF_CHECKED : 0;
803		- AppendMenu(hMenuSynPriority, MF_STRING \| check, IDM_SYN_THREAD_PRIORITY + i, syn_thread_priority_name_jp[i]);
804		- if (i == 4)
805		- AppendMenu(hMenuSynPriority, MF_SEPARATOR, 0, 0);
806		- }
807		-
808		- AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
809		- AppendMenu(hMenu, MF_POPUP, (UINT_PTR) hMenuReset, TEXT("各種システムリセット"));
810		- AppendMenu(hMenu, MF_POPUP, (UINT_PTR) hMenuChange, TEXT("特定のシステムへ変更"));
811		- AppendMenu(hMenu, MF_POPUP, (UINT_PTR) hMenuModule, TEXT("特定の音源モードへ変更"));
812		-
813		- if (uMess != WM_LBUTTONDOWN) {
814		- AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
815		- AppendMenu(hMenu, MF_POPUP, (UINT_PTR) hMenuProcessPriority, TEXT("プロセスプライオリティ設定"));
816		- AppendMenu(hMenu, MF_POPUP, (UINT_PTR) hMenuSynPriority, TEXT("シンセスレッドプライオリティ設定"));
817		- AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
818		- AppendMenu(hMenu, MF_STRING, IDM_PREFERENCE, TEXT("設定(&P)..."));
	757	+ for (i = 0; i < module_list_num && module_list[i].name; i++) {
	758	+ flag = MF_STRING;
	759	+ flag \|= (i > 0 && i % (module_list_num / 2) == 0) ? MF_MENUBARBREAK : 0;
	760	+ check = opt_default_module == module_list[i].num ? MF_CHECKED : 0;
	761	+ AppendMenuA(hMenuModule, flag \| check, IDM_MODULE + i, module_list[i].name);
	762	+ }
	763	+
	764	+ for (i = 0; i < system_mode_list_num; i++) {
	765	+ check = rtsyn_system_mode == system_mode_num[i] ? MF_CHECKED : 0;
	766	+ if (i < system_mode_list_num - 1)
	767	+ AppendMenu(hMenuReset, MF_STRING \| check, IDM_SYSTEM_RESET_X + i, system_mode_name_reset_jp[i]);
	768	+ AppendMenu(hMenuChange, MF_STRING \| check, IDM_CHANGE_SYSTEM_X + i, system_mode_name_change_jp[i]);
	769	+ }
	770	+
	771	+ for (i = 0; i < process_priority_list_num; i++) {
	772	+ check = processPriority == process_priority_num[i] ? MF_CHECKED : 0;
	773	+ AppendMenu(hMenuProcessPriority, MF_STRING \| check, IDM_PROCESS_PRIORITY + i, process_priority_name_jp[i]);
	774	+ if (i == 4)
	775	+ AppendMenu(hMenuProcessPriority, MF_SEPARATOR, 0, 0);
	776	+ }
	777	+
	778	+ for (i = 0; i < syn_thread_priority_list_num; i++) {
	779	+ check = syn_ThreadPriority == syn_thread_priority_num[i] ? MF_CHECKED : 0;
	780	+ AppendMenu(hMenuSynPriority, MF_STRING \| check, IDM_SYN_THREAD_PRIORITY + i, syn_thread_priority_name_jp[i]);
	781	+ if (i == 4)
	782	+ AppendMenu(hMenuSynPriority, MF_SEPARATOR, 0, 0);
	783	+ }
	784	+
	785	+ AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
	786	+ AppendMenu(hMenu, MF_POPUP, (UINT)hMenuReset, TEXT("各種システムリセット"));
	787	+ AppendMenu(hMenu, MF_POPUP, (UINT)hMenuChange, TEXT("特定のシステムへ変更"));
	788	+ AppendMenu(hMenu, MF_POPUP, (UINT)hMenuModule, TEXT("特定の音源モードへ変更"));
	789	+
	790	+ if (uMess != WM_LBUTTONDOWN) {
	791	+ AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
	792	+ AppendMenu(hMenu, MF_POPUP, (UINT)hMenuProcessPriority, TEXT("プロセスプライオリティ設定"));
	793	+ AppendMenu(hMenu, MF_POPUP, (UINT)hMenuSynPriority, TEXT("シンセスレッドプライオリティ設定"));
	794	+ AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
	795	+ AppendMenu(hMenu, MF_STRING, IDM_PREFERENCE, TEXT("設定(&P)..."));
819	796	#ifdef HAVE_SYN_CONSOLE
820		- AppendMenu(hMenu, MF_STRING, IDM_CONSOLE_WND, TEXT("コン\x83\x5Cール(&C)")); // コンソール
	797	+ AppendMenu(hMenu, MF_STRING, IDM_CONSOLE_WND, TEXT("コン\x83\x5Cール(&C)")); // コンソール
821	798	#endif /* HAVE_SYN_CONSOLE */
822	799	///r
823	800	#ifdef VST_LOADER_ENABLE
824		- AppendMenu(hMenu, MF_STRING, IDM_VSTMGR_WND, TEXT("VSTマネージャ(&V)"));
	801	+ AppendMenu(hMenu, MF_STRING, IDM_VSTMGR_WND, TEXT("VSTマネージャ(&V)"));
825	802	#endif /* VST_LOADER_ENABLE */
826	803	#ifdef HAVE_SYN_SOUNDSPEC
827		- AppendMenu(hMenu, MF_STRING, IDM_MWSOUNDSPEC, TEXT("スペクトログラム(&O)"));
	804	+ AppendMenu(hMenu, MF_STRING, IDM_MWSOUNDSPEC, TEXT("スペクトログラム(&O)"));
828	805	#endif /* HAVE_SYN_SOUNDSPEC */
829	806	#ifdef INT_SYNTH
830		- AppendMenu(hMenu, MF_STRING, IDM_ISEDITOR_WND, TEXT("内蔵シンセエディタ"));
	807	+ AppendMenu(hMenu, MF_STRING, IDM_ISEDITOR_WND, TEXT("内蔵シンセエディタ"));
831	808	#endif /* INT_SYNTH */
832		- AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
833		- AppendMenu(hMenu, MF_STRING, IDM_VERSION, TEXT("バージョン情報"));
834		- AppendMenu(hMenu, MF_STRING, IDM_TIMIDITY, TEXT("TiMidity++ について(&A)"));
835		- AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
836		- AppendMenu(hMenu, MF_STRING, IDM_RESTART, TEXT("再起動(&R)"));
837		- AppendMenu(hMenu, MF_STRING, IDM_QUIT, TEXT("終了(&X)"));
838		- }
839		- } else {
840		- if (w32g_syn_status == run) {
841		- AppendMenu(hMenu, MF_STRING, IDM_STOP, TEXT("&Stop synthesizer"));
842		- } else if (w32g_syn_status == stop) {
843		- AppendMenu(hMenu, MF_STRING, IDM_START, TEXT("&Start synthesizer"));
844		- } else if (w32g_syn_status == quit) {
845		- AppendMenu(hMenu, MF_STRING \| MF_GRAYED, IDM_START, TEXT("Quitting..."));
846		- }
847		- AppendMenu(hMenu, MF_STRING, IDM_SYSTEM_RESET, TEXT("System &Reset"));
	809	+ AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
	810	+ AppendMenu(hMenu, MF_STRING, IDM_VERSION, TEXT("バージョン情報"));
	811	+ AppendMenu(hMenu, MF_STRING, IDM_TIMIDITY, TEXT("TiMidity++ について(&A)"));
	812	+ AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
	813	+ AppendMenu(hMenu, MF_STRING, IDM_RESTART, TEXT("再起動(&R)"));
	814	+ AppendMenu(hMenu, MF_STRING, IDM_QUIT, TEXT("終了(&X)"));
	815	+ }
	816	+ } else {
	817	+ if (w32g_syn_status == run) {
	818	+ AppendMenu(hMenu, MF_STRING, IDM_STOP, TEXT("&Stop synthesizer"));
	819	+ } else if (w32g_syn_status == stop) {
	820	+ AppendMenu(hMenu, MF_STRING, IDM_START, TEXT("&Start synthesizer"));
	821	+ } else if (w32g_syn_status == quit) {
	822	+ AppendMenu(hMenu, MF_STRING \| MF_GRAYED, IDM_START, TEXT("Quitting..."));
	823	+ }
	824	+ AppendMenu(hMenu, MF_STRING, IDM_SYSTEM_RESET, TEXT("System &Reset"));
848	825	///r
849		- for (i = 0; i < module_list_num && module_list[i].name; i++) {
850		- flag = MF_STRING;
851		- flag \|= (i > 0 && i % (module_list_num / 2) == 0) ? MF_MENUBARBREAK : 0;
852		- check = opt_default_module == module_list[i].num ? MF_CHECKED : 0;
853		- AppendMenuA(hMenuModule, flag \| check, IDM_MODULE + i, module_list[i].name);
854		- }
855		-
856		- for (i = 0; i < system_mode_list_num; i++) {
857		- check = rtsyn_system_mode == system_mode_num[i] ? MF_CHECKED : 0;
858		- if (i < system_mode_list_num - 1)
859		- AppendMenu(hMenuReset, MF_STRING \| check, IDM_SYSTEM_RESET_X + i, system_mode_name_reset_en[i]);
860		- AppendMenu(hMenuChange, MF_STRING \| check, IDM_CHANGE_SYSTEM_X + i, system_mode_name_change_en[i]);
861		- }
862		-
863		- for (i = 0; i < process_priority_list_num; i++) {
864		- check = processPriority == process_priority_num[i] ? MF_CHECKED : 0;
865		- AppendMenu(hMenuProcessPriority, MF_STRING \| check, IDM_PROCESS_PRIORITY + i, process_priority_name_en[i]);
866		- if (i == 4)
867		- AppendMenu(hMenuProcessPriority, MF_SEPARATOR, 0, 0);
868		- }
869		-
870		- for (i = 0; i < syn_thread_priority_list_num; i++) {
871		- check = syn_ThreadPriority == syn_thread_priority_num[i] ? MF_CHECKED : 0;
872		- AppendMenu(hMenuSynPriority, MF_STRING \| check, IDM_SYN_THREAD_PRIORITY + i, syn_thread_priority_name_en[i]);
873		- if (i == 4)
874		- AppendMenu(hMenuSynPriority, MF_SEPARATOR, 0, 0);
875		- }
876		-
877		- AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
878		- AppendMenu(hMenu, MF_POPUP, (UINT_PTR) hMenuReset, TEXT("Specific system reset"));
879		- AppendMenu(hMenu, MF_POPUP, (UINT_PTR) hMenuChange, TEXT("Change Specific system"));
880		- AppendMenu(hMenu, MF_POPUP, (UINT_PTR) hMenuModule, TEXT("Change Specific Module"));
881		-
882		- if (uMess != WM_LBUTTONDOWN) {
883		- AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
884		- AppendMenu(hMenu, MF_POPUP, (UINT_PTR) hMenuProcessPriority, TEXT("Change process priority"));
885		- AppendMenu(hMenu, MF_POPUP, (UINT_PTR) hMenuSynPriority, TEXT("Change synthesizer thread priority"));
886		- AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
887		- AppendMenu(hMenu, MF_STRING, IDM_PREFERENCE, TEXT("&Preferences..."));
	826	+ for (i = 0; i < module_list_num && module_list[i].name; i++) {
	827	+ flag = MF_STRING;
	828	+ flag \|= (i > 0 && i % (module_list_num / 2) == 0) ? MF_MENUBARBREAK : 0;
	829	+ check = opt_default_module == module_list[i].num ? MF_CHECKED : 0;
	830	+ AppendMenuA(hMenuModule, flag \| check, IDM_MODULE + i, module_list[i].name);
	831	+ }
	832	+
	833	+ for (i = 0; i < system_mode_list_num; i++) {
	834	+ check = rtsyn_system_mode == system_mode_num[i] ? MF_CHECKED : 0;
	835	+ if (i < system_mode_list_num - 1)
	836	+ AppendMenu(hMenuReset, MF_STRING \| check, IDM_SYSTEM_RESET_X + i, system_mode_name_reset_en[i]);
	837	+ AppendMenu(hMenuChange, MF_STRING \| check, IDM_CHANGE_SYSTEM_X + i, system_mode_name_change_en[i]);
	838	+ }
	839	+
	840	+ for (i = 0; i < process_priority_list_num; i++) {
	841	+ check = processPriority == process_priority_num[i] ? MF_CHECKED : 0;
	842	+ AppendMenu(hMenuProcessPriority, MF_STRING \| check, IDM_PROCESS_PRIORITY + i, process_priority_name_en[i]);
	843	+ if (i == 4)
	844	+ AppendMenu(hMenuProcessPriority, MF_SEPARATOR, 0, 0);
	845	+ }
	846	+
	847	+ for (i = 0; i < syn_thread_priority_list_num; i++) {
	848	+ check = syn_ThreadPriority == syn_thread_priority_num[i] ? MF_CHECKED : 0;
	849	+ AppendMenu(hMenuSynPriority, MF_STRING \| check, IDM_SYN_THREAD_PRIORITY + i, syn_thread_priority_name_en[i]);
	850	+ if (i == 4)
	851	+ AppendMenu(hMenuSynPriority, MF_SEPARATOR, 0, 0);
	852	+ }
	853	+
	854	+ AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
	855	+ AppendMenu(hMenu, MF_POPUP, (UINT)hMenuReset, TEXT("Specific system reset"));
	856	+ AppendMenu(hMenu, MF_POPUP, (UINT)hMenuChange, TEXT("Change Specific system"));
	857	+ AppendMenu(hMenu, MF_POPUP, (UINT)hMenuModule, TEXT("Change Specific Module"));
	858	+
	859	+ if (uMess != WM_LBUTTONDOWN) {
	860	+ AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
	861	+ AppendMenu(hMenu, MF_POPUP, (UINT)hMenuProcessPriority, TEXT("Change process priority"));
	862	+ AppendMenu(hMenu, MF_POPUP, (UINT)hMenuSynPriority, TEXT("Change synthesizer thread priority"));
	863	+ AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
	864	+ AppendMenu(hMenu, MF_STRING, IDM_PREFERENCE, TEXT("&Preferences..."));
888	865	#ifdef HAVE_SYN_CONSOLE
889		- AppendMenu(hMenu, MF_STRING, IDM_CONSOLE_WND, TEXT("&Console"));
	866	+ AppendMenu(hMenu, MF_STRING, IDM_CONSOLE_WND, TEXT("&Console"));
890	867	#endif /* HAVE_SYN_CONSOLE */
891	868	///r
892	869	#ifdef VST_LOADER_ENABLE
893		- AppendMenu(hMenu, MF_STRING, IDM_VSTMGR_WND, TEXT("VST Manager(&V)"));
	870	+ AppendMenu(hMenu, MF_STRING, IDM_VSTMGR_WND, TEXT("VST Manager(&V)"));
894	871	#endif /* VST_LOADER_ENABLE */
895	872	#ifdef HAVE_SYN_SOUNDSPEC
896		- AppendMenu(hMenu, MF_STRING, IDM_MWSOUNDSPEC, TEXT("S&ound Spectrogram"));
	873	+ AppendMenu(hMenu, MF_STRING, IDM_MWSOUNDSPEC, TEXT("S&ound Spectrogram"));
897	874	#endif /* HAVE_SYN_SOUNDSPEC */
898	875	#ifdef INT_SYNTH
899		- AppendMenu(hMenu, MF_STRING, IDM_ISEDITOR_WND, TEXT("Internal Synthesizer Edior"));
	876	+ AppendMenu(hMenu, MF_STRING, IDM_ISEDITOR_WND, TEXT("Internal Synthesizer Edior"));
900	877	#endif /* INT_SYNTH */
901		- AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
902		- AppendMenu(hMenu, MF_STRING, IDM_VERSION, TEXT("Version Info"));
903		- AppendMenu(hMenu, MF_STRING, IDM_TIMIDITY, TEXT("&About TiMidity++"));
904		- AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
905		- AppendMenu(hMenu, MF_STRING, IDM_RESTART, TEXT("Restart(&R)"));
906		- AppendMenu(hMenu, MF_STRING, IDM_QUIT, TEXT("E&xit"));
907		- }
908		- }
909		- // ポップアップメニューがきちんと消えるための操作。
910		- // http://support.microsoft.com/default.aspx?scid = KB;EN-US;Q135788& 参照
911		-#if 0 // Win 98/2000 以降用？
912		- {
913		- DWORD dwThreadID = GetWindowThreadProcessId(hwnd, NULL);
914		- if (dwThreadID != w32g_syn.gui_dwThreadId) {
915		- AttachThreadInput(w32g_syn.gui_dwThreadId, dwThreadID, TRUE);
916		- SetForegroundWindow(hwnd);
917		- AttachThreadInput(w32g_syn.gui_dwThreadId, dwThreadID, FALSE);
918		- } else {
919		- SetForegroundWindow(hwnd);
920		- }
921		- }
922		-#else // これでいいらしい？
923		- SetForegroundWindow(hwnd);
	878	+ AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
	879	+ AppendMenu(hMenu, MF_STRING, IDM_VERSION, TEXT("Version Info"));
	880	+ AppendMenu(hMenu, MF_STRING, IDM_TIMIDITY, TEXT("&About TiMidity++"));
	881	+ AppendMenu(hMenu, MF_SEPARATOR, 0, 0);
	882	+ AppendMenu(hMenu, MF_STRING, IDM_RESTART, TEXT("Restart(&R)"));
	883	+ AppendMenu(hMenu, MF_STRING, IDM_QUIT, TEXT("E&xit"));
	884	+ }
	885	+ }
	886	+ // ポップアップメニューがきちんと消えるための操作。
	887	+ // http://support.microsoft.com/default.aspx?scid = KB;EN-US;Q135788& 参照
	888	+#if 0 // Win 98/2000 以降用？
	889	+ {
	890	+ DWORD dwThreadID = GetWindowThreadProcessId(hwnd, NULL);
	891	+ if (dwThreadID != w32g_syn.gui_dwThreadId) {
	892	+ AttachThreadInput(w32g_syn.gui_dwThreadId, dwThreadID, TRUE);
	893	+ SetForegroundWindow(hwnd);
	894	+ AttachThreadInput(w32g_syn.gui_dwThreadId, dwThreadID, FALSE);
	895	+ } else {
	896	+ SetForegroundWindow(hwnd);
	897	+ }
	898	+ }
	899	+#else // これでいいらしい？
	900	+ SetForegroundWindow(hwnd);
924	901	#endif
925		- TrackPopupMenu(hMenu, TPM_TOPALIGN \| TPM_LEFTALIGN,
926		- point.x, point.y, 0, hwnd, NULL);
927		- PostMessage(hwnd, WM_NULL, 0, 0); // これもポップアップメニューのテクニックらしい。
928		- DestroyMenu(hMenu);
929		- have_popupmenu = 0;
930		- return 0;
931		- }
932		- }
933		- break;
934		-
935		- case WM_COMMAND:
936		- switch (LOWORD(wParam)) {
937		- case IDM_RESTART:
938		- RestartTimidity = 1; // WinMain()
939		- // thru quit
940		-
941		- case IDM_QUIT:
	902	+ TrackPopupMenu(hMenu, TPM_TOPALIGN \| TPM_LEFTALIGN,
	903	+ point.x, point.y, 0, hwnd, NULL);
	904	+ PostMessage(hwnd, WM_NULL, 0, 0); // これもポップアップメニューのテクニックらしい。
	905	+ DestroyMenu(hMenu);
	906	+ have_popupmenu = 0;
	907	+ return 0;
	908	+ }
	909	+ }
	910	+ break;
	911	+ case WM_COMMAND:
	912	+ switch (LOWORD(wParam)) {
	913	+ case IDM_RESTART:
	914	+ RestartTimidity = 1; // WinMain()
	915	+ // thru quit
	916	+ case IDM_QUIT:
942	917	#if 1/* 強制終了 */
943		- /* Exit after 20 sec. */
944		- SetTimer(NULL, 0, 20000, forced_exit);
	918	+ /* Exit after 20 sec. */
	919	+ SetTimer(NULL, 0, 20000, forced_exit);
945	920	#endif
946		- w32g_message_set(W32G_SYN_QUIT);
947		- break;
948		-
949		- case IDM_START:
950		- w32g_message_set(W32G_SYN_START);
951		- break;
952		-
953		- case IDM_STOP:
954		- w32g_message_set(W32G_SYN_STOP);
955		- break;
956		-
957		- case IDM_SYSTEM_RESET:
958		- w32g_message_set(W32G_SYN_SYSTEM_RESET);
959		- break;
960		-
961		- case IDM_PREFERENCE:
962		- PrefWndCreate(w32g_syn.nid_hWnd, 0);
963		- break;
964		-
965		- case IDM_VERSION:
966		- VersionWnd(w32g_syn.nid_hWnd);
967		- break;
968		-
969		- case IDM_TIMIDITY:
970		- TiMidityWnd(w32g_syn.nid_hWnd);
971		- break;
972		-
	921	+ w32g_message_set(W32G_SYN_QUIT);
	922	+ break;
	923	+ case IDM_START:
	924	+ w32g_message_set(W32G_SYN_START);
	925	+ break;
	926	+ case IDM_STOP:
	927	+ w32g_message_set(W32G_SYN_STOP);
	928	+ break;
	929	+ case IDM_SYSTEM_RESET:
	930	+ w32g_message_set(W32G_SYN_SYSTEM_RESET);
	931	+ break;
	932	+ case IDM_PREFERENCE:
	933	+ PrefWndCreate(w32g_syn.nid_hWnd, 0);
	934	+ break;
	935	+ case IDM_VERSION:
	936	+ VersionWnd(w32g_syn.nid_hWnd);
	937	+ break;
	938	+ case IDM_TIMIDITY:
	939	+ TiMidityWnd(w32g_syn.nid_hWnd);
	940	+ break;
973	941	#ifdef HAVE_SYN_CONSOLE
974		- case IDM_CONSOLE_WND:
975		- if (!hConsoleWnd)
976		- InitConsoleWnd(w32g_syn.nid_hWnd);
977		- if (IsWindowVisible(hConsoleWnd))
978		- ShowWindow(hConsoleWnd, SW_HIDE);
979		- else
980		- ShowWindow(hConsoleWnd, SW_SHOW);
981		- break;
	942	+ case IDM_CONSOLE_WND:
	943	+ if (!hConsoleWnd)
	944	+ InitConsoleWnd(w32g_syn.nid_hWnd);
	945	+ if (IsWindowVisible(hConsoleWnd))
	946	+ ShowWindow(hConsoleWnd, SW_HIDE);
	947	+ else
	948	+ ShowWindow(hConsoleWnd, SW_SHOW);
	949	+ break;
982	950	#endif /* HAVE_SYN_CONSOLE */
983		-
984	951	///r
985	952	#ifdef VST_LOADER_ENABLE
986		- case IDM_VSTMGR_WND:
987		- if (hVSTHost)
988		- ((open_vst_mgr) GetProcAddress(hVSTHost, "openVSTManager"))(hwnd);
989		- break;
	953	+ case IDM_VSTMGR_WND:
	954	+ if (hVSTHost)
	955	+ ((open_vst_mgr) GetProcAddress(hVSTHost, "openVSTManager"))(hwnd);
	956	+ break;
990	957	#endif /* VST_LOADER_ENABLE */
991		-
992	958	#ifdef HAVE_SYN_SOUNDSPEC
993		- case IDM_MWSOUNDSPEC:
994		- if (!hSoundSpecWnd)
995		- InitSoundSpecWnd(w32g_syn.nid_hWnd);
996		- if (IsWindowVisible(hSoundSpecWnd))
997		- ShowWindow(hSoundSpecWnd, SW_HIDE);
998		- else
999		- ShowWindow(hSoundSpecWnd, SW_SHOW);
1000		- break;
	959	+ case IDM_MWSOUNDSPEC:
	960	+ if (!hSoundSpecWnd)
	961	+ InitSoundSpecWnd(w32g_syn.nid_hWnd);
	962	+ if (IsWindowVisible(hSoundSpecWnd))
	963	+ ShowWindow(hSoundSpecWnd, SW_HIDE);
	964	+ else
	965	+ ShowWindow(hSoundSpecWnd, SW_SHOW);
	966	+ break;
1001	967	#endif /* HAVE_SYN_SOUNDSPEC */
1002		-
1003	968	#ifdef INT_SYNTH
1004		- case IDM_ISEDITOR_WND:
1005		- ISEditorWndCreate(w32g_syn.nid_hWnd);
1006		- break;
	969	+ case IDM_ISEDITOR_WND:
	970	+ ISEditorWndCreate(w32g_syn.nid_hWnd);
	971	+ break;
1007	972	#endif /* INT_SYNTH */
1008		-
1009		- default:
	973	+ default:
1010	974	///r
1011		- // IDM_MODULE
1012		- if (IDM_MODULE <= LOWORD(wParam) && LOWORD(wParam) < (IDM_MODULE + module_list_num))
1013		- w32g_message_set(LOWORD(wParam) + W32G_SYN_MODULE - IDM_MODULE);
1014		- // IDM_SYSTEM_RESET_X
1015		- if (IDM_SYSTEM_RESET_X <= LOWORD(wParam) && LOWORD(wParam) < (IDM_SYSTEM_RESET_X + system_mode_list_num))
1016		- w32g_message_set(LOWORD(wParam) + W32G_SYN_SYSTEM_RESET_X - IDM_SYSTEM_RESET_X);
1017		- // IDM_SYSTEM_RESET_X
1018		- if (IDM_CHANGE_SYSTEM_X <= LOWORD(wParam) && LOWORD(wParam) < (IDM_CHANGE_SYSTEM_X + system_mode_list_num))
1019		- w32g_message_set(LOWORD(wParam) + W32G_SYN_CHANGE_SYSTEM_X - IDM_CHANGE_SYSTEM_X);
1020		-
1021		- // IDM_PROCESS_PRIORITY
1022		- if (IDM_PROCESS_PRIORITY <= LOWORD(wParam) && LOWORD(wParam) < (IDM_PROCESS_PRIORITY + process_priority_list_num)) {
1023		- processPriority = process_priority_num[LOWORD(wParam) - IDM_PROCESS_PRIORITY];
1024		- if (w32g_syn_status == run)
1025		- SetPriorityClass(GetCurrentProcess(), processPriority);
1026		- }
1027		- // IDM_SYN_THREAD_PRIORITY
1028		- if (IDM_SYN_THREAD_PRIORITY <= LOWORD(wParam) && LOWORD(wParam) < (IDM_SYN_THREAD_PRIORITY + syn_thread_priority_list_num)) {
1029		- syn_ThreadPriority = syn_thread_priority_num[LOWORD(wParam) - IDM_SYN_THREAD_PRIORITY];
1030		- if (w32g_syn_status == run)
1031		- SetThreadPriority(w32g_syn.syn_hThread, syn_ThreadPriority);
1032		- }
1033		- break;
1034		- }
1035		- break;
1036		-
1037		-#ifdef WM_POWERBROADCAST
1038		- case WM_POWERBROADCAST:
1039		- if (wParam == PBT_APMRESUMESUSPEND) {
1040		- // ToDo
	975	+ // IDM_MODULE
	976	+ if (IDM_MODULE <= LOWORD(wParam) && LOWORD(wParam) < (IDM_MODULE + module_list_num))
	977	+ w32g_message_set(LOWORD(wParam) + W32G_SYN_MODULE - IDM_MODULE);
	978	+ // IDM_SYSTEM_RESET_X
	979	+ if (IDM_SYSTEM_RESET_X <= LOWORD(wParam) && LOWORD(wParam) < (IDM_SYSTEM_RESET_X + system_mode_list_num))
	980	+ w32g_message_set(LOWORD(wParam) + W32G_SYN_SYSTEM_RESET_X - IDM_SYSTEM_RESET_X);
	981	+ // IDM_SYSTEM_RESET_X
	982	+ if (IDM_CHANGE_SYSTEM_X <= LOWORD(wParam) && LOWORD(wParam) < (IDM_CHANGE_SYSTEM_X + system_mode_list_num))
	983	+ w32g_message_set(LOWORD(wParam) + W32G_SYN_CHANGE_SYSTEM_X - IDM_CHANGE_SYSTEM_X);
	984	+
	985	+ // IDM_PROCESS_PRIORITY
	986	+ if (IDM_PROCESS_PRIORITY <= LOWORD(wParam) && LOWORD(wParam) < (IDM_PROCESS_PRIORITY + process_priority_list_num)) {
	987	+ processPriority = process_priority_num[LOWORD(wParam) - IDM_PROCESS_PRIORITY];
	988	+ if (w32g_syn_status == run)
	989	+ SetPriorityClass(GetCurrentProcess(), processPriority);
	990	+ }
	991	+ // IDM_SYN_THREAD_PRIORITY
	992	+ if (IDM_SYN_THREAD_PRIORITY <= LOWORD(wParam) && LOWORD(wParam) < (IDM_SYN_THREAD_PRIORITY + syn_thread_priority_list_num)) {
	993	+ syn_ThreadPriority = syn_thread_priority_num[LOWORD(wParam) - IDM_SYN_THREAD_PRIORITY];
	994	+ if (w32g_syn_status == run)
	995	+ SetThreadPriority(w32g_syn.syn_hThread, syn_ThreadPriority);
	996	+ }
	997	+ break;
1041	998	}
1042	999	break;
1043		-#endif /* WM_POWERBROADCAST */
1044		-
1045		- default:
1046		- if (uMess == TaskbarCreatedMsg) {
1047		- if (AddTasktrayIcon(hwnd) == FALSE) {
1048		- MessageBox(NULL, TEXT("Fatal Error"), TEXT("TWSYNG32 ERROR"), MB_OK);
1049		- DestroyWindow(hwnd);
1050		- PostQuitMessage(0);
1051		- return 0;
1052		- }
1053		- return 0;
1054		- }
1055		- return DefWindowProc(hwnd, uMess, wParam, lParam);
1056		- }
1057		- return 0L;
	1000	+ default:
	1001	+ if (uMess == RegisterWindowMessage(TEXT("TaskbarCreated"))) {
	1002	+ AddTasktrayIcon(hwnd);
	1003	+ return 0;
	1004	+ }
	1005	+ return DefWindowProc(hwnd, uMess, wParam, lParam);
	1006	+ }
	1007	+ return 0L;
1058	1008	}
1059	1009
1060	1010	static int volatile syn_thread_started = 0;
1061	1011	static int start_syn_thread(void)
1062	1012	{
1063		- w32g_syn.syn_hThread = crt_beginthreadex(NULL, 0,
1064		- (LPTHREAD_START_ROUTINE) syn_thread,
1065		- NULL, 0, &w32g_syn.syn_dwThreadId);
1066		- if (!w32g_syn.syn_hThread)
1067		- return -1;
1068		- for (;;) {
1069		- if (syn_thread_started == 1)
1070		- break;
1071		- if (syn_thread_started == 2)
1072		- return -1;
1073		- Sleep(200);
1074		- }
1075		- if (syn_thread_started == 2)
1076		- return -1;
1077		- return 0;
	1013	+ w32g_syn.syn_hThread = crt_beginthreadex(NULL, 0,
	1014	+ (LPTHREAD_START_ROUTINE) syn_thread,
	1015	+ NULL, 0, & w32g_syn.syn_dwThreadId);
	1016	+ if (!w32g_syn.syn_hThread)
	1017	+ return -1;
	1018	+ for (;;) {
	1019	+ if (syn_thread_started == 1)
	1020	+ break;
	1021	+ if (syn_thread_started == 2)
	1022	+ return -1;
	1023	+ Sleep(200);
	1024	+ }
	1025	+ if (syn_thread_started == 2)
	1026	+ return -1;
	1027	+ return 0;
1078	1028	}
1079	1029
1080	1030	static void WINAPI syn_thread(void)
1081	1031	{
1082		- syn_thread_started = 1;
1083		- win_main(w32g_syn.argc, w32g_syn.argv);
1084		- syn_thread_started = 2;
	1032	+ syn_thread_started = 1;
	1033	+ win_main(w32g_syn.argc, w32g_syn.argv);
	1034	+ syn_thread_started = 2;
1085	1035	}
1086	1036
1087	1037	static void terminate_syn_thread(void)
1088	1038	{
1089		- w32g_message_set(W32G_SYN_QUIT);
	1039	+ w32g_message_set(W32G_SYN_QUIT);
1090	1040	}
1091	1041
1092	1042	static int wait_for_termination_of_syn_thread(void)
1093	1043	{
1094		- int i;
1095		- int ok = 0;
1096		- for (i = 0; i < 10; i++) {
1097		- if (WaitForSingleObject(w32g_syn.syn_hThread, 200) == WAIT_TIMEOUT)
1098		- w32g_message_set(W32G_SYN_QUIT);
1099		- else {
1100		- ok = 1;
1101		- break;
1102		- }
1103		- }
1104		- return ok;
	1044	+ int i;
	1045	+ int ok = 0;
	1046	+ for (i = 0; i < 10; i++) {
	1047	+ if (WaitForSingleObject(w32g_syn.syn_hThread, 200) == WAIT_TIMEOUT)
	1048	+ w32g_message_set(W32G_SYN_QUIT);
	1049	+ else {
	1050	+ ok = 1;
	1051	+ break;
	1052	+ }
	1053	+ }
	1054	+ return ok;
1105	1055	}
1106	1056
1107	1057	#else // !TWSYNSRV

		@@ -1111,161 +1061,161 @@ static int wait_for_termination_of_syn_thread(void)
1111	1061	// To debug output (Require attached debugger)
1112	1062	static void OutputString(const char *format, ...)
1113	1063	{
1114		- char temp[512];
1115		- va_list va;
	1064	+ char temp[256];
	1065	+ va_list va;
1116	1066
1117		- va_start(va, format);
1118		- vsnprintf(temp, ARRAY_SIZE(temp), format, va);
1119		- OutputDebugStringA(temp);
1120		- va_end(va);
	1067	+ va_start(va, format);
	1068	+ vsnprintf(temp, sizeof(temp), format, va);
	1069	+ OutputDebugStringA(temp);
	1070	+ va_end(va);
1121	1071	}
1122	1072
1123		-void PutsConsoleWnd(const char *str)
	1073	+void PutsConsoleWnd(char *str)
1124	1074	{
1125		- OutputString("%s", str);
	1075	+ OutputString("%s", str);
1126	1076	}
1127	1077
1128	1078	// To MessageBox Window (Require grant access windowstation)
1129	1079	static void OutputWindow(const char *format, ...)
1130	1080	{
1131		- char temp[512];
1132		- va_list va;
	1081	+ char temp[256];
	1082	+ va_list va;
1133	1083
1134		- va_start(va, format);
1135		- vsnprintf(temp, ARRAY_SIZE(temp), format, va);
1136		- MessageBoxA(NULL, temp, serviceName, MB_OK \| MB_ICONEXCLAMATION);
1137		- va_end(va);
	1084	+ va_start(va, format);
	1085	+ vsnprintf(temp, sizeof(temp), format, va);
	1086	+ MessageBoxA(NULL, temp, serviceName, MB_OK \| MB_ICONEXCLAMATION);
	1087	+ va_end(va);
1138	1088	}
1139	1089
1140	1090	static void OutputLastError(const char *message)
1141	1091	{
1142		- LPVOID buffer;
1143		-
1144		- FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER \| FORMAT_MESSAGE_FROM_SYSTEM \|
1145		- FORMAT_MESSAGE_IGNORE_INSERTS,
1146		- NULL, GetLastError(),
1147		- MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
1148		- (LPSTR) &buffer, 0, NULL);
1149		- OutputDebugStringA(message);
1150		- OutputDebugStringA(" : ");
1151		- OutputDebugStringA(buffer);
1152		- OutputDebugStringA("\n");
1153		-
1154		- LocalFree(buffer);
	1092	+ LPVOID buffer;
	1093	+
	1094	+ FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER \| FORMAT_MESSAGE_FROM_SYSTEM \|
	1095	+ FORMAT_MESSAGE_IGNORE_INSERTS,
	1096	+ NULL, GetLastError(),
	1097	+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
	1098	+ (LPTSTR)&buffer, 0, NULL);
	1099	+ OutputDebugString(message);
	1100	+ OutputDebugString(" : ");
	1101	+ OutputDebugString(buffer);
	1102	+ OutputDebugString("\n");
	1103	+
	1104	+ LocalFree(buffer);
1155	1105	}
1156	1106
1157	1107	static void OutputWindowLastError(const char *message)
1158	1108	{
1159		- LPVOID buffer;
1160		- char *temp;
	1109	+ LPVOID buffer;
	1110	+ char *temp;
1161	1111
1162		- FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER \| FORMAT_MESSAGE_FROM_SYSTEM \|
1163		- FORMAT_MESSAGE_IGNORE_INSERTS,
1164		- NULL, GetLastError(),
1165		- MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
1166		- (LPSTR) &buffer, 0, NULL);
	1112	+ FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER \| FORMAT_MESSAGE_FROM_SYSTEM \|
	1113	+ FORMAT_MESSAGE_IGNORE_INSERTS,
	1114	+ NULL, GetLastError(),
	1115	+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
	1116	+ (LPTSTR)&buffer, 0, NULL);
1167	1117
1168		- temp = (char) safe_large_malloc(strlen((char) buffer) + strlen(message) + 10);
1169		- sprintf(temp, "%s : %s" NLS, message, (char*) buffer);
	1118	+ temp = (char) safe_malloc(strlen((const char)buffer) + strlen(message) + 10);
	1119	+ sprintf(temp, "%s : %s\n", message, buffer);
1170	1120
1171		- MessageBoxA(NULL, temp, serviceName, MB_OK \| MB_ICONEXCLAMATION);
	1121	+ MessageBoxA(NULL, temp, serviceName, MB_OK \| MB_ICONEXCLAMATION);
1172	1122
1173		- safe_free(temp);
1174		- LocalFree(buffer);
	1123	+ safe_free(temp);
	1124	+ LocalFree(buffer);
1175	1125	}
1176	1126
1177	1127	// Report service status to service control manager
1178	1128	static BOOL ReportStatusToSCM(DWORD newServiceStatus, DWORD checkPoint, DWORD waitHint,
1179		- DWORD win32ExitCode, DWORD serviceSpecificExitCode)
	1129	+ DWORD win32ExitCode, DWORD serviceSpecificExitCode)
1180	1130	{
1181		- BOOL result;
1182		- SERVICE_STATUS serviceStatus;
1183		-
1184		- serviceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
1185		- currentServiceStatus = newServiceStatus;
1186		- serviceStatus.dwCurrentState = newServiceStatus;
1187		- serviceStatus.dwCheckPoint = checkPoint;
1188		- serviceStatus.dwWaitHint = waitHint;
1189		- serviceStatus.dwWin32ExitCode = win32ExitCode;
1190		- serviceStatus.dwServiceSpecificExitCode = serviceSpecificExitCode;
1191		- if (newServiceStatus == SERVICE_START_PENDING) {
1192		- serviceStatus.dwControlsAccepted = 0;
1193		- }
1194		- else {
1195		- serviceStatus.dwControlsAccepted =
1196		- SERVICE_ACCEPT_STOP \| SERVICE_ACCEPT_PAUSE_CONTINUE \| SERVICE_ACCEPT_PARAMCHANGE;
1197		- }
1198		- result = SetServiceStatus(serviceStatusHandle, &serviceStatus);
1199		- if (result == FALSE) {
1200		- OutputLastError("ReportStatusToSCM() == FALSE");
1201		- }
1202		- return result;
	1131	+ BOOL result;
	1132	+ SERVICE_STATUS serviceStatus;
	1133	+
	1134	+ serviceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
	1135	+ currentServiceStatus = newServiceStatus;
	1136	+ serviceStatus.dwCurrentState = newServiceStatus;
	1137	+ serviceStatus.dwCheckPoint = checkPoint;
	1138	+ serviceStatus.dwWaitHint = waitHint;
	1139	+ serviceStatus.dwWin32ExitCode = win32ExitCode;
	1140	+ serviceStatus.dwServiceSpecificExitCode = serviceSpecificExitCode;
	1141	+ if (newServiceStatus == SERVICE_START_PENDING)
	1142	+ {
	1143	+ serviceStatus.dwControlsAccepted = 0;
	1144	+ }
	1145	+ else
	1146	+ {
	1147	+ serviceStatus.dwControlsAccepted =
	1148	+ SERVICE_ACCEPT_STOP \| SERVICE_ACCEPT_PAUSE_CONTINUE \| SERVICE_ACCEPT_PARAMCHANGE;
	1149	+ }
	1150	+ result = SetServiceStatus(serviceStatusHandle, &serviceStatus);
	1151	+ if (result == FALSE)
	1152	+ {
	1153	+ OutputLastError("ReportStatusToSCM() == FALSE");
	1154	+ }
	1155	+ return result;
1203	1156	}
1204	1157
1205	1158	// Report service status to service control manager (Alternate version)
1206	1159	static BOOL PingStatusToSCM(DWORD checkPoint, DWORD waitHint)
1207	1160	{
1208		- return ReportStatusToSCM(currentServiceStatus, checkPoint, waitHint, NO_ERROR, NO_ERROR);
	1161	+ return ReportStatusToSCM(currentServiceStatus, checkPoint, waitHint, NO_ERROR, NO_ERROR);
1209	1162	}
1210	1163
1211	1164	// Service control message from management interface (Callback from SCM)
1212	1165	static void WINAPI ServiceCtrlHandler(DWORD state)
1213	1166	{
1214		- switch (state) {
1215		- case SERVICE_CONTROL_STOP:
1216		- ReportStatusToSCM(SERVICE_STOP_PENDING, 1, 0, NO_ERROR, NO_ERROR);
1217		- w32g_message_set(W32G_SYN_QUIT);
1218		- break;
1219		-
1220		- case SERVICE_CONTROL_PAUSE:
1221		- ReportStatusToSCM(SERVICE_PAUSE_PENDING, 1, 0, NO_ERROR, NO_ERROR);
1222		- w32g_message_set(W32G_SYN_STOP);
1223		- ReportStatusToSCM(SERVICE_PAUSED, 1, 0, NO_ERROR, NO_ERROR);
1224		- break;
1225		-
1226		- case SERVICE_CONTROL_CONTINUE:
1227		- ReportStatusToSCM(SERVICE_CONTINUE_PENDING, 1, 0, NO_ERROR, NO_ERROR);
1228		- w32g_message_set(W32G_SYN_START);
1229		- ReportStatusToSCM(SERVICE_RUNNING, 1, 0, NO_ERROR, NO_ERROR);
1230		- break;
1231		-
1232		- case SERVICE_CONTROL_INTERROGATE:
1233		- OutputString("ServiceCtrlHandler(), SERVICE_CONTROL_INTERROGATE : oops.\n");
1234		- break;
1235		-
1236		- case SERVICE_CONTROL_SHUTDOWN:
1237		- OutputString("ServiceCtrlHandler(), SERVICE_CONTROL_SHUTDOWN : oops.\n");
1238		- break;
1239		-
1240		- default:
1241		- OutputString("ServiceCtrlHandler(), default handler (%d) : oops.\n", state);
1242		- break;
1243		- }
1244		- PingStatusToSCM(0, 0);
	1167	+ switch (state)
	1168	+ {
	1169	+ case SERVICE_CONTROL_STOP:
	1170	+ ReportStatusToSCM(SERVICE_STOP_PENDING, 1, 0, NO_ERROR, NO_ERROR);
	1171	+ w32g_message_set(W32G_SYN_QUIT);
	1172	+ break;
	1173	+ case SERVICE_CONTROL_PAUSE:
	1174	+ ReportStatusToSCM(SERVICE_PAUSE_PENDING, 1, 0, NO_ERROR, NO_ERROR);
	1175	+ w32g_message_set(W32G_SYN_STOP);
	1176	+ ReportStatusToSCM(SERVICE_PAUSED, 1, 0, NO_ERROR, NO_ERROR);
	1177	+ break;
	1178	+ case SERVICE_CONTROL_CONTINUE:
	1179	+ ReportStatusToSCM(SERVICE_CONTINUE_PENDING, 1, 0, NO_ERROR, NO_ERROR);
	1180	+ w32g_message_set(W32G_SYN_START);
	1181	+ ReportStatusToSCM(SERVICE_RUNNING, 1, 0, NO_ERROR, NO_ERROR);
	1182	+ break;
	1183	+ case SERVICE_CONTROL_INTERROGATE:
	1184	+ OutputString("ServiceCtrlHandler(), SERVICE_CONTROL_INTERROGATE : oops.\n");
	1185	+ break;
	1186	+ case SERVICE_CONTROL_SHUTDOWN:
	1187	+ OutputString("ServiceCtrlHandler(), SERVICE_CONTROL_SHUTDOWN : oops.\n");
	1188	+ break;
	1189	+ default:
	1190	+ OutputString("ServiceCtrlHandler(), default handler (%d) : oops.\n", state);
	1191	+ break;
	1192	+ }
	1193	+ PingStatusToSCM(0, 0);
1245	1194	}
1246	1195
1247	1196	// Register service control handler
1248		-static SERVICE_STATUS_HANDLE RegisterCtrlHandler(void)
	1197	+static SERVICE_STATUS_HANDLE RegisterCtrlHandler()
1249	1198	{
1250		- SERVICE_STATUS_HANDLE ssh = RegisterServiceCtrlHandlerA(
1251		- serviceName, ServiceCtrlHandler);
1252		- if (ssh == 0) {
1253		- OutputLastError("RegisterServiceCtrlHandler() == 0");
1254		- return NULL;
1255		- }
1256		- return ssh;
	1199	+ SERVICE_STATUS_HANDLE ssh = RegisterServiceCtrlHandlerA(
	1200	+ serviceName, ServiceCtrlHandler);
	1201	+ if (ssh == 0)
	1202	+ {
	1203	+ OutputLastError("RegisterServiceCtrlHandler() == 0");
	1204	+ return NULL;
	1205	+ }
	1206	+ return ssh;
1257	1207	}
1258	1208
1259	1209	// Service entry function (Callback from SCM)
1260		-static void WINAPI ServiceMain(DWORD argc, LPSTR *argv)
	1210	+static void WINAPI ServiceMain(DWORD argc, LPTSTR *argv)
1261	1211	{
1262		- serviceStatusHandle = RegisterCtrlHandler();
1263		- ReportStatusToSCM(SERVICE_RUNNING, 1, 0, NO_ERROR, NO_ERROR);
	1212	+ serviceStatusHandle = RegisterCtrlHandler();
	1213	+ ReportStatusToSCM(SERVICE_RUNNING, 1, 0, NO_ERROR, NO_ERROR);
1264	1214
1265		- w32g_syn.syn_hThread = GetCurrentThread();
1266		- win_main(w32g_syn.argc, w32g_syn.argv);
	1215	+ w32g_syn.syn_hThread = GetCurrentThread();
	1216	+ win_main(w32g_syn.argc, w32g_syn.argv);
1267	1217
1268		- ReportStatusToSCM(SERVICE_STOPPED, 1, 0, NO_ERROR, NO_ERROR);
	1218	+ ReportStatusToSCM(SERVICE_STOPPED, 1, 0, NO_ERROR, NO_ERROR);
1269	1219	}
1270	1220
1271	1221	// return

		@@ -1273,22 +1223,22 @@ static void WINAPI ServiceMain(DWORD argc, LPSTR *argv)
1273	1223	// -1 : FATAL ERROR
1274	1224	static int w32g_syn_main(void)
1275	1225	{
1276		- int i;
1277		- BOOL result;
1278		- SERVICE_TABLE_ENTRYA ServiceTable[2];
1279		-
1280		- w32g_syn.nid_uID = W32G_SYN_NID_UID;
1281		-// processPriority = NORMAL_PRIORITY_CLASS;
1282		-// syn_ThreadPriority = THREAD_PRIORITY_NORMAL;
1283		- for (i = 0; i < MAX_PORT; i++) {
1284		- w32g_syn_id_port[i] = i + 1;
1285		- }
1286		-
1287		- ServiceTable[0].lpServiceName = (LPSTR) serviceName;
1288		- ServiceTable[0].lpServiceProc = ServiceMain;
1289		- ServiceTable[1].lpServiceName = 0;
1290		- ServiceTable[1].lpServiceProc = 0;
1291		-
	1226	+ int i;
	1227	+ BOOL result;
	1228	+ SERVICE_TABLE_ENTRYA ServiceTable[2];
	1229	+
	1230	+ w32g_syn.nid_uID = W32G_SYN_NID_UID;
	1231	+// processPriority = NORMAL_PRIORITY_CLASS;
	1232	+// syn_ThreadPriority = THREAD_PRIORITY_NORMAL;
	1233	+ for (i = 0; i < MAX_PORT; i++) {
	1234	+ w32g_syn_id_port[i] = i + 1;
	1235	+ }
	1236	+
	1237	+ ServiceTable[0].lpServiceName = (LPSTR)serviceName;
	1238	+ ServiceTable[0].lpServiceProc = ServiceMain;
	1239	+ ServiceTable[1].lpServiceName = 0;
	1240	+ ServiceTable[1].lpServiceProc = 0;
	1241	+
1292	1242	result = StartServiceCtrlDispatcherA(ServiceTable);
1293	1243	if (result == FALSE) {
1294	1244	#ifdef _DEBUG

		@@ -1304,7 +1254,7 @@ static int w32g_syn_main(void)
1304	1254	#endif
1305	1255	return -1;
1306	1256	}
1307		- return 0;
	1257	+ return 0;
1308	1258	}
1309	1259
1310	1260	// Service installer

		@@ -1435,75 +1385,75 @@ static BOOL UninstallService(void)
1435	1385	return TRUE;
1436	1386	}
1437	1387
1438		-#endif // !TWSYNSRV
	1388	+#endif // !TWSYNSRV
1439	1389
1440	1390
1441	1391	// 可変長引数にする予定……
1442	1392	// 0: 成功、1: 追加できなかった
1443	1393	int w32g_message_set(int cmd)
1444	1394	{
1445		- int res = 0, i;
1446		- if (!msg_loopbuf_hMutex) {
1447		- msg_loopbuf_hMutex = CreateMutex(NULL, TRUE, NULL);
1448		- } else {
1449		- WaitForSingleObject(msg_loopbuf_hMutex, INFINITE);
1450		- }
1451		- if (cmd == W32G_SYN_QUIT) { // 優先するメッセージ。
1452		- for (i = 0; i < W32G_SYN_MESSAGE_MAX; i++)
1453		- msg_loopbuf[i].cmd = cmd;
1454		- msg_loopbuf_start = 0;
1455		- msg_loopbuf_end = 0;
1456		- ReleaseMutex(msg_loopbuf_hMutex);
1457		- return res;
1458		- } else if (cmd == W32G_SYN_START \|\| cmd == W32G_SYN_STOP) { // 優先するメッセージ。
1459		- msg_loopbuf_start = 0;
1460		- msg_loopbuf_end = 0;
1461		- msg_loopbuf[msg_loopbuf_end].cmd = cmd;
1462		- ReleaseMutex(msg_loopbuf_hMutex);
1463		- return res;
1464		- } else if (cmd != W32G_SYN_NONE) {
1465		- if (msg_loopbuf_end < 0) {
1466		- msg_loopbuf_start = 0;
1467		- msg_loopbuf_end = 0;
1468		- } else if (msg_loopbuf_start <= msg_loopbuf_end) {
1469		- if (msg_loopbuf_end < W32G_SYN_MESSAGE_MAX - 1)
1470		- msg_loopbuf_end++;
1471		- else
1472		- res = 1;
1473		- } else if (msg_loopbuf_end < msg_loopbuf_start - 1) {
1474		- msg_loopbuf_end++;
1475		- } else {
1476		- res = 1;
1477		- }
1478		- if (res == 0) {
1479		- msg_loopbuf[msg_loopbuf_end].cmd = cmd;
1480		- }
1481		- }
1482		- ReleaseMutex(msg_loopbuf_hMutex);
1483		- Sleep(100);
1484		- return res;
	1395	+ int res = 0, i;
	1396	+ if (!msg_loopbuf_hMutex) {
	1397	+ msg_loopbuf_hMutex = CreateMutex(NULL, TRUE, NULL);
	1398	+ } else {
	1399	+ WaitForSingleObject(msg_loopbuf_hMutex, INFINITE);
	1400	+ }
	1401	+ if (cmd == W32G_SYN_QUIT){ // 優先するメッセージ。
	1402	+ for(i = 0; i < W32G_SYN_MESSAGE_MAX; i++)
	1403	+ msg_loopbuf[i].cmd = cmd;
	1404	+ msg_loopbuf_start = 0;
	1405	+ msg_loopbuf_end = 0;
	1406	+ ReleaseMutex(msg_loopbuf_hMutex);
	1407	+ return res;
	1408	+ } else if (cmd == W32G_SYN_START \|\| cmd == W32G_SYN_STOP) { // 優先するメッセージ。
	1409	+ msg_loopbuf_start = 0;
	1410	+ msg_loopbuf_end = 0;
	1411	+ msg_loopbuf[msg_loopbuf_end].cmd = cmd;
	1412	+ ReleaseMutex(msg_loopbuf_hMutex);
	1413	+ return res;
	1414	+ } else if (cmd != W32G_SYN_NONE) {
	1415	+ if (msg_loopbuf_end < 0) {
	1416	+ msg_loopbuf_start = 0;
	1417	+ msg_loopbuf_end = 0;
	1418	+ } else if (msg_loopbuf_start <= msg_loopbuf_end) {
	1419	+ if (msg_loopbuf_end < W32G_SYN_MESSAGE_MAX - 1)
	1420	+ msg_loopbuf_end++;
	1421	+ else
	1422	+ res = 1;
	1423	+ } else if (msg_loopbuf_end < msg_loopbuf_start - 1) {
	1424	+ msg_loopbuf_end++;
	1425	+ } else {
	1426	+ res = 1;
	1427	+ }
	1428	+ if (res == 0) {
	1429	+ msg_loopbuf[msg_loopbuf_end].cmd = cmd;
	1430	+ }
	1431	+ }
	1432	+ ReleaseMutex(msg_loopbuf_hMutex);
	1433	+ Sleep(100);
	1434	+ return res;
1485	1435	}
1486	1436
1487	1437	int w32g_message_get(w32g_syn_message_t *msg)
1488	1438	{
1489		- int have_msg = 0;
1490		- if (!msg_loopbuf_hMutex) {
1491		- msg_loopbuf_hMutex = CreateMutex(NULL, TRUE, NULL);
1492		- } else {
1493		- WaitForSingleObject(msg_loopbuf_hMutex, INFINITE);
1494		- }
1495		- if (msg_loopbuf_start >= 0) {
1496		- CopyMemory(msg, &msg_loopbuf[msg_loopbuf_start], sizeof(w32g_syn_message_t));
1497		- have_msg = 1;
1498		- msg_loopbuf_start++;
1499		- if (msg_loopbuf_end < msg_loopbuf_start) {
1500		- msg_loopbuf_start = msg_loopbuf_end = -1;
1501		- } else if (msg_loopbuf_start >= W32G_SYN_MESSAGE_MAX) {
1502		- msg_loopbuf_start = 0;
1503		- }
1504		- }
1505		- ReleaseMutex(msg_loopbuf_hMutex);
1506		- return have_msg;
	1439	+ int have_msg = 0;
	1440	+ if (!msg_loopbuf_hMutex) {
	1441	+ msg_loopbuf_hMutex = CreateMutex(NULL, TRUE, NULL);
	1442	+ } else {
	1443	+ WaitForSingleObject(msg_loopbuf_hMutex, INFINITE);
	1444	+ }
	1445	+ if (msg_loopbuf_start >= 0) {
	1446	+ CopyMemory(msg, &msg_loopbuf[msg_loopbuf_start], sizeof(w32g_syn_message_t));
	1447	+ have_msg = 1;
	1448	+ msg_loopbuf_start++;
	1449	+ if (msg_loopbuf_end < msg_loopbuf_start) {
	1450	+ msg_loopbuf_start = msg_loopbuf_end = -1;
	1451	+ } else if (msg_loopbuf_start >= W32G_SYN_MESSAGE_MAX) {
	1452	+ msg_loopbuf_start = 0;
	1453	+ }
	1454	+ }
	1455	+ ReleaseMutex(msg_loopbuf_hMutex);
	1456	+ return have_msg;
1507	1457	}
1508	1458
1509	1459	extern int seq_quit;

		@@ -1511,199 +1461,197 @@ extern void rtsyn_play_event(MidiEvent*);
1511	1461	extern void rtsyn_server_reset();
1512	1462	void w32g_syn_doit(void)
1513	1463	{
1514		- w32g_syn_message_t msg;
1515		- MidiEvent ev;
1516		- DWORD sleep_time;
1517		- while (seq_quit == 0) {
1518		- int have_msg = 0;
1519		- sleep_time = 0;
1520		- have_msg = w32g_message_get(&msg);
1521		- if (have_msg) {
1522		- switch (msg.cmd) {
1523		- case W32G_SYN_QUIT:
1524		- seq_quit = ~0;
1525		- w32g_syn_status = quit;
1526		- sleep_time = 100;
1527		- break;
1528		-
1529		- case W32G_SYN_START:
1530		- seq_quit = ~0;
1531		- w32g_syn_status = run;
	1464	+ w32g_syn_message_t msg;
	1465	+ MidiEvent ev;
	1466	+ DWORD sleep_time;
	1467	+ while (seq_quit == 0) {
	1468	+ int have_msg = 0;
	1469	+ sleep_time = 0;
	1470	+ have_msg = w32g_message_get(&msg);
	1471	+ if (have_msg) {
	1472	+ switch (msg.cmd) {
	1473	+ case W32G_SYN_QUIT:
	1474	+ seq_quit = ~0;
	1475	+ w32g_syn_status = quit;
	1476	+ sleep_time = 100;
	1477	+ break;
	1478	+ case W32G_SYN_START:
	1479	+ seq_quit = ~0;
	1480	+ w32g_syn_status = run;
1532	1481	#ifndef TWSYNSRV
1533		- ChangeTasktrayIcon(w32g_syn.nid_hWnd);
	1482	+ ChangeTasktrayIcon(w32g_syn.nid_hWnd);
1534	1483	#endif /* !TWSYNSRV */
1535		- sleep_time = 100;
1536		- break;
1537		-
1538		- case W32G_SYN_STOP:
1539		- seq_quit = ~0;
1540		- w32g_syn_status = stop;
	1484	+ sleep_time = 100;
	1485	+ break;
	1486	+ case W32G_SYN_STOP:
	1487	+ seq_quit = ~0;
	1488	+ w32g_syn_status = stop;
1541	1489	#ifndef TWSYNSRV
1542		- ChangeTasktrayIcon(w32g_syn.nid_hWnd);
	1490	+ ChangeTasktrayIcon(w32g_syn.nid_hWnd);
1543	1491	#endif /* !TWSYNSRV */
1544		- sleep_time = 100;
1545		- break;
1546		-
	1492	+ sleep_time = 100;
	1493	+ break;
1547	1494	///r
1548		- default:
	1495	+ default:
1549	1496	#ifndef TWSYNSRV
1550		- // W32G_SYN_MODULE
1551		- if (W32G_SYN_MODULE <= msg.cmd && msg.cmd < (W32G_SYN_MODULE + module_list_num))
1552		- {
1553		- opt_default_module = module_list[msg.cmd - W32G_SYN_MODULE].num;
1554		- rtsyn_server_reset();
1555		- ev.type = ME_RESET;
1556		- ev.a = rtsyn_system_mode;
1557		- rtsyn_play_event(&ev);
1558		- change_system_mode(rtsyn_system_mode);
1559		- sleep_time = 100;
1560		- }
1561		- // W32G_SYN_SYSTEM_RESET_X
1562		- if (W32G_SYN_SYSTEM_RESET_X <= msg.cmd && msg.cmd < (W32G_SYN_SYSTEM_RESET_X + system_mode_list_num))
1563		- {
1564		- rtsyn_server_reset();
1565		- ev.type = ME_RESET;
1566		- ev.a = system_mode_num[msg.cmd - W32G_SYN_SYSTEM_RESET_X];
1567		- rtsyn_play_event(&ev);
1568		- sleep_time = 100;
1569		- }
1570		- // W32G_SYN_CHANGE_SYSTEM_X
1571		- if (W32G_SYN_CHANGE_SYSTEM_X <= msg.cmd && msg.cmd < (W32G_SYN_CHANGE_SYSTEM_X + system_mode_list_num))
1572		- {
1573		- rtsyn_system_mode = system_mode_num[msg.cmd - W32G_SYN_CHANGE_SYSTEM_X];
1574		- rtsyn_server_reset();
1575		- ev.type = ME_RESET;
1576		- ev.a = system_mode_num[msg.cmd - W32G_SYN_CHANGE_SYSTEM_X];
1577		- rtsyn_play_event(&ev);
1578		- change_system_mode(rtsyn_system_mode);
1579		- sleep_time = 100;
1580		- break;
1581		- }
	1497	+ // W32G_SYN_MODULE
	1498	+ if (W32G_SYN_MODULE <= msg.cmd && msg.cmd < (W32G_SYN_MODULE + module_list_num))
	1499	+ {
	1500	+ opt_default_module = module_list[msg.cmd - W32G_SYN_MODULE].num;
	1501	+ rtsyn_server_reset();
	1502	+ ev.type = ME_RESET;
	1503	+ ev.a = rtsyn_system_mode;
	1504	+ rtsyn_play_event(&ev);
	1505	+ change_system_mode(rtsyn_system_mode);
	1506	+ sleep_time = 100;
	1507	+ }
	1508	+ // W32G_SYN_SYSTEM_RESET_X
	1509	+ if (W32G_SYN_SYSTEM_RESET_X <= msg.cmd && msg.cmd < (W32G_SYN_SYSTEM_RESET_X + system_mode_list_num))
	1510	+ {
	1511	+ rtsyn_server_reset();
	1512	+ ev.type = ME_RESET;
	1513	+ ev.a = system_mode_num[msg.cmd - W32G_SYN_SYSTEM_RESET_X];
	1514	+ rtsyn_play_event(&ev);
	1515	+ sleep_time = 100;
	1516	+ }
	1517	+ // W32G_SYN_CHANGE_SYSTEM_X
	1518	+ if (W32G_SYN_CHANGE_SYSTEM_X <= msg.cmd && msg.cmd < (W32G_SYN_CHANGE_SYSTEM_X + system_mode_list_num))
	1519	+ {
	1520	+ rtsyn_system_mode = system_mode_num[msg.cmd - W32G_SYN_CHANGE_SYSTEM_X];
	1521	+ rtsyn_server_reset();
	1522	+ ev.type = ME_RESET;
	1523	+ ev.a = system_mode_num[msg.cmd - W32G_SYN_CHANGE_SYSTEM_X];
	1524	+ rtsyn_play_event(&ev);
	1525	+ change_system_mode(rtsyn_system_mode);
	1526	+ sleep_time = 100;
	1527	+ break;
	1528	+ }
1582	1529	#endif /* !TWSYNSRV */
1583		- break;
1584		- }
1585		- }
	1530	+ break;
	1531	+ }
	1532	+ }
1586	1533
1587		- winplaymidi();
1588		- pump_timer_event();
1589		- Sleep(sleep_time);
1590		- }
	1534	+ winplaymidi();
	1535	+ Sleep(sleep_time);
	1536	+ }
1591	1537	}
1592	1538
1593	1539	int w32g_syn_ctl_pass_playing_list(int n_, char *args_[])
1594	1540	{
1595		- int i;
1596		- int breakflag = 0;
	1541	+ int i;
1597	1542	#ifndef TWSYNSRV
1598		- w32g_syn_status = syn_AutoStart ? run : stop;
	1543	+ w32g_syn_status = syn_AutoStart ? run : stop;
1599	1544	#else
1600		- w32g_syn_status = run;
	1545	+ w32g_syn_status = run;
1601	1546	#endif /* !TWSYNSRV */
1602		- for (;;) {
1603		- switch (w32g_syn_status) {
1604		- default:
1605		- case quit:
1606		- breakflag = 1;
1607		- break;
1608		-
1609		- case run: {
1610		- int result;
1611		- char args_[MAX_PORT][10];
1612		- char *args[MAX_PORT];
1613		- if (w32g_syn_port_num <= 0) {
1614		- w32g_syn_status = stop;
1615		- break;
1616		- } else if (w32g_syn_port_num > MAX_PORT) {
1617		- w32g_syn_port_num = MAX_PORT;
1618		- }
1619		- for (i = 0; i < MAX_PORT; i++) {
1620		- args[i] = args_[i];
1621		- sprintf(args[i], "%d", w32g_syn_id_port[i]);
1622		- }
	1547	+ for (;;) {
	1548	+ int breakflag = 0;
	1549	+ switch (w32g_syn_status) {
	1550	+ default:
	1551	+ case quit:
	1552	+ breakflag = 1;
	1553	+ break;
	1554	+ case run:
	1555	+ {
	1556	+ int result;
	1557	+ char args_[MAX_PORT][10];
	1558	+ char *args[MAX_PORT];
	1559	+ if (w32g_syn_port_num <= 0) {
	1560	+ w32g_syn_status = stop;
	1561	+ break;
	1562	+ } else if (w32g_syn_port_num > MAX_PORT) {
	1563	+ w32g_syn_port_num = MAX_PORT;
	1564	+ }
	1565	+ for (i = 0; i < MAX_PORT; i++) {
	1566	+ args[i] = args_[i];
	1567	+ sprintf(args[i], "%d", w32g_syn_id_port[i]);
	1568	+ }
1623	1569	#ifndef TWSYNSRV
1624		- ChangeTasktrayIcon(w32g_syn.nid_hWnd);
	1570	+ ChangeTasktrayIcon(w32g_syn.nid_hWnd);
1625	1571	#endif /* !TWSYNSRV */
1626		- SetPriorityClass(GetCurrentProcess(), processPriority);
1627		- SetThreadPriority(w32g_syn.syn_hThread, syn_ThreadPriority);
1628		- result = ctl_pass_playing_list2(w32g_syn_port_num, args);
1629		- SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
1630		- SetThreadPriority(w32g_syn.syn_hThread, THREAD_PRIORITY_NORMAL);
1631		- if (result == 2) {
1632		- w32g_syn_status = stop;
1633		- }
	1572	+ SetPriorityClass(GetCurrentProcess(), processPriority);
	1573	+ SetThreadPriority(w32g_syn.syn_hThread, syn_ThreadPriority);
	1574	+ result = ctl_pass_playing_list2(w32g_syn_port_num, args);
	1575	+ SetPriorityClass(GetCurrentProcess(), NORMAL_PRIORITY_CLASS);
	1576	+ SetThreadPriority(w32g_syn.syn_hThread, THREAD_PRIORITY_NORMAL);
	1577	+ if (result == 2) {
	1578	+ w32g_syn_status = stop;
	1579	+ }
1634	1580	#ifndef TWSYNSRV
1635		- ChangeTasktrayIcon(w32g_syn.nid_hWnd);
	1581	+ ChangeTasktrayIcon(w32g_syn.nid_hWnd);
1636	1582	#endif /* !TWSYNSRV */
1637		- break; }
1638		-
1639		- case stop: {
1640		- w32g_syn_message_t msg;
1641		- if (w32g_message_get(&msg)) {
1642		- if (msg.cmd == W32G_SYN_START) {
1643		- w32g_syn_status = run;
1644		- break;
1645		- } else {
1646		- if (msg.cmd == W32G_SYN_QUIT) {
1647		- w32g_syn_status = quit;
1648		- break;
1649		- }
1650		- }
1651		- }
1652		- Sleep(500);
1653		- break; }
1654		- }
1655		- if (breakflag)
1656		- break;
1657		- }
	1583	+ }
	1584	+ break;
	1585	+ case stop:
	1586	+ {
	1587	+ w32g_syn_message_t msg;
	1588	+ if (w32g_message_get(&msg)) {
	1589	+ if (msg.cmd == W32G_SYN_START) {
	1590	+ w32g_syn_status = run;
	1591	+ break;
	1592	+ } else {
	1593	+ if (msg.cmd == W32G_SYN_QUIT) {
	1594	+ w32g_syn_status = quit;
	1595	+ break;
	1596	+ }
	1597	+ }
	1598	+ }
	1599	+ Sleep(500);
	1600	+ }
	1601	+ break;
	1602	+ }
	1603	+ if (breakflag)
	1604	+ break;
	1605	+ }
1658	1606	#ifndef TWSYNSRV
1659		- while (w32g_syn.quit_state < 1) {
1660		- PostThreadMessage(w32g_syn.gui_dwThreadId, MYWM_QUIT, 0, 0);
1661		- Sleep(300);
1662		- }
	1607	+ while (w32g_syn.quit_state < 1) {
	1608	+ PostThreadMessage(w32g_syn.gui_dwThreadId, MYWM_QUIT, 0, 0);
	1609	+ Sleep(300);
	1610	+ }
1663	1611	#endif /* !TWSYNSRV */
1664		- if (w32g_syn.quit_state < 2) w32g_syn.quit_state = 2;
1665		- return 0;
	1612	+ if (w32g_syn.quit_state < 2) w32g_syn.quit_state = 2;
	1613	+ return 0;
1666	1614	}
1667	1615
1668	1616	int w32g_syn_do_before_pref_apply(void)
1669	1617	{
1670		- w32g_syn_status_prev = none;
1671		- for (;;) {
1672		- if (w32g_syn_status == quit)
1673		- return -1;
1674		- if (!msg_loopbuf_hMutex) {
1675		- msg_loopbuf_hMutex = CreateMutex(NULL, TRUE, NULL);
1676		- } else {
1677		- WaitForSingleObject(msg_loopbuf_hMutex, INFINITE);
1678		- }
1679		- if (w32g_syn_status_prev == none)
1680		- w32g_syn_status_prev = w32g_syn_status;
1681		- if (w32g_syn_status == stop) {
1682		- return 0;
1683		- }
1684		- ReleaseMutex(msg_loopbuf_hMutex);
1685		- w32g_message_set(W32G_SYN_STOP);
1686		- Sleep(100);
1687		- }
	1618	+ w32g_syn_status_prev = none;
	1619	+ for (;;) {
	1620	+ if (w32g_syn_status == quit)
	1621	+ return -1;
	1622	+ if (!msg_loopbuf_hMutex) {
	1623	+ msg_loopbuf_hMutex = CreateMutex(NULL, TRUE, NULL);
	1624	+ } else {
	1625	+ WaitForSingleObject(msg_loopbuf_hMutex, INFINITE);
	1626	+ }
	1627	+ if (w32g_syn_status_prev == none)
	1628	+ w32g_syn_status_prev = w32g_syn_status;
	1629	+ if (w32g_syn_status == stop) {
	1630	+ return 0;
	1631	+ }
	1632	+ ReleaseMutex(msg_loopbuf_hMutex);
	1633	+ w32g_message_set(W32G_SYN_STOP);
	1634	+ Sleep(100);
	1635	+ }
1688	1636	}
1689	1637
1690	1638	int w32g_syn_do_after_pref_apply(void)
1691	1639	{
1692		- ReleaseMutex(msg_loopbuf_hMutex);
1693		- if (w32g_syn_status_prev == run) {
1694		- w32g_message_set(W32G_SYN_START);
1695		- Sleep(100);
1696		- }
1697		- return 0;
	1640	+ ReleaseMutex(msg_loopbuf_hMutex);
	1641	+ if (w32g_syn_status_prev == run) {
	1642	+ w32g_message_set(W32G_SYN_START);
	1643	+ Sleep(100);
	1644	+ }
	1645	+ return 0;
1698	1646	}
1699	1647
1700	1648	///r
1701	1649	int w32g_syn_do_after_pref_save_restart(void)
1702	1650	{
1703		- ReleaseMutex(msg_loopbuf_hMutex);
1704		- w32g_message_set(W32G_SYN_QUIT);
1705		- Sleep(100);
1706		- return 0;
	1651	+ ReleaseMutex(msg_loopbuf_hMutex);
	1652	+ w32g_message_set(W32G_SYN_QUIT);
	1653	+ Sleep(100);
	1654	+ return 0;
1707	1655	}
1708	1656
1709	1657	#ifdef HAVE_SYN_CONSOLE

		@@ -1713,34 +1661,34 @@ int w32g_syn_do_after_pref_save_restart(void)
1713	1661
1714	1662	void VprintfEditCtlWnd(HWND hwnd, const char *fmt, va_list argList)
1715	1663	{
1716		- char buffer[BUFSIZ], out[BUFSIZ];
1717		- char *in;
1718		- int i;
1719		-
1720		- if (!IsWindow(hwnd))
1721		- return;
1722		-
1723		- vsnprintf(buffer, sizeof(buffer), fmt, argList);
1724		- in = buffer;
1725		- i = 0;
1726		- for (;;) {
1727		- if (*in == '\0' \|\| i > sizeof(out) - 3) {
1728		- out[i] = '\0';
1729		- break;
1730		- }
1731		- if (*in == '\n') {
1732		- out[i] = 13;
1733		- out[i + 1] = 10;
1734		- in++;
1735		- i += 2;
1736		- continue;
1737		- }
1738		- out[i] = *in;
1739		- in++;
1740		- i++;
1741		- }
1742		- Edit_SetSel(hwnd, -1, -1);
1743		- Edit_ReplaceSel(hwnd, out);
	1664	+ char buffer[BUFSIZ], out[BUFSIZ];
	1665	+ char *in;
	1666	+ int i;
	1667	+
	1668	+ if (!IsWindow(hwnd))
	1669	+ return;
	1670	+
	1671	+ vsnprintf(buffer, sizeof(buffer), fmt, argList);
	1672	+ in = buffer;
	1673	+ i = 0;
	1674	+ for (;;) {
	1675	+ if (*in == '\0' \|\| i > sizeof(out) - 3) {
	1676	+ out[i] = '\0';
	1677	+ break;
	1678	+ }
	1679	+ if (*in == '\n') {
	1680	+ out[i] = 13;
	1681	+ out[i + 1] = 10;
	1682	+ in++;
	1683	+ i += 2;
	1684	+ continue;
	1685	+ }
	1686	+ out[i] = *in;
	1687	+ in++;
	1688	+ i++;
	1689	+ }
	1690	+ Edit_SetSel(hwnd, -1, -1);
	1691	+ Edit_ReplaceSel(hwnd, out);
1744	1692	}
1745	1693
1746	1694	void PrintfEditCtlWnd(HWND hwnd, const char *fmt, ...)

		@@ -1754,56 +1702,56 @@ void PrintfEditCtlWnd(HWND hwnd, const char *fmt, ...)
1754	1702	#if 1
1755	1703	void PutsEditCtlWnd(HWND hwnd, char *str)
1756	1704	{
1757		- char *in = str;
1758		- int i;
1759		- char out[BUFSIZ];
1760		- i = 0;
1761		- for (;;) {
1762		- if (*in == '\0' \|\| i > sizeof(out) - 3) {
1763		- out[i] = '\0';
1764		- break;
1765		- }
1766		- if (*in == '\n') {
1767		- out[i] = 13;
1768		- out[i + 1] = 10;
1769		- in++;
1770		- i += 2;
1771		- continue;
1772		- }
1773		- out[i] = *in;
1774		- in++;
1775		- i++;
1776		- }
1777		- if (IsWindow(hwnd)) {
1778		- Edit_SetSel(hwnd, -1, -1);
1779		- Edit_ReplaceSel(hwnd, out);
1780		- }
	1705	+ char *in = str;
	1706	+ int i;
	1707	+ char out[BUFSIZ];
	1708	+ i = 0;
	1709	+ for (;;) {
	1710	+ if (*in == '\0' \|\| i > sizeof(out) - 3) {
	1711	+ out[i] = '\0';
	1712	+ break;
	1713	+ }
	1714	+ if (*in == '\n') {
	1715	+ out[i] = 13;
	1716	+ out[i + 1] = 10;
	1717	+ in++;
	1718	+ i += 2;
	1719	+ continue;
	1720	+ }
	1721	+ out[i] = *in;
	1722	+ in++;
	1723	+ i++;
	1724	+ }
	1725	+ if (IsWindow(hwnd)) {
	1726	+ Edit_SetSel(hwnd, -1, -1);
	1727	+ Edit_ReplaceSel(hwnd, out);
	1728	+ }
1781	1729	}
1782	1730	#else
1783	1731	void PutsEditCtlWnd(HWND hwnd, char *str)
1784	1732	{
1785		- if (!IsWindow(hwnd))
1786		- return;
1787		- PrintfEditCtlWnd(hwnd, "%s", str);
	1733	+ if (!IsWindow(hwnd))
	1734	+ return;
	1735	+ PrintfEditCtlWnd(hwnd, "%s", str);
1788	1736	}
1789	1737	#endif
1790	1738
1791	1739	void ClearEditCtlWnd(HWND hwnd)
1792	1740	{
1793		- char pszVoid[] = "";
1794		- if (!IsWindow(hwnd))
1795		- return;
1796		- if (IsWindow(hwnd)) {
1797		- //Edit_SetSel(hwnd, 0, -1);
1798		- Edit_SetSel(hwnd, -1, -1);
1799		- }
1800		- Edit_SetText(hwnd, pszVoid);
	1741	+ char pszVoid[] = "";
	1742	+ if (!IsWindow(hwnd))
	1743	+ return;
	1744	+ if (IsWindow(hwnd)) {
	1745	+// Edit_SetSel(hwnd, 0, -1);
	1746	+ Edit_SetSel(hwnd, -1, -1);
	1747	+ }
	1748	+ Edit_SetText(hwnd, pszVoid);
1801	1749	}
1802	1750
1803	1751	static void VersionWnd(HWND hParentWnd)
1804	1752	{
1805		- char VersionText[2024];
1806		- sprintf(VersionText,
	1753	+ char VersionText[2024];
	1754	+ sprintf(VersionText,
1807	1755	"TiMidity++ %s%s %s" NLS NLS
1808	1756	"TiMidity-0.2i by Tuukka Toivonen <tt@cgs.fi>." NLS
1809	1757	"TiMidity Win32 version by Davide Moretti <dave@rimini.com>." NLS

		@@ -1811,24 +1759,22 @@ static void VersionWnd(HWND hParentWnd)
1811	1759	"Twsynth by Keishi Suenaga <s_keishi@mutt.freemail.ne.jp>." NLS
1812	1760	"Twsynth GUI by Daisuke Aoki <dai@y7.net>." NLS
1813	1761	" Japanese menu, dialog, etc by Saito <timidity@flashmail.com>." NLS
1814		-"TiMidity++ by Masanao Izumo <iz@onicos.co.jp>." NLS
1815		-"Compiled by yta" NLS
1816		-, (!strstr(timidity_version, "current")) ? "version " : "", timidity_version, arch_string);
1817		- MessageBoxA(hParentWnd, VersionText, "Version", MB_OK);
	1762	+"TiMidity++ by Masanao Izumo <mo@goice.co.jp>." NLS
	1763	+, (strcmp(timidity_version, "current")) ? "version " : "", timidity_version, arch_string);
	1764	+ MessageBoxA(hParentWnd, VersionText, "Version", MB_OK);
1818	1765	}
1819	1766
1820	1767	static void TiMidityWnd(HWND hParentWnd)
1821	1768	{
1822		- char TiMidityText[2024];
1823		- sprintf(TiMidityText,
	1769	+ char TiMidityText[2024];
	1770	+ sprintf(TiMidityText,
1824	1771	" TiMidity++ %s%s %s -- MIDI to WAVE converter and player" NLS
1825		-" Copyright (C) 1999-2018 Masanao Izumo <iz@onicos.co.jp>" NLS
	1772	+" Copyright (C) 1999-2002 Masanao Izumo <mo@goice.co.jp>" NLS
1826	1773	" Copyright (C) 1995 Tuukka Toivonen <tt@cgs.fi>" NLS
1827	1774	NLS
1828	1775	" Win32 version by Davide Moretti <dmoretti@iper.net>" NLS
1829	1776	" GUI by Daisuke Aoki <dai@y7.net>." NLS
1830		-" Modified by Masanao Izumo <iz@onicos.co.jp>." NLS
1831		-" Compiled by yta" NLS
	1777	+" Modified by Masanao Izumo <mo@goice.co.jp>." NLS
1832	1778	NLS
1833	1779	" This program is free software; you can redistribute it and/or modify" NLS
1834	1780	" it under the terms of the GNU General Public License as published by" NLS

		@@ -1844,9 +1790,9 @@ NLS
1844	1790	" along with this program; if not, write to the Free Software" NLS
1845	1791	" Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA" NLS
1846	1792	,
1847		-(!strstr(timidity_version, "current")) ? "version " : "", timidity_version, arch_string
1848		- );
1849		- MessageBoxA(hParentWnd, TiMidityText, "TiMidity", MB_OK);
	1793	+(strcmp(timidity_version, "current")) ? "version " : "", timidity_version, arch_string
	1794	+ );
	1795	+ MessageBoxA(hParentWnd, TiMidityText, "TiMidity", MB_OK);
1850	1796	}
1851	1797
1852	1798

		@@ -1863,7 +1809,7 @@ static HFONT hFontConsoleWnd = NULL;
1863	1809
1864	1810	// ---------------------------------------------------------------------------
1865	1811	// prototypes of functions
1866		-static INT_PTR CALLBACK ConsoleWndProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam);
	1812	+static LRESULT CALLBACK ConsoleWndProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam);
1867	1813	static void ConsoleWndAllUpdate(void);
1868	1814	static void ConsoleWndVerbosityUpdate(void);
1869	1815	static void ConsoleWndVerbosityApply(void);

		@@ -1874,7 +1820,6 @@ static int ConsoleWndInfoReset(HWND hwnd);
1874	1820	static int ConsoleWndInfoApply(void);
1875	1821
1876	1822	void ClearConsoleWnd(void);
1877		-void ConsoleWndApplyLevel(void);
1878	1823
1879	1824	// ---------------------------------------------------------------------------
1880	1825	// Global Functions

		@@ -1882,249 +1827,226 @@ void ConsoleWndApplyLevel(void);
1882	1827	// Initialization
1883	1828	void InitConsoleWnd(HWND hParentWnd)
1884	1829	{
1885		- HICON hIcon;
1886		- if (hConsoleWnd) {
1887		- DestroyWindow(hConsoleWnd);
1888		- hConsoleWnd = NULL;
1889		- }
1890		- switch (PlayerLanguage) {
1891		- case LANGUAGE_ENGLISH:
1892		- hConsoleWnd = CreateDialog
1893		- (hInst, MAKEINTRESOURCE(IDD_DIALOG_CONSOLE_EN), hParentWnd, ConsoleWndProc);
1894		- break;
1895		- default:
1896		- case LANGUAGE_JAPANESE:
1897		- hConsoleWnd = CreateDialog
1898		- (hInst, MAKEINTRESOURCE(IDD_DIALOG_CONSOLE), hParentWnd, ConsoleWndProc);
1899		- break;
1900		- }
1901		- hIcon = LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_TIMIDITY), IMAGE_ICON, 16, 16, 0);
1902		- if (hIcon)
1903		- SendMessage(hConsoleWnd, WM_SETICON, FALSE, (LPARAM) hIcon);
1904		- ShowWindow(hConsoleWnd, ConsoleWndStartFlag ? SW_SHOW : SW_HIDE);
1905		- UpdateWindow(hConsoleWnd);
1906		-
1907		- ConsoleWndVerbosityApplyIncDec(0);
1908		- CheckDlgButton(hConsoleWnd, IDC_CHECKBOX_VALID, ConsoleWndFlag);
1909		- Edit_LimitText(GetDlgItem(hConsoleWnd, IDC_EDIT), ConsoleWndMaxSize);
	1830	+ HICON hIcon;
	1831	+ if (hConsoleWnd) {
	1832	+ DestroyWindow(hConsoleWnd);
	1833	+ hConsoleWnd = NULL;
	1834	+ }
	1835	+ switch (PlayerLanguage) {
	1836	+ case LANGUAGE_ENGLISH:
	1837	+ hConsoleWnd = CreateDialog
	1838	+ (hInst, MAKEINTRESOURCE(IDD_DIALOG_CONSOLE_EN), hParentWnd, ConsoleWndProc);
	1839	+ break;
	1840	+ default:
	1841	+ case LANGUAGE_JAPANESE:
	1842	+ hConsoleWnd = CreateDialog
	1843	+ (hInst, MAKEINTRESOURCE(IDD_DIALOG_CONSOLE), hParentWnd, ConsoleWndProc);
	1844	+ break;
	1845	+ }
	1846	+ hIcon = LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_TIMIDITY), IMAGE_ICON, 16, 16, 0);
	1847	+ if (hIcon)
	1848	+ SendMessage(hConsoleWnd, WM_SETICON, FALSE, (LPARAM)hIcon);
	1849	+ ShowWindow(hConsoleWnd, ConsoleWndStartFlag ? SW_SHOW : SW_HIDE);
	1850	+ UpdateWindow(hConsoleWnd);
	1851	+
	1852	+ ConsoleWndVerbosityApplyIncDec(0);
	1853	+ CheckDlgButton(hConsoleWnd, IDC_CHECKBOX_VALID, ConsoleWndFlag);
	1854	+ Edit_LimitText(GetDlgItem(hConsoleWnd, IDC_EDIT), ConsoleWndMaxSize);
1910	1855	}
1911	1856
1912	1857	// Window Procedure
1913		-static INT_PTR CALLBACK
	1858	+static LRESULT CALLBACK
1914	1859	ConsoleWndProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam)
1915	1860	{
1916		- switch (uMess) {
1917		- case WM_INITDIALOG:
1918		- PutsConsoleWnd("Console Window\n");
1919		- ConsoleWndAllUpdate();
1920		- return FALSE;
1921		-
1922		- case WM_COMMAND:
1923		- switch (LOWORD(wParam)) {
1924		- case IDCLOSE:
1925		- ShowWindow(hwnd, SW_HIDE);
1926		- break;
1927		-
1928		- case IDCLEAR:
1929		- ClearConsoleWnd();
1930		- break;
1931		-
1932		- case IDC_CHECKBOX_VALID:
1933		- ConsoleWndValidApply();
1934		- break;
1935		-
1936		- case IDC_BUTTON_VERBOSITY:
1937		- ConsoleWndVerbosityApply();
1938		- break;
1939		-
1940		- case IDC_BUTTON_INC:
1941		- ConsoleWndVerbosityApplyIncDec(1);
1942		- break;
1943		-
1944		- case IDC_BUTTON_DEC:
1945		- ConsoleWndVerbosityApplyIncDec(-1);
1946		- break;
1947		-
1948		- default:
1949		- break;
1950		- }
1951		-
1952		- switch (HIWORD(wParam)) {
1953		- case EN_ERRSPACE:
1954		- ClearConsoleWnd();
1955		- PutsConsoleWnd("### EN_ERRSPACE -> Clear! ###\n");
1956		- break;
1957		-
1958		- default:
1959		- break;
1960		- }
1961		- break;
1962		-
1963		- case WM_SIZE:
1964		- ConsoleWndAllUpdate();
1965		- switch (wParam) {
1966		- case SIZE_MAXIMIZED:
1967		- case SIZE_RESTORED: { // くそめんどーー
1968		- int x,y,cx,cy;
1969		- int max = 0;
1970		- int width;
1971		- RECT rcParent;
1972		- RECT rcBUTTON_VERBOSITY, rcEDIT_VERBOSITY, rcBUTTON_DEC, rcBUTTON_INC, rcCHECKBOX_VALID, rcCLEAR, rcEDIT;
1973		- HWND hwndBUTTON_VERBOSITY, hwndEDIT_VERBOSITY, hwndBUTTON_DEC, hwndBUTTON_INC, hwndCHECKBOX_VALID, hwndCLEAR, hwndEDIT;
1974		- int nWidth = LOWORD(lParam);
1975		- int nHeight = HIWORD(lParam);
1976		- hwndEDIT = GetDlgItem(hwnd,IDC_EDIT);
1977		- hwndBUTTON_VERBOSITY = GetDlgItem(hwnd,IDC_BUTTON_VERBOSITY);
1978		- hwndEDIT_VERBOSITY = GetDlgItem(hwnd,IDC_EDIT_VERBOSITY);
1979		- hwndBUTTON_DEC = GetDlgItem(hwnd,IDC_BUTTON_DEC);
1980		- hwndBUTTON_INC = GetDlgItem(hwnd,IDC_BUTTON_INC);
1981		- hwndCHECKBOX_VALID = GetDlgItem(hwnd,IDC_CHECKBOX_VALID);
1982		- hwndCLEAR = GetDlgItem(hwnd,IDCLEAR);
1983		- GetWindowRect(hwndEDIT,&rcEDIT); // x0y0 基準
1984		- GetWindowRect(hwndBUTTON_VERBOSITY,&rcBUTTON_VERBOSITY);
1985		- GetWindowRect(hwndEDIT_VERBOSITY,&rcEDIT_VERBOSITY);
1986		- GetWindowRect(hwndBUTTON_DEC,&rcBUTTON_DEC);
1987		- GetWindowRect(hwndBUTTON_INC,&rcBUTTON_INC);
1988		- GetWindowRect(hwndCHECKBOX_VALID,&rcCHECKBOX_VALID);
1989		- GetWindowRect(hwndCLEAR,&rcCLEAR);
1990		- GetClientRect(hwnd,&rcParent);
1991		- // IDC_BUTTON_VERBOSITY
1992		- cx = rcBUTTON_VERBOSITY.right-rcBUTTON_VERBOSITY.left;
1993		- cy = rcBUTTON_VERBOSITY.bottom-rcBUTTON_VERBOSITY.top;
1994		- x = rcBUTTON_VERBOSITY.left - rcEDIT.left;
1995		- y = rcParent.bottom - cy - 4;
1996		- MoveWindow(hwndBUTTON_VERBOSITY,x,y,cx,cy,TRUE);
1997		- if (cy>max) max = cy;
1998		- // IDC_EDIT_VERBOSITY
1999		- cx = rcEDIT_VERBOSITY.right-rcEDIT_VERBOSITY.left;
2000		- cy = rcEDIT_VERBOSITY.bottom-rcEDIT_VERBOSITY.top;
2001		- x = rcEDIT_VERBOSITY.left - rcEDIT.left;
2002		- y = rcParent.bottom - cy - 4;
2003		- MoveWindow(hwndEDIT_VERBOSITY,x,y,cx,cy,TRUE);
2004		- if (cy>max) max = cy;
2005		- // IDC_BUTTON_DEC
2006		- cx = rcBUTTON_DEC.right-rcBUTTON_DEC.left;
2007		- cy = rcBUTTON_DEC.bottom-rcBUTTON_DEC.top;
2008		- x = rcBUTTON_DEC.left - rcEDIT.left;
2009		- y = rcParent.bottom - cy - 4;
2010		- MoveWindow(hwndBUTTON_DEC,x,y,cx,cy,TRUE);
2011		- if (cy>max) max = cy;
2012		- // IDC_BUTTON_INC
2013		- cx = rcBUTTON_INC.right-rcBUTTON_INC.left;
2014		- cy = rcBUTTON_INC.bottom-rcBUTTON_INC.top;
2015		- x = rcBUTTON_INC.left - rcEDIT.left;
2016		- y = rcParent.bottom - cy - 4;
2017		- MoveWindow(hwndBUTTON_INC,x,y,cx,cy,TRUE);
2018		- if (cy>max) max = cy;
2019		- // IDC_CHECKBOX_VALID
2020		- cx = rcCHECKBOX_VALID.right-rcCHECKBOX_VALID.left;
2021		- cy = rcCHECKBOX_VALID.bottom-rcCHECKBOX_VALID.top;
2022		- x = rcCHECKBOX_VALID.left - rcEDIT.left;
2023		- y = rcParent.bottom - cy - 4;
2024		- MoveWindow(hwndCHECKBOX_VALID,x,y,cx,cy,TRUE);
2025		- if (cy>max) max = cy;
2026		- // IDCLEAR
2027		- cx = rcCLEAR.right-rcCLEAR.left;
2028		- cy = rcCLEAR.bottom-rcCLEAR.top;
2029		- x = rcCLEAR.left - rcEDIT.left;
2030		- y = rcParent.bottom - cy - 4;
2031		- MoveWindow(hwndCLEAR,x,y,cx,cy,TRUE);
2032		- if (cy>max) max = cy;
2033		- // IDC_EDIT
2034		- cx = rcParent.right - rcParent.left;
2035		- cy = rcParent.bottom - rcParent.top - max - 8;
2036		- x = rcParent.left;
2037		- y = rcParent.top;
2038		- MoveWindow(hwndEDIT,x,y,cx,cy,TRUE);
2039		- //
2040		- InvalidateRect(hwnd,&rcParent,FALSE);
2041		- UpdateWindow(hwnd);
2042		- GetWindowRect(hwnd,&rcParent);
2043		- break; }
2044		-
2045		- case SIZE_MINIMIZED:
2046		- case SIZE_MAXHIDE:
2047		- case SIZE_MAXSHOW:
2048		- default:
2049		- break;
2050		- }
2051		- return FALSE;
2052		-
2053		- case WM_MOVE:
2054		- break;
2055		-
2056		- // See PreDispatchMessage() in w32g2_main.c
2057		- case WM_SYSKEYDOWN:
2058		- case WM_KEYDOWN: {
2059		- int nVirtKey = (int) wParam;
2060		- switch (nVirtKey) {
2061		- case VK_ESCAPE:
2062		- SendMessage(hwnd, WM_CLOSE, 0, 0);
2063		- break;
2064		-
2065		- default:
2066		- break;
2067		- }
2068		- break; }
2069		-
2070		- case WM_DESTROY:
2071		- break;
2072		-
2073		- case WM_CLOSE:
2074		- ShowWindow(hConsoleWnd, SW_HIDE);
2075		- break;
2076		-
2077		- case WM_SETFOCUS:
2078		- HideCaret(hwnd);
2079		- break;
2080		-
2081		- case WM_KILLFOCUS:
2082		- ShowCaret(hwnd);
2083		- break;
2084		-
2085		- default:
2086		- return FALSE;
2087		- }
2088		- return FALSE;
	1861	+ switch (uMess) {
	1862	+ case WM_INITDIALOG:
	1863	+ PutsConsoleWnd("Console Window\n");
	1864	+ ConsoleWndAllUpdate();
	1865	+ return FALSE;
	1866	+ case WM_COMMAND:
	1867	+ switch (LOWORD(wParam)) {
	1868	+ case IDCLOSE:
	1869	+ ShowWindow(hwnd, SW_HIDE);
	1870	+ break;
	1871	+ case IDCLEAR:
	1872	+ ClearConsoleWnd();
	1873	+ break;
	1874	+ case IDC_CHECKBOX_VALID:
	1875	+ ConsoleWndValidApply();
	1876	+ break;
	1877	+ case IDC_BUTTON_VERBOSITY:
	1878	+ ConsoleWndVerbosityApply();
	1879	+ break;
	1880	+ case IDC_BUTTON_INC:
	1881	+ ConsoleWndVerbosityApplyIncDec(1);
	1882	+ break;
	1883	+ case IDC_BUTTON_DEC:
	1884	+ ConsoleWndVerbosityApplyIncDec(-1);
	1885	+ break;
	1886	+ default:
	1887	+ break;
	1888	+ }
	1889	+ switch (HIWORD(wParam)) {
	1890	+ case EN_ERRSPACE:
	1891	+ ClearConsoleWnd();
	1892	+ PutsConsoleWnd("### EN_ERRSPACE -> Clear! ###\n");
	1893	+ break;
	1894	+ default:
	1895	+ break;
	1896	+ }
	1897	+ break;
	1898	+ case WM_SIZE:
	1899	+ ConsoleWndAllUpdate();
	1900	+ switch(wParam){
	1901	+ case SIZE_MAXIMIZED:
	1902	+ case SIZE_RESTORED:
	1903	+ { // くそめんどーー
	1904	+ int x,y,cx,cy;
	1905	+ int max = 0;
	1906	+ int width;
	1907	+ RECT rcParent;
	1908	+ RECT rcBUTTON_VERBOSITY, rcEDIT_VERBOSITY, rcBUTTON_DEC, rcBUTTON_INC, rcCHECKBOX_VALID, rcCLEAR, rcEDIT;
	1909	+ HWND hwndBUTTON_VERBOSITY, hwndEDIT_VERBOSITY, hwndBUTTON_DEC, hwndBUTTON_INC, hwndCHECKBOX_VALID, hwndCLEAR, hwndEDIT;
	1910	+ int nWidth = LOWORD(lParam);
	1911	+ int nHeight = HIWORD(lParam);
	1912	+ hwndEDIT = GetDlgItem(hwnd,IDC_EDIT);
	1913	+ hwndBUTTON_VERBOSITY = GetDlgItem(hwnd,IDC_BUTTON_VERBOSITY);
	1914	+ hwndEDIT_VERBOSITY = GetDlgItem(hwnd,IDC_EDIT_VERBOSITY);
	1915	+ hwndBUTTON_DEC = GetDlgItem(hwnd,IDC_BUTTON_DEC);
	1916	+ hwndBUTTON_INC = GetDlgItem(hwnd,IDC_BUTTON_INC);
	1917	+ hwndCHECKBOX_VALID = GetDlgItem(hwnd,IDC_CHECKBOX_VALID);
	1918	+ hwndCLEAR = GetDlgItem(hwnd,IDCLEAR);
	1919	+ GetWindowRect(hwndEDIT,&rcEDIT); // x0y0 基準
	1920	+ GetWindowRect(hwndBUTTON_VERBOSITY,&rcBUTTON_VERBOSITY);
	1921	+ GetWindowRect(hwndEDIT_VERBOSITY,&rcEDIT_VERBOSITY);
	1922	+ GetWindowRect(hwndBUTTON_DEC,&rcBUTTON_DEC);
	1923	+ GetWindowRect(hwndBUTTON_INC,&rcBUTTON_INC);
	1924	+ GetWindowRect(hwndCHECKBOX_VALID,&rcCHECKBOX_VALID);
	1925	+ GetWindowRect(hwndCLEAR,&rcCLEAR);
	1926	+ GetClientRect(hwnd,&rcParent);
	1927	+ // IDC_BUTTON_VERBOSITY
	1928	+ cx = rcBUTTON_VERBOSITY.right-rcBUTTON_VERBOSITY.left;
	1929	+ cy = rcBUTTON_VERBOSITY.bottom-rcBUTTON_VERBOSITY.top;
	1930	+ x = rcBUTTON_VERBOSITY.left - rcEDIT.left;
	1931	+ y = rcParent.bottom - cy - 4;
	1932	+ MoveWindow(hwndBUTTON_VERBOSITY,x,y,cx,cy,TRUE);
	1933	+ if(cy>max) max = cy;
	1934	+ // IDC_EDIT_VERBOSITY
	1935	+ cx = rcEDIT_VERBOSITY.right-rcEDIT_VERBOSITY.left;
	1936	+ cy = rcEDIT_VERBOSITY.bottom-rcEDIT_VERBOSITY.top;
	1937	+ x = rcEDIT_VERBOSITY.left - rcEDIT.left;
	1938	+ y = rcParent.bottom - cy - 4;
	1939	+ MoveWindow(hwndEDIT_VERBOSITY,x,y,cx,cy,TRUE);
	1940	+ if(cy>max) max = cy;
	1941	+ // IDC_BUTTON_DEC
	1942	+ cx = rcBUTTON_DEC.right-rcBUTTON_DEC.left;
	1943	+ cy = rcBUTTON_DEC.bottom-rcBUTTON_DEC.top;
	1944	+ x = rcBUTTON_DEC.left - rcEDIT.left;
	1945	+ y = rcParent.bottom - cy - 4;
	1946	+ MoveWindow(hwndBUTTON_DEC,x,y,cx,cy,TRUE);
	1947	+ if(cy>max) max = cy;
	1948	+ // IDC_BUTTON_INC
	1949	+ cx = rcBUTTON_INC.right-rcBUTTON_INC.left;
	1950	+ cy = rcBUTTON_INC.bottom-rcBUTTON_INC.top;
	1951	+ x = rcBUTTON_INC.left - rcEDIT.left;
	1952	+ y = rcParent.bottom - cy - 4;
	1953	+ MoveWindow(hwndBUTTON_INC,x,y,cx,cy,TRUE);
	1954	+ if(cy>max) max = cy;
	1955	+ // IDC_CHECKBOX_VALID
	1956	+ cx = rcCHECKBOX_VALID.right-rcCHECKBOX_VALID.left;
	1957	+ cy = rcCHECKBOX_VALID.bottom-rcCHECKBOX_VALID.top;
	1958	+ x = rcCHECKBOX_VALID.left - rcEDIT.left;
	1959	+ y = rcParent.bottom - cy - 4;
	1960	+ MoveWindow(hwndCHECKBOX_VALID,x,y,cx,cy,TRUE);
	1961	+ if(cy>max) max = cy;
	1962	+ // IDCLEAR
	1963	+ cx = rcCLEAR.right-rcCLEAR.left;
	1964	+ cy = rcCLEAR.bottom-rcCLEAR.top;
	1965	+ x = rcCLEAR.left - rcEDIT.left;
	1966	+ y = rcParent.bottom - cy - 4;
	1967	+ MoveWindow(hwndCLEAR,x,y,cx,cy,TRUE);
	1968	+ if(cy>max) max = cy;
	1969	+ // IDC_EDIT
	1970	+ cx = rcParent.right - rcParent.left;
	1971	+ cy = rcParent.bottom - rcParent.top - max - 8;
	1972	+ x = rcParent.left;
	1973	+ y = rcParent.top;
	1974	+ MoveWindow(hwndEDIT,x,y,cx,cy,TRUE);
	1975	+ //
	1976	+ InvalidateRect(hwnd,&rcParent,FALSE);
	1977	+ UpdateWindow(hwnd);
	1978	+ GetWindowRect(hwnd,&rcParent);
	1979	+ break;
	1980	+ }
	1981	+ case SIZE_MINIMIZED:
	1982	+ case SIZE_MAXHIDE:
	1983	+ case SIZE_MAXSHOW:
	1984	+ default:
	1985	+ break;
	1986	+ }
	1987	+ return FALSE;
	1988	+ case WM_MOVE:
	1989	+ break;
	1990	+ // See PreDispatchMessage() in w32g2_main.c
	1991	+ case WM_SYSKEYDOWN:
	1992	+ case WM_KEYDOWN:
	1993	+ {
	1994	+ int nVirtKey = (int)wParam;
	1995	+ switch (nVirtKey) {
	1996	+ case VK_ESCAPE:
	1997	+ SendMessage(hwnd, WM_CLOSE, 0, 0);
	1998	+ break;
	1999	+ }
	2000	+ }
	2001	+ break;
	2002	+ case WM_DESTROY:
	2003	+ break;
	2004	+ case WM_CLOSE:
	2005	+ ShowWindow(hConsoleWnd, SW_HIDE);
	2006	+ break;
	2007	+ case WM_SETFOCUS:
	2008	+ HideCaret(hwnd);
	2009	+ break;
	2010	+ case WM_KILLFOCUS:
	2011	+ ShowCaret(hwnd);
	2012	+ break;
	2013	+ default:
	2014	+ return FALSE;
	2015	+ }
	2016	+ return FALSE;
2089	2017	}
2090	2018
2091	2019	// puts()
2092		-void PutsConsoleWnd(const char *str)
	2020	+void PutsConsoleWnd(char *str)
2093	2021	{
2094		- HWND hwnd;
2095		- if (!IsWindow(hConsoleWnd) \|\| !ConsoleWndFlag)
2096		- return;
2097		- hwnd = GetDlgItem(hConsoleWnd, IDC_EDIT);
2098		- PutsEditCtlWnd(hwnd, str);
	2022	+ HWND hwnd;
	2023	+ if (!IsWindow(hConsoleWnd) \|\| !ConsoleWndFlag)
	2024	+ return;
	2025	+ hwnd = GetDlgItem(hConsoleWnd, IDC_EDIT);
	2026	+ PutsEditCtlWnd(hwnd, str);
2099	2027	}
2100	2028
2101	2029	// printf()
2102	2030	void PrintfConsoleWnd(const char *fmt, ...)
2103	2031	{
2104		- HWND hwnd;
2105		- va_list ap;
2106		- if (!IsWindow(hConsoleWnd) \|\| !ConsoleWndFlag)
2107		- return;
2108		- hwnd = GetDlgItem(hConsoleWnd, IDC_EDIT);
2109		- va_start(ap, fmt);
2110		- VprintfEditCtlWnd(hwnd, fmt, ap);
2111		- va_end(ap);
	2032	+ HWND hwnd;
	2033	+ va_list ap;
	2034	+ if (!IsWindow(hConsoleWnd) \|\| !ConsoleWndFlag)
	2035	+ return;
	2036	+ hwnd = GetDlgItem(hConsoleWnd, IDC_EDIT);
	2037	+ va_start(ap, fmt);
	2038	+ VprintfEditCtlWnd(hwnd, fmt, ap);
	2039	+ va_end(ap);
2112	2040	}
2113	2041
2114	2042	// Clear
2115	2043	void ClearConsoleWnd(void)
2116	2044	{
2117		- HWND hwnd;
2118		- if (!IsWindow(hConsoleWnd))
2119		- return;
2120		- hwnd = GetDlgItem(hConsoleWnd, IDC_EDIT);
2121		- ClearEditCtlWnd(hwnd);
2122		-}
2123		-
2124		-// Update
2125		-void ConsoleWndApplyLevel(void)
2126		-{
2127		- ConsoleWndVerbosityUpdate();
	2045	+ HWND hwnd;
	2046	+ if (!IsWindow(hConsoleWnd))
	2047	+ return;
	2048	+ hwnd = GetDlgItem(hConsoleWnd, IDC_EDIT);
	2049	+ ClearEditCtlWnd(hwnd);
2128	2050	}
2129	2051
2130	2052	// ---------------------------------------------------------------------------

		@@ -2132,50 +2054,50 @@ void ConsoleWndApplyLevel(void)
2132	2054
2133	2055	static void ConsoleWndAllUpdate(void)
2134	2056	{
2135		- ConsoleWndVerbosityUpdate();
2136		- ConsoleWndValidUpdate();
2137		- Edit_LimitText(GetDlgItem(hConsoleWnd, IDC_EDIT_VERBOSITY), 3);
2138		- Edit_LimitText(GetDlgItem(hConsoleWnd, IDC_EDIT), ConsoleWndMaxSize);
	2057	+ ConsoleWndVerbosityUpdate();
	2058	+ ConsoleWndValidUpdate();
	2059	+ Edit_LimitText(GetDlgItem(hConsoleWnd, IDC_EDIT_VERBOSITY), 3);
	2060	+ Edit_LimitText(GetDlgItem(hConsoleWnd, IDC_EDIT), ConsoleWndMaxSize);
2139	2061	}
2140	2062
2141	2063	static void ConsoleWndValidUpdate(void)
2142	2064	{
2143		- if (ConsoleWndFlag)
2144		- CheckDlgButton(hConsoleWnd, IDC_CHECKBOX_VALID, 1);
2145		- else
2146		- CheckDlgButton(hConsoleWnd, IDC_CHECKBOX_VALID, 0);
	2065	+ if (ConsoleWndFlag)
	2066	+ CheckDlgButton(hConsoleWnd, IDC_CHECKBOX_VALID, 1);
	2067	+ else
	2068	+ CheckDlgButton(hConsoleWnd, IDC_CHECKBOX_VALID, 0);
2147	2069	}
2148	2070
2149	2071	static void ConsoleWndValidApply(void)
2150	2072	{
2151		- if (IsDlgButtonChecked(hConsoleWnd, IDC_CHECKBOX_VALID))
2152		- ConsoleWndFlag = 1;
2153		- else
2154		- ConsoleWndFlag = 0;
	2073	+ if (IsDlgButtonChecked(hConsoleWnd, IDC_CHECKBOX_VALID))
	2074	+ ConsoleWndFlag = 1;
	2075	+ else
	2076	+ ConsoleWndFlag = 0;
2155	2077	}
2156	2078
2157	2079	static void ConsoleWndVerbosityUpdate(void)
2158	2080	{
2159		- SetDlgItemInt(hConsoleWnd, IDC_EDIT_VERBOSITY, (UINT) ctl->verbosity, TRUE);
	2081	+ SetDlgItemInt(hConsoleWnd, IDC_EDIT_VERBOSITY, (UINT)ctl->verbosity, TRUE);
2160	2082	}
2161	2083
2162	2084	static void ConsoleWndVerbosityApply(void)
2163	2085	{
2164		- char buffer[64];
2165		- HWND hwnd;
2166		- hwnd = GetDlgItem(hConsoleWnd, IDC_EDIT_VERBOSITY);
2167		- if (!IsWindow(hConsoleWnd)) return;
2168		- if (Edit_GetText(hwnd, buffer, 60) <= 0) return;
2169		- ctl->verbosity = atoi(buffer);
2170		- ConsoleWndVerbosityUpdate();
	2086	+ char buffer[64];
	2087	+ HWND hwnd;
	2088	+ hwnd = GetDlgItem(hConsoleWnd, IDC_EDIT_VERBOSITY);
	2089	+ if (!IsWindow(hConsoleWnd)) return;
	2090	+ if (Edit_GetText(hwnd, buffer, 60) <= 0) return;
	2091	+ ctl->verbosity = atoi(buffer);
	2092	+ ConsoleWndVerbosityUpdate();
2171	2093	}
2172	2094
2173	2095	static void ConsoleWndVerbosityApplyIncDec(int num)
2174	2096	{
2175		- if (!IsWindow(hConsoleWnd)) return;
2176		- ctl->verbosity += num;
2177		- RANGE(ctl->verbosity, -1, 4);
2178		- ConsoleWndVerbosityUpdate();
	2097	+ if (!IsWindow(hConsoleWnd)) return;
	2098	+ ctl->verbosity += num;
	2099	+ RANGE(ctl->verbosity, -1, 4);
	2100	+ ConsoleWndVerbosityUpdate();
2179	2101	}
2180	2102
2181	2103	#endif /* HAVE_SYN_CONSOLE */

		@@ -2184,8 +2106,8 @@ static void ConsoleWndVerbosityApplyIncDec(int num)
2184	2106	static int winplaymidi_sleep_level = 2;
2185	2107	static DWORD winplaymidi_active_start_time = 0;
2186	2108
2187		-void winplaymidi(void)
2188		-{
	2109	+void winplaymidi(void) {
	2110	+
2189	2111	if (winplaymidi_sleep_level < 1) {
2190	2112	winplaymidi_sleep_level = 1;
2191	2113	}

		@@ -2231,7 +2153,7 @@ void winplaymidi(void)
2231	2153
2232	2154	// ---------------------------------------------------------------------------
2233	2155	// prototypes of functions
2234		-INT_PTR CALLBACK SoundSpecWndProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam);
	2156	+LRESULT CALLBACK SoundSpecWndProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam);
2235	2157	#ifdef SUPPORT_SOUNDSPEC
2236	2158	extern void TargetSpectrogramCanvas(HWND hwnd);
2237	2159	extern void HandleSpecKeydownEvent(long message, short modifiers);

		@@ -2245,108 +2167,99 @@ extern void UpdateSpectrogramCanvas(void);
2245	2167	// Global Functions
2246	2168	void InitSoundSpecWnd(HWND hParentWnd)
2247	2169	{
2248		- HICON hIcon;
2249		- if (hSoundSpecWnd) {
2250		- DestroyWindow(hSoundSpecWnd);
2251		- hSoundSpecWnd = NULL;
2252		- }
2253		- switch (PlayerLanguage) {
2254		- case LANGUAGE_JAPANESE:
2255		- hSoundSpecWnd = CreateDialog
2256		- (hInst, MAKEINTRESOURCE(IDD_DIALOG_SOUNDSPEC), hParentWnd, SoundSpecWndProc);
2257		- break;
2258		- case LANGUAGE_ENGLISH:
2259		- default:
2260		- hSoundSpecWnd = CreateDialog
2261		- (hInst, MAKEINTRESOURCE(IDD_DIALOG_SOUNDSPEC_EN), hParentWnd, SoundSpecWndProc);
2262		- break;
2263		- }
2264		- hIcon = LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_TIMIDITY), IMAGE_ICON, 16, 16, 0);
2265		- if (hIcon)
2266		- SendMessage(hSoundSpecWnd, WM_SETICON, FALSE, (LPARAM) hIcon);
2267		- ShowWindow(hSoundSpecWnd, SoundSpecWndStartFlag ? SW_SHOW : SW_HIDE);
2268		- UpdateWindow(hSoundSpecWnd);
	2170	+ HICON hIcon;
	2171	+ if (hSoundSpecWnd) {
	2172	+ DestroyWindow(hSoundSpecWnd);
	2173	+ hSoundSpecWnd = NULL;
	2174	+ }
	2175	+ switch (PlayerLanguage) {
	2176	+ case LANGUAGE_JAPANESE:
	2177	+ hSoundSpecWnd = CreateDialog
	2178	+ (hInst, MAKEINTRESOURCE(IDD_DIALOG_SOUNDSPEC), hParentWnd, SoundSpecWndProc);
	2179	+ break;
	2180	+ case LANGUAGE_ENGLISH:
	2181	+ default:
	2182	+ hSoundSpecWnd = CreateDialog
	2183	+ (hInst, MAKEINTRESOURCE(IDD_DIALOG_SOUNDSPEC_EN), hParentWnd, SoundSpecWndProc);
	2184	+ break;
	2185	+ }
	2186	+ hIcon = LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_TIMIDITY), IMAGE_ICON, 16, 16, 0);
	2187	+ if (hIcon)
	2188	+ SendMessage(hSoundSpecWnd, WM_SETICON, FALSE, (LPARAM)hIcon);
	2189	+ ShowWindow(hSoundSpecWnd, SoundSpecWndStartFlag ? SW_SHOW : SW_HIDE);
	2190	+ UpdateWindow(hSoundSpecWnd);
2269	2191	}
2270	2192
2271		-INT_PTR CALLBACK
	2193	+LRESULT CALLBACK
2272	2194	SoundSpecWndProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam)
2273	2195	{
2274		- switch (uMess) {
2275		- case WM_INITDIALOG:
	2196	+ switch (uMess) {
	2197	+ case WM_INITDIALOG:
2276	2198	#ifdef SUPPORT_SOUNDSPEC
2277		- open_soundspec();
2278		- TargetSpectrogramCanvas(hwnd);
2279		- soundspec_update_wave(NULL, 0);
	2199	+ open_soundspec();
	2200	+ TargetSpectrogramCanvas(hwnd);
	2201	+ soundspec_update_wave(NULL, 0);
2280	2202	#endif /* SUPPORT_SOUNDSPEC */
2281		- return FALSE;
2282		-
2283		- case WM_COMMAND:
2284		- switch (LOWORD(wParam)) {
2285		- case IDCLOSE:
2286		- ShowWindow(hwnd, SW_HIDE);
2287		- break;
2288		-
2289		- default:
2290		- return FALSE;
2291		- }
2292		- break;
2293		-
2294		- case WM_ERASEBKGND:
2295		- return 0;
2296		-
2297		- case WM_PAINT:
	2203	+ return FALSE;
	2204	+ case WM_COMMAND:
	2205	+ switch (LOWORD(wParam)) {
	2206	+ case IDCLOSE:
	2207	+ ShowWindow(hwnd, SW_HIDE);
	2208	+ break;
	2209	+ default:
	2210	+ return FALSE;
	2211	+ }
	2212	+ break;
	2213	+ case WM_ERASEBKGND:
	2214	+ return 0;
	2215	+ case WM_PAINT:
2298	2216	#ifdef SUPPORT_SOUNDSPEC
2299		- UpdateSpectrogramCanvas();
	2217	+ UpdateSpectrogramCanvas();
2300	2218	#endif /* SUPPORT_SOUNDSPEC */
2301		- break;
2302		-
2303		- case WM_SIZE:
2304		- InvalidateRect(hwnd, NULL, FALSE);
2305		- return FALSE;
2306		-
2307		- case WM_MOVE:
2308		- return FALSE;
2309		-
2310		- case WM_DESTROY:
	2219	+ break;
	2220	+ case WM_SIZE:
	2221	+ InvalidateRect(hwnd, NULL, FALSE);
	2222	+ return FALSE;
	2223	+ case WM_MOVE:
	2224	+ return FALSE;
	2225	+ case WM_DESTROY:
2311	2226	#ifdef SUPPORT_SOUNDSPEC
2312		- close_soundspec();
	2227	+ close_soundspec();
2313	2228	#endif /* SUPPORT_SOUNDSPEC */
2314		- break;
2315		-
2316		- case WM_CLOSE:
2317		- ShowWindow(hSoundSpecWnd, SW_HIDE);
2318		- break;
2319		-
2320		- case WM_CHAR:
2321		- break;
2322		-
2323		- case WM_SYSKEYDOWN:
2324		- case WM_KEYDOWN: {
2325		- int nVirtKey = (int) wParam;
2326		- short nModifiers = (int) lParam & 0xFFFF;
2327		- switch (nVirtKey) {
2328		- case VK_ESCAPE:
2329		- SendMessage(hwnd, WM_CLOSE, 0, 0);
2330		- break;
2331		-
2332		- default:
	2229	+ break;
	2230	+ case WM_CLOSE:
	2231	+ ShowWindow(hSoundSpecWnd, SW_HIDE);
	2232	+ break;
	2233	+ case WM_CHAR:
	2234	+ break;
	2235	+ case WM_SYSKEYDOWN:
	2236	+ case WM_KEYDOWN:
	2237	+ {
	2238	+ int nVirtKey = (int)wParam;
	2239	+ short nModifiers = (int)lParam & 0xFFFF;
	2240	+ switch (nVirtKey) {
	2241	+ case VK_ESCAPE:
	2242	+ SendMessage(hwnd, WM_CLOSE, 0, 0);
	2243	+ break;
	2244	+ default:
2333	2245	#ifdef SUPPORT_SOUNDSPEC
2334		- HandleSpecKeydownEvent(nVirtKey, nModifiers);
	2246	+ HandleSpecKeydownEvent(nVirtKey, nModifiers);
2335	2247	#endif /* SUPPORT_SOUNDSPEC */
2336		- break;
2337		- }
2338		- break; }
2339		-
2340		- case WM_GETMINMAXINFO: {
2341		- LPMINMAXINFO lpmmi = (LPMINMAXINFO) lParam;
2342		- lpmmi->ptMinTrackSize.x = max(192, lpmmi->ptMinTrackSize.x);
2343		- lpmmi->ptMinTrackSize.y = max(100, lpmmi->ptMinTrackSize.y);
2344		- return 0; }
2345		-
2346		- default:
2347		- return FALSE;
2348		- }
2349		- return FALSE;
	2248	+ break;
	2249	+ }
	2250	+ }
	2251	+ break;
	2252	+ case WM_GETMINMAXINFO:
	2253	+ {
	2254	+ LPMINMAXINFO lpmmi = (LPMINMAXINFO) lParam;
	2255	+ lpmmi->ptMinTrackSize.x = max(192, lpmmi->ptMinTrackSize.x);
	2256	+ lpmmi->ptMinTrackSize.y = max(100, lpmmi->ptMinTrackSize.y);
	2257	+ }
	2258	+ return 0;
	2259	+ default:
	2260	+ return FALSE;
	2261	+ }
	2262	+ return FALSE;
2350	2263	}
2351	2264
2352	2265	// ---------------------------------------------------------------------------

--- a/interface/w32g_utl.c

+++ b/interface/w32g_utl.c

		@@ -1,6 +1,6 @@
1	1	/*
2	2	TiMidity++ -- MIDI to WAVE converter and player
3		- Copyright (C) 1999-2018 Masanao Izumo <iz@onicos.co.jp>
	3	+ Copyright (C) 1999-2002 Masanao Izumo <mo@goice.co.jp>
4	4	Copyright (C) 1995 Tuukka Toivonen <toivonen@clinet.fi>
5	5
6	6	This program is free software; you can redistribute it and/or modify

		@@ -18,7 +18,7 @@
18	18	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	19
20	20	w32g_utl.c: written by Daisuke Aoki <dai@y7.net>
21		- Masanao Izumo <iz@onicos.co.jp>
	21	+ Masanao Izumo <mo@goice.co.jp>
22	22	*/
23	23
24	24

		@@ -31,7 +31,11 @@
31	31	#include <stdlib.h>
32	32	#endif /* HAVE_STDLIB_H */
33	33	#include <stdio.h>
34		-#include "_string.h"
	34	+#ifndef NO_STRING_H
	35	+#include <string.h>
	36	+#else
	37	+#include <strings.h>
	38	+#endif
35	39	#include <ctype.h>
36	40
37	41	#include "timidity.h"

		@@ -48,7 +52,6 @@
48	52	#include "soundspec.h"
49	53	#endif /* SUPPORT_SOUNDSPEC */
50	54	#include "wrd.h"
51		-#include <tchar.h>
52	55	#include "w32g.h"
53	56	#include "w32g_pref.h"
54	57	#include "w32g_utl.h"

		@@ -109,7 +112,7 @@ extern int SecondMode;
109	112	extern int AutoloadPlaylist;
110	113	extern int AutosavePlaylist;
111	114	extern int PosSizeSave;
112		-extern unsigned char opt_normal_chorus_plus;
	115	+extern unsigned char opt_normal_chorus_plus;
113	116
114	117	///r
115	118	//char DefaultPlaylistName[PLAYLIST_MAX][] = {"default.pls"};

		@@ -135,27 +138,22 @@ int
135	138	IniGetKeyInt64(char section, char key,int64 *n)
136	139	{
137	140	CHAR buffer[INI_MAXLEN];
138		- GetPrivateProfileStringA
	141	+ GetPrivateProfileString
139	142	(section,key,INI_INVALID,buffer,INI_MAXLEN-1,IniFile);
140		- if (strcasecmp(buffer,INI_INVALID)){
141		-#ifdef TIMIDITY_HAVE_INT64
	143	+ if(strcasecmp(buffer,INI_INVALID)){
142	144	*n =_atoi64(buffer);
143		-#else
144		- double d = (double) atof(buffer);
145		- *n = (int) d;
146		-#endif
147	145	return 0;
148	146	} else
149	147	return 1;
150	148	}
151	149
152	150	int
153		-IniGetKeyInt32(char section, char key, int32 *n)
	151	+IniGetKeyInt32(char section, char key,int32 *n)
154	152	{
155	153	CHAR buffer[INI_MAXLEN];
156		- GetPrivateProfileStringA
157		- (section, key, INI_INVALID, buffer, INI_MAXLEN - 1, IniFile);
158		- if (strcasecmp(buffer, INI_INVALID)) {
	154	+ GetPrivateProfileString
	155	+ (section,key,INI_INVALID,buffer,INI_MAXLEN-1,IniFile);
	156	+ if(strcasecmp(buffer,INI_INVALID)){
159	157	*n =atol(buffer);
160	158	return 0;
161	159	} else

		@@ -163,12 +161,12 @@ IniGetKeyInt32(char section, char key, int32 *n)
163	161	}
164	162
165	163	int
166		-IniGetKeyInt(char section, char key, int *n)
	164	+IniGetKeyInt(char section, char key,int *n)
167	165	{
168	166	CHAR buffer[INI_MAXLEN];
169		- GetPrivateProfileStringA
170		- (section, key, INI_INVALID, buffer, INI_MAXLEN - 1, IniFile);
171		- if (strcasecmp(buffer, INI_INVALID)) {
	167	+ GetPrivateProfileString
	168	+ (section,key,INI_INVALID,buffer,INI_MAXLEN-1,IniFile);
	169	+ if(strcasecmp(buffer,INI_INVALID)){
172	170	*n =atoi(buffer);
173	171	return 0;
174	172	} else

		@@ -176,12 +174,12 @@ IniGetKeyInt(char section, char key, int *n)
176	174	}
177	175
178	176	int
179		-IniGetKeyInt8(char section, char key, int8 *n)
	177	+IniGetKeyInt8(char section, char key,int8 *n)
180	178	{
181	179	CHAR buffer[INI_MAXLEN];
182		- GetPrivateProfileStringA
183		- (section, key, INI_INVALID, buffer, INI_MAXLEN - 1, IniFile);
184		- if (strcasecmp(buffer, INI_INVALID)) {
	180	+ GetPrivateProfileString
	181	+ (section,key,INI_INVALID,buffer,INI_MAXLEN-1,IniFile);
	182	+ if(strcasecmp(buffer,INI_INVALID)){
185	183	*n = (int8)atoi(buffer);
186	184	return 0;
187	185	} else

		@@ -195,11 +193,11 @@ IniGetKeyInt32Array(char section, char key, int32 *n, int arraysize)
195	193	int ret = 0;
196	194	CHAR buffer[INI_MAXLEN];
197	195	char keybuffer[INI_MAXLEN];
198		- for (i = 0; i < arraysize; i++) {
199		- snprintf(keybuffer, INI_MAXLEN - 1, "%s%d", key, i);
200		- GetPrivateProfileStringA
201		- (section, keybuffer, INI_INVALID, buffer, INI_MAXLEN - 1, IniFile);
202		- if (strcasecmp(buffer, INI_INVALID))
	196	+ for(i=0;i<arraysize;i++){
	197	+ sprintf(keybuffer,"%s%d",key,i);
	198	+ GetPrivateProfileString
	199	+ (section,keybuffer,INI_INVALID,buffer,INI_MAXLEN-1,IniFile);
	200	+ if(strcasecmp(buffer,INI_INVALID))
203	201	n[i] =atol(buffer);
204	202	else
205	203	ret++;

		@@ -214,12 +212,12 @@ IniGetKeyIntArray(char section, char key, int *n, int arraysize)
214	212	int ret = 0;
215	213	CHAR buffer[INI_MAXLEN];
216	214	char keybuffer[INI_MAXLEN];
217		- for (i = 0; i < arraysize; i++) {
218		- snprintf(keybuffer, INI_MAXLEN - 1, "%s%d", key, i);
219		- GetPrivateProfileStringA
220		- (section, keybuffer, INI_INVALID, buffer, INI_MAXLEN - 1, IniFile);
221		- if (strcasecmp(buffer, INI_INVALID))
222		- n[i] =atoi(buffer);
	215	+ for(i=0;i<arraysize;i++){
	216	+ sprintf(keybuffer,"%s%d",key,i);
	217	+ GetPrivateProfileString
	218	+ (section,keybuffer,INI_INVALID,buffer,INI_MAXLEN-1,IniFile);
	219	+ if(strcasecmp(buffer,INI_INVALID))
	220	+ n[i] =atol(buffer);
223	221	else
224	222	ret++;
225	223	}

		@@ -230,22 +228,22 @@ int
230	228	IniGetKeyFloat(char section, char key, FLOAT_T *n)
231	229	{
232	230	CHAR buffer[INI_MAXLEN];
233		- GetPrivateProfileStringA(section, key, INI_INVALID, buffer,
234		- INI_MAXLEN - 1, IniFile);
235		- if (strcasecmp(buffer, INI_INVALID))
	231	+ GetPrivateProfileString(section, key, INI_INVALID, buffer,
	232	+ INI_MAXLEN-1, IniFile);
	233	+ if(strcasecmp(buffer, INI_INVALID))
236	234	{
237		- *n = (FLOAT_T) atof(buffer);
238		- return 0;
	235	+ *n = (FLOAT_T)atof(buffer);
	236	+ return 0;
239	237	}
240	238	else
241		- return 1;
	239	+ return 1;
242	240	}
243	241
244	242	int
245	243	IniGetKeyChar(char section, char key, char *c)
246	244	{
247	245	char buffer[64];
248		- if (IniGetKeyStringN(section, key, buffer, 64 - 1))
	246	+ if(IniGetKeyStringN(section,key,buffer,60))
249	247	return 1;
250	248	else {
251	249	*c = buffer[0];

		@@ -254,28 +252,28 @@ IniGetKeyChar(char section, char key, char *c)
254	252	}
255	253
256	254	int
257		-IniGetKeyString(char section, char key, char *str)
	255	+IniGetKeyString(char section, char key,char *str)
258	256	{
259	257	CHAR buffer[INI_MAXLEN];
260		- GetPrivateProfileStringA
261		- (section, key, INI_INVALID, buffer, INI_MAXLEN - 1, IniFile);
262		- if (strcasecmp(buffer, INI_INVALID)) {
263		- strcpy(str, buffer);
	258	+ GetPrivateProfileString
	259	+ (section,key,INI_INVALID,buffer,INI_MAXLEN-1,IniFile);
	260	+ if(strcasecmp(buffer,INI_INVALID)){
	261	+ strcpy(str,buffer);
264	262	return 0;
265	263	} else
266	264	return 1;
267	265	}
268	266
269	267	int
270		-IniGetKeyStringN(char section, char key, char *str, int size)
	268	+IniGetKeyStringN(char section, char key,char *str, int size)
271	269	{
272	270	CHAR buffer[INI_MAXLEN];
273		- GetPrivateProfileStringA
274		- (section, key, INI_INVALID, buffer, INI_MAXLEN - 1, IniFile);
275		- if (strcasecmp(buffer, INI_INVALID)) {
276		- strncpy(str, buffer, size);
	271	+ GetPrivateProfileString
	272	+ (section,key,INI_INVALID,buffer,INI_MAXLEN-1,IniFile);
	273	+ if(strcasecmp(buffer,INI_INVALID)){
	274	+ strncpy(str,buffer,size);
277	275	return 0;
278		- } else
	276	+ } else
279	277	return 1;
280	278	}
281	279	///r

		@@ -284,38 +282,38 @@ IniPutKeyInt64(char section, char key,int64 *n)
284	282	{
285	283	CHAR buffer[INI_MAXLEN];
286	284	sprintf(buffer,"%ld",*n);
287		- WritePrivateProfileStringA
	285	+ WritePrivateProfileString
288	286	(section,key,buffer,IniFile);
289	287	return 0;
290	288	}
291	289
292	290	int
293		-IniPutKeyInt32(char section, char key, int32 *n)
	291	+IniPutKeyInt32(char section, char key,int32 *n)
294	292	{
295		- CHAR buffer[INI_MAXLEN] = { 0 };
296		- snprintf(buffer, INI_MAXLEN - 1, "%ld", *n);
297		- WritePrivateProfileStringA
298		- (section, key, buffer, IniFile);
	293	+ CHAR buffer[INI_MAXLEN];
	294	+ sprintf(buffer,"%ld",*n);
	295	+ WritePrivateProfileString
	296	+ (section,key,buffer,IniFile);
299	297	return 0;
300	298	}
301	299
302	300	int
303		-IniPutKeyInt(char section, char key, int *n)
	301	+IniPutKeyInt(char section, char key,int *n)
304	302	{
305		- CHAR buffer[INI_MAXLEN] = { 0 };
306		- snprintf(buffer, INI_MAXLEN - 1, "%ld", *n);
307		- WritePrivateProfileStringA
308		- (section, key, buffer, IniFile);
	303	+ CHAR buffer[INI_MAXLEN];
	304	+ sprintf(buffer,"%ld",*n);
	305	+ WritePrivateProfileString
	306	+ (section,key,buffer,IniFile);
309	307	return 0;
310	308	}
311	309
312	310	int
313		-IniPutKeyInt8(char section, char key, int8 *n)
	311	+IniPutKeyInt8(char section, char key,int8 *n)
314	312	{
315		- CHAR buffer[INI_MAXLEN] = { 0 };
316		- snprintf(buffer, INI_MAXLEN - 1, "%ld", (int)(*n));
317		- WritePrivateProfileStringA
318		- (section, key, buffer, IniFile);
	313	+ CHAR buffer[INI_MAXLEN];
	314	+ sprintf(buffer,"%ld",(int)(*n));
	315	+ WritePrivateProfileString
	316	+ (section,key,buffer,IniFile);
319	317	return 0;
320	318	}
321	319

		@@ -323,12 +321,12 @@ int
323	321	IniPutKeyInt32Array(char section, char key, int32 *n, int arraysize)
324	322	{
325	323	int i;
326		- CHAR buffer[INI_MAXLEN] = { 0 };
327		- CHAR keybuffer[INI_MAXLEN] = { 0 };
328		- for (i = 0; i < arraysize; i++) {
329		- snprintf(buffer, INI_MAXLEN - 1, "%ld", n[i]);
330		- snprintf(keybuffer, INI_MAXLEN - 1, "%s%d", key, i);
331		- WritePrivateProfileStringA(section, keybuffer, buffer, IniFile);
	324	+ CHAR buffer[INI_MAXLEN];
	325	+ CHAR keybuffer[INI_MAXLEN];
	326	+ for(i=0;i<arraysize;i++){
	327	+ sprintf(buffer,"%ld",n[i]);
	328	+ sprintf(keybuffer,"%s%d",key,i);
	329	+ WritePrivateProfileString(section,keybuffer,buffer,IniFile);
332	330	}
333	331	return 0;
334	332	}

		@@ -337,12 +335,12 @@ int
337	335	IniPutKeyIntArray(char section, char key, int *n, int arraysize)
338	336	{
339	337	int i;
340		- CHAR buffer[INI_MAXLEN] = { 0 };
341		- CHAR keybuffer[INI_MAXLEN] = { 0 };
342		- for (i = 0; i < arraysize; i++) {
343		- snprintf(buffer, INI_MAXLEN - 1, "%ld", n[i]);
344		- snprintf(keybuffer, INI_MAXLEN - 1, "%s%d", key, i);
345		- WritePrivateProfileStringA(section, keybuffer, buffer, IniFile);
	338	+ CHAR buffer[INI_MAXLEN];
	339	+ CHAR keybuffer[INI_MAXLEN];
	340	+ for(i=0;i<arraysize;i++){
	341	+ sprintf(buffer,"%ld",n[i]);
	342	+ sprintf(keybuffer,"%s%d",key,i);
	343	+ WritePrivateProfileString(section,keybuffer,buffer,IniFile);
346	344	}
347	345	return 0;
348	346	}

		@@ -350,62 +348,62 @@ IniPutKeyIntArray(char section, char key, int *n, int arraysize)
350	348	int
351	349	IniPutKeyChar(char section, char key, char *c)
352	350	{
353		- char buffer[64] = { 0 };
354		- snprintf(buffer, 64 - 1, "%c", *c);
355		- return IniPutKeyStringN(section, key, buffer, 64 - 1);
	351	+ char buffer[64];
	352	+ sprintf(buffer,"%c",*c);
	353	+ return IniPutKeyStringN(section,key,buffer,60);
356	354	}
357	355
358	356	int
359	357	IniPutKeyString(char section, char key, char *str)
360	358	{
361		- WritePrivateProfileStringA(section, key, str, IniFile);
	359	+ WritePrivateProfileString(section,key,str,IniFile);
362	360	return 0;
363	361	}
364	362
365	363	int
366	364	IniPutKeyStringN(char section, char key, char *str, int size)
367	365	{
368		- WritePrivateProfileStringA(section, key, str, IniFile);
	366	+ WritePrivateProfileString(section,key,str,IniFile);
369	367	return 0;
370	368	}
371	369
372	370	int
373		-IniPutKeyFloat(char section, char key, FLOAT_T n)
	371	+IniPutKeyFloat(char section, char key,FLOAT_T n)
374	372	{
375	373	CHAR buffer[INI_MAXLEN];
376		- snprintf(buffer, INI_MAXLEN - 1, "%f", (double)n);
377		- WritePrivateProfileStringA(section, key, buffer, IniFile);
	374	+ sprintf(buffer,"%f", (double)n);
	375	+ WritePrivateProfileString(section, key, buffer, IniFile);
378	376	return 0;
379	377	}
380	378
381	379	void IniFlush(void)
382	380	{
383		- WritePrivateProfileStringA(NULL, NULL, NULL, IniFile);
	381	+ WritePrivateProfileString(NULL,NULL,NULL,IniFile);
384	382	}
385	383
386		-// LoadIniFile(), SaveIniFile()
	384	+// LoadIniFile() , SaveIniFile()
387	385	// ***************************************************************************
388	386	// Setting
389	387
390	388	#define SetFlag(flag) (!!(flag))
391	389
392		-static int32 SetValue(int32 value, int32 min, int32 max)
	390	+static long SetValue(int32 value, int32 min, int32 max)
393	391	{
394	392	int32 v = value;
395		- if (v < min) v = min;
396		- else if (v > max) v = max;
	393	+ if(v < min) v = min;
	394	+ else if( v > max) v = max;
397	395	return v;
398	396	}
399	397
400	398	void
401	399	ApplySettingPlayer(SETTING_PLAYER *sp)
402	400	{
403		- static int first = 0;
	401	+ static int first = 0;
404	402	InitMinimizeFlag = SetFlag(sp->InitMinimizeFlag);
405	403	DebugWndStartFlag = SetFlag(sp->DebugWndStartFlag);
406	404	ConsoleWndStartFlag = SetFlag(sp->ConsoleWndStartFlag);
407	405	ListWndStartFlag = SetFlag(sp->ListWndStartFlag);
408		- TracerWndStartFlag = SetFlag(sp->TracerWndStartFlag);
	406	+ TracerWndStartFlag = SetFlag(sp->TracerWndStartFlag);
409	407	DocWndStartFlag = SetFlag(sp->DocWndStartFlag);
410	408	WrdWndStartFlag = SetFlag(sp->WrdWndStartFlag);
411	409	SoundSpecWndStartFlag = SetFlag(sp->SoundSpecWndStartFlag);

		@@ -416,20 +414,20 @@ ApplySettingPlayer(SETTING_PLAYER *sp)
416	414	DocWndFlag = SetFlag(sp->DocWndFlag);
417	415	WrdWndFlag = SetFlag(sp->WrdWndFlag);
418	416	SoundSpecWndFlag = SetFlag(sp->SoundSpecWndFlag);
419		- SubWindowMax = SetValue(sp->SubWindowMax, 1, 10);
	417	+ SubWindowMax = SetValue(sp->SubWindowMax,1,10);
420	418	playlist_max_ini = SetValue(sp->PlaylistMax,1,PLAYLIST_MAX);
421	419	ConsoleClearFlag = SetValue(sp->ConsoleClearFlag,0,256);
422		- strncpy(ConfigFile, sp->ConfigFile, FILEPATH_MAX);
	420	+ strncpy(ConfigFile,sp->ConfigFile,FILEPATH_MAX);
423	421	ConfigFile[FILEPATH_MAX - 1] = '\0';
424		- strncpy(PlaylistFile, sp->PlaylistFile, FILEPATH_MAX);
	422	+ strncpy(PlaylistFile,sp->PlaylistFile,FILEPATH_MAX);
425	423	PlaylistFile[FILEPATH_MAX - 1] = '\0';
426		- strncpy(PlaylistHistoryFile, sp->PlaylistHistoryFile, FILEPATH_MAX);
	424	+ strncpy(PlaylistHistoryFile,sp->PlaylistHistoryFile,FILEPATH_MAX);
427	425	PlaylistHistoryFile[FILEPATH_MAX - 1] = '\0';
428		- strncpy(MidiFileOpenDir, sp->MidiFileOpenDir, FILEPATH_MAX);
	426	+ strncpy(MidiFileOpenDir,sp->MidiFileOpenDir,FILEPATH_MAX);
429	427	MidiFileOpenDir[FILEPATH_MAX - 1] = '\0';
430		- strncpy(ConfigFileOpenDir, sp->ConfigFileOpenDir, FILEPATH_MAX);
	428	+ strncpy(ConfigFileOpenDir,sp->ConfigFileOpenDir,FILEPATH_MAX);
431	429	ConfigFileOpenDir[FILEPATH_MAX - 1] = '\0';
432		- strncpy(PlaylistFileOpenDir, sp->PlaylistFileOpenDir, FILEPATH_MAX);
	430	+ strncpy(PlaylistFileOpenDir,sp->PlaylistFileOpenDir,FILEPATH_MAX);
433	431	PlaylistFileOpenDir[FILEPATH_MAX - 1] = '\0';
434	432	PlayerThreadPriority = sp->PlayerThreadPriority;
435	433	GUIThreadPriority = sp->GUIThreadPriority;

		@@ -441,26 +439,26 @@ ApplySettingPlayer(SETTING_PLAYER *sp)
441	439	DocFontSize = sp->DocFontSize;
442	440	ListFontSize = sp->ListFontSize;
443	441	TracerFontSize = sp->TracerFontSize;
444		- strncpy(SystemFont, sp->SystemFont, LF_FULLFACESIZE + 1);
	442	+ strncpy(SystemFont,sp->SystemFont,LF_FULLFACESIZE + 1);
445	443	SystemFont[LF_FULLFACESIZE] = '\0';
446		- strncpy(PlayerFont, sp->PlayerFont, LF_FULLFACESIZE + 1);
	444	+ strncpy(PlayerFont,sp->PlayerFont,LF_FULLFACESIZE + 1);
447	445	PlayerFont[LF_FULLFACESIZE] = '\0';
448		- strncpy(WrdFont, sp->WrdFont, LF_FULLFACESIZE + 1);
	446	+ strncpy(WrdFont,sp->WrdFont,LF_FULLFACESIZE + 1);
449	447	WrdFont[LF_FULLFACESIZE] = '\0';
450		- strncpy(DocFont, sp->DocFont, LF_FULLFACESIZE + 1);
	448	+ strncpy(DocFont,sp->DocFont,LF_FULLFACESIZE + 1);
451	449	DocFont[LF_FULLFACESIZE] = '\0';
452		- strncpy(ListFont, sp->ListFont, LF_FULLFACESIZE + 1);
	450	+ strncpy(ListFont,sp->ListFont,LF_FULLFACESIZE + 1);
453	451	ListFont[LF_FULLFACESIZE] = '\0';
454		- strncpy(TracerFont, sp->TracerFont, LF_FULLFACESIZE + 1);
	452	+ strncpy(TracerFont,sp->TracerFont,LF_FULLFACESIZE + 1);
455	453	TracerFont[LF_FULLFACESIZE] = '\0';
456	454	// Apply font functions ...
457	455
458	456	DocMaxSize = sp->DocMaxSize;
459		- strncpy(DocFileExt, sp->DocFileExt, 256);
	457	+ strncpy(DocFileExt,sp->DocFileExt,256);
460	458	DocFileExt[256 - 1] = '\0';
461	459	PlayerLanguage = sp->PlayerLanguage;
462		- DocWndIndependent = sp->DocWndIndependent;
463		- DocWndAutoPopup = sp->DocWndAutoPopup;
	460	+ DocWndIndependent = sp->DocWndIndependent;
	461	+ DocWndAutoPopup = sp->DocWndAutoPopup;
464	462	SeachDirRecursive = sp->SeachDirRecursive;
465	463	IniFileAutoSave = sp->IniFileAutoSave;
466	464	SecondMode = sp->SecondMode;

		@@ -468,12 +466,12 @@ ApplySettingPlayer(SETTING_PLAYER *sp)
468	466	AutosavePlaylist = sp->AutosavePlaylist;
469	467	PosSizeSave = sp->PosSizeSave;
470	468	///r
471		- main_panel_update_time = sp->main_panel_update_time;
	469	+ main_panel_update_time = sp->main_panel_update_time;
472	470
473		- if (!first) { // 初回のみ
474		- first++;
475		- playlist_max = playlist_max_ini;
476		- }
	471	+ if(!first){ // 初回のみ
	472	+ first++;
	473	+ playlist_max = playlist_max_ini;
	474	+ }
477	475	}
478	476
479	477	void

		@@ -486,7 +484,7 @@ SaveSettingPlayer(SETTING_PLAYER *sp)
486	484	sp->TracerWndStartFlag = SetFlag(TracerWndStartFlag);
487	485	sp->DocWndStartFlag = SetFlag(DocWndStartFlag);
488	486	sp->WrdWndStartFlag = SetFlag(WrdWndStartFlag);
489		- sp->SoundSpecWndStartFlag = SetFlag(SoundSpecWndStartFlag);
	487	+ sp->SoundSpecWndStartFlag = SetFlag(SoundSpecWndStartFlag);
490	488	sp->DebugWndFlag = SetFlag(DebugWndFlag);
491	489	sp->ConsoleWndFlag = SetFlag(ConsoleWndFlag);
492	490	sp->ListWndFlag = SetFlag(ListWndFlag);

		@@ -494,21 +492,21 @@ SaveSettingPlayer(SETTING_PLAYER *sp)
494	492	sp->DocWndFlag = SetFlag(DocWndFlag);
495	493	sp->WrdWndFlag = SetFlag(WrdWndFlag);
496	494	sp->SoundSpecWndFlag = SetFlag(SoundSpecWndFlag);
497		- sp->SubWindowMax = SetValue(SubWindowMax, 1, 10);
	495	+ sp->SubWindowMax = SetValue(SubWindowMax,1,10);
498	496	sp->PlaylistMax = SetValue(playlist_max_ini,1,PLAYLIST_MAX);
499	497	sp->ConsoleClearFlag = SetValue(ConsoleClearFlag,0,256);
500	498
501		- strncpy(sp->ConfigFile, ConfigFile, FILEPATH_MAX);
	499	+ strncpy(sp->ConfigFile,ConfigFile,FILEPATH_MAX);
502	500	(sp->ConfigFile)[FILEPATH_MAX - 1] = '\0';
503		- strncpy(sp->PlaylistFile, PlaylistFile, FILEPATH_MAX);
	501	+ strncpy(sp->PlaylistFile,PlaylistFile,FILEPATH_MAX);
504	502	(sp->PlaylistFile)[FILEPATH_MAX - 1] = '\0';
505		- strncpy(sp->PlaylistHistoryFile, PlaylistHistoryFile, FILEPATH_MAX);
	503	+ strncpy(sp->PlaylistHistoryFile,PlaylistHistoryFile,FILEPATH_MAX);
506	504	(sp->PlaylistHistoryFile)[FILEPATH_MAX - 1] = '\0';
507		- strncpy(sp->MidiFileOpenDir, MidiFileOpenDir, FILEPATH_MAX);
	505	+ strncpy(sp->MidiFileOpenDir,MidiFileOpenDir,FILEPATH_MAX);
508	506	(sp->MidiFileOpenDir)[FILEPATH_MAX - 1] = '\0';
509		- strncpy(sp->ConfigFileOpenDir, ConfigFileOpenDir, FILEPATH_MAX);
	507	+ strncpy(sp->ConfigFileOpenDir,ConfigFileOpenDir,FILEPATH_MAX);
510	508	(sp->ConfigFileOpenDir)[FILEPATH_MAX - 1] = '\0';
511		- strncpy(sp->PlaylistFileOpenDir, PlaylistFileOpenDir, FILEPATH_MAX);
	509	+ strncpy(sp->PlaylistFileOpenDir,PlaylistFileOpenDir,FILEPATH_MAX);
512	510	(sp->PlaylistFileOpenDir)[FILEPATH_MAX - 1] = '\0';
513	511	sp->PlayerThreadPriority = PlayerThreadPriority;
514	512	sp->GUIThreadPriority = GUIThreadPriority;

		@@ -521,24 +519,24 @@ SaveSettingPlayer(SETTING_PLAYER *sp)
521	519	sp->DocFontSize = DocFontSize;
522	520	sp->ListFontSize = ListFontSize;
523	521	sp->TracerFontSize = TracerFontSize;
524		- strncpy(sp->SystemFont, SystemFont, LF_FULLFACESIZE + 1);
	522	+ strncpy(sp->SystemFont,SystemFont,LF_FULLFACESIZE + 1);
525	523	sp->SystemFont[LF_FULLFACESIZE] = '\0';
526		- strncpy(sp->PlayerFont, PlayerFont, LF_FULLFACESIZE + 1);
	524	+ strncpy(sp->PlayerFont,PlayerFont,LF_FULLFACESIZE + 1);
527	525	sp->PlayerFont[LF_FULLFACESIZE] = '\0';
528		- strncpy(sp->WrdFont, WrdFont, LF_FULLFACESIZE + 1);
	526	+ strncpy(sp->WrdFont,WrdFont,LF_FULLFACESIZE + 1);
529	527	sp->WrdFont[LF_FULLFACESIZE] = '\0';
530		- strncpy(sp->DocFont, DocFont, LF_FULLFACESIZE + 1);
	528	+ strncpy(sp->DocFont,DocFont,LF_FULLFACESIZE + 1);
531	529	DocFont[LF_FULLFACESIZE] = '\0';
532		- strncpy(sp->ListFont, ListFont, LF_FULLFACESIZE + 1);
	530	+ strncpy(sp->ListFont,ListFont,LF_FULLFACESIZE + 1);
533	531	sp->ListFont[LF_FULLFACESIZE] = '\0';
534		- strncpy(sp->TracerFont, TracerFont, LF_FULLFACESIZE + 1);
	532	+ strncpy(sp->TracerFont,TracerFont,LF_FULLFACESIZE + 1);
535	533	sp->TracerFont[LF_FULLFACESIZE] = '\0';
536	534	sp->DocMaxSize = DocMaxSize;
537		- strncpy(sp->DocFileExt, DocFileExt, 256);
	535	+ strncpy(sp->DocFileExt,DocFileExt,256);
538	536	sp->DocFileExt[256 - 1] = '\0';
539	537	sp->PlayerLanguage = PlayerLanguage;
540		- sp->DocWndIndependent = DocWndIndependent;
541		- sp->DocWndAutoPopup = DocWndAutoPopup;
	538	+ sp->DocWndIndependent = DocWndIndependent;
	539	+ sp->DocWndAutoPopup = DocWndAutoPopup;
542	540	sp->SeachDirRecursive = SeachDirRecursive;
543	541	sp->IniFileAutoSave = IniFileAutoSave;
544	542	sp->SecondMode = SecondMode;

		@@ -546,11 +544,11 @@ SaveSettingPlayer(SETTING_PLAYER *sp)
546	544	sp->AutosavePlaylist = AutosavePlaylist;
547	545	sp->PosSizeSave = PosSizeSave;
548	546	///r
549		- sp->main_panel_update_time = main_panel_update_time;
	547	+ sp->main_panel_update_time = main_panel_update_time;
550	548	}
551	549
552	550	extern int set_play_mode(char *cp);
553		-extern int set_tim_opt(int c, const char *optarg);
	551	+extern int set_tim_opt(int c, char *optarg);
554	552	extern int set_ctl(char *cp);
555	553	extern int set_wrd(char *w);
556	554

		@@ -581,9 +579,9 @@ ApplySettingTiMidity(SETTING_TIMIDITY *st)
581	579	{
582	580	int i;
583	581	char buffer[INI_MAXLEN];
584		-
	582	+
585	583	if (*st->opt_playmode != '\0')
586		- set_play_mode(st->opt_playmode);
	584	+ set_play_mode(st->opt_playmode);
587	585
588	586	/* Player must be stopped.
589	587	* DANGER to apply settings while playing.

		@@ -591,27 +589,23 @@ ApplySettingTiMidity(SETTING_TIMIDITY *st)
591	589	amplification = SetValue(st->amplification, 0, MAX_AMPLIFICATION);
592	590	output_amplification = SetValue(st->output_amplification, 0, MAX_AMPLIFICATION);
593	591	antialiasing_allowed = SetFlag(st->antialiasing_allowed);
594		- if (st->buffer_fragments == -1)
595		- opt_buffer_fragments = -1;
	592	+ if(st->buffer_fragments == -1)
	593	+ opt_buffer_fragments = -1;
596	594	else
597		- opt_buffer_fragments = SetValue(st->buffer_fragments, 2, 4096);
598		- if (st->audio_buffer_bits == -1)
599		- opt_audio_buffer_bits = -1;
	595	+ opt_buffer_fragments = SetValue(st->buffer_fragments, 2, 4096);
	596	+ if(st->audio_buffer_bits == -1)
	597	+ opt_audio_buffer_bits = -1;
600	598	else
601		- opt_audio_buffer_bits = SetValue(st->audio_buffer_bits, 5, 12);
	599	+ opt_audio_buffer_bits = SetValue(st->audio_buffer_bits, 5, 12);
602	600	///r
603		- if (st->compute_buffer_bits == -128)
604		- opt_compute_buffer_bits = -128;
	601	+ if(st->compute_buffer_bits == -128)
	602	+ opt_compute_buffer_bits = -128;
605	603	else
606		- opt_compute_buffer_bits = SetValue(st->compute_buffer_bits, -5, 10);
607		- if (opt_audio_buffer_bits != -1)
608		- opt_compute_buffer_bits = SetValue(opt_compute_buffer_bits, -5, opt_audio_buffer_bits - 1);
609		- //default_drumchannels = st->default_drumchannels;
610		- //default_drumchannel_mask = st->default_drumchannel_mask;
611		- //CopyMemory(&default_drumchannels, &st->default_drumchannels, sizeof(ChannelBitMask));
612		- //CopyMemory(&default_drumchannel_mask, &st->default_drumchannel_mask, sizeof(ChannelBitMask));
613		- COPY_CHANNELMASK(default_drumchannels, st->default_drumchannels);
614		- COPY_CHANNELMASK(default_drumchannel_mask, st->default_drumchannel_mask);
	604	+ opt_compute_buffer_bits = SetValue(st->compute_buffer_bits, -5, 10);
	605	+ if(opt_audio_buffer_bits != -1)
	606	+ opt_compute_buffer_bits = SetValue(opt_compute_buffer_bits, -5, opt_audio_buffer_bits - 1);
	607	+ default_drumchannels = st->default_drumchannels;
	608	+ default_drumchannel_mask = st->default_drumchannel_mask;
615	609	opt_modulation_wheel = SetFlag(st->opt_modulation_wheel);
616	610	opt_portamento = SetFlag(st->opt_portamento);
617	611	opt_nrpn_vibrato = SetFlag(st->opt_nrpn_vibrato);

		@@ -619,72 +613,70 @@ ApplySettingTiMidity(SETTING_TIMIDITY *st)
619	613	opt_trace_text_meta_event = SetFlag(st->opt_trace_text_meta_event);
620	614	opt_overlap_voice_allow = SetFlag(st->opt_overlap_voice_allow);
621	615	///r
622		- opt_overlap_voice_count = SetValue(st->opt_overlap_voice_count, 0, 512);
623		- opt_max_channel_voices = SetValue(st->opt_max_channel_voices, 4, 512);
	616	+ opt_overlap_voice_count = SetValue(st->opt_overlap_voice_count, 0, 512);
	617	+ opt_max_channel_voices = SetValue(st->opt_max_channel_voices, 4, 512);
624	618
625		- opt_default_mid = SetValue(st->opt_default_mid, 0, 127);
626		- opt_system_mid = SetValue(st->opt_system_mid, 0, 127);
	619	+ opt_default_mid = st->opt_default_mid;
	620	+ opt_system_mid = st->opt_system_mid;
627	621	default_tonebank = st->default_tonebank;
628	622	special_tonebank = st->special_tonebank;
629	623	opt_reverb_control = st->opt_reverb_control;
630	624	opt_chorus_control = st->opt_chorus_control;
631		- opt_surround_chorus = st->opt_surround_chorus;
632		- opt_normal_chorus_plus = st->opt_normal_chorus_plus;
633		- noise_sharp_type = SetValue(st->noise_sharp_type, 0, 4);
634		- opt_evil_mode = SetFlag(st->opt_evil_mode);
635		- opt_tva_attack = SetFlag(st->opt_tva_attack);
636		- opt_tva_decay = SetFlag(st->opt_tva_decay);
637		- opt_tva_release = SetFlag(st->opt_tva_release);
638		- opt_delay_control = SetValue(st->opt_delay_control, 0, INT_MAX);
639		- opt_default_module = SetValue(st->opt_default_module, 0, 127);
640		- opt_lpf_def = SetValue(st->opt_lpf_def, 0, INT_MAX);
641		- opt_hpf_def = SetValue(st->opt_hpf_def, 0, INT_MAX);
642		- opt_drum_effect = SetFlag(st->opt_drum_effect);
643		- opt_modulation_envelope = SetFlag(st->opt_modulation_envelope);
644		- opt_eq_control = SetFlag(st->opt_eq_control);
645		- opt_insertion_effect = SetFlag(st->opt_insertion_effect);
	625	+ opt_surround_chorus = st->opt_surround_chorus;
	626	+ opt_normal_chorus_plus = st->opt_normal_chorus_plus;
	627	+ noise_sharp_type = st->noise_sharp_type;
	628	+ opt_evil_mode = st->opt_evil_mode;
	629	+ opt_tva_attack = st->opt_tva_attack;
	630	+ opt_tva_decay = st->opt_tva_decay;
	631	+ opt_tva_release = st->opt_tva_release;
	632	+ opt_delay_control = st->opt_delay_control;
	633	+ opt_default_module = st->opt_default_module;
	634	+ opt_lpf_def = st->opt_lpf_def;
	635	+ opt_hpf_def = st->opt_hpf_def;
	636	+ opt_drum_effect = st->opt_drum_effect;
	637	+ opt_modulation_envelope = st->opt_modulation_envelope;
	638	+ opt_eq_control = st->opt_eq_control;
	639	+ opt_insertion_effect = st->opt_insertion_effect;
646	640	adjust_panning_immediately = SetFlag(st->adjust_panning_immediately);
647	641	opt_fast_decay = SetFlag(st->opt_fast_decay);
648	642	fast_decay = opt_fast_decay;
649	643	min_sustain_time = st->min_sustain_time;
650		- opt_print_fontname = SetFlag(st->opt_print_fontname);
	644	+ opt_print_fontname = st->opt_print_fontname;
651	645	#ifdef SUPPORT_SOUNDSPEC
652	646	view_soundspec_flag = SetFlag(st->view_soundspec_flag);
653	647	spectrogram_update_sec = st->spectrogram_update_sec;
654	648	#endif
655	649	///r
656		- for (i = 0; i < MAX_CHANNELS; i++) {
657		- default_program[i] = st->default_program[i];
658		- special_program[i] = st->special_program[i];
659		- }
	650	+ for(i = 0; i < MAX_CHANNELS; i++){
	651	+ default_program[i] = st->default_program[i];
	652	+ special_program[i] = st->special_program[i];
	653	+ }
660	654	set_ctl(st->opt_ctl);
661	655	opt_realtime_playing = SetFlag(st->opt_realtime_playing);
662		-
	656	+
663	657	strncpy(OutputName, st->OutputName, FILEPATH_MAX);
664	658	#if 0
665	659	if (OutputName[0] && !is_device_output_ID(play_mode->id_character))
666		- play_mode->name = safe_strdup(OutputName); // メモリリークするかな？はずすとだめだし。
	660	+ play_mode->name = safe_strdup(OutputName); // メモリリークするかな？はずすとだめだし。
667	661	#elif 0
668	662	if (OutputName[0] && !is_device_output_ID(play_mode->id_character))
669		- play_mode->name = OutputName;
	663	+ play_mode->name = OutputName;
670	664	#else
671	665	if (OutputName[0] && !is_device_output_ID(play_mode->id_character))
672		- play_mode->name = strdup(OutputName);
	666	+ play_mode->name = strdup(OutputName);
673	667	#endif
674		- strncpy(w32g_output_dir, st->OutputDirName, FILEPATH_MAX);
675		- w32g_output_dir[FILEPATH_MAX - 1] = '\0';
676		- w32g_auto_output_mode = st->auto_output_mode;
	668	+ strncpy(w32g_output_dir,st->OutputDirName,FILEPATH_MAX);
	669	+ w32g_output_dir[FILEPATH_MAX-1] = '\0';
	670	+ w32g_auto_output_mode = st->auto_output_mode;
677	671	opt_output_rate = st->output_rate;
678		- if (st->output_rate)
679		- play_mode->rate = SetValue(st->output_rate, MIN_OUTPUT_RATE, MAX_OUTPUT_RATE);
680		- else if (play_mode->rate == 0)
681		- play_mode->rate = DEFAULT_RATE;
682		- voices = SetValue(st->voices, 1, MAX_VOICES);
683		- if (voices > max_voices) max_voices = voices;
684		- auto_reduce_polyphony = SetFlag(st->auto_reduce_polyphony);
685		- //quietchannels = st->quietchannels;
686		- //CopyMemory(&quietchannels, &st->quietchannels, sizeof(ChannelBitMask));
687		- COPY_CHANNELMASK(quietchannels, st->quietchannels);
	672	+ if(st->output_rate)
	673	+ play_mode->rate = SetValue(st->output_rate, MIN_OUTPUT_RATE, MAX_OUTPUT_RATE);
	674	+ else if(play_mode->rate == 0)
	675	+ play_mode->rate = DEFAULT_RATE;
	676	+ voices = st->voices;
	677	+ if( voices > max_voices) max_voices = voices;
	678	+ auto_reduce_polyphony = st->auto_reduce_polyphony;
	679	+ quietchannels = st->quietchannels;
688	680	temper_type_mute = st->temper_type_mute;
689	681	safe_free(opt_aq_max_buff);
690	682	opt_aq_max_buff = NULL;

		@@ -704,142 +696,141 @@ ApplySettingTiMidity(SETTING_TIMIDITY *st)
704	696	opt_aq_max_buff = safe_strdup(opt_aq_max_buff);
705	697	opt_aq_fill_buff = safe_strdup(opt_aq_fill_buff);
706	698	///r
707		- opt_reduce_voice_threshold = safe_strdup(st->reduce_voice_threshold);
	699	+ opt_reduce_voice_threshold = safe_strdup(st->reduce_voice_threshold);
708	700	opt_reduce_quality_threshold = safe_strdup(st->reduce_quality_threshold);
709	701	opt_reduce_polyphony_threshold = safe_strdup(st->reduce_polyphony_threshold);
710	702	modify_release = SetValue(st->modify_release, 0, MAX_MREL);
711		- //if (modify_release == 0) modify_release = DEFAULT_MREL;
712	703	allocate_cache_size = st->allocate_cache_size;
713		- key_adjust = st->key_adjust;
714		- opt_force_keysig = st->opt_force_keysig;
715		- opt_pure_intonation = st->opt_pure_intonation;
716		- opt_init_keysig = st->opt_init_keysig;
	704	+ key_adjust = st->key_adjust;
	705	+ opt_force_keysig = st->opt_force_keysig;
	706	+ opt_pure_intonation = st->opt_pure_intonation;
	707	+ opt_init_keysig = st->opt_init_keysig;
717	708	safe_free(output_text_code);
718	709	output_text_code = safe_strdup(st->output_text_code);
719		- free_instruments_afterwards = SetFlag(st->free_instruments_afterwards);
720		- opt_user_volume_curve = st->opt_user_volume_curve;
721		- if (opt_user_volume_curve != 0)
722		- init_user_vol_table(opt_user_volume_curve);
	710	+ free_instruments_afterwards = st->free_instruments_afterwards;
	711	+ opt_user_volume_curve = st->opt_user_volume_curve;
	712	+ if (opt_user_volume_curve != 0)
	713	+ init_user_vol_table(opt_user_volume_curve);
723	714	set_wrd(st->opt_wrd);
724	715	///r
725	716	#ifdef AU_W32
726		- opt_wmme_device_id = st->wmme_device_id;
727		- opt_wave_format_ext = st->wave_format_ext;
	717	+ opt_wmme_device_id = st->wmme_device_id;
	718	+ opt_wave_format_ext = st->wave_format_ext;
728	719	#endif
729		-#ifdef AU_WASAPI
730		- opt_wasapi_device_id = st->wasapi_device_id;
731		- opt_wasapi_latency = st->wasapi_latency;
732		- opt_wasapi_format_ext = st->wasapi_format_ext;
733		- opt_wasapi_exclusive = st->wasapi_exclusive;
734		- opt_wasapi_polling = st->wasapi_polling;
735		- opt_wasapi_priority = st->wasapi_priority;
736		- opt_wasapi_stream_category = st->wasapi_stream_category;
737		- opt_wasapi_stream_option = st->wasapi_stream_option;
	720	+#ifdef AU_WASAPI
	721	+ opt_wasapi_device_id = st->wasapi_device_id;
	722	+ opt_wasapi_latency = st->wasapi_latency;
	723	+ opt_wasapi_format_ext = st->wasapi_format_ext;
	724	+ opt_wasapi_exclusive = st->wasapi_exclusive;
	725	+ opt_wasapi_polling = st->wasapi_polling;
	726	+ opt_wasapi_priority = st->wasapi_priority;
	727	+ opt_wasapi_stream_category = st->wasapi_stream_category;
	728	+ opt_wasapi_stream_option = st->wasapi_stream_option;
738	729	#endif
739		-#ifdef AU_WDMKS
740		- opt_wdmks_device_id = st->wdmks_device_id;
741		- opt_wdmks_latency = st->wdmks_latency;
742		- opt_wdmks_format_ext = st->wdmks_format_ext;
743		- opt_wdmks_polling = st->wdmks_polling;
744		- opt_wdmks_thread_priority = st->wdmks_thread_priority;
745		- opt_wdmks_rt_priority = st->wdmks_rt_priority;
746		- opt_wdmks_pin_priority = st->wdmks_pin_priority;
	730	+#ifdef AU_WDMKS
	731	+ opt_wdmks_device_id = st->wdmks_device_id;
	732	+ opt_wdmks_latency = st->wdmks_latency;
	733	+ opt_wdmks_format_ext = st->wdmks_format_ext;
	734	+ opt_wdmks_polling = st->wdmks_polling;
	735	+ opt_wdmks_thread_priority = st->wdmks_thread_priority;
	736	+ opt_wdmks_rt_priority = st->wdmks_rt_priority;
	737	+ opt_wdmks_pin_priority = st->wdmks_pin_priority;
747	738	#endif
748	739	#ifdef AU_PORTAUDIO
749		- opt_pa_wmme_device_id = st->pa_wmme_device_id;
750		- opt_pa_ds_device_id = st->pa_ds_device_id;
751		- opt_pa_asio_device_id = st->pa_asio_device_id;
	740	+ opt_pa_wmme_device_id = st->pa_wmme_device_id;
	741	+ opt_pa_ds_device_id = st->pa_ds_device_id;
	742	+ opt_pa_asio_device_id = st->pa_asio_device_id;
752	743	#ifdef PORTAUDIO_V19
753		- opt_pa_wdmks_device_id = st->pa_wdmks_device_id;
754		- opt_pa_wasapi_device_id = st->pa_wasapi_device_id;
755		- opt_pa_wasapi_flag = st->pa_wasapi_flag;
756		- opt_pa_wasapi_stream_category = st->pa_wasapi_stream_category;
757		- opt_pa_wasapi_stream_option = st->pa_wasapi_stream_option;
	744	+ opt_pa_wdmks_device_id = st->pa_wdmks_device_id;
	745	+ opt_pa_wasapi_device_id = st->pa_wasapi_device_id;
	746	+ opt_pa_wasapi_flag = st->pa_wasapi_flag;
	747	+ opt_pa_wasapi_stream_category = st->pa_wasapi_stream_category;
	748	+ opt_pa_wasapi_stream_option = st->pa_wasapi_stream_option;
758	749	#endif
759	750	#endif
760		- opt_resample_type = SetValue(st->opt_resample_type, 0, RESAMPLE_MAX - 1);
761		- opt_resample_param = st->opt_resample_param;
762		- opt_resample_filter = SetValue(st->opt_resample_filter, 0, RESAMPLE_FILTER_LIST_MAX - 1);
763		- opt_resample_over_sampling = st->opt_resample_over_sampling;
764		- opt_pre_resamplation = st->opt_pre_resamplation;
	751	+ opt_resample_type = st->opt_resample_type;
	752	+ opt_resample_param = st->opt_resample_param;
	753	+ opt_resample_filter = st->opt_resample_filter;
	754	+ opt_resample_over_sampling = st->opt_resample_over_sampling;
	755	+ opt_pre_resamplation = st->opt_pre_resamplation;
765	756
766	757	#if defined(__W32__) && defined(SMFCONV)
767		- opt_rcpcv_dll = SetFlag(st->opt_rcpcv_dll);
	758	+ opt_rcpcv_dll = st->opt_rcpcv_dll;
768	759	#endif /* SMFCONV */
769	760
770	761	opt_control_ratio = st->control_ratio;
771		- if (opt_control_ratio)
772		- control_ratio = SetValue(opt_control_ratio, 1, MAX_CONTROL_RATIO);
	762	+ if(opt_control_ratio)
	763	+ control_ratio = SetValue(opt_control_ratio, 1, MAX_CONTROL_RATIO);
773	764	else
774	765	{
775		- control_ratio = play_mode->rate / CONTROLS_PER_SECOND;
776		- control_ratio = SetValue(control_ratio, 1, MAX_CONTROL_RATIO);
	766	+ control_ratio = play_mode->rate / CONTROLS_PER_SECOND;
	767	+ control_ratio = SetValue(control_ratio, 1, MAX_CONTROL_RATIO);
777	768	}
778		- opt_drum_power = SetValue(st->opt_drum_power, 0, MAX_AMPLIFICATION);
779		- opt_amp_compensation = SetFlag(st->opt_amp_compensation);
780		-// data_block_bits = st->data_block_bits;
781		-// data_block_num = st->data_block_num;
	769	+ opt_drum_power = SetValue(st->opt_drum_power, 0, MAX_AMPLIFICATION);
	770	+ opt_amp_compensation = st->opt_amp_compensation;
	771	+// data_block_bits = st->data_block_bits;
	772	+// data_block_num = st->data_block_num;
782	773	#ifdef AU_W32
783	774	opt_wmme_buffer_bits = st->wmme_buffer_bits;
784	775	opt_wmme_buffer_num = st->wmme_buffer_num;
785	776	#endif
786	777
787		- add_play_time = st->add_play_time;
	778	+ add_play_time = st->add_play_time;
788	779	add_silent_time = st->add_silent_time;
789		- emu_delay_time = st->emu_delay_time;
	780	+ emu_delay_time = st->emu_delay_time;
790	781
791		- opt_limiter = st->opt_limiter;
792		- opt_mix_envelope = st->opt_mix_envelope;
793		- opt_modulation_update = st->opt_modulation_update;
794		- opt_cut_short_time = st->opt_cut_short_time;
795		- opt_use_midi_loop_repeat = st->opt_use_midi_loop_repeat;
	782	+ opt_limiter = st->opt_limiter;
	783	+ opt_mix_envelope = st->opt_mix_envelope;
	784	+ opt_modulation_update = st->opt_modulation_update;
	785	+ opt_cut_short_time = st->opt_cut_short_time;
	786	+ opt_use_midi_loop_repeat = SetFlag(st->opt_use_midi_loop_repeat);
796	787	opt_midi_loop_repeat = SetValue(st->opt_midi_loop_repeat, 0, 99);
797		-
	788	+
798	789	#if defined(WINDRV_SETUP) \|\| defined(WINDRV)
799		- syn_ThreadPriority = st->syn_ThreadPriority;
800		- stream_max_compute = st->SynShTime;
801		- opt_rtsyn_latency = SetValue(st->opt_rtsyn_latency, 1, 1000);
802		- rtsyn_set_latency((double) opt_rtsyn_latency * 0.001);
803		- opt_rtsyn_skip_aq = st->opt_rtsyn_skip_aq;
804		- rtsyn_set_skip_aq(opt_rtsyn_skip_aq);
	790	+ syn_ThreadPriority = st->syn_ThreadPriority;
	791	+ stream_max_compute = st->SynShTime;
	792	+ opt_rtsyn_latency = SetValue(st->opt_rtsyn_latency, 1, 1000);
	793	+ rtsyn_set_latency((double)opt_rtsyn_latency * 0.001);
	794	+ opt_rtsyn_skip_aq = st->opt_rtsyn_skip_aq;
	795	+ rtsyn_set_skip_aq(opt_rtsyn_skip_aq);
805	796	#elif defined(IA_W32G_SYN)
806		- for (i = 0; i < MAX_PORT; i++) {
807		- w32g_syn_id_port[i] = st->SynIDPort[i];
808		- }
809		- syn_AutoStart = st->syn_AutoStart;
810		- syn_ThreadPriority = st->syn_ThreadPriority;
811		- w32g_syn_port_num = st->SynPortNum;
812		- stream_max_compute = st->SynShTime;
813		- opt_rtsyn_latency = SetValue(st->opt_rtsyn_latency, 1, 1000);
814		- rtsyn_set_latency((double) opt_rtsyn_latency * 0.001);
815		- opt_rtsyn_skip_aq = st->opt_rtsyn_skip_aq;
816		- rtsyn_set_skip_aq(opt_rtsyn_skip_aq);
817		- opt_use_twsyn_bridge = st->opt_use_twsyn_bridge;
	797	+ for ( i = 0; i < MAX_PORT; i ++ ) {
	798	+ w32g_syn_id_port[i] = st->SynIDPort[i];
	799	+ }
	800	+ syn_AutoStart = st->syn_AutoStart;
	801	+ syn_ThreadPriority = st->syn_ThreadPriority;
	802	+ w32g_syn_port_num = st->SynPortNum;
	803	+ stream_max_compute = st->SynShTime;
	804	+ opt_rtsyn_latency = SetValue(st->opt_rtsyn_latency, 1, 1000);
	805	+ rtsyn_set_latency((double)opt_rtsyn_latency * 0.001);
	806	+ opt_rtsyn_skip_aq = st->opt_rtsyn_skip_aq;
	807	+ rtsyn_set_skip_aq(opt_rtsyn_skip_aq);
	808	+ opt_use_twsyn_bridge = st->opt_use_twsyn_bridge;
818	809	#endif
819	810	///r
820		- processPriority = st->processPriority;
821		- compute_thread_num = SetValue(st->compute_thread_num, 0, 16);
822		-#ifdef USE_TRACE_TIMER
823		- trace_mode_update_time = SetValue(st->trace_mode_update_time, 0, MAX_TRACE_TIMER_ELAPSE);
	811	+ processPriority = st->processPriority;
	812	+ compute_thread_num = st->compute_thread_num;
	813	+#ifdef USE_TRACE_TIMER
	814	+ trace_mode_update_time = st->trace_mode_update_time;
824	815	#endif
825		- opt_load_all_instrument = st->opt_load_all_instrument;
826		-
	816	+ opt_load_all_instrument = st->opt_load_all_instrument;
	817	+
827	818	///r
828	819	#ifdef SUPPORT_SOUNDSPEC
829		- soundspec_setinterval(spectrogram_update_sec); // need playmode rate
	820	+ soundspec_setinterval(spectrogram_update_sec); // need playmode rate
830	821	#endif
831		-
832		-#ifdef USE_TRACE_TIMER
833		- set_trace_mode_update_time();
	822	+
	823	+#ifdef USE_TRACE_TIMER
	824	+ set_trace_mode_update_time();
834	825	#endif
835	826
836		-// if (*st->opt_playmode != '\0')
837		- //set_play_mode(st->opt_playmode);
838		-
	827	+ // if (*st->opt_playmode != '\0')
	828	+ //set_play_mode(st->opt_playmode);
	829	+
839	830	/* for INT_SYNTH */
840		- opt_int_synth_sine = st->opt_int_synth_sine;
841		- opt_int_synth_rate = st->opt_int_synth_rate;
842		- opt_int_synth_update = st->opt_int_synth_update;
	831	+ opt_int_synth_sine = st->opt_int_synth_sine;
	832	+ opt_int_synth_rate = st->opt_int_synth_rate;
	833	+ opt_int_synth_update = st->opt_int_synth_update;
843	834	}
844	835
845	836	void

		@@ -852,7 +843,7 @@ SaveSettingTiMidity(SETTING_TIMIDITY *st)
852	843	st->antialiasing_allowed = SetFlag(antialiasing_allowed);
853	844	st->buffer_fragments = opt_buffer_fragments;
854	845	///r
855		- st->audio_buffer_bits = opt_audio_buffer_bits; // = audio_buffer_bits; //
	846	+ st->audio_buffer_bits = opt_audio_buffer_bits; // = audio_buffer_bits; //
856	847	st->compute_buffer_bits = opt_compute_buffer_bits;
857	848
858	849	st->control_ratio = SetValue(opt_control_ratio, 0, MAX_CONTROL_RATIO);

		@@ -873,24 +864,24 @@ SaveSettingTiMidity(SETTING_TIMIDITY *st)
873	864	st->opt_max_channel_voices = SetValue(opt_max_channel_voices, 4, 512);
874	865
875	866	st->opt_default_mid = opt_default_mid;
876		- st->opt_system_mid = opt_system_mid;
	867	+ st->opt_system_mid = opt_system_mid;
877	868	st->default_tonebank = default_tonebank;
878	869	st->special_tonebank = special_tonebank;
879	870	st->opt_reverb_control = opt_reverb_control;
880	871	st->opt_chorus_control = opt_chorus_control;
881		- st->opt_surround_chorus = opt_surround_chorus;
882		- st->opt_normal_chorus_plus = opt_normal_chorus_plus;
883		- st->opt_tva_attack = opt_tva_attack;
884		- st->opt_tva_decay = opt_tva_decay;
885		- st->opt_tva_release = opt_tva_release;
886		- st->opt_delay_control = opt_delay_control;
887		- st->opt_default_module = opt_default_module;
888		- st->opt_lpf_def = opt_lpf_def;
889		- st->opt_hpf_def = opt_hpf_def;
890		- st->opt_drum_effect = opt_drum_effect;
891		- st->opt_modulation_envelope = opt_modulation_envelope;
892		- st->opt_eq_control = opt_eq_control;
893		- st->opt_insertion_effect = opt_insertion_effect;
	872	+ st->opt_surround_chorus = opt_surround_chorus;
	873	+ st->opt_normal_chorus_plus = opt_normal_chorus_plus;
	874	+ st->opt_tva_attack = opt_tva_attack;
	875	+ st->opt_tva_decay = opt_tva_decay;
	876	+ st->opt_tva_release = opt_tva_release;
	877	+ st->opt_delay_control = opt_delay_control;
	878	+ st->opt_default_module = opt_default_module;
	879	+ st->opt_lpf_def = opt_lpf_def;
	880	+ st->opt_hpf_def = opt_hpf_def;
	881	+ st->opt_drum_effect = opt_drum_effect;
	882	+ st->opt_modulation_envelope = opt_modulation_envelope;
	883	+ st->opt_eq_control = opt_eq_control;
	884	+ st->opt_insertion_effect = opt_insertion_effect;
894	885	st->noise_sharp_type = noise_sharp_type;
895	886	st->opt_evil_mode = SetFlag(opt_evil_mode);
896	887	st->adjust_panning_immediately = SetFlag(adjust_panning_immediately);

		@@ -902,40 +893,40 @@ SaveSettingTiMidity(SETTING_TIMIDITY *st)
902	893	st->spectrogram_update_sec = spectrogram_update_sec;
903	894	#endif
904	895	///r
905		- for (i = 0; i < MAX_CHANNELS; i++)
	896	+ for(i = 0; i < MAX_CHANNELS; i++)
906	897	{
907		- st->special_program[i] = special_program[i];
908		- if (def_instr_name[0])
909		- st->default_program[i] = SPECIAL_PROGRAM;
910		- else
911		- st->default_program[i] = default_program[i];
	898	+ st->special_program[i] = special_program[i];
	899	+ if(def_instr_name[0])
	900	+ st->default_program[i] = SPECIAL_PROGRAM;
	901	+ else
	902	+ st->default_program[i] = default_program[i];
912	903	}
913	904	j = 0;
914	905	st->opt_ctl[j++] = ctl->id_character;
915		- for (i = 1; i < ctl->verbosity; i++)
916		- st->opt_ctl[j++] = 'v';
917		- for (i = 1; i > ctl->verbosity; i--)
918		- st->opt_ctl[j++] = 'q';
919		- if (ctl->trace_playing)
920		- st->opt_ctl[j++] = 't';
921		- if (ctl->flags & CTLF_LIST_LOOP)
922		- st->opt_ctl[j++] = 'l';
923		- if (ctl->flags & CTLF_LIST_RANDOM)
924		- st->opt_ctl[j++] = 'r';
925		- if (ctl->flags & CTLF_LIST_SORT)
926		- st->opt_ctl[j++] = 's';
927		- if (ctl->flags & CTLF_AUTOSTART)
928		- st->opt_ctl[j++] = 'a';
929		- if (ctl->flags & CTLF_AUTOEXIT)
930		- st->opt_ctl[j++] = 'x';
931		- if (ctl->flags & CTLF_DRAG_START)
932		- st->opt_ctl[j++] = 'd';
933		- if (ctl->flags & CTLF_AUTOUNIQ)
934		- st->opt_ctl[j++] = 'u';
935		- if (ctl->flags & CTLF_AUTOREFINE)
936		- st->opt_ctl[j++] = 'R';
937		- if (ctl->flags & CTLF_NOT_CONTINUE)
938		- st->opt_ctl[j++] = 'C';
	906	+ for(i = 1; i < ctl->verbosity; i++)
	907	+ st->opt_ctl[j++] = 'v';
	908	+ for(i = 1; i > ctl->verbosity; i--)
	909	+ st->opt_ctl[j++] = 'q';
	910	+ if(ctl->trace_playing)
	911	+ st->opt_ctl[j++] = 't';
	912	+ if(ctl->flags & CTLF_LIST_LOOP)
	913	+ st->opt_ctl[j++] = 'l';
	914	+ if(ctl->flags & CTLF_LIST_RANDOM)
	915	+ st->opt_ctl[j++] = 'r';
	916	+ if(ctl->flags & CTLF_LIST_SORT)
	917	+ st->opt_ctl[j++] = 's';
	918	+ if(ctl->flags & CTLF_AUTOSTART)
	919	+ st->opt_ctl[j++] = 'a';
	920	+ if(ctl->flags & CTLF_AUTOEXIT)
	921	+ st->opt_ctl[j++] = 'x';
	922	+ if(ctl->flags & CTLF_DRAG_START)
	923	+ st->opt_ctl[j++] = 'd';
	924	+ if(ctl->flags & CTLF_AUTOUNIQ)
	925	+ st->opt_ctl[j++] = 'u';
	926	+ if(ctl->flags & CTLF_AUTOREFINE)
	927	+ st->opt_ctl[j++] = 'R';
	928	+ if(ctl->flags & CTLF_NOT_CONTINUE)
	929	+ st->opt_ctl[j++] = 'C';
939	930	st->opt_ctl[j] = '\0';
940	931	st->opt_realtime_playing = SetFlag(opt_realtime_playing);
941	932

		@@ -944,105 +935,105 @@ SaveSettingTiMidity(SETTING_TIMIDITY *st)
944	935	st->opt_playmode[j++] = ((play_mode->encoding & PE_MONO) ? 'M' : 'S');
945	936	st->opt_playmode[j++] = ((play_mode->encoding & PE_SIGNED) ? 's' : 'u');
946	937	///r
947		- if (play_mode->encoding & PE_F64BIT) { st->opt_playmode[j++] = 'D'; }
948		- else if (play_mode->encoding & PE_F32BIT) { st->opt_playmode[j++] = 'f'; }
949		- else if (play_mode->encoding & PE_64BIT) { st->opt_playmode[j++] = '6'; }
950		- else if (play_mode->encoding & PE_32BIT) { st->opt_playmode[j++] = '3'; }
951		- else if (play_mode->encoding & PE_24BIT) { st->opt_playmode[j++] = '2'; }
952		- else if (play_mode->encoding & PE_16BIT) { st->opt_playmode[j++] = '1'; }
953		- else { st->opt_playmode[j++] = '8'; }
954		- if (play_mode->encoding & PE_ULAW)
955		- st->opt_playmode[j++] = 'U';
956		- else if (play_mode->encoding & PE_ALAW)
957		- st->opt_playmode[j++] = 'A';
	938	+ if (play_mode->encoding & PE_F64BIT) {st->opt_playmode[j++] = 'D';}
	939	+ else if (play_mode->encoding & PE_F32BIT) {st->opt_playmode[j++] = 'f';}
	940	+ else if (play_mode->encoding & PE_64BIT) {st->opt_playmode[j++] = '6';}
	941	+ else if (play_mode->encoding & PE_32BIT) {st->opt_playmode[j++] = '3';}
	942	+ else if (play_mode->encoding & PE_24BIT) {st->opt_playmode[j++] = '2';}
	943	+ else if (play_mode->encoding & PE_16BIT) {st->opt_playmode[j++] = '1';}
	944	+ else {st->opt_playmode[j++] = '8';}
	945	+ if(play_mode->encoding & PE_ULAW)
	946	+ st->opt_playmode[j++] = 'U';
	947	+ else if(play_mode->encoding & PE_ALAW)
	948	+ st->opt_playmode[j++] = 'A';
958	949	else
959		- st->opt_playmode[j++] = 'l';
960		- if (play_mode->encoding & PE_BYTESWAP)
961		- st->opt_playmode[j++] = 'x';
	950	+ st->opt_playmode[j++] = 'l';
	951	+ if(play_mode->encoding & PE_BYTESWAP)
	952	+ st->opt_playmode[j++] = 'x';
962	953	st->opt_playmode[j] = '\0';
963		- strncpy(st->OutputName, OutputName, sizeof(st->OutputName) - 1);
964		- strncpy(st->OutputDirName, w32g_output_dir, FILEPATH_MAX);
965		- st->OutputDirName[FILEPATH_MAX - 1] = '\0';
966		- st->auto_output_mode = w32g_auto_output_mode;
967		- st->voices = SetValue(voices, 1, MAX_VOICES);
968		- st->auto_reduce_polyphony = auto_reduce_polyphony;
	954	+ strncpy(st->OutputName,OutputName,sizeof(st->OutputName)-1);
	955	+ strncpy(st->OutputDirName,w32g_output_dir,FILEPATH_MAX);
	956	+ st->OutputDirName[FILEPATH_MAX-1] = '\0';
	957	+ st->auto_output_mode = w32g_auto_output_mode;
	958	+ st->voices = voices;
	959	+ st->auto_reduce_polyphony = auto_reduce_polyphony;
969	960	//st->quietchannels = quietchannels;
970	961	//CopyMemory(&st->quietchannels, &quietchannels, sizeof(ChannelBitMask));
971	962	COPY_CHANNELMASK(st->quietchannels, quietchannels);
972	963	st->temper_type_mute = temper_type_mute;
973		- snprintf(st->opt_qsize, sizeof(st->opt_qsize), "%s/%s",
974		- opt_aq_max_buff, opt_aq_fill_buff);
	964	+ snprintf(st->opt_qsize,sizeof(st->opt_qsize),"%s/%s",
	965	+ opt_aq_max_buff,opt_aq_fill_buff);
975	966	strncpy(st->reduce_voice_threshold, opt_reduce_voice_threshold, sizeof(st->reduce_voice_threshold));
976	967	strncpy(st->reduce_quality_threshold, opt_reduce_quality_threshold, sizeof(st->reduce_quality_threshold));
977	968	strncpy(st->reduce_polyphony_threshold, opt_reduce_polyphony_threshold, sizeof(st->reduce_polyphony_threshold));
978	969	st->modify_release = SetValue(modify_release, 0, MAX_MREL);
979	970	st->allocate_cache_size = allocate_cache_size;
980		- st->opt_drum_power = SetValue(opt_drum_power, 0, MAX_AMPLIFICATION);
981		- st->opt_amp_compensation = opt_amp_compensation;
982		- st->key_adjust = key_adjust;
983		- st->opt_force_keysig = opt_force_keysig;
984		- st->opt_pure_intonation = opt_pure_intonation;
985		- st->opt_init_keysig = opt_init_keysig;
	971	+ st->opt_drum_power = SetValue(opt_drum_power, 0, MAX_AMPLIFICATION);
	972	+ st->opt_amp_compensation = opt_amp_compensation;
	973	+ st->key_adjust = key_adjust;
	974	+ st->opt_force_keysig = opt_force_keysig;
	975	+ st->opt_pure_intonation = opt_pure_intonation;
	976	+ st->opt_init_keysig = opt_init_keysig;
986	977	st->output_rate = opt_output_rate;
987		- if (st->output_rate == 0)
	978	+ if(st->output_rate == 0)
988	979	{
989		- st->output_rate = play_mode->rate;
990		- if (st->output_rate == 0)
991		- st->output_rate = DEFAULT_RATE;
	980	+ st->output_rate = play_mode->rate;
	981	+ if(st->output_rate == 0)
	982	+ st->output_rate = DEFAULT_RATE;
992	983	}
993		- st->output_rate = SetValue(st->output_rate, MIN_OUTPUT_RATE, MAX_OUTPUT_RATE);
994		- if (output_text_code)
995		- strncpy(st->output_text_code, output_text_code, sizeof(st->output_text_code) - 1);
	984	+ st->output_rate = SetValue(st->output_rate,MIN_OUTPUT_RATE,MAX_OUTPUT_RATE);
	985	+ if(output_text_code)
	986	+ strncpy(st->output_text_code,output_text_code,sizeof(st->output_text_code)-1);
996	987	else
997		- strncpy(st->output_text_code, OUTPUT_TEXT_CODE, sizeof(st->output_text_code) - 1);
998		- st->free_instruments_afterwards = free_instruments_afterwards;
999		- st->opt_user_volume_curve = opt_user_volume_curve;
	988	+ strncpy(st->output_text_code,OUTPUT_TEXT_CODE,sizeof(st->output_text_code)-1);
	989	+ st->free_instruments_afterwards = free_instruments_afterwards;
	990	+ st->opt_user_volume_curve = opt_user_volume_curve;
1000	991	st->opt_wrd[0] = wrdt->id;
1001		- if (wrdt_open_opts)
1002		- strncpy(st->opt_wrd + 1, wrdt_open_opts, sizeof(st->opt_wrd) - 2);
	992	+ if(wrdt_open_opts)
	993	+ strncpy(st->opt_wrd + 1, wrdt_open_opts, sizeof(st->opt_wrd) - 2);
1003	994	else
1004		- st->opt_wrd[1] = '\0';
	995	+ st->opt_wrd[1] = '\0';
1005	996	///r
1006	997	#ifdef AU_W32
1007		- st->wmme_device_id = opt_wmme_device_id;
1008		- st->wave_format_ext = SetValue(opt_wave_format_ext, 0, 1);
1009		-#endif
1010		-#ifdef AU_WASAPI
1011		- st->wasapi_device_id = opt_wasapi_device_id;
1012		- st->wasapi_latency = opt_wasapi_latency;
1013		- st->wasapi_format_ext = opt_wasapi_format_ext;
1014		- st->wasapi_exclusive = opt_wasapi_exclusive;
1015		- st->wasapi_polling = opt_wasapi_polling;
1016		- st->wasapi_priority = opt_wasapi_priority;
1017		- st->wasapi_stream_category = opt_wasapi_stream_category;
1018		- st->wasapi_stream_option = opt_wasapi_stream_option;
	998	+ st->wmme_device_id = opt_wmme_device_id;
	999	+ st->wave_format_ext = SetValue(opt_wave_format_ext, 0, 1);
	1000	+#endif
	1001	+#ifdef AU_WASAPI
	1002	+ st->wasapi_device_id = opt_wasapi_device_id;
	1003	+ st->wasapi_latency = opt_wasapi_latency;
	1004	+ st->wasapi_format_ext = opt_wasapi_format_ext;
	1005	+ st->wasapi_exclusive = opt_wasapi_exclusive;
	1006	+ st->wasapi_polling = opt_wasapi_polling;
	1007	+ st->wasapi_priority = opt_wasapi_priority;
	1008	+ st->wasapi_stream_category = opt_wasapi_stream_category;
	1009	+ st->wasapi_stream_option = opt_wasapi_stream_option;
1019	1010	#endif
1020	1011	#ifdef AU_WDMKS
1021		- st->wdmks_device_id = opt_wdmks_device_id;
1022		- st->wdmks_latency = opt_wdmks_latency;
1023		- st->wdmks_format_ext = opt_wdmks_format_ext;
1024		- st->wdmks_polling = opt_wdmks_polling;
1025		- st->wdmks_thread_priority = opt_wdmks_thread_priority;
1026		- st->wdmks_rt_priority = opt_wdmks_rt_priority;
1027		- st->wdmks_pin_priority = opt_wdmks_pin_priority;
	1012	+ st->wdmks_device_id = opt_wdmks_device_id;
	1013	+ st->wdmks_latency = opt_wdmks_latency;
	1014	+ st->wdmks_format_ext = opt_wdmks_format_ext;
	1015	+ st->wdmks_polling = opt_wdmks_polling;
	1016	+ st->wdmks_thread_priority = opt_wdmks_thread_priority;
	1017	+ st->wdmks_rt_priority = opt_wdmks_rt_priority;
	1018	+ st->wdmks_pin_priority = opt_wdmks_pin_priority;
1028	1019	#endif
1029	1020	#ifdef AU_PORTAUDIO
1030		- st->pa_wmme_device_id = opt_pa_wmme_device_id;
1031		- st->pa_ds_device_id = opt_pa_ds_device_id;
1032		- st->pa_asio_device_id = opt_pa_asio_device_id;
	1021	+ st->pa_wmme_device_id = opt_pa_wmme_device_id;
	1022	+ st->pa_ds_device_id = opt_pa_ds_device_id;
	1023	+ st->pa_asio_device_id = opt_pa_asio_device_id;
1033	1024	#ifdef PORTAUDIO_V19
1034		- st->pa_wdmks_device_id = opt_pa_wdmks_device_id;
1035		- st->pa_wasapi_device_id = opt_pa_wasapi_device_id;
1036		- st->pa_wasapi_flag = opt_pa_wasapi_flag;
1037		- st->pa_wasapi_stream_category = opt_pa_wasapi_stream_category;
1038		- st->pa_wasapi_stream_option = opt_pa_wasapi_stream_option;
	1025	+ st->pa_wdmks_device_id = opt_pa_wdmks_device_id;
	1026	+ st->pa_wasapi_device_id = opt_pa_wasapi_device_id;
	1027	+ st->pa_wasapi_flag = opt_pa_wasapi_flag;
	1028	+ st->pa_wasapi_stream_category = opt_pa_wasapi_stream_category;
	1029	+ st->pa_wasapi_stream_option = opt_pa_wasapi_stream_option;
1039	1030	#endif
1040	1031	#endif
1041		- st->opt_resample_type = SetValue(opt_resample_type, 0, RESAMPLE_MAX - 1);
1042		- st->opt_resample_param = opt_resample_param;
1043		- st->opt_resample_filter = SetValue(opt_resample_filter, 0, RESAMPLE_FILTER_LIST_MAX - 1);
1044		- st->opt_resample_over_sampling = opt_resample_over_sampling;
1045		- st->opt_pre_resamplation = opt_pre_resamplation;
	1032	+ st->opt_resample_type = SetValue(opt_resample_type, 0, RESAMPLE_MAX);
	1033	+ st->opt_resample_param = opt_resample_param;
	1034	+ st->opt_resample_filter = opt_resample_filter;
	1035	+ st->opt_resample_over_sampling = opt_resample_over_sampling;
	1036	+ st->opt_pre_resamplation = opt_pre_resamplation;
1046	1037
1047	1038	#if defined(__W32__) && defined(SMFCONV)
1048	1039	st->opt_rcpcv_dll = opt_rcpcv_dll;

		@@ -1050,66 +1041,49 @@ SaveSettingTiMidity(SETTING_TIMIDITY *st)
1050	1041	// st->data_block_bits = data_block_bits;
1051	1042	// st->data_block_num = data_block_num;
1052	1043	#ifdef AU_W32
1053		- st->wmme_buffer_bits = opt_wmme_buffer_bits;
1054		- st->wmme_buffer_num = opt_wmme_buffer_num;
	1044	+ st->wmme_buffer_bits = opt_wmme_buffer_bits;
	1045	+ st->wmme_buffer_num = opt_wmme_buffer_num;
1055	1046	#endif
1056		- st->add_play_time = add_play_time;
1057		- st->add_silent_time = add_silent_time;
1058		- st->emu_delay_time = emu_delay_time;
1059		- st->opt_limiter = opt_limiter;
1060		- st->opt_use_midi_loop_repeat = opt_use_midi_loop_repeat;
	1047	+ st->add_play_time = add_play_time;
	1048	+ st->add_silent_time = add_silent_time;
	1049	+ st->emu_delay_time = emu_delay_time;
	1050	+ st->opt_limiter = opt_limiter;
	1051	+ st->opt_use_midi_loop_repeat = SetValue(opt_use_midi_loop_repeat, 0, 1);
1061	1052	st->opt_midi_loop_repeat = opt_midi_loop_repeat;
1062		-
1063		- st->opt_mix_envelope = opt_mix_envelope;
1064		- st->opt_modulation_update = opt_modulation_update;
1065		- st->opt_cut_short_time = opt_cut_short_time;
1066		-
	1053	+
	1054	+ st->opt_mix_envelope = opt_mix_envelope;
	1055	+ st->opt_modulation_update = opt_modulation_update;
	1056	+ st->opt_cut_short_time = opt_cut_short_time;
	1057	+
1067	1058	#if defined(WINDRV_SETUP) \|\| defined(WINDRV)
1068		- st->syn_ThreadPriority = syn_ThreadPriority;
1069		- st->SynShTime = stream_max_compute;
1070		- st->opt_rtsyn_latency = opt_rtsyn_latency;
1071		- st->opt_rtsyn_skip_aq = opt_rtsyn_skip_aq;
	1059	+ st->syn_ThreadPriority = syn_ThreadPriority;
	1060	+ st->SynShTime = stream_max_compute;
	1061	+ st->opt_rtsyn_latency = opt_rtsyn_latency;
	1062	+ st->opt_rtsyn_skip_aq = opt_rtsyn_skip_aq;
1072	1063	#elif defined(IA_W32G_SYN)
1073		- for (i = 0; i < MAX_PORT; i++) {
1074		- st->SynIDPort[i] = w32g_syn_id_port[i];
1075		- }
1076		- st->syn_AutoStart = syn_AutoStart;
1077		- st->syn_ThreadPriority = syn_ThreadPriority;
1078		- st->SynPortNum = w32g_syn_port_num;
1079		- st->SynShTime = stream_max_compute;
1080		- st->opt_rtsyn_latency = opt_rtsyn_latency;
1081		- st->opt_rtsyn_skip_aq = opt_rtsyn_skip_aq;
1082		- st->opt_use_twsyn_bridge = opt_use_twsyn_bridge;
	1064	+ for ( i = 0; i < MAX_PORT; i ++ ) {
	1065	+ st->SynIDPort[i] = w32g_syn_id_port[i];
	1066	+ }
	1067	+ st->syn_AutoStart = syn_AutoStart;
	1068	+ st->syn_ThreadPriority = syn_ThreadPriority;
	1069	+ st->SynPortNum = w32g_syn_port_num;
	1070	+ st->SynShTime = stream_max_compute;
	1071	+ st->opt_rtsyn_latency = opt_rtsyn_latency;
	1072	+ st->opt_rtsyn_skip_aq = opt_rtsyn_skip_aq;
	1073	+ st->opt_use_twsyn_bridge = opt_use_twsyn_bridge;
1083	1074	#endif
1084	1075	///r
1085		- st->processPriority = processPriority;
1086		- st->compute_thread_num = compute_thread_num;
1087		-#ifdef USE_TRACE_TIMER
1088		- st->trace_mode_update_time = trace_mode_update_time;
	1076	+ st->processPriority = processPriority;
	1077	+ st->compute_thread_num = compute_thread_num;
	1078	+#ifdef USE_TRACE_TIMER
	1079	+ st->trace_mode_update_time = trace_mode_update_time;
1089	1080	#endif
1090		- st->opt_load_all_instrument = opt_load_all_instrument;
1091		-
	1081	+ st->opt_load_all_instrument = opt_load_all_instrument;
	1082	+
1092	1083	/* for INT_SYNTH */
1093		- st->opt_int_synth_sine = opt_int_synth_sine;
1094		- st->opt_int_synth_rate = opt_int_synth_rate;
1095		- st->opt_int_synth_update = opt_int_synth_update;
1096		-}
1097		-
1098		-void
1099		-InitSettingTiMidity(SETTING_TIMIDITY *st)
1100		-{
1101		- st->voices = voices = DEFAULT_VOICES;
1102		- st->output_rate = opt_output_rate = DEFAULT_RATE;
1103		-#if defined(TWSYNSRV) \|\| defined(TWSYNG32)
1104		- st->audio_buffer_bits = opt_audio_buffer_bits = DEFAULT_AUDIO_BUFFER_BITS;
1105		- st->opt_reverb_control = opt_reverb_control = 0; /* default off */
1106		- st->opt_chorus_control = opt_chorus_control = 0; /* default off */
1107		- st->opt_surround_chorus = opt_surround_chorus = 0; /* default off */
1108		- st->opt_normal_chorus_plus = opt_normal_chorus_plus = 0; /* default off */
1109		- st->opt_lpf_def = opt_lpf_def = 0; /* default off */
1110		- st->noise_sharp_type = noise_sharp_type = 0; /* default off */
1111		- st->opt_resample_type = opt_resample_type = 0; /* default off */
1112		-#endif /* TWSYNSRV \|\| TWSYNG32 */
	1084	+ st->opt_int_synth_sine = opt_int_synth_sine;
	1085	+ st->opt_int_synth_rate = opt_int_synth_rate;
	1086	+ st->opt_int_synth_update = opt_int_synth_update;
1113	1087	}
1114	1088
1115	1089

		@@ -1161,18 +1135,15 @@ int TracerFontSize = 16;
1161	1135
1162	1136	#define DEFAULT_DOCFILEEXT "doc;txt;hed"
1163	1137
1164		-SETTING_PLAYER sp_default = NULL, sp_current = NULL, *sp_temp = NULL;
1165		-SETTING_TIMIDITY st_default = NULL, st_current = NULL, *st_temp = NULL;
	1138	+SETTING_PLAYER sp_default=NULL, sp_current=NULL, *sp_temp=NULL;
	1139	+SETTING_TIMIDITY st_default=NULL, st_current=NULL, *st_temp=NULL;
1166	1140	char *timidity_window_inifile;
1167	1141	char *timidity_output_inifile;
1168	1142
1169		-extern int wave_ConfigDialogInfoInit(void);
1170		-extern int wave_ConfigDialogInfoSaveINI(void);
1171		-extern int wave_ConfigDialogInfoLoadINI(void);
1172		-#ifdef AU_LAME
1173		-extern int lame_ConfigDialogInfoInit(void);
1174		-extern int lame_ConfigDialogInfoSaveINI(void);
1175		-extern int lame_ConfigDialogInfoLoadINI(void);
	1143	+#ifdef AU_GOGO
	1144	+extern int gogo_ConfigDialogInfoInit(void);
	1145	+extern int gogo_ConfigDialogInfoSaveINI(void);
	1146	+extern int gogo_ConfigDialogInfoLoadINI(void);
1176	1147	#endif
1177	1148	#ifdef AU_VORBIS
1178	1149	extern int vorbis_ConfigDialogInfoInit(void);

		@@ -1184,36 +1155,21 @@ extern int flac_ConfigDialogInfoInit(void);
1184	1155	extern int flac_ConfigDialogInfoSaveINI(void);
1185	1156	extern int flac_ConfigDialogInfoLoadINI(void);
1186	1157	#endif
1187		-#ifdef AU_OPUS
1188		-extern int opus_ConfigDialogInfoInit(void);
1189		-extern int opus_ConfigDialogInfoSaveINI(void);
1190		-extern int opus_ConfigDialogInfoLoadINI(void);
1191		-#endif
1192		-#ifdef AU_SPEEX
1193		-extern int speex_ConfigDialogInfoInit(void);
1194		-extern int speex_ConfigDialogInfoSaveINI(void);
1195		-extern int speex_ConfigDialogInfoLoadINI(void);
1196		-#endif
1197		-#ifdef AU_GOGO
1198		-extern int gogo_ConfigDialogInfoInit(void);
1199		-extern int gogo_ConfigDialogInfoSaveINI(void);
1200		-extern int gogo_ConfigDialogInfoLoadINI(void);
1201		-#endif
1202	1158
1203	1159	void w32g_uninitialize(void)
1204	1160	{
1205		- safe_free(sp_default);
1206		- sp_default = NULL;
1207		- safe_free(st_default);
1208		- st_default = NULL;
1209		- safe_free(sp_current);
1210		- sp_current = NULL;
1211		- safe_free(st_current);
1212		- st_current = NULL;
1213		- safe_free(sp_temp);
1214		- sp_temp = NULL;
1215		- safe_free(st_temp);
1216		- st_temp = NULL;
	1161	+ safe_free(sp_default);
	1162	+ sp_default = NULL;
	1163	+ safe_free(st_default);
	1164	+ st_default = NULL;
	1165	+ safe_free(sp_current);
	1166	+ sp_current = NULL;
	1167	+ safe_free(st_current);
	1168	+ st_current = NULL;
	1169	+ safe_free(sp_temp);
	1170	+ sp_temp = NULL;
	1171	+ safe_free(st_temp);
	1172	+ st_temp = NULL;
1217	1173	}
1218	1174
1219	1175	#ifdef KBTIM_SETUP

		@@ -1221,9 +1177,8 @@ extern void get_ini_path(char *ini);
1221	1177
1222	1178	void w32g_initialize(void)
1223	1179	{
1224		- char buffer[FILEPATH_MAX] = { 0 };
	1180	+ char buffer[FILEPATH_MAX] = {0};
1225	1181	char *p;
1226		- const int inilen = (int) strlen(TIMW32_INITFILE_NAME);
1227	1182
1228	1183	IniFile = S_IniFile;
1229	1184	ConfigFile = S_ConfigFile;

		@@ -1234,12 +1189,17 @@ void w32g_initialize(void)
1234	1189	PlaylistFileOpenDir = S_PlaylistFileOpenDir;
1235	1190	DocFileExt = S_DocFileExt;
1236	1191	OutputName = S_OutputName;
1237		- w32g_output_dir = S_w32g_output_dir;
1238		- switch (PRIMARYLANGID(GetUserDefaultLangID())) {
1239		- case LANG_JAPANESE: PlayerLanguage = LANGUAGE_JAPANESE; break;
1240		- default: PlayerLanguage = LANGUAGE_ENGLISH; break;
	1192	+ w32g_output_dir = S_w32g_output_dir;
	1193	+ switch (PRIMARYLANGID(GetUserDefaultLangID()))
	1194	+ {
	1195	+ case LANG_JAPANESE:
	1196	+ PlayerLanguage = LANGUAGE_JAPANESE;
	1197	+ break;
	1198	+ default:
	1199	+ PlayerLanguage = LANGUAGE_ENGLISH;
	1200	+ break;
1241	1201	}
1242		-
	1202	+
1243	1203	IniFile[0] = '\0';
1244	1204	ConfigFile[0] = '\0';
1245	1205	PlaylistFile[0] = '\0';

		@@ -1248,88 +1208,79 @@ void w32g_initialize(void)
1248	1208	ConfigFileOpenDir[0] = '\0';
1249	1209	PlaylistFileOpenDir[0] = '\0';
1250	1210	OutputName[0] = '\0';
1251		- w32g_output_dir[0] = '\0';
1252		-
1253		- strcpy(DocFileExt, DEFAULT_DOCFILEEXT);
1254		- strcpy(SystemFont, "ＭＳ明朝");
1255		- strcpy(PlayerFont, "ＭＳ明朝");
1256		- strcpy(WrdFont, "ＭＳ明朝");
1257		- strcpy(DocFont, "ＭＳ明朝");
1258		- strcpy(ListFont, "ＭＳ明朝");
1259		- strcpy(TracerFont, "ＭＳ明朝");
1260		-
1261		- get_ini_path(IniFile);
1262		-
1263		- st_default = (SETTING_TIMIDITY*) safe_malloc(sizeof(SETTING_TIMIDITY));
1264		- sp_default = (SETTING_PLAYER*) safe_malloc(sizeof(SETTING_PLAYER));
1265		- st_current = (SETTING_TIMIDITY*) safe_malloc(sizeof(SETTING_TIMIDITY));
1266		- sp_current = (SETTING_PLAYER*) safe_malloc(sizeof(SETTING_PLAYER));
1267		- st_temp = (SETTING_TIMIDITY*) safe_malloc(sizeof(SETTING_TIMIDITY));
1268		- sp_temp = (SETTING_PLAYER*) safe_malloc(sizeof(SETTING_PLAYER));
1269		-
1270		- ZeroMemory(sp_current, sizeof(SETTING_PLAYER));
1271		- ZeroMemory(st_current, sizeof(SETTING_TIMIDITY));
1272		- ZeroMemory(sp_default, sizeof(SETTING_PLAYER));
1273		- ZeroMemory(st_default, sizeof(SETTING_TIMIDITY));
1274		- ZeroMemory(sp_temp, sizeof(SETTING_PLAYER));
1275		- ZeroMemory(st_temp, sizeof(SETTING_TIMIDITY));
	1211	+ w32g_output_dir[0] = '\0';
	1212	+
	1213	+ strcpy(DocFileExt,DEFAULT_DOCFILEEXT);
	1214	+ strcpy(SystemFont,"ＭＳ明朝");
	1215	+ strcpy(PlayerFont,"ＭＳ明朝");
	1216	+ strcpy(WrdFont,"ＭＳ明朝");
	1217	+ strcpy(DocFont,"ＭＳ明朝");
	1218	+ strcpy(ListFont,"ＭＳ明朝");
	1219	+ strcpy(TracerFont,"ＭＳ明朝");
	1220	+
	1221	+ get_ini_path(IniFile);
	1222	+
	1223	+ st_default = (SETTING_TIMIDITY *)safe_malloc(sizeof(SETTING_TIMIDITY));
	1224	+ sp_default = (SETTING_PLAYER *)safe_malloc(sizeof(SETTING_PLAYER));
	1225	+ st_current = (SETTING_TIMIDITY *)safe_malloc(sizeof(SETTING_TIMIDITY));
	1226	+ sp_current = (SETTING_PLAYER *)safe_malloc(sizeof(SETTING_PLAYER));
	1227	+ st_temp = (SETTING_TIMIDITY *)safe_malloc(sizeof(SETTING_TIMIDITY));
	1228	+ sp_temp = (SETTING_PLAYER *)safe_malloc(sizeof(SETTING_PLAYER));
	1229	+
	1230	+ memset(sp_current, 0, sizeof(SETTING_PLAYER));
	1231	+ memset(st_current, 0, sizeof(SETTING_TIMIDITY));
	1232	+ memset(sp_default, 0, sizeof(SETTING_PLAYER));
	1233	+ memset(st_default, 0, sizeof(SETTING_TIMIDITY));
	1234	+ memset(sp_temp, 0, sizeof(SETTING_PLAYER));
	1235	+ memset(st_temp, 0, sizeof(SETTING_TIMIDITY));
1276	1236
1277	1237	SaveSettingPlayer(sp_current);
1278	1238	SaveSettingTiMidity(st_current);
1279		- InitSettingTiMidity(st_current);
1280		- if (IniVersionCheck())
	1239	+ if(IniVersionCheck())
1281	1240	{
1282		- LoadIniFile(sp_current, st_current);
1283		- ApplySettingPlayer(sp_current);
1284		- ApplySettingTiMidity(st_current);
1285		- w32g_has_ini_file = 1;
	1241	+ LoadIniFile(sp_current, st_current);
	1242	+ ApplySettingPlayer(sp_current);
	1243	+ ApplySettingTiMidity(st_current);
	1244	+ w32g_has_ini_file = 1;
1286	1245	}
1287	1246	else
1288	1247	{
1289		- const char *confirm,
1290		- confirm_en[] = "Ini file is not found, or old format is found." NLS
1291		- "Do you want to initialize the ini file?" NLS NLS
1292		- "Ini file path: %s",
1293		- confirm_ja[] = "設定ファイルが見つからないか古い形式です。" NLS
1294		- "設定ファイルを初期化してよろしいですか？" NLS NLS
1295		- "設定ファイルのパス: %s";
1296		- switch (PlayerLanguage) {
1297		- case LANGUAGE_ENGLISH: confirm = confirm_en; break;
1298		- case LANGUAGE_JAPANESE: default: confirm = confirm_ja; break;
1299		- }
1300		- snprintf(buffer, FILEPATH_MAX - 1, confirm,
1301		- IniFile);
1302		-
1303		- if (MessageBoxA(0, buffer, "TiMidity Notice", MB_YESNO \| MB_ICONINFORMATION \| MB_SYSTEMMODAL) == IDYES)
1304		- {
1305		- SaveIniFile(sp_current, st_current);
1306		- w32g_has_ini_file = 1;
1307		- }
1308		- else
1309		- {
1310		- w32g_has_ini_file = 0;
1311		- }
	1248	+ sprintf(buffer,
	1249	+"Ini file is not found, or old format is found.\n"
	1250	+"Do you want to initialize the ini file?\n\n"
	1251	+"Ini file path: %s",
	1252	+ IniFile);
	1253	+
	1254	+ if(MessageBox(0, buffer, "TiMidity Notice", MB_YESNO) == IDYES)
	1255	+ {
	1256	+ SaveIniFile(sp_current, st_current);
	1257	+ w32g_has_ini_file = 1;
	1258	+ }
	1259	+ else
	1260	+ {
	1261	+ w32g_has_ini_file = 0;
	1262	+ }
1312	1263	}
1313	1264
1314		- CopyMemory(sp_default, sp_current, sizeof(SETTING_PLAYER));
1315		- CopyMemory(st_default, st_current, sizeof(SETTING_TIMIDITY));
	1265	+ memcpy(sp_default, sp_current, sizeof(SETTING_PLAYER));
	1266	+ memcpy(st_default, st_current, sizeof(SETTING_TIMIDITY));
1316	1267
1317		- CopyMemory(sp_temp, sp_current, sizeof(SETTING_PLAYER));
1318		- CopyMemory(st_temp, st_current, sizeof(SETTING_TIMIDITY));
	1268	+ memcpy(sp_temp, sp_current, sizeof(SETTING_PLAYER));
	1269	+ memcpy(st_temp, st_current, sizeof(SETTING_TIMIDITY));
1319	1270
1320		- wrdt = wrdt_list[0];
	1271	+ wrdt=wrdt_list[0];
1321	1272	}
1322	1273
	1274	+
1323	1275	#else
1324	1276
1325	1277	void w32g_initialize(void)
1326	1278	{
1327		- char buffer[FILEPATH_MAX] = { 0 };
	1279	+ char buffer[FILEPATH_MAX] = {0};
1328	1280	char *p;
1329		- const int inilen = (int) strlen(TIMW32_INITFILE_NAME);
1330	1281
1331	1282	hInst = GetModuleHandle(0);
1332		-
	1283	+
1333	1284	IniFile = S_IniFile;
1334	1285	ConfigFile = S_ConfigFile;
1335	1286	PlaylistFile = S_PlaylistFile;

		@@ -1339,12 +1290,17 @@ void w32g_initialize(void)
1339	1290	PlaylistFileOpenDir = S_PlaylistFileOpenDir;
1340	1291	DocFileExt = S_DocFileExt;
1341	1292	OutputName = S_OutputName;
1342		- w32g_output_dir = S_w32g_output_dir;
1343		- switch (PRIMARYLANGID(GetUserDefaultLangID())) {
1344		- case LANG_JAPANESE: PlayerLanguage = LANGUAGE_JAPANESE; break;
1345		- default: PlayerLanguage = LANGUAGE_ENGLISH; break;
	1293	+ w32g_output_dir = S_w32g_output_dir;
	1294	+ switch (PRIMARYLANGID(GetUserDefaultLangID()))
	1295	+ {
	1296	+ case LANG_JAPANESE:
	1297	+ PlayerLanguage = LANGUAGE_JAPANESE;
	1298	+ break;
	1299	+ default:
	1300	+ PlayerLanguage = LANGUAGE_ENGLISH;
	1301	+ break;
1346	1302	}
1347		-
	1303	+
1348	1304	IniFile[0] = '\0';
1349	1305	ConfigFile[0] = '\0';
1350	1306	PlaylistFile[0] = '\0';

		@@ -1353,209 +1309,183 @@ void w32g_initialize(void)
1353	1309	ConfigFileOpenDir[0] = '\0';
1354	1310	PlaylistFileOpenDir[0] = '\0';
1355	1311	OutputName[0] = '\0';
1356		- w32g_output_dir[0] = '\0';
	1312	+ w32g_output_dir[0] = '\0';
1357	1313
1358		- strcpy(DocFileExt, DEFAULT_DOCFILEEXT);
1359		- strcpy(SystemFont, "ＭＳ明朝");
1360		- strcpy(PlayerFont, "ＭＳ明朝");
1361		- strcpy(WrdFont, "ＭＳ明朝");
1362		- strcpy(DocFont, "ＭＳ明朝");
1363		- strcpy(ListFont, "ＭＳ明朝");
1364		- strcpy(TracerFont, "ＭＳ明朝");
	1314	+ strcpy(DocFileExt,DEFAULT_DOCFILEEXT);
	1315	+ strcpy(SystemFont,"ＭＳ明朝");
	1316	+ strcpy(PlayerFont,"ＭＳ明朝");
	1317	+ strcpy(WrdFont,"ＭＳ明朝");
	1318	+ strcpy(DocFont,"ＭＳ明朝");
	1319	+ strcpy(ListFont,"ＭＳ明朝");
	1320	+ strcpy(TracerFont,"ＭＳ明朝");
1365	1321
1366	1322	#if defined(WINDRV)
1367		- if (GetWindowsDirectoryA(buffer, FILEPATH_MAX - inilen - 1))
	1323	+ if (GetWindowsDirectory(buffer, FILEPATH_MAX - 12 - 1))
1368	1324	{
1369		- directory_form(buffer);
	1325	+ directory_form(buffer);
1370	1326	}
1371	1327	else
1372	1328	{
1373		- buffer[0] = '.';
1374		- buffer[1] = PATH_SEP;
1375		- buffer[2] = '\0';
	1329	+ buffer[0] = '.';
	1330	+ buffer[1] = PATH_SEP;
	1331	+ buffer[2] = '\0';
1376	1332	}
1377	1333	#else
1378		- if (GetModuleFileNameA(hInst, buffer, FILEPATH_MAX - inilen - 1))
	1334	+ if(GetModuleFileName(hInst, buffer, FILEPATH_MAX - 1))
1379	1335	{
1380		- if ((p = pathsep_strrchr(buffer)) != NULL)
1381		- {
1382		- p++;
1383		- *p = '\0';
1384		- }
1385		- else
1386		- {
1387		- buffer[0] = '.';
1388		- buffer[1] = PATH_SEP;
1389		- buffer[2] = '\0';
1390		- }
	1336	+ if((p = pathsep_strrchr(buffer)) != NULL)
	1337	+ {
	1338	+ p++;
	1339	+ *p = '\0';
	1340	+ }
	1341	+ else
	1342	+ {
	1343	+ buffer[0] = '.';
	1344	+ buffer[1] = PATH_SEP;
	1345	+ buffer[2] = '\0';
	1346	+ }
1391	1347	}
1392	1348	else
1393	1349	{
1394		- buffer[0] = '.';
1395		- buffer[1] = PATH_SEP;
1396		- buffer[2] = '\0';
	1350	+ buffer[0] = '.';
	1351	+ buffer[1] = PATH_SEP;
	1352	+ buffer[2] = '\0';
1397	1353	}
1398	1354	#endif /* WINDRV */
1399	1355
1400		- // twsyng32.ini or timpp32g.ini
	1356	+ // timpp32g.ini
1401	1357	strncpy(IniFile, buffer, FILEPATH_MAX);
1402		- IniFile[FILEPATH_MAX - inilen - 1] = '\0';
	1358	+ IniFile[FILEPATH_MAX - 1] = '\0';
1403	1359	///r
1404		- strcat(IniFile, TIMW32_INITFILE_NAME);
1405		- // timidity_window.ini
1406		- timidity_window_inifile = S_timidity_window_inifile;
1407		- strncpy(timidity_window_inifile, buffer, FILEPATH_MAX);
	1360	+#if defined(TIMDRVINI)
	1361	+ strcat(IniFile,"timdrv.ini");
	1362	+#elif defined(TWSYNG32INI)
	1363	+ strcat(IniFile,"twsyng32.ini");
	1364	+#else
	1365	+ strcat(IniFile,"timpp32g.ini");
	1366	+#endif
	1367	+ // timidity_window.ini
	1368	+ timidity_window_inifile = S_timidity_window_inifile;
	1369	+ strncpy(timidity_window_inifile, buffer, FILEPATH_MAX);
1408	1370	timidity_window_inifile[FILEPATH_MAX - 1] = '\0';
1409		- strlcat(timidity_window_inifile, "timidity_window.ini", FILEPATH_MAX);
1410		- // timidity_output.ini
1411		- timidity_output_inifile = S_timidity_output_inifile;
1412		- strncpy(timidity_output_inifile, buffer, FILEPATH_MAX);
	1371	+ strlcat(timidity_window_inifile,"timidity_window.ini", FILEPATH_MAX);
	1372	+ // timidity_output.ini
	1373	+ timidity_output_inifile = S_timidity_output_inifile;
	1374	+ strncpy(timidity_output_inifile, buffer, FILEPATH_MAX);
1413	1375	timidity_output_inifile[FILEPATH_MAX - 1] = '\0';
1414		- strlcat(timidity_output_inifile, "timidity_output.ini", FILEPATH_MAX);
1415		- // default playlist
1416		- {
1417		- int i, len;
1418		- ZeroMemory(DefaultPlaylistPath, sizeof(DefaultPlaylistPath));
1419		- for (i = 0; i < PLAYLIST_MAX; i++) {
1420		- strncpy(DefaultPlaylistPath[i], buffer, FILEPATH_MAX);
1421		- strlcat(DefaultPlaylistPath[i],"default", FILEPATH_MAX);
1422		- len = strlen(DefaultPlaylistPath[i]);
1423		- if (i < 10)
1424		- DefaultPlaylistPath[i][len] = '0' + i;
1425		- else {
1426		- DefaultPlaylistPath[i][len] = '0' + i / 10;
1427		- DefaultPlaylistPath[i][len + 1] = '0' + i % 10;
1428		- }
1429		- strlcat(DefaultPlaylistPath[i],".pls", FILEPATH_MAX);
1430		- //snprintf(DefaultPlaylistPath[i], sizeof(DefaultPlaylistPath[i]), "%sdefault%d.pls", buffer, i);
1431		- }
1432		- }
1433		- //
1434		- st_default = (SETTING_TIMIDITY*) safe_malloc(sizeof(SETTING_TIMIDITY));
1435		- sp_default = (SETTING_PLAYER*) safe_malloc(sizeof(SETTING_PLAYER));
1436		- st_current = (SETTING_TIMIDITY*) safe_malloc(sizeof(SETTING_TIMIDITY));
1437		- sp_current = (SETTING_PLAYER*) safe_malloc(sizeof(SETTING_PLAYER));
1438		- st_temp = (SETTING_TIMIDITY*) safe_malloc(sizeof(SETTING_TIMIDITY));
1439		- sp_temp = (SETTING_PLAYER*) safe_malloc(sizeof(SETTING_PLAYER));
1440		-
1441		- ZeroMemory(sp_current, sizeof(SETTING_PLAYER));
1442		- ZeroMemory(st_current, sizeof(SETTING_TIMIDITY));
1443		- ZeroMemory(sp_default, sizeof(SETTING_PLAYER));
1444		- ZeroMemory(st_default, sizeof(SETTING_TIMIDITY));
1445		- ZeroMemory(sp_temp, sizeof(SETTING_PLAYER));
1446		- ZeroMemory(st_temp, sizeof(SETTING_TIMIDITY));
1447		-
1448		-#ifndef TWSYNSRV
1449		- {
1450		- DWORD dwRes;
1451		- wave_ConfigDialogInfoInit();
1452		-#ifdef AU_LAME
1453		- lame_ConfigDialogInfoInit();
	1376	+ strlcat(timidity_output_inifile,"timidity_output.ini", FILEPATH_MAX);
	1377	+ // default playlist
	1378	+ {
	1379	+ int i, len;
	1380	+ memset(DefaultPlaylistPath, 0, sizeof(DefaultPlaylistPath));
	1381	+ for(i = 0; i < PLAYLIST_MAX; i++){
	1382	+ strncpy(DefaultPlaylistPath[i], buffer, FILEPATH_MAX);
	1383	+ strlcat(DefaultPlaylistPath[i],"default", FILEPATH_MAX);
	1384	+ len = strlen(DefaultPlaylistPath[i]);
	1385	+ if(i < 10)
	1386	+ DefaultPlaylistPath[i][len] = '0' + i;
	1387	+ else{
	1388	+ DefaultPlaylistPath[i][len] = '0' + i / 10;
	1389	+ DefaultPlaylistPath[i][len + 1] = '0' + i % 10;
	1390	+ }
	1391	+ strlcat(DefaultPlaylistPath[i],".pls", FILEPATH_MAX);
	1392	+ // snprintf(DefaultPlaylistPath[i], sizeof(DefaultPlaylistPath[i]), "%sdefault%d.pls", buffer, i);
	1393	+ }
	1394	+ }
	1395	+ //
	1396	+ st_default = (SETTING_TIMIDITY *)safe_malloc(sizeof(SETTING_TIMIDITY));
	1397	+ sp_default = (SETTING_PLAYER *)safe_malloc(sizeof(SETTING_PLAYER));
	1398	+ st_current = (SETTING_TIMIDITY *)safe_malloc(sizeof(SETTING_TIMIDITY));
	1399	+ sp_current = (SETTING_PLAYER *)safe_malloc(sizeof(SETTING_PLAYER));
	1400	+ st_temp = (SETTING_TIMIDITY *)safe_malloc(sizeof(SETTING_TIMIDITY));
	1401	+ sp_temp = (SETTING_PLAYER *)safe_malloc(sizeof(SETTING_PLAYER));
	1402	+
	1403	+ memset(sp_current, 0, sizeof(SETTING_PLAYER));
	1404	+ memset(st_current, 0, sizeof(SETTING_TIMIDITY));
	1405	+ memset(sp_default, 0, sizeof(SETTING_PLAYER));
	1406	+ memset(st_default, 0, sizeof(SETTING_TIMIDITY));
	1407	+ memset(sp_temp, 0, sizeof(SETTING_PLAYER));
	1408	+ memset(st_temp, 0, sizeof(SETTING_TIMIDITY));
	1409	+
	1410	+ {
	1411	+ DWORD dwRes;
	1412	+#ifdef AU_GOGO
	1413	+ gogo_ConfigDialogInfoInit();
1454	1414	#endif
1455	1415	#ifdef AU_VORBIS
1456		- vorbis_ConfigDialogInfoInit();
1457		-#endif
1458		-#ifdef AU_FLAC
1459		- flac_ConfigDialogInfoInit();
	1416	+ vorbis_ConfigDialogInfoInit();
1460	1417	#endif
1461		-#ifdef AU_OPUS
1462		- opus_ConfigDialogInfoInit();
	1418	+#ifdef AU_LAME
	1419	+ lame_ConfigDialogInfoInit();
1463	1420	#endif
1464		-#ifdef AU_SPEEX
1465		- speex_ConfigDialogInfoInit();
	1421	+#ifdef AU_FLAC
	1422	+ flac_ConfigDialogInfoInit();
1466	1423	#endif
	1424	+ dwRes = GetFileAttributes(timidity_output_inifile);
	1425	+ if(dwRes==0xFFFFFFFF \|\| dwRes & FILE_ATTRIBUTE_DIRECTORY){
1467	1426	#ifdef AU_GOGO
1468		- gogo_ConfigDialogInfoInit();
1469		-#endif
1470		- dwRes = GetFileAttributesA(timidity_output_inifile);
1471		- if (dwRes == 0xFFFFFFFF \|\| dwRes & FILE_ATTRIBUTE_DIRECTORY) {
1472		- wave_ConfigDialogInfoSaveINI();
1473		-#ifdef AU_LAME
1474		- lame_ConfigDialogInfoSaveINI();
	1427	+ gogo_ConfigDialogInfoSaveINI();
1475	1428	#endif
1476	1429	#ifdef AU_VORBIS
1477		- vorbis_ConfigDialogInfoSaveINI();
1478		-#endif
1479		-#ifdef AU_FLAC
1480		- flac_ConfigDialogInfoSaveINI();
	1430	+ vorbis_ConfigDialogInfoSaveINI();
1481	1431	#endif
1482		-#ifdef AU_OPUS
1483		- opus_ConfigDialogInfoSaveINI();
	1432	+#ifdef AU_LAME
	1433	+ lame_ConfigDialogInfoSaveINI();
1484	1434	#endif
1485		-#ifdef AU_SPEEX
1486		- speex_ConfigDialogInfoSaveINI();
	1435	+#ifdef AU_FLAC
	1436	+ flac_ConfigDialogInfoSaveINI();
1487	1437	#endif
	1438	+ } else {
1488	1439	#ifdef AU_GOGO
1489		- gogo_ConfigDialogInfoSaveINI();
1490		-#endif
1491		- } else {
1492		- wave_ConfigDialogInfoLoadINI();
1493		-#ifdef AU_LAME
1494		- lame_ConfigDialogInfoLoadINI();
	1440	+ gogo_ConfigDialogInfoLoadINI();
1495	1441	#endif
1496	1442	#ifdef AU_VORBIS
1497		- vorbis_ConfigDialogInfoLoadINI();
	1443	+ vorbis_ConfigDialogInfoLoadINI();
1498	1444	#endif
1499		-#ifdef AU_FLAC
1500		- flac_ConfigDialogInfoLoadINI();
1501		-#endif
1502		-#ifdef AU_OPUS
1503		- opus_ConfigDialogInfoLoadINI();
1504		-#endif
1505		-#ifdef AU_SPEEX
1506		- speex_ConfigDialogInfoLoadINI();
	1445	+#ifdef AU_LAME
	1446	+ lame_ConfigDialogInfoLoadINI();
1507	1447	#endif
1508		-#ifdef AU_GOGO
1509		- gogo_ConfigDialogInfoLoadINI();
	1448	+#ifdef AU_FLAC
	1449	+ flac_ConfigDialogInfoLoadINI();
1510	1450	#endif
1511		- }
1512		- }
1513		-#endif /* !TWSYNSRV */
	1451	+ }
	1452	+ }
1514	1453
1515	1454	SaveSettingPlayer(sp_current);
1516	1455	SaveSettingTiMidity(st_current);
1517		- InitSettingTiMidity(st_current);
1518		- if (IniVersionCheck())
	1456	+ if(IniVersionCheck())
1519	1457	{
1520		- LoadIniFile(sp_current, st_current);
1521		- ApplySettingPlayer(sp_current);
1522		- ApplySettingTiMidity(st_current);
1523		- w32g_has_ini_file = 1;
	1458	+ LoadIniFile(sp_current, st_current);
	1459	+ ApplySettingPlayer(sp_current);
	1460	+ ApplySettingTiMidity(st_current);
	1461	+ w32g_has_ini_file = 1;
1524	1462	}
1525	1463	else
1526	1464	{
1527		- const char *confirm,
1528		- confirm_en[] = "Ini file is not found, or old format is found." NLS
1529		- "Do you want to initialize the ini file?" NLS NLS
1530		- "Ini file path: %.1023s",
1531		- confirm_ja[] = "設定ファイルが見つからないか古い形式です。" NLS
1532		- "設定ファイルを初期化しますか？" NLS NLS
1533		- "設定ファイルのパス: %.1023s";
1534		- switch (PlayerLanguage) {
1535		- case LANGUAGE_ENGLISH: confirm = confirm_en; break;
1536		- case LANGUAGE_JAPANESE: default: confirm = confirm_ja; break;
1537		- }
1538		- snprintf(buffer, FILEPATH_MAX - 1, confirm,
1539		- IniFile);
1540		-
1541		- if (MessageBoxA(0, buffer, "TiMidity Notice", MB_YESNO \| MB_ICONINFORMATION \| MB_SYSTEMMODAL) == IDYES)
1542		- {
1543		- SaveIniFile(sp_current, st_current);
1544		- w32g_has_ini_file = 1;
1545		- }
1546		- else
1547		- {
1548		- w32g_has_ini_file = 0;
1549		- }
	1465	+ sprintf(buffer,
	1466	+"Ini file is not found, or old format is found.\n"
	1467	+"Do you want to initialize the ini file?\n\n"
	1468	+"Ini file path: %s",
	1469	+ IniFile);
	1470	+
	1471	+ if(MessageBox(0, buffer, "TiMidity Notice", MB_YESNO) == IDYES)
	1472	+ {
	1473	+ SaveIniFile(sp_current, st_current);
	1474	+ w32g_has_ini_file = 1;
	1475	+ }
	1476	+ else
	1477	+ {
	1478	+ w32g_has_ini_file = 0;
	1479	+ }
1550	1480	}
1551	1481
1552		- CopyMemory(sp_default, sp_current, sizeof(SETTING_PLAYER));
1553		- CopyMemory(st_default, st_current, sizeof(SETTING_TIMIDITY));
	1482	+ memcpy(sp_default, sp_current, sizeof(SETTING_PLAYER));
	1483	+ memcpy(st_default, st_current, sizeof(SETTING_TIMIDITY));
1554	1484
1555		- CopyMemory(sp_temp, sp_current, sizeof(SETTING_PLAYER));
1556		- CopyMemory(st_temp, st_current, sizeof(SETTING_TIMIDITY));
	1485	+ memcpy(sp_temp, sp_current, sizeof(SETTING_PLAYER));
	1486	+ memcpy(st_temp, st_current, sizeof(SETTING_TIMIDITY));
1557	1487
1558		- wrdt = wrdt_list[0];
	1488	+ wrdt=wrdt_list[0];
1559	1489
1560	1490	#ifndef IA_W32G_SYN
1561	1491	w32g_i_init();

		@@ -1565,38 +1495,35 @@ void w32g_initialize(void)
1565	1495
1566	1496	int IniVersionCheck(void)
1567	1497	{
1568		- char version[INI_MAXLEN] = { 0 };
1569		- if (IniGetKeyStringN(INI_SEC_PLAYER, "IniVersion", version, sizeof(version) - 1) == 0 &&
1570		- !strcmp(version, IniVersion))
1571		- return 1; // UnChanged
	1498	+ char version[INI_MAXLEN] = {0};
	1499	+ if(IniGetKeyStringN(INI_SEC_PLAYER,"IniVersion",version,sizeof(version)-1) == 0 &&
	1500	+ strcmp(version, IniVersion) == 0)
	1501	+ return 1; // UnChanged
1572	1502	return 0;
1573	1503	}
1574	1504
1575		-#ifdef __W32G__
1576		-void BitBltRect(HDC dst, HDC src, const RECT *rc)
	1505	+void BitBltRect(HDC dst, HDC src, RECT *rc)
1577	1506	{
1578	1507	BitBlt(dst, rc->left, rc->top,
1579		- rc->right - rc->left, rc->bottom - rc->top,
1580		- src, rc->left, rc->top, SRCCOPY);
	1508	+ rc->right - rc->left, rc->bottom - rc->top,
	1509	+ src, rc->left, rc->top, SRCCOPY);
1581	1510	}
1582		-#endif
1583	1511
1584	1512	static void SafeGetFileName_DeleteSep(char *str)
1585	1513	{
1586	1514	if (str && is_last_path_sep(str)) {
1587		- char *p = pathsep_strrchr(str);
1588		- *p = '\0';
	1515	+ char *p = pathsep_strrchr(str);
	1516	+ *p = '\0';
1589	1517	}
1590	1518	}
1591	1519
1592		-#ifdef __W32G__
1593	1520	BOOL SafeGetOpenFileName(LPOPENFILENAMEA lpofn)
1594	1521	{
1595	1522	BOOL result;
1596	1523	char currentdir[FILEPATH_MAX];
1597	1524
1598	1525	if (lpofn->lpstrFile) {
1599		- SafeGetFileName_DeleteSep(lpofn->lpstrFile);
	1526	+ SafeGetFileName_DeleteSep(lpofn->lpstrFile);
1600	1527	}
1601	1528
1602	1529	GetCurrentDirectoryA(FILEPATH_MAX, currentdir);

		@@ -1612,7 +1539,7 @@ BOOL SafeGetSaveFileName(LPOPENFILENAMEA lpofn)
1612	1539	char currentdir[FILEPATH_MAX];
1613	1540
1614	1541	if (lpofn->lpstrFile) {
1615		- SafeGetFileName_DeleteSep(lpofn->lpstrFile);
	1542	+ SafeGetFileName_DeleteSep(lpofn->lpstrFile);
1616	1543	}
1617	1544
1618	1545	GetCurrentDirectoryA(FILEPATH_MAX, currentdir);

		@@ -1621,7 +1548,6 @@ BOOL SafeGetSaveFileName(LPOPENFILENAMEA lpofn)
1621	1548
1622	1549	return result;
1623	1550	}
1624		-#endif
1625	1551
1626	1552	#if 0
1627	1553	/*

		@@ -1643,13 +1569,13 @@ void TmInitColor(void)
1643	1569	{
1644	1570	int i;
1645	1571
1646		- tm_colors[TMCC_BLACK].color = TMCCC_BLACK;
1647		- tm_colors[TMCC_WHITE].color = TMCCC_WHITE;
1648		- tm_colors[TMCC_RED].color = TMCCC_RED;
1649		- tm_colors[TMCC_BACK].color = TMCCC_BACK;
1650		- tm_colors[TMCC_LOW].color = TMCCC_LOW;
	1572	+ tm_colors[TMCC_BLACK].color = TMCCC_BLACK;
	1573	+ tm_colors[TMCC_WHITE].color = TMCCC_WHITE;
	1574	+ tm_colors[TMCC_RED].color = TMCCC_RED;
	1575	+ tm_colors[TMCC_BACK].color = TMCCC_BACK;
	1576	+ tm_colors[TMCC_LOW].color = TMCCC_LOW;
1651	1577	tm_colors[TMCC_MIDDLE].color= TMCCC_MIDDLE;
1652		- tm_colors[TMCC_HIGH].color = TMCCC_HIGH;
	1578	+ tm_colors[TMCC_HIGH].color = TMCCC_HIGH;
1653	1579
1654	1580	tm_colors[TMCC_FORE_HALF].color = HalfColor(TMCCC_FORE,TMCCC_BACK);
1655	1581	tm_colors[TMCC_FORE_WEAKHALF].color = WeakHalfColor(TMCCC_FORE,TMCCC_BACK);

		@@ -1657,24 +1583,24 @@ void TmInitColor(void)
1657	1583	tm_colors[TMCC_MIDDLE_HALF].color = HalfColor(TMCCC_MIDDLE,TMCCC_BACK);
1658	1584	tm_colors[TMCC_HIGH_HALF].color = HalfColor(TMCCC_HIGH,TMCCC_BACK);
1659	1585
1660		- for (i = 0; i < TMCC_SIZE; i++)
	1586	+ for(i = 0; i < TMCC_SIZE; i++)
1661	1587	{
1662		- tm_colors[i].pen = CreatePen(PS_SOLID, 1, tm_colors[i].color);
1663		- tm_colors[i].brush = CreateSolidBrush(tm_colors[i].color);
	1588	+ tm_colors[i].pen = CreatePen(PS_SOLID, 1, tm_colors[i].color);
	1589	+ tm_colors[i].brush = CreateSolidBrush(tm_colors[i].color);
1664	1590	}
1665	1591	}
1666	1592
1667	1593	void TmFreeColor(void)
1668	1594	{
1669	1595	int i;
1670		- for (i = 0; i < TMCC_SIZE; i++)
	1596	+ for(i = 0; i < TMCC_SIZE; i++)
1671	1597	{
1672		- if (tm_colors[i].pen != NULL)
1673		- {
1674		- DeleteObject(tm_colors[i].pen);
1675		- DeleteObject(tm_colors[i].brush);
1676		- tm_colors[i].pen = NULL;
1677		- }
	1598	+ if(tm_colors[i].pen != NULL)
	1599	+ {
	1600	+ DeleteObject(tm_colors[i].pen);
	1601	+ DeleteObject(tm_colors[i].brush);
	1602	+ tm_colors[i].pen = NULL;
	1603	+ }
1678	1604	}
1679	1605	}
1680	1606

		@@ -1693,16 +1619,16 @@ void TmFillRect(HDC hdc, RECT *rc, int color)
1693	1619	#endif
1694	1620
1695	1621	#ifndef S_ISDIR
1696		-#define S_ISDIR(mode) (((mode) & 0xF000) == 0x4000)
1697		-#endif /* !S_ISDIR */
1698		-int is_directory(const char *path)
	1622	+#define S_ISDIR(mode) (((mode)&0xF000) == 0x4000)
	1623	+#endif /* S_ISDIR */
	1624	+int is_directory(char *path)
1699	1625	{
1700		- struct stat st;
1701		- if (path == '@') / special identifire for playlist file */
1702		- return 0;
1703		- if (stat(path, &st) != -1)
1704		- return S_ISDIR(st.st_mode);
1705		- return GetFileAttributesA(path) == FILE_ATTRIBUTE_DIRECTORY;
	1626	+ struct stat st;
	1627	+ if(path == '@') / special identifire for playlist file */
	1628	+ return 0;
	1629	+ if(stat(path, &st) != -1)
	1630	+ return S_ISDIR(st.st_mode);
	1631	+ return GetFileAttributes(path) == FILE_ATTRIBUTE_DIRECTORY;
1706	1632	}
1707	1633
1708	1634	/* Return: 0: - not modified

		@@ -1710,16 +1636,16 @@ int is_directory(const char *path)
1710	1636	*/
1711	1637	int directory_form(char *buffer)
1712	1638	{
1713		- int len;
1714		-
1715		- len = strlen(buffer);
1716		- if (len == 0 \|\| buffer[len - 1] == PATH_SEP)
1717		- return 0;
1718		- if (IS_PATH_SEP(buffer[len - 1]))
1719		- len--;
1720		- buffer[len++] = PATH_SEP;
1721		- buffer[len] = '\0';
1722		- return 1;
	1639	+ int len;
	1640	+
	1641	+ len = strlen(buffer);
	1642	+ if(len == 0 \|\| buffer[len - 1] == PATH_SEP)
	1643	+ return 0;
	1644	+ if(IS_PATH_SEP(buffer[len - 1]))
	1645	+ len--;
	1646	+ buffer[len++] = PATH_SEP;
	1647	+ buffer[len] = '\0';
	1648	+ return 1;
1723	1649	}
1724	1650
1725	1651	/* Return: 0: - not separate character

		@@ -1730,7 +1656,7 @@ int is_last_path_sep(const char *path)
1730	1656	const int len = strlen(path);
1731	1657
1732	1658	if (len == 0 \|\| !IS_PATH_SEP(path[len - 1]))
1733		- return 0;
	1659	+ return 0;
1734	1660	return 1;
1735	1661	}
1736	1662

		@@ -1739,334 +1665,318 @@ int is_last_path_sep(const char *path)
1739	1665	*/
1740	1666	int nodirectory_form(char *buffer)
1741	1667	{
1742		- char *lastp = buffer + strlen(buffer);
1743		- char *p = lastp;
1744		-
1745		- while (p > buffer && IS_PATH_SEP(*(p - 1)))
1746		- p--;
1747		- if (p == lastp)
1748		- return 0;
1749		- *p = '\0';
1750		- return 1;
	1668	+ char *lastp = buffer + strlen(buffer);
	1669	+ char *p = lastp;
	1670	+
	1671	+ while(p > buffer && IS_PATH_SEP(*(p - 1)))
	1672	+ p--;
	1673	+ if(p == lastp)
	1674	+ return 0;
	1675	+ *p = '\0';
	1676	+ return 1;
1751	1677	}
1752	1678
1753	1679	void SettingCtlFlag(SETTING_TIMIDITY *st, int c, int onoff)
1754	1680	{
1755	1681	int n;
1756	1682	char *opt;
1757		-
	1683	+
1758	1684	opt = st->opt_ctl + 1;
1759	1685	n = strlen(opt);
1760		- if (onoff)
	1686	+ if(onoff)
1761	1687	{
1762		- if (strchr(opt, c) != NULL)
1763		- return; /* Already set */
1764		- opt[n++] = c;
1765		- opt[n] = '\0';
	1688	+ if(strchr(opt, c) != NULL)
	1689	+ return; /* Already set */
	1690	+ opt[n++] = c;
	1691	+ opt[n] = '\0';
1766	1692	}
1767	1693	else
1768	1694	{
1769		- char *p;
1770		- if ((p = strchr(opt, c)) == NULL)
1771		- return; /* Already removed */
1772		- while (*(p + 1))
1773		- {
1774		- p = (p + 1);
1775		- p++;
1776		- }
1777		- *p = '\0';
	1695	+ char *p;
	1696	+ if((p = strchr(opt, c)) == NULL)
	1697	+ return; /* Already removed */
	1698	+ while(*(p + 1))
	1699	+ {
	1700	+ p = (p + 1);
	1701	+ p++;
	1702	+ }
	1703	+ *p = '\0';
1778	1704	}
1779	1705	}
1780	1706
1781	1707
1782	1708
1783	1709
1784		-int IsAvailableFilename(const char *filename)
	1710	+int IsAvailableFilename(char *filename)
1785	1711	{
1786		- char *p = strrchr(filename,'.');
1787		- if (p == NULL)
1788		- return 0;
1789		- if (!strcasecmp(p, ".lzh") \|\|
1790		- !strcasecmp(p, ".zip") \|\|
1791		- !strcasecmp(p, ".gz") \|\|
1792		- !strcasecmp(p, ".mid") \|\|
1793		- !strcasecmp(p, ".midi") \|\|
1794		- !strcasecmp(p, ".rmi") \|\|
1795		- !strcasecmp(p, ".rcp") \|\|
1796		- !strcasecmp(p, ".r36") \|\|
1797		- !strcasecmp(p, ".g18") \|\|
1798		- !strcasecmp(p, ".g36") \|\|
1799		- !strcasecmp(p, ".mod") \|\|
1800		- !strcasecmp(p, ".xm") \|\|
1801		- !strcasecmp(p, ".s3m") \|\|
1802		- !strcasecmp(p, ".it") \|\|
1803		- !strcasecmp(p, ".669") \|\|
1804		- !strcasecmp(p, ".amf") \|\|
1805		- !strcasecmp(p, ".dsm") \|\|
1806		- !strcasecmp(p, ".far") \|\|
1807		- !strcasecmp(p, ".gdm") \|\|
1808		- !strcasecmp(p, ".imf") \|\|
1809		- !strcasecmp(p, ".med") \|\|
1810		- !strcasecmp(p, ".mtm") \|\|
1811		- !strcasecmp(p, ".stm") \|\|
1812		- !strcasecmp(p, ".stx") \|\|
1813		- !strcasecmp(p, ".ult") \|\|
1814		- !strcasecmp(p, ".uni") \|\|
1815		-// !strcasecmp(p, ".hqx") \|\|
1816		- !strcasecmp(p, ".tar") \|\|
1817		- !strcasecmp(p, ".tgz") \|\|
1818		- !strcasecmp(p, ".lha") \|\|
1819		- !strcasecmp(p, ".mime") \|\|
1820		- !strcasecmp(p, ".smf"))
1821		- return 1;
1822		-// if (url_check_type(filename)!=-1)
1823		-// return 1;
1824		- return 0;
	1712	+ char *p = strrchr(filename,'.');
	1713	+ if(p == NULL)
	1714	+ return 0;
	1715	+ if( strcasecmp(p,".lzh")==0 \|\|
	1716	+ strcasecmp(p,".zip")==0 \|\|
	1717	+ strcasecmp(p,".gz")==0 \|\|
	1718	+ strcasecmp(p,".mid")==0 \|\|
	1719	+ strcasecmp(p,".rcp")==0 \|\|
	1720	+ strcasecmp(p,".r36")==0 \|\|
	1721	+ strcasecmp(p,".g18")==0 \|\|
	1722	+ strcasecmp(p,".g36")==0 \|\|
	1723	+ strcasecmp(p,".mod")==0 \|\|
	1724	+// strcasecmp(p,".hqx")==0 \|\|
	1725	+ strcasecmp(p,".tar")==0 \|\|
	1726	+ strcasecmp(p,".tgz")==0 \|\|
	1727	+ strcasecmp(p,".lha")==0 \|\|
	1728	+ strcasecmp(p,".mime")==0 \|\|
	1729	+ strcasecmp(p,".smf")==0)
	1730	+ return 1;
	1731	+// if(url_check_type(filename)!=-1)
	1732	+// return 1;
	1733	+ return 0;
1825	1734	}
1826	1735
1827	1736	/* ScanDirectoryFiles() works like UNIX find. */
1828	1737	#define SCANDIR_MAX_DEPTH 32
1829	1738	void ScanDirectoryFiles(char *basedir,
1830		- int (file_proc)(char pathname, /* (const) */
1831		- void *user_val),
1832		- void *user_val)
	1739	+ int (* file_proc)(char pathname, / (const) */
	1740	+ void *user_val),
	1741	+ void *user_val)
1833	1742	{
1834		- int baselen;
1835		- URL dir;
1836		-
1837		- static int depth = 0;
1838		- static int stop_flag; /* Stop scanning if true */
1839		- static int error_disp; /* Whether error is displayed or not */
1840		- static char pathbuf[FILEPATH_MAX]; /* pathname buffer */
1841		-
1842		- if (depth == 0) /* Initialize variables at first recursive */
1843		- {
1844		- stop_flag = 0;
1845		- error_disp = 0;
1846		- strcpy(pathbuf, basedir);
1847		- }
1848		- else if (depth > SCANDIR_MAX_DEPTH) /* Avoid infinite recursive */
1849		- {
1850		- if (!error_disp)
1851		- {
1852		- /* Display this message at once */
1853		- ctl->cmsg(CMSG_WARNING, VERB_NORMAL,
1854		- "%s: Directory is too deep",
1855		- basedir);
1856		- error_disp = 1;
1857		- }
1858		- return; /* Skip scanning this directory */
1859		- }
1860		-
1861		- directory_form(pathbuf);
1862		- baselen = strlen(pathbuf);
1863		- if (baselen > sizeof(pathbuf) - 16)
1864		- {
1865		- /* Ignore too long file name */
1866		- return;
1867		- }
1868		-
1869		- if ((dir = url_dir_open(pathbuf)) == NULL)
1870		- {
1871		- ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: Can't open directory", pathbuf);
1872		- return;
1873		- }
1874		-
1875		- if (file_proc(pathbuf, user_val))
1876		- {
1877		- stop_flag = 1; /* Terminate */
1878		- return;
1879		- }
1880		-
1881		- while (!stop_flag &&
1882		- url_gets(dir, pathbuf + baselen, sizeof(pathbuf) - baselen - 1))
1883		- {
1884		- if (strcmp(pathbuf + baselen, ".") == 0 \|\|
1885		- strcmp(pathbuf + baselen, "..") == 0)
1886		- continue;
1887		- if (file_proc(pathbuf, user_val))
1888		- {
1889		- stop_flag = 1; /* Terminate */
1890		- break;
1891		- }
1892		- if (is_directory(pathbuf))
1893		- {
1894		- /* into subdirectory */
1895		- depth++;
1896		- ScanDirectoryFiles(pathbuf, file_proc, user_val);
1897		- depth--;
1898		- }
1899		- }
1900		- url_close(dir);
	1743	+ char baselen;
	1744	+ URL dir;
	1745	+
	1746	+ static int depth = 0;
	1747	+ static int stop_flag; /* Stop scanning if true */
	1748	+ static int error_disp; /* Whether error is displayed or not */
	1749	+ static char pathbuf[FILEPATH_MAX]; /* pathname buffer */
	1750	+
	1751	+ if(depth == 0) /* Initialize variables at first recursive */
	1752	+ {
	1753	+ stop_flag = 0;
	1754	+ error_disp = 0;
	1755	+ strcpy(pathbuf, basedir);
	1756	+ }
	1757	+ else if(depth > SCANDIR_MAX_DEPTH) /* Avoid infinite recursive */
	1758	+ {
	1759	+ if(!error_disp)
	1760	+ {
	1761	+ /* Display this message at once */
	1762	+ ctl->cmsg(CMSG_WARNING, VERB_NORMAL,
	1763	+ "%s: Directory is too deep",
	1764	+ basedir);
	1765	+ error_disp = 1;
	1766	+ }
	1767	+ return; /* Skip scanning this directory */
	1768	+ }
	1769	+
	1770	+ directory_form(pathbuf);
	1771	+ baselen = strlen(pathbuf);
	1772	+ if(baselen > sizeof(pathbuf) - 16)
	1773	+ {
	1774	+ /* Ignore too long file name */
	1775	+ return;
	1776	+ }
	1777	+
	1778	+ if((dir = url_dir_open(pathbuf)) == NULL)
	1779	+ {
	1780	+ ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: Can't open directory", pathbuf);
	1781	+ return;
	1782	+ }
	1783	+
	1784	+ if(file_proc(pathbuf, user_val))
	1785	+ {
	1786	+ stop_flag = 1; /* Terminate */
	1787	+ return;
	1788	+ }
	1789	+
	1790	+ while(!stop_flag &&
	1791	+ url_gets(dir, pathbuf + baselen, sizeof(pathbuf) - baselen - 1))
	1792	+ {
	1793	+ if(strcmp(pathbuf + baselen, ".") == 0 \|\|
	1794	+ strcmp(pathbuf + baselen, "..") == 0)
	1795	+ continue;
	1796	+ if(file_proc(pathbuf, user_val))
	1797	+ {
	1798	+ stop_flag = 1; /* Terminate */
	1799	+ break;
	1800	+ }
	1801	+ if(is_directory(pathbuf))
	1802	+ {
	1803	+ /* into subdirectory */
	1804	+ depth++;
	1805	+ ScanDirectoryFiles(pathbuf, file_proc, user_val);
	1806	+ depth--;
	1807	+ }
	1808	+ }
	1809	+ url_close(dir);
1901	1810	}
1902	1811
1903		-#define EXPANDDIR_MAX_SIZE 1000000 /* Limit of total bytes of the file names */
	1812	+#define EXPANDDIR_MAX_SIZE 1000000 /* Limit of total bytes of the file names */
1904	1813	static int expand_dir_proc(char filename, void v)
1905	1814	{
1906		- void user_val = (void) v;
1907		- StringTable st = (StringTable) user_val[0];
1908		- int total_size = (int) user_val[1];
1909		- char startdir = (char) user_val[2];
1910		-
1911		- if (IsAvailableFilename(filename))
1912		- {
1913		- if (*total_size > EXPANDDIR_MAX_SIZE)
1914		- {
1915		- ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: There are too many files.",
1916		- startdir);
1917		- return 1; /* Terminate */
1918		- }
1919		- put_string_table(st, filename, strlen(filename));
1920		- *total_size += strlen(filename);
1921		- }
1922		- return 0;
	1815	+ void user_val = (void )v;
	1816	+ StringTable st = (StringTable )user_val[0];
	1817	+ int total_size = (int )user_val[1];
	1818	+ char startdir = (char )user_val[2];
	1819	+
	1820	+ if(IsAvailableFilename(filename))
	1821	+ {
	1822	+ if(*total_size > EXPANDDIR_MAX_SIZE)
	1823	+ {
	1824	+ ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: There are too many files.",
	1825	+ startdir);
	1826	+ return 1; /* Terminate */
	1827	+ }
	1828	+ put_string_table(st, filename, strlen(filename));
	1829	+ *total_size += strlen(filename);
	1830	+ }
	1831	+ return 0;
1923	1832	}
1924	1833
1925	1834	char *FilesExpandDir(int p_nfiles, char **files)
1926	1835	{
1927		- StringTable st;
1928		- int i;
1929		-
1930		- init_string_table(&st);
1931		- for (i = 0; i < *p_nfiles; i++)
1932		- {
1933		- void *user_val[3];
1934		- int total_size;
1935		-
1936		- total_size = 0;
1937		- user_val[0] = &st;
1938		- user_val[1] = &total_size;
1939		- user_val[2] = files[i];
1940		-
1941		- if (is_directory(files[i]))
1942		- ScanDirectoryFiles(files[i], expand_dir_proc, user_val);
1943		- else
1944		- {
1945		- int len = strlen(files[i]);
1946		- put_string_table(&st, files[i], len);
1947		- }
1948		- }
1949		- *p_nfiles = st.nstring;
	1836	+ StringTable st;
	1837	+ int i;
	1838	+
	1839	+ init_string_table(&st);
	1840	+ for(i = 0; i < *p_nfiles; i++)
	1841	+ {
	1842	+ void *user_val[3];
	1843	+ int total_size;
	1844	+
	1845	+ total_size = 0;
	1846	+ user_val[0] = &st;
	1847	+ user_val[1] = &total_size;
	1848	+ user_val[2] = files[i];
	1849	+
	1850	+ if(is_directory(files[i]))
	1851	+ ScanDirectoryFiles(files[i], expand_dir_proc, user_val);
	1852	+ else
	1853	+ {
	1854	+ int len = strlen(files[i]);
	1855	+ put_string_table(&st, files[i], len);
	1856	+ }
	1857	+ }
	1858	+ *p_nfiles = st.nstring;
1950	1859	return make_string_array(&st);
	1860	+
1951	1861	}
1952	1862
1953	1863	#ifndef IA_W32G_SYN
1954	1864	int w32gLoadDefaultPlaylist(void)
1955	1865	{
1956		- int i;
1957		- if (AutoloadPlaylist) {
1958		- w32g_lock_open_file = 1;
	1866	+ int i;
	1867	+ if(AutoloadPlaylist) {
	1868	+ w32g_lock_open_file = 1;
1959	1869	#ifdef EXT_CONTROL_MAIN_THREAD
1960		- for (i = 0; i < playlist_max; i++) {
1961		- w32g_ext_control_main_thread(RC_EXT_PLAYLIST_CTRL, i);
1962		- w32g_ext_control_main_thread(RC_EXT_LOAD_PLAYLIST, (ptr_size_t) DefaultPlaylistPath[i]);
1963		- }
1964		- w32g_ext_control_main_thread(RC_EXT_PLAYLIST_CTRL, 0);
	1870	+ for(i = 0; i < playlist_max; i++){
	1871	+ w32g_ext_control_main_thread(RC_EXT_PLAYLIST_CTRL, i);
	1872	+ w32g_ext_control_main_thread(RC_EXT_LOAD_PLAYLIST, (ptr_size_t)DefaultPlaylistPath[i]);
	1873	+ }
	1874	+ w32g_ext_control_main_thread(RC_EXT_PLAYLIST_CTRL, 0);
1965	1875	#else
1966		- for (i = 0; i < playlist_max; i++) {
1967		- w32g_send_rc(RC_EXT_PLAYLIST_CTRL, i);
1968		- w32g_send_rc(RC_EXT_LOAD_PLAYLIST, (ptr_size_t) DefaultPlaylistPath[i]);
1969		- }
1970		- w32g_send_rc(RC_EXT_PLAYLIST_CTRL, 0);
	1876	+ for(i = 0; i < playlist_max; i++){
	1877	+ w32g_send_rc(RC_EXT_PLAYLIST_CTRL, i);
	1878	+ w32g_send_rc(RC_EXT_LOAD_PLAYLIST, (ptr_size_t)DefaultPlaylistPath[i]);
	1879	+ }
	1880	+ w32g_send_rc(RC_EXT_PLAYLIST_CTRL, 0);
1971	1881	#endif
1972		- }
1973		- return 0;
	1882	+ }
	1883	+ return 0;
1974	1884	}
1975	1885
1976	1886	int w32gSaveDefaultPlaylist(void)
1977	1887	{
1978		- int i;
1979		- if (AutosavePlaylist) {
1980		- w32g_lock_open_file = 1;
	1888	+ int i;
	1889	+ if(AutosavePlaylist) {
	1890	+ w32g_lock_open_file = 1;
1981	1891	#ifdef EXT_CONTROL_MAIN_THREAD
1982		- for (i = 0; i < playlist_max; i++) {
1983		- w32g_ext_control_main_thread(RC_EXT_PLAYLIST_CTRL, i);
1984		- w32g_ext_control_main_thread(RC_EXT_SAVE_PLAYLIST, (ptr_size_t) DefaultPlaylistPath[i]);
1985		- }
1986		- w32g_ext_control_main_thread(RC_EXT_PLAYLIST_CTRL, 0);
	1892	+ for(i = 0; i < playlist_max; i++){
	1893	+ w32g_ext_control_main_thread(RC_EXT_PLAYLIST_CTRL, i);
	1894	+ w32g_ext_control_main_thread(RC_EXT_SAVE_PLAYLIST, (ptr_size_t)DefaultPlaylistPath[i]);
	1895	+ }
	1896	+ w32g_ext_control_main_thread(RC_EXT_PLAYLIST_CTRL, 0);
1987	1897	#else
1988		- for (i = 0; i < playlist_max; i++) {
1989		- w32g_send_rc(RC_EXT_PLAYLIST_CTRL, i);
1990		- w32g_send_rc(RC_EXT_SAVE_PLAYLIST, (ptr_size_t) DefaultPlaylistPath[i]);
1991		- }
1992		- w32g_send_rc(RC_EXT_PLAYLIST_CTRL, 0);
	1898	+ for(i = 0; i < playlist_max; i++){
	1899	+ w32g_send_rc(RC_EXT_PLAYLIST_CTRL, i);
	1900	+ w32g_send_rc(RC_EXT_SAVE_PLAYLIST, (ptr_size_t)DefaultPlaylistPath[i]);
	1901	+ }
	1902	+ w32g_send_rc(RC_EXT_PLAYLIST_CTRL, 0);
1993	1903	#endif
1994		- }
1995		- return 0;
	1904	+ }
	1905	+ return 0;
1996	1906	}
1997	1907	#endif
1998	1908
1999		-static char get_filename(const char src, char *dest)
	1909	+static char get_filename(char src, char *dest)
2000	1910	{
2001		- const char *p = src;
2002		- const char *start = NULL;
2003		- int quot_flag = 0;
2004		- if (p == NULL)
2005		- return NULL;
2006		- for (;;) {
2007		- if (p != ' ' && p != '\0' && start == NULL)
2008		- start = p;
2009		- if (p == '\'' \|\| p == '\"') {
2010		- if (quot_flag) {
2011		- if (p - start != 0)
2012		- strncpy(dest, start, p - start);
2013		- dest[p-start] = '\0';
2014		- p++;
2015		- return p;
2016		- } else {
2017		- quot_flag = !quot_flag;
2018		- p++;
2019		- start = p;
2020		- continue;
2021		- }
2022		- }
2023		- if (p == '\0' \|\| (p == ' ' && !quot_flag)) {
2024		- if (start == NULL)
2025		- return NULL;
2026		- if (p - start != 0)
2027		- strncpy(dest, start, p - start);
2028		- dest[p-start] = '\0';
2029		- if (*p != '\0')
2030		- p++;
2031		- return p;
2032		- }
2033		- p++;
2034		- }
	1911	+ char *p = src;
	1912	+ char *start = NULL;
	1913	+ int quot_flag = 0;
	1914	+ if(p == NULL)
	1915	+ return NULL;
	1916	+ for(;;){
	1917	+ if(p != ' ' && p != '\0' && start == NULL)
	1918	+ start = p;
	1919	+ if(p == '\'' \|\| p == '\"'){
	1920	+ if(quot_flag){
	1921	+ if(p - start != 0)
	1922	+ strncpy(dest, start, p - start);
	1923	+ dest[p-start] = '\0';
	1924	+ p++;
	1925	+ return p;
	1926	+ } else {
	1927	+ quot_flag = !quot_flag;
	1928	+ p++;
	1929	+ start = p;
	1930	+ continue;
	1931	+ }
	1932	+ }
	1933	+ if(p == '\0' \|\| (p == ' ' && !quot_flag)){
	1934	+ if(start == NULL)
	1935	+ return NULL;
	1936	+ if(p - start != 0)
	1937	+ strncpy(dest, start, p - start);
	1938	+ dest[p-start] = '\0';
	1939	+ if(*p != '\0')
	1940	+ p++;
	1941	+ return p;
	1942	+ }
	1943	+ p++;
	1944	+ }
2035	1945	}
2036	1946
2037	1947	void CmdLineToArgv(LPSTR lpCmdLine, int pArgc, CHAR **pArgv)
2038	1948	{
2039		- LPSTR p = lpCmdLine, buffer = NULL, lpsRes = NULL;
2040		- int i, max = -1, inc = 16;
2041		- int buffer_size;
2042		-
2043		- *pArgv = NULL;
2044		- buffer_size = strlen(lpCmdLine) + 4096;
2045		- buffer = (LPSTR) safe_malloc(sizeof(CHAR) * buffer_size + 1);
2046		-// buffer = (LPSTR) malloc(sizeof(CHAR) * buffer_size + 1);
2047		- strcpy(buffer, lpCmdLine);
2048		-
2049		- for (i = 0;; i++)
2050		- {
2051		- if (i > max) {
2052		- max += inc;
2053		- pArgv = (CHAR) safe_realloc(pArgv, sizeof(CHAR) (max + 2));
2054		-// pArgv = (CHAR) realloc(pArgv, sizeof(CHAR) (max + 2));
2055		- }
2056		- if (i == 0) {
2057		- GetModuleFileNameA(NULL, buffer, buffer_size);
2058		- lpsRes = p;
2059		- } else
2060		- lpsRes = get_filename(p, buffer);
2061		- if (lpsRes != NULL) {
2062		- (pArgv)[i] = (CHAR) safe_malloc(sizeof(CHAR) * strlen(buffer) + 1);
2063		-// (pArgv)[i] = (CHAR) malloc(sizeof(CHAR) * strlen(buffer) + 1);
2064		- strcpy((*pArgv)[i], buffer);
2065		- p = lpsRes;
2066		- } else {
2067		- *pArgc = i;
2068		- safe_free(buffer);
2069		- return;
2070		- }
2071		- }
	1949	+ LPSTR p = lpCmdLine , buffer = NULL, lpsRes = NULL;
	1950	+ int i, max = -1, inc = 16;
	1951	+ int buffer_size;
	1952	+
	1953	+ *pArgv = NULL;
	1954	+ buffer_size = strlen(lpCmdLine) + 4096;
	1955	+ buffer = (LPSTR)safe_malloc(sizeof(CHAR) * buffer_size + 1);
	1956	+// buffer = (LPSTR)malloc(sizeof(CHAR) * buffer_size + 1);
	1957	+ strcpy(buffer, lpCmdLine);
	1958	+
	1959	+ for(i=0;;i++)
	1960	+ {
	1961	+ if(i > max){
	1962	+ max += inc;
	1963	+ pArgv = (CHAR )safe_realloc(pArgv, sizeof(CHAR ) (max + 2));
	1964	+// pArgv = (CHAR )realloc(pArgv, sizeof(CHAR ) (max + 2));
	1965	+ }
	1966	+ if(i==0){
	1967	+ GetModuleFileName(NULL,buffer,buffer_size);
	1968	+ lpsRes = p;
	1969	+ } else
	1970	+ lpsRes = get_filename(p,buffer);
	1971	+ if(lpsRes != NULL){
	1972	+ (pArgv)[i] = (CHAR )safe_malloc(sizeof(CHAR) * strlen(buffer) + 1);
	1973	+// (pArgv)[i] = (CHAR )malloc(sizeof(CHAR) * strlen(buffer) + 1);
	1974	+ strcpy((*pArgv)[i],buffer);
	1975	+ p = lpsRes;
	1976	+ } else {
	1977	+ *pArgc = i;
	1978	+ safe_free(buffer);
	1979	+ return;
	1980	+ }
	1981	+ }
2072	1982	}

--- a/timidity/effect.c

+++ b/timidity/effect.c

		@@ -68,6 +68,14 @@ inialize_effect
68	68	#include "mt19937ar.h"
69	69	#include "sndfontini.h"
70	70
	71	+#if defined(__W32__)
	72	+#include <windows.h>
	73	+//#if defined(IA_W32GUI) \|\| defined(IA_W32G_SYN) defined(KBTIM) \|\| defined(WINVSTI)
	74	+#pragma comment(lib, "shlwapi.lib")
	75	+#include <shlwapi.h>
	76	+//#endif
	77	+#endif /* defined(__W32__) */
	78	+
71	79	#if defined(_M_IX86) \|\| defined(__i386__) \|\| defined(__i386) \|\| defined(_X86_) \|\| defined(__X86__) \|\| defined(__I86__)
72	80	#define IX86CPU 1
73	81	#endif

		@@ -5176,10 +5184,10 @@ static void do_reverb_ex_chSTMS(DATA_T buf, int32 count, InfoReverbEX info)
5176	5184	}
5177	5185	}
5178	5186
5179		-#elif (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	5187	+#elif defined(IX86CPU) && (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
5180	5188	/*
5181	5189	SSE2 128bitSIMD : double2ch, int324ch
5182		-x64AVXで問題・・?
	5190	+x64で問題・・?
5183	5191	*/
5184	5192	static void do_reverb_ex_chSTMS(DATA_T buf, int32 count, InfoReverbEX info)
5185	5193	{

		@@ -5616,7 +5624,9 @@ static void init_reverb_ex_mod(InfoReverbEX *info)
5616	5624	case CH_STEREO:
5617	5625	case CH_MIX_STEREO:
5618	5626	#if defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
5619		- if(!set_effect_sub_thread(do_reverb_ex_mod_chSTMS_thread1, info, 2)){
	5627	+ if(compute_thread_ready < 4)
	5628	+ info->thread = 0;
	5629	+ else if(!set_effect_sub_thread(do_reverb_ex_mod_chSTMS_thread1, info, 2)){
5620	5630	info->thread = 1;
5621	5631	info->do_reverb_mode = do_reverb_ex_mod_chSTMS_thread;
5622	5632	break;

		@@ -5711,7 +5721,7 @@ static void do_reverb_ex_mod_chSTMS_thread(DATA_T *buf, int32 count, InfoReverbE
5711	5721	}
5712	5722	}
5713	5723
5714		-#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	5724	+#if defined(IX86CPU) && (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
5715	5725	static void do_reverb_ex_mod_chSTMS_thread1(int thread_num, void *info2)
5716	5726	{
5717	5727	InfoReverbEX *info;

		@@ -6184,7 +6194,7 @@ static void do_reverb_ex_mod_chSTMS(DATA_T buf, int32 count, InfoReverbEX info
6184	6194	}
6185	6195	}
6186	6196
6187		-#elif (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	6197	+#elif defined(IX86CPU) && (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
6188	6198	/*
6189	6199	SSE2 128bitSIMD : double2ch, int324ch
6190	6200	*/

		@@ -6515,9 +6525,111 @@ static void do_reverb_ex(DATA_T buf, int32 count, InfoReverbEX info)
6515	6525
6516	6526
6517	6527
6518		-// reverb ex2
6519		-#ifdef REV_EX2
	6528	+// reverb ex2 (sampling reverb
	6529	+
	6530	+#define REV_EX2_LEVEL (1.0) // total
	6531	+#define REV_EX2_ST_CROSS (0.3)
	6532	+#define REV_EX2_REV_LEVEL (0.5 * (1.0 - REV_EX2_ST_CROSS))
	6533	+
	6534	+double ext_reverb_ex2_level = 1.0;
	6535	+int ext_reverb_ex2_rsmode = 3;
	6536	+int ext_reverb_ex2_fftmode = 0;
	6537	+
	6538	+
	6539	+#if defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	6540	+static void do_reverb_ex2_thread(int thread_num, void *info2);
	6541	+#endif // defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	6542	+
	6543	+#if defined(REV_EX2_FFT)
	6544	+static void init_reverb_ex2_fft(InfoReverbEX2 *info);
	6545	+static void do_reverb_ex2_fft_thread(int thread_num, void *info2);
	6546	+static void do_reverb_ex2_fft(DATA_T buf, int32 count, InfoReverbEX2 info);
	6547	+#endif
	6548	+
	6549	+
	6550	+#define MYINI_LIBRARY_DEFIND_VAR
	6551	+#include "myini.h"
	6552	+
	6553	+const TCHAR *ini_rev_type_name[] = {
	6554	+ "GS_ROOM1",
	6555	+ "GS_ROOM2",
	6556	+ "GS_ROOM3",
	6557	+ "GS_HALL1",
	6558	+ "GS_HALL2",
	6559	+ "GS_PLATE",
	6560	+ "XG_HALL1",
	6561	+ "XG_HALL2",
	6562	+ "XG_HALL_M",
	6563	+ "XG_HALL_L",
	6564	+ "XG_ROOM1",
	6565	+ "XG_ROOM2",
	6566	+ "XG_ROOM3",
	6567	+ "XG_ROOM_S",
	6568	+ "XG_ROOM_M",
	6569	+ "XG_ROOM_L",
	6570	+ "XG_STAGE1",
	6571	+ "XG_STAGE2",
	6572	+ "XG_PLATE",
	6573	+ "XG_GM_PLATE",
	6574	+ "XG_WHITE_ROOM",
	6575	+ "XG_TUNNEL",
	6576	+ "XG_CANYON",
	6577	+ "XG_BASEMENT",
	6578	+ "SD_ROOM1",
	6579	+ "SD_ROOM2",
	6580	+ "SD_STAGE1",
	6581	+ "SD_STAGE2",
	6582	+ "SD_HALL1",
	6583	+ "SD_HALL2",
	6584	+ "SD_SRV_ROOM",
	6585	+ "SD_SRV_HALL",
	6586	+ "SD_SRV_PLATE",
	6587	+ "SD_GM2_SMALL_ROOM",
	6588	+ "SD_GM2_MEDIUM_ROOM",
	6589	+ "SD_GM2_LARGE_ROOM",
	6590	+ "SD_GM2_MEDIUM_HALL",
	6591	+ "SD_GM2_LARGE_HALL",
	6592	+ "SD_GM2_PLATE",
	6593	+};
6520	6594
	6595	+static void reverb_ex2_read_ini(int32 revtype, TCHAR path, int32 amp)
	6596	+{
	6597	+ INIDATA ini = {0};
	6598	+ LPINISEC sec = NULL;
	6599	+ TCHAR tbf[FILEPATH_MAX] = "";
	6600	+ TCHAR *p = NULL;
	6601	+ TCHAR *ini_file = "timidity_irfile.ini";
	6602	+ char fn[FILEPATH_MAX] = "";
	6603	+ int len;
	6604	+
	6605	+ if(revtype < 0 \|\| revtype >= 39)
	6606	+ return;
	6607	+ memcpy(fn, sfini_path, sizeof(sfini_path));
	6608	+#if defined(__W32__)
	6609	+ PathRemoveFileSpec(fn);
	6610	+ strcat(fn, "\\");
	6611	+#else
	6612	+ len = strlen(fn);
	6613	+ if(len < 13) // "soundfont.ini" の分 UNICODEでは不明
	6614	+ return;
	6615	+ fn[len - 13] = '\0'; // soundfont.ini の分 UNICODEでは不明
	6616	+#endif /* defined(__W32__) */
	6617	+ strlcat(fn, ini_file, FILEPATH_MAX);
	6618	+ MyIni_Load(&ini, fn);
	6619	+// MyIni_Load_timidity(&ini, ini_file, 1, OF_SILENT); // dir指定のところからロードしたいがなぜかエラー・・・
	6620	+ sec = MyIni_GetSection(&ini, ini_rev_type_name[revtype], 0);
	6621	+ if(sec == NULL)
	6622	+ return;
	6623	+ p = MyIni_GetString(sec, "path", tbf, FILEPATH_MAX, "");
	6624	+ if(p)
	6625	+ strcpy(path, p);
	6626	+ *amp = MyIni_GetInt32(sec, "amp", 100);
	6627	+ if(*amp < 0)
	6628	+ *amp = 0;
	6629	+ else if(*amp > 1600)
	6630	+ *amp = 1600;
	6631	+ return;
	6632	+}
6521	6633
6522	6634	/* from instrum.c */
6523	6635	#define READ_CHAR(thing) \

		@@ -6626,16 +6738,20 @@ static int read_sample_data(int32 flags, struct timidity_file *tf, int bits, int
6626	6738	BLOCK_READ_BEGIN(uint32, 4, channels)
6627	6739	{
6628	6740	int c;
6629		- for (c = 0; c < channels; c++, j++)
6630		- sdata[c][i] = (float)BE_LONG(data[j]) * DIV_31BIT;
	6741	+ for (c = 0; c < channels; c++, j++){
	6742	+ uint32 d = BE_LONG(data[j]);
	6743	+ sdata[c][i] = (float)((int32 )&d) * DIV_31BIT;
	6744	+ }
6631	6745	}
6632	6746	BLOCK_READ_END
6633	6747	} else {
6634	6748	BLOCK_READ_BEGIN(uint32, 4, channels)
6635	6749	{
6636	6750	int c;
6637		- for (c = 0; c < channels; c++, j++)
6638		- sdata[c][i] = (float)LE_LONG(data[j]) * DIV_31BIT;
	6751	+ for (c = 0; c < channels; c++, j++){
	6752	+ uint32 d = LE_LONG(data[j]);
	6753	+ sdata[c][i] = (float)((int32 )&d) * DIV_31BIT;
	6754	+ }
6639	6755	}
6640	6756	BLOCK_READ_END
6641	6757	}

		@@ -6674,16 +6790,20 @@ static int read_sample_data(int32 flags, struct timidity_file *tf, int bits, int
6674	6790	BLOCK_READ_BEGIN(uint16, 2, channels)
6675	6791	{
6676	6792	int c;
6677		- for (c = 0; c < channels; c++, j++)
6678		- sdata[c][i] = (float)BE_SHORT(data[j]) * DIV_15BIT;
	6793	+ for (c = 0; c < channels; c++, j++){
	6794	+ uint16 tmp = BE_SHORT(data[j]);
	6795	+ sdata[c][i] = (float)((int16 )&tmp) * DIV_15BIT;
	6796	+ }
6679	6797	}
6680	6798	BLOCK_READ_END
6681	6799	} else {
6682	6800	BLOCK_READ_BEGIN(uint16, 2, channels)
6683	6801	{
6684	6802	int c;
6685		- for (c = 0; c < channels; c++, j++)
6686		- sdata[c][i] = (float)LE_SHORT(data[j]) * DIV_15BIT;
	6803	+ for (c = 0; c < channels; c++, j++){
	6804	+ uint16 tmp = LE_SHORT(data[j]);
	6805	+ sdata[c][i] = (float)((int16 )&tmp) * DIV_15BIT;
	6806	+ }
6687	6807	}
6688	6808	BLOCK_READ_END
6689	6809	}

		@@ -6696,7 +6816,7 @@ static int read_sample_data(int32 flags, struct timidity_file *tf, int bits, int
6696	6816	return 0;
6697	6817	}
6698	6818
6699		-static int import_wave_load(char sample_file, InfoReverbEX2 info)
	6819	+static int reverb_ex2_import_wave(char sample_file, InfoReverbEX2 info)
6700	6820	{
6701	6821	struct timidity_file *tf;
6702	6822	union {

		@@ -6710,7 +6830,7 @@ static int import_wave_load(char sample_file, InfoReverbEX2 info)
6710	6830	Sample *sample;
6711	6831	WAVFormatChunk format = { 0, 0, 0, 0, 0, 0 };
6712	6832
6713		- if ((tf = open_file(sample_file, 1, OF_NORMAL)) == NULL)
	6833	+ if ((tf = open_file(sample_file, 1, OF_SILENT)) == NULL)
6714	6834	return 1;
6715	6835	if (tf_read(buf, 12, 1, tf) != 1
6716	6836	\|\| memcmp(&buf[0], "RIFF", 4) != 0 \|\| memcmp(&buf[8], "WAVE", 4) != 0)

		@@ -6737,7 +6857,7 @@ static int import_wave_load(char sample_file, InfoReverbEX2 info)
6737	6857	info->irdata[1] = NULL;
6738	6858	}
6739	6859	#endif
6740		- ctl->cmsg(CMSG_INFO, VERB_NOISY, "Loading IR WAV: %s", sample_file);
	6860	+ ctl->cmsg(CMSG_INFO, VERB_NOISY, "Loading IR: %s", sample_file);
6741	6861	state = chunk_flags = 0;
6742	6862	type_index = 4, type_size = 8;
6743	6863	for (;;) {

		@@ -6772,8 +6892,8 @@ static int import_wave_load(char sample_file, InfoReverbEX2 info)
6772	6892	break;
6773	6893	samples = format.wChannels;
6774	6894	info->srate = format.dwSamplesPerSec;
6775		- info->frame = frames + 8; // + 8 for simd thread
6776		- bytes = (frames + 16) * sizeof(float); // + 16 for simd thread
	6895	+ info->frame = frames + 32; // for hpf
	6896	+ bytes = (frames + 32 + 16) * sizeof(float); // + 16 for simd thread
6777	6897	#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
6778	6898	info->irdata[0] = sdata[0] = (float *) aligned_malloc(bytes, ALIGN_SIZE);
6779	6899	info->irdata[1] = sdata[1] = (float *) aligned_malloc(bytes, ALIGN_SIZE);

		@@ -6781,8 +6901,8 @@ static int import_wave_load(char sample_file, InfoReverbEX2 info)
6781	6901	info->irdata[0] = sdata[0] = (float *) safe_large_malloc(bytes);
6782	6902	info->irdata[1] = sdata[1] = (float *) safe_large_malloc(bytes);
6783	6903	#endif
6784		- memset(&info->irdata[0][frames], 0, sizeof(float) * 16);
6785		- memset(&info->irdata[1][frames], 0, sizeof(float) * 16);
	6904	+ memset(info->irdata[0], 0, bytes);
	6905	+ memset(info->irdata[1], 0, bytes);
6786	6906	sflg = fflg ? (SAMPLE_8BIT_UNSIGNED\|SAMPLE_IEEE_FLOAT) : SAMPLE_8BIT_UNSIGNED;
6787	6907	if (!read_sample_data(sflg, tf, bits, samples, frames, sdata))
6788	6908	break;

		@@ -6797,12 +6917,94 @@ static int import_wave_load(char sample_file, InfoReverbEX2 info)
6797	6917	return (state != 2);
6798	6918	}
6799	6919
6800		-#if defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
6801		-static void do_reverb_ex2_thread(int thread_num, void *info2);
6802		-#define REV_IR_4T
6803		-// undef LR分割での2thread
6804		-// define LR分割 + 入力バッファを前後分割で4thread
6805		-#endif // defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	6920	+static void do_reverb_ex2_resample(float in0, float in1, float out0, float out1, int32 nframe, double rrate)
	6921	+{
	6922	+ int32 i;
	6923	+ double rcount = 0.0;
	6924	+
	6925	+ for (i = 0; i < nframe; i++){
	6926	+ int32 index;
	6927	+ double v01, v02, v11, v12, fp;
	6928	+ double tmp01, tmp02, tmp11, tmp12;
	6929	+ index = (int32)rcount;
	6930	+ v01 = in0[index];
	6931	+ v11 = in1[index];
	6932	+ v02 = in0[index + 1];
	6933	+ v12 = in1[index + 1];
	6934	+ fp = rcount - floor(rcount);
	6935	+ rcount += rrate;
	6936	+ tmp01 = v01 + (v02 - v01) * fp;
	6937	+ tmp11 = v11 + (v12 - v11) * fp;
	6938	+ out0[i] = tmp01;
	6939	+ out1[i] = tmp11;
	6940	+ }
	6941	+}
	6942	+
	6943	+static void do_reverb_ex2_resample_ov2(float in0, float in1, float out0, float out1, int32 nframe, double rate)
	6944	+{
	6945	+ int32 i;
	6946	+ double rcount = 0.0, rrate = DIV_2 * rate; // DIV_2:OVx2
	6947	+
	6948	+ for (i = 0; i < nframe; i++){
	6949	+ int32 index;
	6950	+ double v01, v02, v11, v12, fp;
	6951	+ double tmp01, tmp02, tmp11, tmp12;
	6952	+ index = (int32)rcount;
	6953	+ v01 = in0[index];
	6954	+ v11 = in1[index];
	6955	+ v02 = in0[index + 1];
	6956	+ v12 = in1[index + 1];
	6957	+ fp = rcount - floor(rcount);
	6958	+ rcount += rrate;
	6959	+ tmp01 = v01 + (v02 - v01) * fp;
	6960	+ tmp11 = v11 + (v12 - v11) * fp;
	6961	+ index = (int32)rcount;
	6962	+ v01 = in0[index];
	6963	+ v11 = in1[index];
	6964	+ v02 = in0[index + 1];
	6965	+ v12 = in1[index + 1];
	6966	+ fp = rcount - floor(rcount);
	6967	+ rcount += rrate;
	6968	+ tmp02 = v01 + (v02 - v01) * fp;
	6969	+ tmp12 = v11 + (v12 - v11) * fp;
	6970	+ out0[i] = (tmp01 + tmp02) * DIV_2;
	6971	+ out1[i] = (tmp11 + tmp12) * DIV_2;
	6972	+ }
	6973	+}
	6974	+
	6975	+static void do_reverb_ex2_resample_ds2(float in0, float in1, float out0, float out1, int32 nframe)
	6976	+{
	6977	+ int32 i, k;
	6978	+
	6979	+ for (i = 0, k = 0; i < nframe; i++, k += 2){
	6980	+ out0[i] = (in0[k] + in0[k + 1]) * DIV_2;
	6981	+ out1[i] = (in1[k] + in1[k + 1]) * DIV_2;
	6982	+ }
	6983	+}
	6984	+
	6985	+static void do_reverb_ex2_resample_ds4(float in0, float in1, float out0, float out1, int32 nframe)
	6986	+{
	6987	+ int32 i, k;
	6988	+
	6989	+ for (i = 0, k = 0; i < nframe; i++, k += 4){
	6990	+ out0[i] = (in0[k] + in0[k + 1] + in0[k + 2] + in0[k + 3]) * DIV_4;
	6991	+ out1[i] = (in1[k] + in1[k + 1] + in1[k + 1] + in1[k + 3]) * DIV_4;
	6992	+ }
	6993	+}
	6994	+
	6995	+static void do_reverb_ex2_resample_ds8(float in0, float in1, float out0, float out1, int32 nframe)
	6996	+{
	6997	+ int32 i, k;
	6998	+
	6999	+ for (i = 0, k = 0; i < nframe; i++, k += 8){
	7000	+ out0[i] = (
	7001	+ in0[k ] + in0[k + 1] + in0[k + 2] + in0[k + 3] +
	7002	+ in0[k + 4] + in0[k + 5] + in0[k + 6] + in0[k + 7]) * DIV_8;
	7003	+ out1[i] = (
	7004	+ in1[k ] + in1[k + 1] + in1[k + 1] + in1[k + 3] +
	7005	+ in1[k + 4] + in1[k + 5] + in1[k + 6] + in1[k + 7]) * DIV_8;
	7006	+ }
	7007	+}
6806	7008
6807	7009	void free_reverb_ex2(InfoReverbEX2 *info)
6808	7010	{

		@@ -6810,176 +7012,192 @@ void free_reverb_ex2(InfoReverbEX2 *info)
6810	7012
6811	7013	for(i = 0; i < 2; i++){
6812	7014	#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
6813		- if(info->irdata[i] != NULL){
6814		- aligned_free(info->irdata[i]);
6815		- info->irdata[i] = NULL;
6816		- }
6817		- if(info->buf[i] != NULL){
6818		- aligned_free(info->buf[i]);
6819		- info->buf[i] = NULL;
6820		- }
	7015	+ if(info->irdata[i] != NULL){ aligned_free(info->irdata[i]); info->irdata[i] = NULL; }
	7016	+ if(info->buf[i] != NULL){ aligned_free(info->buf[i]); info->buf[i] = NULL; }
	7017	+ if(info->tbuf[i] != NULL){ aligned_free(info->tbuf[i]); info->tbuf[i] = NULL; }
6821	7018	#else
6822		- if(info->irdata[i] != NULL){
6823		- safe_free(info->irdata[i]);
6824		- info->irdata[i] = NULL;
6825		- }
6826		- if(info->buf[i] != NULL){
6827		- safe_free(info->buf[i]);
6828		- info->buf[i] = NULL;
6829		- }
	7019	+ if(info->irdata[i] != NULL){ safe_free(info->irdata[i]); info->irdata[i] = NULL; }
	7020	+ if(info->buf[i] != NULL){ safe_free(info->buf[i]); info->buf[i] = NULL; }
	7021	+ if(info->tbuf[i] != NULL){ safe_free(info->tbuf[i]); info->tbuf[i] = NULL; }
6830	7022	#endif // USE_X86_EXT_INTRIN
6831		-#if defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
6832		-#if defined(REV_IR_4T)
	7023	+ }
	7024	+
	7025	+#if defined(REV_EX2_FFT)
	7026	+ for(i = 0; i < 2; i++){
6833	7027	#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
6834		- if(info->buf2[i] != NULL){
6835		- aligned_free(info->buf2[i]);
6836		- info->buf2[i] = NULL;
6837		- }
	7028	+ if(info->rvs[i] != NULL){ aligned_free(info->rvs[i]); info->rvs[i] = NULL; }
	7029	+ if(info->rs[i] != NULL){ aligned_free(info->rs[i]); info->rs[i] = NULL; }
	7030	+ if(info->is[i] != NULL){ aligned_free(info->is[i]); info->is[i] = NULL; }
	7031	+ if(info->ss[i] != NULL){ aligned_free(info->ss[i]); info->ss[i] = NULL; }
	7032	+ if(info->os[i] != NULL){ aligned_free(info->os[i]); info->os[i] = NULL; }
	7033	+ if(info->fs[i] != NULL){ aligned_free(info->fs[i]); info->fs[i] = NULL; }
	7034	+ if(info->fi[i] != NULL){ aligned_free(info->fi[i]); info->fi[i] = NULL; }
	7035	+ if(info->bd[i] != NULL){ aligned_free(info->bd[i]); info->bd[i] = NULL; }
	7036	+ if(info->ios[i] != NULL){ aligned_free(info->ios[i]); info->ios[i] = NULL; }
6838	7037	#else
6839		- if(info->buf2[i] != NULL){
6840		- safe_free(info->buf2[i]);
6841		- info->buf2[i] = NULL;
6842		- }
6843		-#endif
6844		-#endif // defined(REV_IR_4T)
6845		- for(k = 0; k < 4; k++){
	7038	+ if(info->rvs[i] != NULL){ safe_freeinfo->rvs[i]); info->rvs[i] = NULL; }
	7039	+ if(info->rs[i] != NULL){ safe_freeinfo->rs[i]); info->rs[i] = NULL; }
	7040	+ if(info->is[i] != NULL){ safe_freeinfo->is[i]); info->is[i] = NULL; }
	7041	+ if(info->ss[i] != NULL){ safe_freeinfo->ss[i]); info->ss[i] = NULL; }
	7042	+ if(info->os[i] != NULL){ safe_freeinfo->os[i]); info->os[i] = NULL; }
	7043	+ if(info->fs[i] != NULL){ safe_freeinfo->fs[i]); info->fs[i] = NULL; }
	7044	+ if(info->fi[i] != NULL){ safe_freeinfo->fi[i]); info->fi[i] = NULL; }
	7045	+ if(info->bd[i] != NULL){ safe_freeinfo->bd[i]); info->bd[i] = NULL; }
	7046	+ if(info->ios[i] != NULL){ safe_freeinfo->ios[i]); info->ios[i] = NULL; }
	7047	+#endif // USE_X86_EXT_INTRIN
	7048	+ }
6846	7049	#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
6847		- if(info->tbuf[k] != NULL){
6848		- aligned_free(info->tbuf[k]);
6849		- info->tbuf[k] = NULL;
6850		- }
	7050	+ if(info->sint != NULL){ aligned_free(info->sint); info->sint = NULL; }
6851	7051	#else
6852		- if(info->tbuf[k] != NULL){
6853		- safe_free(info->tbuf[k]);
6854		- info->tbuf[k] = NULL;
6855		- }
	7052	+ if(info->sint != NULL){ safe_free(info->sint); info->sint = NULL; }
6856	7053	#endif // USE_X86_EXT_INTRIN
6857		- }
6858		-#endif // defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
6859		- }
6860		-
	7054	+#endif // defined(REV_EX2_FFT)
	7055	+
6861	7056	#if defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
6862	7057	reset_effect_sub_thread(do_reverb_ex2_thread, info);
6863	7058	info->thread = 0;
	7059	+ info->ithread = 0;
6864	7060	#endif // defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7061	+ info->rsfb[0] = 0;
	7062	+ info->rsfb[1] = 0;
6865	7063	info->init = 0;
6866	7064	}
6867	7065
6868		-void init_reverb_ex2(InfoReverbEX2 *info)
	7066	+static void init_reverb_ex2(InfoReverbEX2 *info)
6869	7067	{
6870		- int i, k;
	7068	+ int i, k, flg = 0;
6871	7069	float div;
6872		- int32 bytes;
	7070	+ int32 bytes, rsrate, cbs;
6873	7071	char *sample_file = "irfile.wav";
6874		-
6875		- if(play_mode->encoding & PE_MONO){
6876		- info->init = 0;
6877		- return;
6878		- }
6879		- if(import_wave_load(sample_file, info)){
6880		- info->init = 0;
6881		- return;
6882		- }
6883		- if(info->frame < 1 \|\| info->srate < 1){
6884		- info->init = 0;
	7072	+ int32 amp = 100;
	7073	+ TCHAR path[FILEPATH_MAX] = {0};
	7074	+
	7075	+#if defined(REV_EX2_FFT)
	7076	+ if(ext_reverb_ex2_fftmode){
	7077	+ init_reverb_ex2_fft(info);
6885	7078	return;
6886	7079	}
6887		- // irdata resample OVx2
6888		- if(info->srate != play_mode->rate){
6889		- double ratio = (double)play_mode->rate / (double)info->srate;
6890		- int32 nframe = (double)info->frame * ratio + 0.5;
6891		- int32 nbytes = (nframe + 4) * sizeof(float);
6892		- double rcount = 0.0, rrate = DIV_2 / ratio; // DIV_2:OVx2
6893		- float *ndata[2];
6894		-
6895		-#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
6896		- ndata[0] = (float *) aligned_malloc(nbytes, ALIGN_SIZE);
6897		- ndata[1] = (float *) aligned_malloc(nbytes, ALIGN_SIZE);
6898		-#else
6899		- ndata[0] = (float *) safe_large_malloc(nbytes);
6900		- ndata[1] = (float *) safe_large_malloc(nbytes);
	7080	+ if(info->fftmode)
	7081	+ free_reverb_ex2(info);
	7082	+ info->fftmode = 0;
6901	7083	#endif
6902		- memset(ndata[0], 0, nbytes);
6903		- memset(ndata[1], 0, nbytes);
6904		- for (i = 0; i < nframe; i++){
6905		- int32 index;
6906		- double v1, v2, fp;
6907		- double tmp1, tmp2;
6908		- // L
6909		- index = (int32)rcount;
6910		- v1 = info->irdata[0][index];
6911		- v2 = info->irdata[0][index + 1];
6912		- fp = rcount - floor(rcount);
6913		- tmp1 = v1 + (v2 - v1) * fp;
6914		- rcount += rrate;
6915		- index = (int32)rcount;
6916		- v1 = info->irdata[0][index];
6917		- v2 = info->irdata[0][index + 1];
6918		- fp = rcount - floor(rcount);
6919		- tmp2 = v1 + (v2 - v1) * fp;
6920		- ndata[0][i] = (tmp1 + tmp2) * DIV_2;
6921		- // R
6922		- index = (int32)rcount;
6923		- v1 = info->irdata[1][index];
6924		- v2 = info->irdata[1][index + 1];
6925		- fp = rcount - floor(rcount);
6926		- tmp1 = v1 + (v2 - v1) * fp;
6927		- rcount += rrate;
6928		- index = (int32)rcount;
6929		- v1 = info->irdata[1][index];
6930		- v2 = info->irdata[1][index + 1];
6931		- fp = rcount - floor(rcount);
6932		- tmp2 = v1 + (v2 - v1) * fp;
6933		- ndata[1][i] = (tmp1 + tmp2) * DIV_2;
	7084	+ if(info->init){
	7085	+ if(info->pmr_p != play_mode->rate \|\| info->rt_p != info->revtype)
	7086	+ free_reverb_ex2(info);
	7087	+ else
	7088	+ return;
	7089	+ }
	7090	+ if(play_mode->encoding & PE_MONO)
	7091	+ goto error;
	7092	+
	7093	+ reverb_ex2_read_ini(info->revtype, path, &amp);
	7094	+ if(!(*path)){
	7095	+ flg = 1;
	7096	+ }else{
	7097	+ ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
	7098	+ "SamplingReverb: Trying to load IR %s (type:%s)", path, ini_rev_type_name[info->revtype]);
	7099	+ if(reverb_ex2_import_wave(path, info)){
	7100	+ ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
	7101	+ "SamplingReverb: Can't load IR %s (type:%s)", path, ini_rev_type_name[info->revtype]);
	7102	+ flg = 1;
6934	7103	}
6935		- for(i = 0; i < 2; i++){
6936		-#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
6937		- if(info->irdata[i] != NULL){
6938		- aligned_free(info->irdata[i]);
6939		- info->irdata[i] = NULL;
6940		- }
6941		-#else
6942		- if(info->irdata[i] != NULL){
6943		- safe_free(info->irdata[i]);
6944		- info->irdata[i] = NULL;
6945		- }
6946		-#endif
	7104	+ }
	7105	+ if(flg){
	7106	+ ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "SamplingReverb: Trying to load IR %s", sample_file);
	7107	+ amp = 100;
	7108	+ if(reverb_ex2_import_wave(sample_file, info)){
	7109	+ ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "SamplingReverb: ERROR Can't load IR %s", sample_file);
	7110	+ goto error;
6947	7111	}
6948		- info->frame = nframe;
6949		- info->srate = play_mode->rate;
6950		- info->irdata[0] = ndata[0];
6951		- info->irdata[1] = ndata[1];
	7112	+ }
	7113	+
	7114	+ if(info->frame < 1 \|\| info->srate < 1)
	7115	+ goto error;
	7116	+ info->fm_p = info->fftmode;
	7117	+ info->rt_p = info->revtype;
	7118	+ info->pmr_p = play_mode->rate;
	7119	+ switch(ext_reverb_ex2_rsmode){
	7120	+ default:
	7121	+ case 3:
	7122	+ if(play_mode->rate >= 128000){
	7123	+ info->rsmode = 3;
	7124	+ rsrate = play_mode->rate >> 3;
	7125	+ cbs = compute_buffer_size >> 3;
	7126	+ break;
	7127	+ } // else thru
	7128	+ case 2:
	7129	+ if(play_mode->rate >= 64000){
	7130	+ info->rsmode = 2;
	7131	+ rsrate = play_mode->rate >> 2;
	7132	+ cbs = compute_buffer_size >> 2;
	7133	+ break;
	7134	+ } // else thru
	7135	+ case 1:
	7136	+ if(play_mode->rate >= 32000){
	7137	+ info->rsmode = 1;
	7138	+ rsrate = play_mode->rate >> 1;
	7139	+ cbs = compute_buffer_size >> 1;
	7140	+ break;
	7141	+ } // else thru
	7142	+ case 0:
	7143	+ info->rsmode = 0;
	7144	+ rsrate = play_mode->rate;
	7145	+ cbs = compute_buffer_size;
	7146	+ break;
6952	7147	}
6953		-#if 0
	7148	+
	7149	+ // irdata resample
	7150	+ if(info->srate != rsrate)
6954	7151	{
6955		- int32 b = 1;
6956		- int32 nframe = 1;
6957		- int32 nbytes;
6958		- float fdiv;
6959		- float *ndata[2];
6960		-
6961		- for(b = 1; b < 26; b++) {
6962		- nframe = 1 << b;
6963		- if(info->frame < nframe)
6964		- break;
6965		- }
6966		- nframe *= 2;
6967		- nbytes = nframe * sizeof(float);
	7152	+ double ratio = (double)rsrate / (double)info->srate;
	7153	+ int32 nframe = (double)info->frame * ratio + 0.5;
	7154	+ int32 nbytes = (nframe + 8) * sizeof(float);
	7155	+ double rate = 1.0 / ratio; //
	7156	+ float *ndata[2];
6968	7157	#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
6969	7158	ndata[0] = (float *) aligned_malloc(nbytes, ALIGN_SIZE);
6970	7159	ndata[1] = (float *) aligned_malloc(nbytes, ALIGN_SIZE);
6971	7160	#else
6972	7161	ndata[0] = (float *) safe_large_malloc(nbytes);
6973	7162	ndata[1] = (float *) safe_large_malloc(nbytes);
6974		-#endif
	7163	+#endif
	7164	+ if(!ndata[0] \|\| !ndata[0])
	7165	+ goto error;
6975	7166	memset(ndata[0], 0, nbytes);
6976	7167	memset(ndata[1], 0, nbytes);
6977		- fdiv = 1.0 / nframe;
6978		- for (i = 0; i < info->frame; i++){
6979		- ndata[0][i] = info->irdata[0][i] * fdiv;
6980		- ndata[1][i] = info->irdata[1][i] * fdiv;
	7168	+ {
	7169	+ FilterCoefficients lpf;
	7170	+ set_sample_filter_type(&lpf, FILTER_LPF6);
	7171	+ set_sample_filter_ext_rate(&lpf, info->srate);
	7172	+ set_sample_filter_freq(&lpf, rsrate * 0.45); // 90%
	7173	+ recalc_filter(&lpf);
	7174	+ for (i = 0; i < info->frame; i++){
	7175	+ DATA_T in0 = info->irdata[0][i];
	7176	+ DATA_T in1 = info->irdata[1][i];
	7177	+ sample_filter_stereo(&lpf, &in0, &in1);
	7178	+ info->irdata[0][i] = in0;
	7179	+ info->irdata[1][i] = in1;
	7180	+ }
6981	7181	}
6982		-
	7182	+ if(rate == 1.0){
	7183	+ memcpy(ndata[0], info->irdata[0], nframe * sizeof(float));
	7184	+ memcpy(ndata[1], info->irdata[1], nframe * sizeof(float));
	7185	+ }else if(rate == 8.0)
	7186	+ do_reverb_ex2_resample_ds8(info->irdata[0], info->irdata[1], ndata[0], ndata[1], info->frame >> 3);
	7187	+ else if(rate == 4.0)
	7188	+ do_reverb_ex2_resample_ds4(info->irdata[0], info->irdata[1], ndata[0], ndata[1], info->frame >> 2);
	7189	+ else if(rate == 2.0)
	7190	+ do_reverb_ex2_resample_ds2(info->irdata[0], info->irdata[1], ndata[0], ndata[1], info->frame >> 1);
	7191	+ else if(rate > 4.0){
	7192	+ do_reverb_ex2_resample_ds4(info->irdata[0], info->irdata[1], info->irdata[0], info->irdata[1], info->frame >> 2);
	7193	+ do_reverb_ex2_resample_ov2(info->irdata[0], info->irdata[1], ndata[0], ndata[1], nframe, rate * DIV_4);
	7194	+ }else if(rate > 2.0){
	7195	+ do_reverb_ex2_resample_ds2(info->irdata[0], info->irdata[1], info->irdata[0], info->irdata[1], info->frame >> 1);
	7196	+ do_reverb_ex2_resample_ov2(info->irdata[0], info->irdata[1], ndata[0], ndata[1], nframe, rate * DIV_2);
	7197	+ }else if(rate > 1.0)
	7198	+ do_reverb_ex2_resample_ov2(info->irdata[0], info->irdata[1], ndata[0], ndata[1], nframe, rate);
	7199	+ else
	7200	+ do_reverb_ex2_resample(info->irdata[0], info->irdata[1], ndata[0], ndata[1], nframe, rate);
6983	7201	for(i = 0; i < 2; i++){
6984	7202	#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
6985	7203	if(info->irdata[i] != NULL){

		@@ -6993,31 +7211,47 @@ void init_reverb_ex2(InfoReverbEX2 *info)
6993	7211	}
6994	7212	#endif
6995	7213	}
6996		- info->frame = nframe;
6997		- info->div_frame = fdiv;
6998		- info->srate = play_mode->rate;
	7214	+ info->frame = nframe;
	7215	+ info->srate = rsrate;
6999	7216	info->irdata[0] = ndata[0];
7000	7217	info->irdata[1] = ndata[1];
7001	7218	}
7002		-#endif
7003		-
7004		-
7005		- div = 0.125 * 48000.0 / (double)play_mode->rate * info->level * ext_reverb_ex_level;
7006		-#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7219	+
	7220	+ // DC
7007	7221	{
7008		- __m128 vdiv = _mm_set1_ps(div);
7009		- for (i = 0; i < info->frame; i += 4){
7010		- MM_LS_MUL_PS(&info->irdata[0][i], vdiv);
7011		- MM_LS_MUL_PS(&info->irdata[1][i], vdiv);
7012		- }
7013		- }
7014		-#else
7015		- for (i = 0; i < info->frame; i++){
7016		- info->irdata[0][i] *= div;
7017		- info->irdata[1][i] *= div;
7018		- }
7019		-#endif
7020		- bytes = (info->frame + 4) * 2 * sizeof(float);
	7222	+ FilterCoefficients hpf;
	7223	+ set_sample_filter_type(&hpf, FILTER_HPF6);
	7224	+ set_sample_filter_ext_rate(&hpf, info->srate);
	7225	+ set_sample_filter_freq(&hpf, 5);
	7226	+ recalc_filter(&hpf);
	7227	+ for (i = 0; i < info->frame; i++){
	7228	+ DATA_T in0 = info->irdata[0][i];
	7229	+ DATA_T in1 = info->irdata[1][i];
	7230	+ sample_filter_stereo(&hpf, &in0, &in1);
	7231	+ info->irdata[0][i] = in0;
	7232	+ info->irdata[1][i] = in1;
	7233	+ }
	7234	+ }
	7235	+
	7236	+// div = 1.0;
	7237	+//#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7238	+// {
	7239	+// __m128 vdiv = _mm_set1_ps(div);
	7240	+// for (i = 0; i < info->frame; i += 4){
	7241	+// MM_LS_MUL_PS(&info->irdata[0][i], vdiv);
	7242	+// MM_LS_MUL_PS(&info->irdata[1][i], vdiv);
	7243	+// }
	7244	+// }
	7245	+//#else
	7246	+// for (i = 0; i < info->frame; i++){
	7247	+// info->irdata[0][i] *= div;
	7248	+// info->irdata[1][i] *= div;
	7249	+// }
	7250	+//#endif
	7251	+
	7252	+ info->frame = ((info->frame >> 2) + 1) << 2; // 4samples * n
	7253	+ info->bsize = info->frame + cbs * 3;
	7254	+ bytes = (info->bsize + 8) * 2 * sizeof(float);
7021	7255	for(i = 0; i < 2; i++){
7022	7256	#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
7023	7257	if(info->buf[i] != NULL){

		@@ -7032,38 +7266,13 @@ void init_reverb_ex2(InfoReverbEX2 *info)
7032	7266	}
7033	7267	info->buf[i] = (float *) safe_large_malloc(bytes);
7034	7268	#endif
	7269	+ if(!info->buf[i])
	7270	+ goto error;
7035	7271	memset(info->buf[i], 0, bytes);
7036	7272	}
7037		- info->wcount = 0;
7038		-
7039		-#if defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
7040		- if(set_effect_sub_thread(do_reverb_ex2_thread, info, 4)){
7041		- info->thread = 0;
7042		- goto thru_thread;
7043		- }
7044		- bytes = (info->frame + 4) * 2 * sizeof(float);
7045		-
7046		-#if defined(REV_IR_4T)
7047		- for(i = 0; i < 2; i++){
7048		-#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
7049		- if(info->buf2[i] != NULL){
7050		- aligned_free(info->buf2[i]);
7051		- info->buf2[i] = NULL;
7052		- }
7053		- info->buf2[i] = (float *) aligned_malloc(bytes, ALIGN_SIZE);
7054		-#else
7055		- if(info->buf2[i] != NULL){
7056		- safe_free(info->buf2[i]);
7057		- info->buf2[i] = NULL;
7058		- }
7059		- info->buf2[i] = (float *) safe_large_malloc(bytes);
7060		-#endif
7061		- memset(info->buf2[i], 0, bytes);
7062		- }
7063		-#endif // defined(REV_IR_4T)
7064		-
	7273	+
7065	7274	bytes = compute_buffer_size * sizeof(float);
7066		- for(k = 0; k < 4; k++){
	7275	+ for(k = 0; k < 2; k++){
7067	7276	#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
7068	7277	if(info->tbuf[k] != NULL){
7069	7278	aligned_free(info->tbuf[k]);

		@@ -7077,199 +7286,687 @@ void init_reverb_ex2(InfoReverbEX2 *info)
7077	7286	}
7078	7287	info->tbuf[k] = (float *) safe_large_malloc(bytes);
7079	7288	#endif
	7289	+ if(!info->tbuf[k])
	7290	+ goto error;
7080	7291	memset(info->tbuf[k], 0, bytes);
7081	7292	}
7082		- info->twcount[0] = 0;
7083		- info->twcount[1] = 0;
7084		- info->twcount[2] = 0;
7085		- info->twcount[3] = 0;
7086		- info->tcount = 0;
7087		- info->thread = 1;
	7293	+
	7294	+#if defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7295	+ { //
	7296	+ int tr = 2, tc = 0;
	7297	+ if(compute_thread_ready < 2){
	7298	+ info->thread = 0;
	7299	+ goto thru_thread;
	7300	+ }
	7301	+ if(compute_thread_ready == 2){
	7302	+ info->thread = 2;
	7303	+ }else{
	7304	+ for(;;){
	7305	+ int tdiv;
	7306	+ if(compute_thread_ready < tr)
	7307	+ break;
	7308	+ tdiv = 4 * (tr >> 1);
	7309	+ if((cbs % tdiv) == 0)
	7310	+ tc = tr;
	7311	+ tr += 2;
	7312	+ }
	7313	+ if(tc < 2){
	7314	+ info->thread = 0;
	7315	+ goto thru_thread;
	7316	+ }
	7317	+ info->thread = tc;
	7318	+ }
	7319	+ info->ithread = compute_thread_ready > info->thread ? 1 : 0;
	7320	+ if(set_effect_sub_thread(do_reverb_ex2_thread, info, info->thread + info->ithread)){
	7321	+ info->thread = 0;
	7322	+ goto thru_thread;
	7323	+ }
	7324	+ }
7088	7325	thru_thread:
7089		-#endif // defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7326	+#endif // defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7327	+ info->levelrv = (double)amp * DIV_100 * info->level * ext_reverb_ex2_level * REV_EX2_REV_LEVEL * REV_EX2_LEVEL;
	7328	+ info->bcount = cbs + 3; // align 4sample [-3,-2,-1,0] -> [0,1,2,3]
	7329	+ info->tbcount = 3; // align 4sample [-3,-2,-1,0] -> [0,1,2,3]
	7330	+ info->tcount = 0;
	7331	+ info->count = 0;
	7332	+ info->rsfb[0] = 0;
	7333	+ info->rsfb[1] = 0;
7090	7334	info->init = 1;
	7335	+ return;
	7336	+error:
	7337	+ info->init = 0;
	7338	+ return;
7091	7339	}
7092	7340
7093		-
7094		-#if defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
7095		-static void do_reverb_ex2_thread(int thread_num, void *info2)
	7341	+static void do_reverb_ex2_process(int ch, int32 scount, int32 ecount, InfoReverbEX2 *info)
7096	7342	{
7097		- InfoReverbEX2 *info;
7098	7343	int i, k;
7099		- float buf, ibuf, obuf, irdata;
7100		- int32 *wcount;
7101		- int32 scount, ecount;
7102		-
7103		-#if defined(REV_IR_4T)
7104		- if(thread_num >= 4)
7105		-#else
7106		- if(thread_num >= 2)
	7344	+ float obuf = info->tbuf[ch], buf = info->buf[ch], *irdata = info->irdata[ch];
	7345	+ int32 bcount = info->bcount;
	7346	+
	7347	+ bcount -= scount;
	7348	+ if(bcount < 0)
	7349	+ bcount += info->bsize;
	7350	+
	7351	+#if (USE_X86_EXT_INTRIN >= 3)
	7352	+// 4set/1ch simd optimize 4samples
	7353	+ {
	7354	+ __m128i vwc = _mm_cvtsi32_si128(bcount);
	7355	+ const __m128i vbsize = _mm_cvtsi32_si128(info->bsize);
	7356	+ const __m128i vi4 = _mm_cvtsi32_si128(4), vi0 = _mm_setzero_si128();
	7357	+ int32 nc = bcount - (ecount - scount);
	7358	+ float *nbuf = nc < 0 ? buf : buf + nc;
	7359	+ _mm_prefetch((const char *)&nbuf, _MM_HINT_T0);
	7360	+ _mm_prefetch((const char *)&irdata, _MM_HINT_T0);
	7361	+ for (i = scount; i < ecount; i += 4){
	7362	+#if (USE_X86_EXT_INTRIN >= 9)
	7363	+ __m256 ysum0 = _mm256_setzero_ps();
	7364	+ __m256 ysum1 = _mm256_setzero_ps();
	7365	+ __m256 ysum2 = _mm256_setzero_ps();
	7366	+ __m256 ysum3 = _mm256_setzero_ps();
7107	7367	#endif
7108		- return;
7109		- if(!info2)
7110		- return;
7111		- info = (InfoReverbEX2 *)info2;
7112		- if(!info->init)
7113		- return;
7114		- if(thread_num == 0){ // L
7115		- ibuf = info->tbuf[0];
7116		- obuf = info->tbuf[2];
7117		- buf = info->buf[0];
7118		- irdata = info->irdata[0];
7119		- wcount = &info->twcount[0];
7120		- scount = 0;
7121		-#if defined(REV_IR_4T)
7122		- ecount = info->tcount >> 1;
	7368	+ __m128 sum0 = _mm_setzero_ps();
	7369	+ __m128 sum1 = _mm_setzero_ps();
	7370	+ __m128 sum2 = _mm_setzero_ps();
	7371	+ __m128 sum3 = _mm_setzero_ps();
	7372	+ __m128 tmp0, tmp2, tmp1, tmp3;
	7373	+ int32 bc = _mm_cvtsi128_si32(vwc);
	7374	+ float *bcbuf = buf + bc - 3; // aligned 4sample
	7375	+ vwc = _mm_sub_epi32(vwc, vi4);
	7376	+ vwc = _mm_add_epi32(vwc, _mm_and_si128(vbsize, _mm_cmplt_epi32(vwc, vi0)));
	7377	+#if (USE_X86_EXT_INTRIN >= 9)
	7378	+ for (k = 0; k < info->frame; k += 8){
	7379	+ __m256 yvir = _mm256_load_ps(&irdata[k]);
	7380	+ float *tmpbuf = bcbuf + k;
	7381	+ __m256 yvtb0 = _mm256_load_ps(tmpbuf ); // [01234567] // aligned 4sample
	7382	+ __m256 yvtb1 = _mm256_loadu_ps(tmpbuf + 1); // [12345678]
	7383	+ __m256 yvtb2 = _mm256_loadu_ps(tmpbuf + 2); // [23456789]
	7384	+ __m256 yvtb3 = _mm256_loadu_ps(tmpbuf + 3); // [3456789A]
	7385	+ ysum3 = MM256_FMA_PS(yvtb0, yvir, ysum3); // buf + bcount - 3
	7386	+ ysum2 = MM256_FMA_PS(yvtb1, yvir, ysum2); // buf + bcount - 2
	7387	+ ysum1 = MM256_FMA_PS(yvtb2, yvir, ysum1); // buf + bcount - 1
	7388	+ ysum0 = MM256_FMA_PS(yvtb3, yvir, ysum0); // buf + bcount - 0
	7389	+ }
	7390	+ // ymm to xmm
	7391	+ sum0 = _mm_add_ps(_mm256_extractf128_ps(ysum0, 0x0), _mm256_extractf128_ps(ysum0, 0x1));
	7392	+ sum1 = _mm_add_ps(_mm256_extractf128_ps(ysum1, 0x0), _mm256_extractf128_ps(ysum1, 0x1));
	7393	+ sum2 = _mm_add_ps(_mm256_extractf128_ps(ysum2, 0x0), _mm256_extractf128_ps(ysum2, 0x1));
	7394	+ sum3 = _mm_add_ps(_mm256_extractf128_ps(ysum3, 0x0), _mm256_extractf128_ps(ysum3, 0x1));
7123	7395	#else
7124		- ecount = info->tcount;
	7396	+ for (k = 0; k < info->frame; k += 4){
	7397	+ __m128 vir = _mm_load_ps(&irdata[k]);
	7398	+ float *tmpbuf = bcbuf + k;
	7399	+ __m128 vtb0 = _mm_load_ps(tmpbuf ); // [0123] // aligned 4sample
	7400	+ __m128 vtb1 = _mm_loadu_ps(tmpbuf + 1); // [1234]
	7401	+ __m128 vtb2 = _mm_loadu_ps(tmpbuf + 2); // [2345]
	7402	+ __m128 vtb3 = _mm_loadu_ps(tmpbuf + 3); // [3456]
	7403	+ sum3 = MM_FMA_PS(vtb0, vir, sum3); // buf + bcount - 3
	7404	+ sum2 = MM_FMA_PS(vtb1, vir, sum2); // buf + bcount - 2
	7405	+ sum1 = MM_FMA_PS(vtb2, vir, sum1); // buf + bcount - 1
	7406	+ sum0 = MM_FMA_PS(vtb3, vir, sum0); // buf + bcount - 0
	7407	+ }
7125	7408	#endif
7126		- }else if(thread_num == 1){ // R
7127		- ibuf = info->tbuf[1];
7128		- obuf = info->tbuf[3];
7129		- buf = info->buf[1];
7130		- irdata = info->irdata[1];
7131		- wcount = &info->twcount[1];
7132		- scount = 0;
7133		-#if defined(REV_IR_4T)
7134		- ecount = info->tcount >> 1;
	7409	+ // sum0 v0,v1,v2,v3 // sum1 v4,v5,v6,v7 // sum2 v8,v9,v10,v11 // sum3 v12,v13,v14,v15
	7410	+ tmp0 = _mm_shuffle_ps(sum0, sum1, 0x44); // v0,v1,v4,v5
	7411	+ tmp2 = _mm_shuffle_ps(sum0, sum1, 0xEE); // v2,v3,v6,v7
	7412	+ tmp1 = _mm_shuffle_ps(sum2, sum3, 0x44); // v8,v9,v12,v13
	7413	+ tmp3 = _mm_shuffle_ps(sum2, sum3, 0xEE); // v10,v11,v14,v15
	7414	+ sum0 = _mm_shuffle_ps(tmp0, tmp1, 0x88); // v0,v4,v8,v12
	7415	+ sum1 = _mm_shuffle_ps(tmp0, tmp1, 0xDD); // v1,v5,v9,v13
	7416	+ sum2 = _mm_shuffle_ps(tmp2, tmp3, 0x88); // v2,v6,v10,v14
	7417	+ sum3 = _mm_shuffle_ps(tmp2, tmp3, 0xDD); // v3,v7,v11,v15
	7418	+ sum0 = _mm_add_ps(sum0, sum1);
	7419	+ sum2 = _mm_add_ps(sum2, sum3);
	7420	+ sum0 = _mm_add_ps(sum0, sum2); // v0123,v4567,v89AB,vCDEF
	7421	+ _mm_store_ps(&obuf[i], sum0);
	7422	+ }
	7423	+ }
	7424	+
7135	7425	#else
7136		- ecount = info->tcount;
7137		-#endif
7138		- }else
7139		-#if defined(REV_IR_4T)
7140		- if(thread_num == 2){ // L
7141		- ibuf = info->tbuf[0];
7142		- obuf = info->tbuf[2];
7143		- buf = info->buf2[0];
7144		- irdata = info->irdata[0];
7145		- wcount = &info->twcount[2];
7146		- scount = info->tcount >> 1;
7147		- ecount = info->tcount;
7148		- }else if(thread_num == 3){ // R
7149		- ibuf = info->tbuf[1];
7150		- obuf = info->tbuf[3];
7151		- buf = info->buf2[1];
7152		- irdata = info->irdata[1];
7153		- wcount = &info->twcount[3];
7154		- scount = info->tcount >> 1;
7155		- ecount = info->tcount;
7156		- }else
7157		-#endif
7158		- return;
7159		-#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
7160		- // 4set/1ch
7161	7426	{
7162		- __m128i vwc = _mm_set1_epi32(*wcount);
7163		- __m128i vframe = _mm_set1_epi32(info->frame);
7164		- __m128i vi4 = _mm_set1_epi32(4), vi0 = _mm_setzero_si128(), viset = _mm_set_epi32(3, 2, 1, 0);
7165		- __m128i vwcp;
7166		-
7167		- vwc = _mm_sub_epi32(vwc, viset);
7168		- vwc = _mm_add_epi32(vwc, _mm_and_si128(vframe, _mm_cmplt_epi32(vwc, vi0)));
7169		-#if defined(REV_IR_4T)
7170		- for (i = 0; i < scount; i += 4){
7171		- vwcp = _mm_add_epi32(vwc, vframe);
7172		- buf[MM_EXTRACT_I32(vwcp,0)] = buf[MM_EXTRACT_I32(vwc,0)] = ibuf[i];
7173		- buf[MM_EXTRACT_I32(vwcp,1)] = buf[MM_EXTRACT_I32(vwc,1)] = ibuf[i + 1];
7174		- buf[MM_EXTRACT_I32(vwcp,2)] = buf[MM_EXTRACT_I32(vwc,2)] = ibuf[i + 2];
7175		- buf[MM_EXTRACT_I32(vwcp,3)] = buf[MM_EXTRACT_I32(vwc,3)] = ibuf[i + 3];
7176		- vwc = _mm_sub_epi32(vwc, vi4);
7177		- vwc = _mm_add_epi32(vwc, _mm_and_si128(vframe, _mm_cmplt_epi32(vwc, vi0)));
	7427	+ for (i = scount; i < ecount; i++){
	7428	+ float sum = 0;
	7429	+ float tmpbuf = buf + bcount;
	7430	+ for (k = 0; k < info->frame; k++)
	7431	+ sum += tmpbuf[k] * irdata[k];
	7432	+ if((--bcount) < 0)
	7433	+ bcount += info->bsize;
	7434	+ obuf[i] = sum;
	7435	+ }
7178	7436	}
7179	7437	#endif
7180		- for (i = scount; i < ecount; i += 4){
7181		- __m128 sum0 = _mm_setzero_ps();
7182		- __m128 sum1 = _mm_setzero_ps();
7183		- __m128 sum2 = _mm_setzero_ps();
7184		- __m128 sum3 = _mm_setzero_ps();
7185		- __m128 tmp0, tmp2, tmp1, tmp3;
7186		- vwcp = _mm_add_epi32(vwc, vframe);
7187		- buf[MM_EXTRACT_I32(vwcp,0)] = buf[MM_EXTRACT_I32(vwc,0)] = ibuf[i];
7188		- buf[MM_EXTRACT_I32(vwcp,1)] = buf[MM_EXTRACT_I32(vwc,1)] = ibuf[i + 1];
7189		- buf[MM_EXTRACT_I32(vwcp,2)] = buf[MM_EXTRACT_I32(vwc,2)] = ibuf[i + 2];
7190		- buf[MM_EXTRACT_I32(vwcp,3)] = buf[MM_EXTRACT_I32(vwc,3)] = ibuf[i + 3];
7191		- // FMAループの最後のw0w1w2w3重複部分は事前にirdata最後に0を追加することで回避
7192		- for (k = 0; k < info->frame; k += 4){
7193		- __m128 vir = _mm_load_ps(&irdata[k]);
7194		- vwcp = _mm_add_epi32(vwc, _mm_set1_epi32(k));
7195		- sum0 = MM_FMA_PS(_mm_loadu_ps(&buf[MM_EXTRACT_I32(vwcp,0)]), vir, sum0);
7196		- sum1 = MM_FMA_PS(_mm_loadu_ps(&buf[MM_EXTRACT_I32(vwcp,1)]), vir, sum1);
7197		- sum2 = MM_FMA_PS(_mm_loadu_ps(&buf[MM_EXTRACT_I32(vwcp,2)]), vir, sum2);
7198		- sum3 = MM_FMA_PS(_mm_loadu_ps(&buf[MM_EXTRACT_I32(vwcp,3)]), vir, sum3);
7199		- }
7200		- vwc = _mm_sub_epi32(vwc, vi4);
7201		- vwc = _mm_add_epi32(vwc, _mm_and_si128(vframe, _mm_cmplt_epi32(vwc, vi0)));
7202		- // sum0 v0,v1,v2,v3 // sum1 v4,v5,v6,v7 // sum2 v8,v9,v10,v11 // sum3 v12,v13,v14,v15
7203		- tmp0 = _mm_shuffle_ps(sum0, sum1, 0x44); // v0,v1,v4,v5
7204		- tmp2 = _mm_shuffle_ps(sum0, sum1, 0xEE); // v2,v3,v6,v7
7205		- tmp1 = _mm_shuffle_ps(sum2, sum3, 0x44); // v8,v9,v12,v13
7206		- tmp3 = _mm_shuffle_ps(sum2, sum3, 0xEE); // v10,v11,v14,v15
7207		- sum0 = _mm_shuffle_ps(tmp0, tmp1, 0x88); // v0,v4,v8,v12
7208		- sum1 = _mm_shuffle_ps(tmp0, tmp1, 0xDD); // v1,v5,v9,v13
7209		- sum2 = _mm_shuffle_ps(tmp2, tmp3, 0x88); // v2,v6,v10,v14
7210		- sum3 = _mm_shuffle_ps(tmp2, tmp3, 0xDD); // v3,v7,v11,v15
7211		- sum0 = _mm_add_ps(sum0, sum1);
7212		- sum2 = _mm_add_ps(sum2, sum3);
7213		- sum0 = _mm_add_ps(sum0, sum2); // v0123,v4567,v89AB,vCDEF
7214		- _mm_store_ps(&obuf[i], sum0);
7215		- }
7216		-#if defined(REV_IR_4T)
7217		- for (i = ecount; i < info->tcount; i += 4){
7218		- vwcp = _mm_add_epi32(vwc, vframe);
7219		- buf[MM_EXTRACT_I32(vwcp,0)] = buf[MM_EXTRACT_I32(vwc,0)] = ibuf[i];
7220		- buf[MM_EXTRACT_I32(vwcp,1)] = buf[MM_EXTRACT_I32(vwc,1)] = ibuf[i + 1];
7221		- buf[MM_EXTRACT_I32(vwcp,2)] = buf[MM_EXTRACT_I32(vwc,2)] = ibuf[i + 2];
7222		- buf[MM_EXTRACT_I32(vwcp,3)] = buf[MM_EXTRACT_I32(vwc,3)] = ibuf[i + 3];
7223		- vwc = _mm_sub_epi32(vwc, vi4);
7224		- vwc = _mm_add_epi32(vwc, _mm_and_si128(vframe, _mm_cmplt_epi32(vwc, vi0)));
	7438	+}
	7439	+
	7440	+static void do_reverb_ex2_rsmode0_in(DATA_T buf, int32 count, InfoReverbEX2 info)
	7441	+{
	7442	+ int32 i, k;
	7443	+ int32 bcount = info->tbcount;
	7444	+
	7445	+ for (i = 0; i < count; i += 2){
	7446	+ int32 bcount2 = bcount + info->bsize;
	7447	+ info->buf[0][bcount2] = info->buf[0][bcount] = buf[i];
	7448	+ info->buf[1][bcount2] = info->buf[1][bcount] = buf[i + 1];
	7449	+ if((--bcount) < 0) bcount += info->bsize;
7225	7450	}
7226		-#endif
7227		- *wcount = MM_EXTRACT_I32(vwc,0);
	7451	+ info->tbcount = bcount;
	7452	+}
	7453	+
	7454	+static void do_reverb_ex2_rsmode1_in(DATA_T buf, int32 count, InfoReverbEX2 info)
	7455	+{
	7456	+ int32 i, k;
	7457	+ int32 bcount = info->tbcount;
	7458	+
	7459	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7460	+ {
	7461	+ const __m128d vdiv2 = _mm_set1_pd(0.5);
	7462	+ for (i = 0; i < count; i += 4){
	7463	+ int32 bcount2 = bcount + info->bsize;
	7464	+ __m128d vin0 = _mm_load_pd(&buf[i ]);
	7465	+ __m128d vin2 = _mm_load_pd(&buf[i + 2]);
	7466	+ __m128d vt = _mm_mul_pd(_mm_add_pd(vin0, vin2), vdiv2);
	7467	+ __m128 vo = _mm_cvtpd_ps(vt);
	7468	+ info->buf[0][bcount2] = info->buf[0][bcount] = MM_EXTRACT_F32(vo, 0);
	7469	+ info->buf[1][bcount2] = info->buf[1][bcount] = MM_EXTRACT_F32(vo, 1);
	7470	+ if((--bcount) < 0) bcount += info->bsize;
	7471	+ }
7228	7472	}
7229	7473	#else
7230	7474	{
7231		-#if defined(REV_IR_4T)
7232		- for (i = 0; i < scount; i++){
7233		- int32 w0 = *wcount;
7234		- --(*wcount);
7235		- if(*wcount < 0)
7236		- *wcount += info->frame;
7237		- buf[w0 + info->frame] = buf[w0] = ibuf[i];
7238		- }
7239		-#endif
7240		- for (i = scount; i < ecount; i++){
7241		- float sum = 0;
7242		- int32 w = *wcount;
7243		- --(*wcount);
7244		- if(*wcount < 0)
7245		- *wcount += info->frame;
7246		- buf[w] = ibuf[i];
7247		- buf[w + info->frame] = ibuf[i];
7248		- for (k = 0; k < info->frame; k++){
7249		- int32 r = w + k;
7250		- sum += buf[r] * irdata[k];
7251		- }
7252		- obuf[i] = sum;
7253		- }
7254		-#if defined(REV_IR_4T)
7255		- for (i = ecount; i < info->tcount; i++){
7256		- int32 w0 = *wcount;
7257		- --(*wcount);
7258		- if(*wcount < 0)
7259		- *wcount += info->frame;
7260		- buf[w0 + info->frame] = buf[w0] = ibuf[i];
7261		- }
7262		-#endif
	7475	+ for (i = 0; i < count; i += 4){
	7476	+ int32 bcount2 = bcount + info->bsize;
	7477	+ info->buf[0][bcount2] = info->buf[0][bcount] = (buf[i ] + buf[i + 2]) * 0.5;
	7478	+ info->buf[1][bcount2] = info->buf[1][bcount] = (buf[i + 1] + buf[i + 3]) * 0.5;
	7479	+ if((--bcount) < 0) bcount += info->bsize;
	7480	+ }
7263	7481	}
7264	7482	#endif
	7483	+ info->tbcount = bcount;
7265	7484	}
7266		-#endif // defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
7267	7485
	7486	+static void do_reverb_ex2_rsmode2_in(DATA_T buf, int32 count, InfoReverbEX2 info)
	7487	+{
	7488	+ int32 i, k;
	7489	+ int32 bcount = info->tbcount;
	7490	+
	7491	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7492	+ {
	7493	+ const __m128d vdiv4 = _mm_set1_pd(0.25);
	7494	+ for (i = 0; i < count; i += 8){
	7495	+ int32 bcount2 = bcount + info->bsize;
	7496	+ __m128d vin0 = _mm_load_pd(&buf[i ]);
	7497	+ __m128d vin2 = _mm_load_pd(&buf[i + 2]);
	7498	+ __m128d vin4 = _mm_load_pd(&buf[i + 4]);
	7499	+ __m128d vin6 = _mm_load_pd(&buf[i + 6]);
	7500	+ __m128d vt = _mm_mul_pd(_mm_add_pd(_mm_add_pd(vin0, vin2), _mm_add_pd(vin4, vin6)), vdiv4);
	7501	+ __m128 vo = _mm_cvtpd_ps(vt);
	7502	+ info->buf[0][bcount2] = info->buf[0][bcount] = MM_EXTRACT_F32(vo, 0);
	7503	+ info->buf[1][bcount2] = info->buf[1][bcount] = MM_EXTRACT_F32(vo, 1);
	7504	+ if((--bcount) < 0) bcount += info->bsize;
	7505	+ }
	7506	+ }
	7507	+#else
	7508	+ {
	7509	+ for (i = 0; i < count; i += 8){
	7510	+ int32 bcount2 = bcount + info->bsize;
	7511	+ info->buf[0][bcount2] = info->buf[0][bcount] = (buf[i ] + buf[i + 2] + buf[i + 4] + buf[i + 6]) * 0.25;
	7512	+ info->buf[1][bcount2] = info->buf[1][bcount] = (buf[i + 1] + buf[i + 3] + buf[i + 5] + buf[i + 7]) * 0.25;
	7513	+ if((--bcount) < 0) bcount += info->bsize;
	7514	+ }
	7515	+ }
	7516	+#endif
	7517	+ info->tbcount = bcount;
	7518	+}
7268	7519
7269		-static void do_reverb_ex2(DATA_T buf, int32 count, InfoReverbEX2 info)
	7520	+static void do_reverb_ex2_rsmode3_in(DATA_T buf, int32 count, InfoReverbEX2 info)
	7521	+{
	7522	+ int32 i, k;
	7523	+ int32 bcount = info->tbcount;
	7524	+
	7525	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7526	+ {
	7527	+ const __m128d vdiv8 = _mm_set1_pd(0.125);
	7528	+ for (i = 0; i < count; i += 16){
	7529	+ int32 bcount2 = bcount + info->bsize;
	7530	+#if (USE_X86_EXT_INTRIN >= 9)
	7531	+ __m256d yvin0 = _mm256_load_pd(&buf[i ]);
	7532	+ __m256d yvin4 = _mm256_load_pd(&buf[i + 4]);
	7533	+ __m256d yvin8 = _mm256_load_pd(&buf[i + 8]);
	7534	+ __m256d yvin12 = _mm256_load_pd(&buf[i + 12]);
	7535	+ __m256d yvt = _mm256_add_pd(_mm256_add_pd(yvin0, yvin4), _mm256_add_pd(yvin8, yvin12));
	7536	+ __m128d vt = _mm_mul_pd(_mm_add_pd(
	7537	+ _mm256_extractf128_pd(yvt, 0x0), _mm256_extractf128_pd(yvt, 0x1)
	7538	+ ), vdiv8);
	7539	+#else
	7540	+ __m128d vin0 = _mm_load_pd(&buf[i ]);
	7541	+ __m128d vin2 = _mm_load_pd(&buf[i + 2]);
	7542	+ __m128d vin4 = _mm_load_pd(&buf[i + 4]);
	7543	+ __m128d vin6 = _mm_load_pd(&buf[i + 6]);
	7544	+ __m128d vin8 = _mm_load_pd(&buf[i + 8]);
	7545	+ __m128d vin10 = _mm_load_pd(&buf[i + 10]);
	7546	+ __m128d vin12 = _mm_load_pd(&buf[i + 12]);
	7547	+ __m128d vin14 = _mm_load_pd(&buf[i + 14]);
	7548	+ __m128d vt = _mm_mul_pd(_mm_add_pd(
	7549	+ _mm_add_pd(_mm_add_pd(vin0, vin2), _mm_add_pd(vin4, vin6)),
	7550	+ _mm_add_pd(_mm_add_pd(vin8, vin10), _mm_add_pd(vin12, vin14))
	7551	+ ), vdiv8);
	7552	+#endif
	7553	+ __m128 vo = _mm_cvtpd_ps(vt);
	7554	+ info->buf[0][bcount2] = info->buf[0][bcount] = MM_EXTRACT_F32(vo, 0);
	7555	+ info->buf[1][bcount2] = info->buf[1][bcount] = MM_EXTRACT_F32(vo, 1);
	7556	+ if((--bcount) < 0) bcount += info->bsize;
	7557	+ }
	7558	+ }
	7559	+#else
	7560	+ {
	7561	+ for (i = 0; i < count; i += 16){
	7562	+ int32 bcount2 = bcount + info->bsize;
	7563	+ info->buf[0][bcount2] = info->buf[0][bcount] = (
	7564	+ buf[i ] + buf[i + 2] + buf[i + 4] + buf[i + 6] +
	7565	+ buf[i + 6] + buf[i + 8] + buf[i + 12] + buf[i + 14]
	7566	+ ) * 0.125;
	7567	+ info->buf[1][bcount2] = info->buf[1][bcount] = (
	7568	+ buf[i + 1] + buf[i + 3] + buf[i + 5] + buf[i + 7] +
	7569	+ buf[i + 9] + buf[i + 11] + buf[i + 13] + buf[i + 15]
	7570	+ ) * 0.125;
	7571	+ if((--bcount) < 0) bcount += info->bsize;
	7572	+ }
	7573	+ }
	7574	+#endif
	7575	+ info->tbcount = bcount;
	7576	+}
	7577	+
	7578	+static void do_reverb_ex2_rsmode0_out(DATA_T buf, int32 count, InfoReverbEX2 info)
	7579	+{
	7580	+ int32 i, k;
	7581	+
	7582	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7583	+ {
	7584	+ const __m128d vlv = _mm_set1_pd(info->levelrv);
	7585	+ const __m128d vst = _mm_set1_pd(REV_EX2_ST_CROSS * info->levelrv);
	7586	+ for (i = 0, k = 0; i < count; i += 2, k++){
	7587	+ __m128d vi = _mm_set_pd(info->tbuf[1][k], info->tbuf[0][k]);
	7588	+ __m128d vo = MM_FMA2_PD(vi, vlv, _mm_shuffle_pd(vi, vi, 0x1), vst);
	7589	+ _mm_store_pd(&buf[i], vo);
	7590	+ }
	7591	+ }
	7592	+#else
	7593	+ const FLOAT_T vlv = info->levelrv;
	7594	+ const FLOAT_T vst = REV_EX2_ST_CROSS * info->levelrv;
	7595	+ for (i = 0, k = 0; i < count; i += 2, k++){
	7596	+ buf[i ] = info->tbuf[0][k] * vlv + info->tbuf[1][k] * vst;
	7597	+ buf[i + 1] = info->tbuf[1][k] * vlv + info->tbuf[0][k] * vst;
	7598	+ }
	7599	+#endif
	7600	+}
	7601	+
	7602	+static void do_reverb_ex2_rsmode1_out(DATA_T buf, int32 count, InfoReverbEX2 info)
7270	7603	{
7271	7604	int32 i, k;
7272	7605
	7606	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7607	+ {
	7608	+ const __m128d vlv = _mm_set1_pd(info->levelrv);
	7609	+ const __m128d vst = _mm_set1_pd(REV_EX2_ST_CROSS);
	7610	+ const __m128d vdiv2 = _mm_set1_pd(0.5);
	7611	+ __m128d vfb = _mm_loadu_pd(info->rsfb);
	7612	+ for (i = 0, k = 0; i < count; i += 4, k++){
	7613	+ __m128d vi = _mm_set_pd(info->tbuf[1][k], info->tbuf[0][k]);
	7614	+ __m128d vrs, vo0, vo2;
	7615	+ vrs = _mm_mul_pd(_mm_add_pd(vfb, vi), vdiv2);
	7616	+ vo0 = MM_FMA_PD(_mm_shuffle_pd(vi, vi, 0x1), vst, vi);
	7617	+ vo2 = MM_FMA_PD(_mm_shuffle_pd(vrs, vrs, 0x1), vst, vrs);
	7618	+ vo0 = _mm_mul_pd(vo0, vlv);
	7619	+ vo2 = _mm_mul_pd(vo2, vlv);
	7620	+ _mm_store_pd(&buf[i ], vo0);
	7621	+ _mm_store_pd(&buf[i + 2], vo2);
	7622	+ vfb = vi;
	7623	+ }
	7624	+ _mm_storeu_pd(info->rsfb, vfb);
	7625	+ }
	7626	+#else
	7627	+ {
	7628	+ const FLOAT_T vlv = info->levelrv;
	7629	+ const FLOAT_T vst = REV_EX2_ST_CROSS * info->levelrv;
	7630	+ FLOAT_T fb0 = info->rsfb[0];
	7631	+ FLOAT_T fb1 = info->rsfb[1];
	7632	+ for (i = 0, k = 0; i < count; i += 4, k++){
	7633	+ FLOAT_T in0 = info->tbuf[0][k];
	7634	+ FLOAT_T in1 = info->tbuf[1][k];
	7635	+ FLOAT_T rs0, rs1, rs2, rs3;
	7636	+ rs2 = (fb0 + in0) * 0.5;
	7637	+ rs3 = (fb1 + in1) * 0.5;
	7638	+ rs0 = in0 * vlv + in1 * vst;
	7639	+ rs1 = in1 * vlv + in0 * vst;
	7640	+ rs2 = rs0 * vlv + rs1 * vst;
	7641	+ rs3 = rs1 * vlv + rs0 * vst;
	7642	+ buf[i ] = rs0;
	7643	+ buf[i + 1] = rs1;
	7644	+ buf[i + 2] = rs2;
	7645	+ buf[i + 3] = rs3;
	7646	+ fb0 = in0;
	7647	+ fb0 = in1;
	7648	+ }
	7649	+ info->rsfb[0] = fb0;
	7650	+ info->rsfb[1] = fb1;
	7651	+ }
	7652	+#endif
	7653	+}
	7654	+
	7655	+static void do_reverb_ex2_rsmode2_out(DATA_T buf, int32 count, InfoReverbEX2 info)
	7656	+{
	7657	+ int32 i, k;
	7658	+
	7659	+#if (USE_X86_EXT_INTRIN >= 9) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7660	+ {
	7661	+ const __m256d yvlv = _mm256_set1_pd(info->levelrv);
	7662	+ const __m256d yvst = _mm256_set1_pd(REV_EX2_ST_CROSS);
	7663	+ const __m256d yvdiv4_43 = _mm256_set_pd(0.75, 0.75, 1.0, 1.0);
	7664	+ const __m256d yvdiv4_21 = _mm256_set_pd(0.25, 0.25, 0.5, 0.5);
	7665	+ const __m256d yvdiv4_01 = _mm256_set_pd(0.25, 0.25, 0.0, 0.0);
	7666	+ const __m256d yvdiv4_23 = _mm256_set_pd(0.75, 0.75, 0.5, 0.5);
	7667	+ __m128d vfb = _mm_loadu_pd(info->rsfb);
	7668	+ __m256d yvfb = MM256_SET2X_PD(vfb, vfb);
	7669	+ for (i = 0, k = 0; i < count; i += 8, k++){
	7670	+ __m128d vi = _mm_set_pd(info->tbuf[1][k], info->tbuf[0][k]);
	7671	+ __m256d yvi = MM256_SET2X_PD(vi, vi);
	7672	+ __m256d yvrs0, yvrs4, yvo0, yvo4;
	7673	+ yvrs0 = MM256_FMA2_PD(yvfb, yvdiv4_43, yvi, yvdiv4_01);
	7674	+ yvrs4 = MM256_FMA2_PD(yvfb, yvdiv4_21, yvi, yvdiv4_23);
	7675	+ yvo0 = MM256_FMA_PD(_mm256_shuffle_pd(yvrs0, yvrs0, 0xA), yvst, yvrs0);
	7676	+ yvo4 = MM256_FMA_PD(_mm256_shuffle_pd(yvrs4, yvrs4, 0xA), yvst, yvrs4);
	7677	+ yvo0 = _mm256_mul_pd(yvo0, yvlv);
	7678	+ yvo4 = _mm256_mul_pd(yvo4, yvlv);
	7679	+ _mm256_store_pd(&buf[i ], yvo0);
	7680	+ _mm256_store_pd(&buf[i + 4], yvo4);
	7681	+ yvfb = yvi;
	7682	+ }
	7683	+ _mm_storeu_pd(info->rsfb, _mm256_extractf128_pd(yvfb, 0x0));
	7684	+ }
	7685	+#elif (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7686	+ {
	7687	+ const __m128d vlv = _mm_set1_pd(info->levelrv);
	7688	+ const __m128d vst = _mm_set1_pd(REV_EX2_ST_CROSS);
	7689	+ const __m128d vdiv4_1 = _mm_set1_pd(0.25);
	7690	+ const __m128d vdiv4_2 = _mm_set1_pd(0.5);
	7691	+ const __m128d vdiv4_3 = _mm_set1_pd(0.75);
	7692	+ __m128d vfb = _mm_loadu_pd(info->rsfb);
	7693	+ for (i = 0, k = 0; i < count; i += 8, k++){
	7694	+ __m128d vi = _mm_set_pd(info->tbuf[1][k], info->tbuf[0][k]);
	7695	+ __m128d vrs2, vrs4, vrs6, vo0, vo2, vo4, vo6;
	7696	+ vrs2 = MM_FMA2_PD(vfb, vdiv4_3, vi, vdiv4_1);
	7697	+ vrs4 = _mm_mul_pd(_mm_add_pd(vfb, vi), vdiv4_2);
	7698	+ vrs6 = MM_FMA2_PD(vfb, vdiv4_1, vi, vdiv4_3);
	7699	+ vo0 = MM_FMA_PD(_mm_shuffle_pd(vi, vi, 0x1), vst, vi);
	7700	+ vo2 = MM_FMA_PD(_mm_shuffle_pd(vrs2, vrs2, 0x1), vst, vrs2);
	7701	+ vo4 = MM_FMA_PD(_mm_shuffle_pd(vrs4, vrs4, 0x1), vst, vrs4);
	7702	+ vo6 = MM_FMA_PD(_mm_shuffle_pd(vrs6, vrs6, 0x1), vst, vrs6);
	7703	+ vo0 = _mm_mul_pd(vo0, vlv);
	7704	+ vo2 = _mm_mul_pd(vo2, vlv);
	7705	+ vo4 = _mm_mul_pd(vo4, vlv);
	7706	+ vo6 = _mm_mul_pd(vo6, vlv);
	7707	+ _mm_store_pd(&buf[i ], vo0);
	7708	+ _mm_store_pd(&buf[i + 2], vo2);
	7709	+ _mm_store_pd(&buf[i + 4], vo4);
	7710	+ _mm_store_pd(&buf[i + 6], vo6);
	7711	+ vfb = vi;
	7712	+ }
	7713	+ _mm_storeu_pd(info->rsfb, vfb);
	7714	+ }
	7715	+#else
	7716	+ {
	7717	+ const FLOAT_T vlv = info->levelrv;
	7718	+ const FLOAT_T vst = REV_EX2_ST_CROSS * info->levelrv;
	7719	+ FLOAT_T fb0 = info->rsfb[0];
	7720	+ FLOAT_T fb1 = info->rsfb[1];
	7721	+ for (i = 0, k = 0; i < count; i += 8, k++){
	7722	+ FLOAT_T in0 = info->tbuf[0][k];
	7723	+ FLOAT_T in1 = info->tbuf[1][k];
	7724	+ FLOAT_T rs0, rs1, rs2, rs3, rs4, rs5, rs6, rs7;
	7725	+ rs2 = fb0 * 0.75 + in0 * 0.25;
	7726	+ rs3 = fb1 * 0.75 + in1 * 0.25;
	7727	+ rs4 = (fb0 + in0) * 0.5;
	7728	+ rs5 = (fb1 + in1) * 0.5;
	7729	+ rs6 = fb0 * 0.25 + in0 * 0.75;
	7730	+ rs7 = fb1 * 0.25 + in1 * 0.75;
	7731	+ rs0 = in0 * vlv + in1 * vst;
	7732	+ rs1 = in1 * vlv + in0 * vst;
	7733	+ rs2 = rs2 * vlv + rs3 * vst;
	7734	+ rs3 = rs3 * vlv + rs2 * vst;
	7735	+ rs4 = rs4 * vlv + rs5 * vst;
	7736	+ rs5 = rs5 * vlv + rs4 * vst;
	7737	+ rs6 = rs6 * vlv + rs7 * vst;
	7738	+ rs7 = rs7 * vlv + rs6 * vst;
	7739	+ buf[i ] = rs0;
	7740	+ buf[i + 1] = rs1;
	7741	+ buf[i + 2] = rs2;
	7742	+ buf[i + 3] = rs3;
	7743	+ buf[i + 4] = rs4;
	7744	+ buf[i + 5] = rs5;
	7745	+ buf[i + 6] = rs6;
	7746	+ buf[i + 7] = rs7;
	7747	+ fb0 = in0;
	7748	+ fb0 = in1;
	7749	+ }
	7750	+ info->rsfb[0] = fb0;
	7751	+ info->rsfb[1] = fb1;
	7752	+ }
	7753	+#endif
	7754	+}
	7755	+
	7756	+static void do_reverb_ex2_rsmode3_out(DATA_T buf, int32 count, InfoReverbEX2 info)
	7757	+{
	7758	+ int32 i, k;
	7759	+
	7760	+#if (USE_X86_EXT_INTRIN >= 9) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7761	+ {
	7762	+ const __m256d yvlv = _mm256_set1_pd(info->levelrv);
	7763	+ const __m256d yvst = _mm256_set1_pd(REV_EX2_ST_CROSS);
	7764	+ const __m256d yvdiv8_87 = _mm256_set_pd(0.875, 0.875, 1.0, 1.0);
	7765	+ const __m256d yvdiv8_65 = _mm256_set_pd(0.625, 0.625, 0.75, 0.75);
	7766	+ const __m256d yvdiv8_43 = _mm256_set_pd(0.375, 0.375, 0.5, 0.5);
	7767	+ const __m256d yvdiv8_21 = _mm256_set_pd(0.125, 0.125, 0.25, 0.25);
	7768	+ const __m256d yvdiv8_01 = _mm256_set_pd(0.25, 0.25, 0.0, 0.0);
	7769	+ const __m256d yvdiv8_23 = _mm256_set_pd(0.75, 0.75, 0.5, 0.5);
	7770	+ const __m256d yvdiv8_45 = _mm256_set_pd(0.75, 0.75, 0.5, 0.5);
	7771	+ const __m256d yvdiv8_67 = _mm256_set_pd(0.75, 0.75, 0.5, 0.5);
	7772	+ __m128d vfb = _mm_loadu_pd(info->rsfb);
	7773	+ __m256d yvfb = MM256_SET2X_PD(vfb, vfb);
	7774	+ for (i = 0, k = 0; i < count; i += 16, k++){
	7775	+ __m128d vi = _mm_set_pd(info->tbuf[1][k], info->tbuf[0][k]);
	7776	+ __m256d yvi = MM256_SET2X_PD(vi, vi);
	7777	+ __m256d yvrs0, yvrs4, yvrs8, yvrs12, yvo0, yvo4, yvo8, yvo12;
	7778	+ yvrs0 = MM256_FMA2_PD(yvfb, yvdiv8_87, yvi, yvdiv8_01);
	7779	+ yvrs4 = MM256_FMA2_PD(yvfb, yvdiv8_65, yvi, yvdiv8_23);
	7780	+ yvrs8 = MM256_FMA2_PD(yvfb, yvdiv8_43, yvi, yvdiv8_45);
	7781	+ yvrs12 = MM256_FMA2_PD(yvfb, yvdiv8_21, yvi, yvdiv8_67);
	7782	+ yvo0 = MM256_FMA_PD(_mm256_shuffle_pd(yvrs0, yvrs0, 0xA), yvst, yvrs0);
	7783	+ yvo4 = MM256_FMA_PD(_mm256_shuffle_pd(yvrs4, yvrs4, 0xA), yvst, yvrs4);
	7784	+ yvo8 = MM256_FMA_PD(_mm256_shuffle_pd(yvrs8, yvrs8, 0xA), yvst, yvrs8);
	7785	+ yvo12 = MM256_FMA_PD(_mm256_shuffle_pd(yvrs12, yvrs12, 0xA), yvst, yvrs12);
	7786	+ yvo0 = _mm256_mul_pd(yvo0, yvlv);
	7787	+ yvo4 = _mm256_mul_pd(yvo4, yvlv);
	7788	+ yvo8 = _mm256_mul_pd(yvo8, yvlv);
	7789	+ yvo12 = _mm256_mul_pd(yvo12, yvlv);
	7790	+ _mm256_store_pd(&buf[i ], yvo0);
	7791	+ _mm256_store_pd(&buf[i + 4], yvo4);
	7792	+ _mm256_store_pd(&buf[i + 8], yvo8);
	7793	+ _mm256_store_pd(&buf[i + 12], yvo12);
	7794	+ yvfb = yvi;
	7795	+ }
	7796	+ _mm_storeu_pd(info->rsfb, _mm256_extractf128_pd(yvfb, 0x0));
	7797	+ }
	7798	+#elif (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7799	+ {
	7800	+ const __m128d vlv = _mm_set1_pd(info->levelrv);
	7801	+ const __m128d vst = _mm_set1_pd(REV_EX2_ST_CROSS);
	7802	+ const __m128d vdiv8_1 = _mm_set1_pd(0.125);
	7803	+ const __m128d vdiv8_2 = _mm_set1_pd(0.25);
	7804	+ const __m128d vdiv8_3 = _mm_set1_pd(0.375);
	7805	+ const __m128d vdiv8_4 = _mm_set1_pd(0.5);
	7806	+ const __m128d vdiv8_5 = _mm_set1_pd(0.625);
	7807	+ const __m128d vdiv8_6 = _mm_set1_pd(0.75);
	7808	+ const __m128d vdiv8_7 = _mm_set1_pd(0.875);
	7809	+ __m128d vfb = _mm_loadu_pd(info->rsfb);
	7810	+ for (i = 0, k = 0; i < count; i += 16, k++){
	7811	+ __m128d vi = _mm_set_pd(info->tbuf[1][k], info->tbuf[0][k]);
	7812	+ __m128d vrs2, vrs4, vrs6, vrs8, vrs10, vrs12, vrs14, vo0, vo2, vo4, vo6, vo8, vo10, vo12, vo14;
	7813	+ vrs2 = MM_FMA2_PD(vfb, vdiv8_7, vi, vdiv8_1);
	7814	+ vrs4 = MM_FMA2_PD(vfb, vdiv8_6, vi, vdiv8_2);
	7815	+ vrs6 = MM_FMA2_PD(vfb, vdiv8_5, vi, vdiv8_3);
	7816	+ vrs8 = _mm_mul_pd(_mm_add_pd(vfb, vi), vdiv8_4);
	7817	+ vrs10 = MM_FMA2_PD(vfb, vdiv8_3, vi, vdiv8_5);
	7818	+ vrs12 = MM_FMA2_PD(vfb, vdiv8_2, vi, vdiv8_6);
	7819	+ vrs14 = MM_FMA2_PD(vfb, vdiv8_1, vi, vdiv8_7);
	7820	+ vo0 = MM_FMA_PD(_mm_shuffle_pd(vi, vi, 0x1), vst, vi);
	7821	+ vo2 = MM_FMA_PD(_mm_shuffle_pd(vrs2, vrs2, 0x1), vst, vrs2);
	7822	+ vo4 = MM_FMA_PD(_mm_shuffle_pd(vrs4, vrs4, 0x1), vst, vrs4);
	7823	+ vo6 = MM_FMA_PD(_mm_shuffle_pd(vrs6, vrs6, 0x1), vst, vrs6);
	7824	+ vo8 = MM_FMA_PD(_mm_shuffle_pd(vrs8, vrs8, 0x1), vst, vrs8);
	7825	+ vo10 = MM_FMA_PD(_mm_shuffle_pd(vrs10, vrs10, 0x1), vst, vrs10);
	7826	+ vo12 = MM_FMA_PD(_mm_shuffle_pd(vrs12, vrs12, 0x1), vst, vrs12);
	7827	+ vo14 = MM_FMA_PD(_mm_shuffle_pd(vrs14, vrs14, 0x1), vst, vrs14);
	7828	+ vo0 = _mm_mul_pd(vo0, vlv);
	7829	+ vo2 = _mm_mul_pd(vo2, vlv);
	7830	+ vo4 = _mm_mul_pd(vo4, vlv);
	7831	+ vo6 = _mm_mul_pd(vo6, vlv);
	7832	+ vo8 = _mm_mul_pd(vo8, vlv);
	7833	+ vo10 = _mm_mul_pd(vo10, vlv);
	7834	+ vo12 = _mm_mul_pd(vo12, vlv);
	7835	+ vo14 = _mm_mul_pd(vo14, vlv);
	7836	+ _mm_store_pd(&buf[i ], vo0);
	7837	+ _mm_store_pd(&buf[i + 2], vo2);
	7838	+ _mm_store_pd(&buf[i + 4], vo4);
	7839	+ _mm_store_pd(&buf[i + 6], vo6);
	7840	+ _mm_store_pd(&buf[i + 8], vo8);
	7841	+ _mm_store_pd(&buf[i + 10], vo10);
	7842	+ _mm_store_pd(&buf[i + 12], vo12);
	7843	+ _mm_store_pd(&buf[i + 14], vo14);
	7844	+ vfb = vi;
	7845	+ }
	7846	+ _mm_storeu_pd(info->rsfb, vfb);
	7847	+ }
	7848	+#else
	7849	+ {
	7850	+ const FLOAT_T vst = REV_EX2_ST_CROSS;
	7851	+ FLOAT_T fb0 = info->rsfb[0];
	7852	+ FLOAT_T fb1 = info->rsfb[1];
	7853	+ for (i = 0, k = 0; i < count; i += 16, k++){
	7854	+ FLOAT_T in0 = info->tbuf[0][k];
	7855	+ FLOAT_T in1 = info->tbuf[1][k];
	7856	+ FLOAT_T rs0, rs1, rs2, rs3, rs4, rs5, rs6, rs7, rs8, rs9, rs10, rs11, rs12, rs13, rs14, rs15;
	7857	+ rs2 = fb0 * 0.875 + in0 * 0.125;
	7858	+ rs3 = fb1 * 0.875 + in1 * 0.125;
	7859	+ rs4 = fb0 * 0.75 + in0 * 0.25;
	7860	+ rs5 = fb1 * 0.75 + in1 * 0.25;
	7861	+ rs6 = fb0 * 0.625 + in0 * 0.375;
	7862	+ rs7 = fb1 * 0.625 + in1 * 0.375;
	7863	+ rs8 = (fb0 + in0) * 0.5;
	7864	+ rs9 = (fb1 + in1) * 0.5;
	7865	+ rs10 = fb0 * 0.375 + in0 * 0.625;
	7866	+ rs11 = fb1 * 0.375 + in1 * 0.625;
	7867	+ rs12 = fb0 * 0.25 + in0 * 0.75;
	7868	+ rs13 = fb1 * 0.25 + in1 * 0.75;
	7869	+ rs14 = fb0 * 0.125 + in0 * 0.875;
	7870	+ rs15 = fb1 * 0.125 + in1 * 0.875;
	7871	+ rs0 = in0 + in1 * vst;
	7872	+ rs1 = in1 + in0 * vst;
	7873	+ rs2 = rs2 + rs3 * vst;
	7874	+ rs3 = rs3 + rs2 * vst;
	7875	+ rs4 = rs4 + rs5 * vst;
	7876	+ rs5 = rs5 + rs4 * vst;
	7877	+ rs6 = rs6 + rs7 * vst;
	7878	+ rs7 = rs7 + rs6 * vst;
	7879	+ rs8 = rs8 + rs9 * vst;
	7880	+ rs9 = rs9 + rs8 * vst;
	7881	+ rs10 = rs10 + rs11 * vst;
	7882	+ rs11 = rs11 + rs10 * vst;
	7883	+ rs12 = rs12 + rs13 * vst;
	7884	+ rs13 = rs13 + rs12 * vst;
	7885	+ rs14 = rs14 + rs15 * vst;
	7886	+ rs15 = rs15 + rs14 * vst;
	7887	+ buf[i ] = rs0;
	7888	+ buf[i + 1] = rs1;
	7889	+ buf[i + 2] = rs2;
	7890	+ buf[i + 3] = rs3;
	7891	+ buf[i + 4] = rs4;
	7892	+ buf[i + 5] = rs5;
	7893	+ buf[i + 6] = rs6;
	7894	+ buf[i + 7] = rs7;
	7895	+ buf[i + 8] = rs8;
	7896	+ buf[i + 9] = rs9;
	7897	+ buf[i + 10] = rs10;
	7898	+ buf[i + 11] = rs11;
	7899	+ buf[i + 12] = rs12;
	7900	+ buf[i + 13] = rs13;
	7901	+ buf[i + 14] = rs14;
	7902	+ buf[i + 15] = rs15;
	7903	+ fb0 = in0;
	7904	+ fb0 = in1;
	7905	+ }
	7906	+ info->rsfb[0] = fb0;
	7907	+ info->rsfb[1] = fb1;
	7908	+ }
	7909	+#endif
	7910	+}
	7911	+
	7912	+static void do_reverb_ex2_pre_process(DATA_T buf, int32 count, InfoReverbEX2 info)
	7913	+{
	7914	+ switch(info->rsmode){
	7915	+ case 0: do_reverb_ex2_rsmode0_in(buf, count, info); break;
	7916	+ case 1: do_reverb_ex2_rsmode1_in(buf, count, info); break;
	7917	+ case 2: do_reverb_ex2_rsmode2_in(buf, count, info); break;
	7918	+ case 3: do_reverb_ex2_rsmode3_in(buf, count, info); break;
	7919	+ }
	7920	+}
	7921	+
	7922	+static void do_reverb_ex2_post_process(DATA_T buf, int32 count, InfoReverbEX2 info)
	7923	+{
	7924	+ switch(info->rsmode){
	7925	+ case 0: do_reverb_ex2_rsmode0_out(buf, count, info); break;
	7926	+ case 1: do_reverb_ex2_rsmode1_out(buf, count, info); break;
	7927	+ case 2: do_reverb_ex2_rsmode2_out(buf, count, info); break;
	7928	+ case 3: do_reverb_ex2_rsmode3_out(buf, count, info); break;
	7929	+ }
	7930	+}
	7931	+
	7932	+#if defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7933	+static void do_reverb_ex2_thread(int thread_num, void *info2)
	7934	+{
	7935	+ InfoReverbEX2 *info;
	7936	+ int i, k, ch;
	7937	+ int32 scount, ecount, tc, tn;
	7938	+
	7939	+ if(!info2)
	7940	+ return;
	7941	+ info = (InfoReverbEX2 *)info2;
	7942	+ if(!info->init)
	7943	+ return;
	7944	+#if defined(REV_EX2_FFT)
	7945	+ if(info->fftmode){
	7946	+ do_reverb_ex2_fft_thread(thread_num, info2);
	7947	+ return;
	7948	+ }
	7949	+#endif
	7950	+ if(thread_num >= (info->thread + info->ithread))
	7951	+ return;
	7952	+ if(info->ithread){
	7953	+ if(thread_num == info->thread){
	7954	+ do_reverb_ex2_pre_process(info->ptr, info->count, info);
	7955	+ return;
	7956	+ }
	7957	+ }else if(thread_num == 0){
	7958	+ do_reverb_ex2_pre_process(info->ptr, info->count, info);
	7959	+ }
	7960	+ tc = info->tcount / (info->thread >> 1);
	7961	+ tn = thread_num >> 1;
	7962	+ scount = tc * tn;
	7963	+ ecount = tc * (tn + 1);
	7964	+ do_reverb_ex2_process(thread_num & 0x1, scount, ecount, info);
	7965	+}
	7966	+#endif // defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	7967	+
	7968	+static void do_reverb_ex2(DATA_T buf, int32 count, InfoReverbEX2 info)
	7969	+{
7273	7970	if(count == MAGIC_INIT_EFFECT_INFO) {
7274	7971	init_reverb_ex2(info);
7275	7972	return;

		@@ -7280,138 +7977,853 @@ static void do_reverb_ex2(DATA_T buf, int32 count, InfoReverbEX2 info)
7280	7977	return;
7281	7978	else if(!info->init)
7282	7979	return;
	7980	+#if defined(REV_EX2_FFT)
	7981	+ if(info->fftmode){
	7982	+ do_reverb_ex2_fft(buf, count, info);
	7983	+ return;
	7984	+ }
	7985	+#endif
	7986	+ info->ptr = buf;
	7987	+ info->count = count;
	7988	+ info->tcount = count >> (1 + info->rsmode);
	7989	+#if defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
7283	7990	if(info->thread){
7284		- info->tcount = count >> 1;
	7991	+ go_effect_sub_thread(do_reverb_ex2_thread, info, info->thread + info->ithread);
	7992	+ }else
	7993	+#endif
	7994	+ {
	7995	+ do_reverb_ex2_pre_process(buf, count, info);
	7996	+ do_reverb_ex2_process(0, 0, info->tcount, info);
	7997	+ do_reverb_ex2_process(1, 0, info->tcount, info);
	7998	+ }
	7999	+ info->bcount = info->tbcount;
	8000	+ do_reverb_ex2_post_process(buf, count, info);
	8001	+}
	8002	+
	8003	+
	8004	+#if defined(REV_EX2_FFT)
	8005	+// freeverb3 irmodel2zl.cpp を参考に書いてみたが・・
	8006	+
	8007	+
	8008	+#define REV_EX2_FFT_LEVEL (1. * (1.0 - REV_EX2_ST_CROSS))
	8009	+#define REV_EX2_FRAGBIT (12) // 10 ~ 14
	8010	+#define REV_EX2_FRAGSIZE (1 << REV_EX2_FRAGBIT) // 2^REV_EX2_FRAGBIT > synthbuffer size
	8011	+#define REV_EX2_FFTSIZE (REV_EX2_FRAGSIZE << 1)
	8012	+
	8013	+static void do_reverb_ex2__fft(float fft, float st)
	8014	+{
	8015	+ const int32 cosofs = REV_EX2_FRAGSIZE >> 2;
	8016	+ const uint32 stmask = REV_EX2_FRAGSIZE - 1;
	8017	+ float *ar = fft;
	8018	+ float *ai = fft + REV_EX2_FRAGSIZE;
	8019	+ int i = 0, j, k, m, mh, irev;
	8020	+ float xr, xi;
	8021	+
	8022	+ for (j = 1; j < (REV_EX2_FRAGSIZE - 1); j++){
	8023	+ for(k = (REV_EX2_FRAGSIZE >> 1); k > (i ^= k); k >>= 1){}
	8024	+ if(j < i){
	8025	+ xr = *(ar + j);
	8026	+ xi = *(ai + j);
	8027	+ (ar + j) = (ar + i);
	8028	+ (ai + j) = (ai + i);
	8029	+ *(ar + i) = xr;
	8030	+ *(ai + i) = xi;
	8031	+ }
	8032	+ }
	8033	+ for(mh = 1; (m = mh << 1) <= REV_EX2_FRAGSIZE; mh = m){
	8034	+ irev = 0;
	8035	+ for(i = 0; i < REV_EX2_FRAGSIZE; i += m){
	8036	+ float tsin = st[irev & stmask];
	8037	+ float tcos = st[(irev + cosofs) & stmask];
	8038	+ for(k = (REV_EX2_FRAGSIZE >> 2); k > (irev ^= k); k >>= 1){}
	8039	+ for(j = i; j < mh + i; j++){
	8040	+ k = j + mh;
	8041	+ xr = (ar + j) - (ar + k);
	8042	+ xi = (ai + j) - (ai + k);
	8043	+ (ar + j) += (ar + k);
	8044	+ (ai + j) += (ai + k);
	8045	+ (ar + k) = tcos xr - tsin * xi;
	8046	+ (ai + k) = tcos xi + tsin * xr;
	8047	+ }
	8048	+ }
	8049	+ }
	8050	+}
	8051	+
	8052	+static void do_reverb_ex2_R2HC(float iL, float oL, float *st)
	8053	+{
	8054	+ const int32 fbyte = sizeof(float) * REV_EX2_FRAGSIZE;
	8055	+ int32 i = 0;
	8056	+ ALIGN float fo[REV_EX2_FFTSIZE] = {0};
	8057	+
	8058	+ memcpy(fo, iL, fbyte);
	8059	+ do_reverb_ex2__fft(fo, st);
	8060	+#if 0
	8061	+ for(i = 0; i < REV_EX2_FRAGSIZE; i++){
	8062	+ oL[i ] = fo[i];
	8063	+ oL[REV_EX2_FFTSIZE - 1 - 1] = fo[REV_EX2_FFTSIZE - 1 - i];
	8064	+ }
	8065	+#elif 0
	8066	+ oL[0] = fo[0];
	8067	+ oL[1] = fo[REV_EX2_FRAGSIZE];
	8068	+ for(i = 1; i < REV_EX2_FRAGSIZE; i++){
	8069	+ oL[2 * i ] = fo[REV_EX2_FFTSIZE - i];
	8070	+ oL[2 * i + 1] = fo[REV_EX2_FFTSIZE - i];
	8071	+ }
	8072	+#elif 0
	8073	+ for(i = 0; i < REV_EX2_FRAGSIZE; i++){
	8074	+ oL[2 * i ] = fo[i];
	8075	+ oL[2 * i + 1] = fo[REV_EX2_FFTSIZE - 1 - i];
	8076	+ }
	8077	+#else
	8078	+ memcpy(oL, fo, sizeof(float) * REV_EX2_FFTSIZE);
	8079	+#endif
	8080	+
	8081	+}
	8082	+
	8083	+static void do_reverb_ex2_HC2R(float iL, float oL, float *st)
	8084	+{
	8085	+ int32 i = 0;
	8086	+ ALIGN float fo[REV_EX2_FFTSIZE] = {0};
	8087	+
	8088	+#if 0
	8089	+ for(i = 0; i < REV_EX2_FRAGSIZE; i++){
	8090	+ fo[i] = iL[i ];
	8091	+ fo[REV_EX2_FFTSIZE - 1 - 1] = iL[REV_EX2_FFTSIZE - 1 - i];
	8092	+ }
	8093	+
	8094	+#elif 0
	8095	+ fo[0] = iL[0];
	8096	+ fo[REV_EX2_FRAGSIZE] = iL[1];
	8097	+ for(i = 1; i < REV_EX2_FRAGSIZE; i++){
	8098	+ fo[REV_EX2_FFTSIZE - i] = iL[2 * i ];
	8099	+ fo[REV_EX2_FFTSIZE - i] = iL[2 * i + 1];
	8100	+ }
	8101	+#elif 0
	8102	+ for(i = 0; i < REV_EX2_FRAGSIZE; i++){
	8103	+ fo[i ] = iL[2 * i ];
	8104	+ fo[REV_EX2_FFTSIZE - 1 - i] = iL[2 * i + 1];
	8105	+ }
	8106	+#else
	8107	+ memcpy(fo, iL, sizeof(float) * REV_EX2_FFTSIZE);
	8108	+#endif
	8109	+ do_reverb_ex2__fft(fo, st);
	8110	+ {
	8111	+ float *pfor = fo;
	8112	+ float *pfoi = fo + REV_EX2_FRAGSIZE;
	8113	+ float *or = oL;
	8114	+ float *oi = oL + REV_EX2_FRAGSIZE;
	8115	+ const float divfr = 1.0;// / (double)REV_EX2_FRAGSIZE;
	8116	+ const float divfi = -1.0;// / (double)REV_EX2_FRAGSIZE;
	8117	+ for(i = 0; i < REV_EX2_FFTSIZE; i++){
	8118	+ // or[i] += pfor[i] * divfi;
	8119	+ or[REV_EX2_FFTSIZE - 1 - i] += pfor[i] * divfr;
	8120	+ // oi[i] += pfoi[i] * divfi;
	8121	+ }
	8122	+ }
	8123	+}
	8124	+
	8125	+static void do_reverb_ex2_mul(float iL, float fL, float *oL)
	8126	+{
	8127	+ int32 i;
	8128	+#if 0
	8129	+ float tL0 = oL[0] + iL[0] * fL[0];
	8130	+ float tL1 = oL[1] + iL[1] * fL[1];
	8131	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8132	+ const __m128 vm1 = _mm_set_ps(1, -1, 1, -1);
	8133	+ for(i = 0; i < REV_EX2_FRAGSIZE; i += 2){
	8134	+ __m128 vo = _mm_load_ps(&oL[2 * i]);
	8135	+ __m128 vi = _mm_loadu_ps(&iL[2 * i]);
	8136	+ __m128 vf0 = _mm_load_ps(&fL[2 * i]);
	8137	+ __m128 vf1 = _mm_shuffle_ps(vf0, vf0, 0xB1);
	8138	+ __m128 vi0 = _mm_shuffle_ps(vi, vi, 0xA0);
	8139	+ __m128 vi1 = _mm_shuffle_ps(vi, vi, 0xF5);
	8140	+ vf1 = _mm_mul_ps(vf1, vm1);
	8141	+ vo = MM_FMA_PS(vi0, vf0, vo);
	8142	+ vo = MM_FMA_PS(vi1, vf1, vo);
	8143	+ _mm_store_ps(&oL[2 * i], vo);
	8144	+ }
	8145	+#else
	8146	+ for(i = 0; i < REV_EX2_FRAGSIZE; i++){
	8147	+ float i0 = iL[2 * i + 0];
	8148	+ float i1 = iL[2 * i + 1];
	8149	+ float f0 = fL[2 * i + 0];
	8150	+ float f1 = fL[2 * i + 1];
	8151	+ oL[2 * i + 0] += i0 * f0 - i1 * f1;
	8152	+ oL[2 * i + 1] += i0 * f1 + i1 * f0;
	8153	+ }
	8154	+#endif
	8155	+ oL[0] = tL0;
	8156	+ oL[1] = tL1;
	8157	+
	8158	+#else
	8159	+ float *ir = iL;
	8160	+ float *ii = iL + REV_EX2_FRAGSIZE;
	8161	+ float *fr = fL;
	8162	+ float *fi = fL + REV_EX2_FRAGSIZE;
	8163	+ float *or = oL;
	8164	+ float *oi = oL + REV_EX2_FRAGSIZE;
	8165	+ float tor = or[0] + ir[0] * fr[0];
	8166	+ float toi = oi[0] + ii[0] * fi[0];
	8167	+
	8168	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8169	+ const __m128 vm1 = _mm_set1_ps(-1);
	8170	+ for(i = 0; i < REV_EX2_FRAGSIZE; i += 4){
	8171	+ __m128 vir = _mm_load_ps(&ir[i]);
	8172	+ __m128 vii = _mm_load_ps(&ii[i]);
	8173	+ __m128 vfr = _mm_load_ps(&fr[i]);
	8174	+ __m128 vfi = _mm_load_ps(&fi[i]);
	8175	+ __m128 vor = _mm_load_ps(&or[i]);
	8176	+ __m128 voi = _mm_load_ps(&oi[i]);
	8177	+ __m128 vfm = _mm_mul_ps(vfi, vm1);
	8178	+ vor = MM_FMA_PS(vir, vfr , vor);
	8179	+ vor = MM_FMA_PS(vii, vfm , vor);
	8180	+ voi = MM_FMA_PS(vir, vfi, voi);
	8181	+ voi = MM_FMA_PS(vii, vfr, voi);
	8182	+ _mm_store_ps(&or[i], vor);
	8183	+ _mm_store_ps(&oi[i], voi);
	8184	+ }
	8185	+#else
	8186	+ for(i = 0; i < REV_EX2_FRAGSIZE; i++){
	8187	+ float tir = ir[i];
	8188	+ float tii = ii[i];
	8189	+ float tfr = fr[i];
	8190	+ float tfi = fi[i];
	8191	+ or[i] += tir * tfr - tii * tfi;
	8192	+ oi[i] += tir * tfi + tii * tfr;
	8193	+ }
	8194	+#endif
	8195	+ or[0] = tor;
	8196	+ oi[0] = toi;
	8197	+
	8198	+#endif
	8199	+}
	8200	+
	8201	+static float* do_reverb_ex2_delay(float in, int32 prev, float dbuf, int32 *bcount, int32 bnum)
	8202	+{
	8203	+ if(prev == 0){
	8204	+ float *pos;
	8205	+
	8206	+ bcount = (bcount + 1) % bnum;
	8207	+ pos = dbuf + REV_EX2_FFTSIZE * *bcount;
	8208	+ memcpy(pos, in, sizeof(float) * REV_EX2_FFTSIZE);
	8209	+ return pos;
	8210	+ }else{
	8211	+ return dbuf + REV_EX2_FFTSIZE * ((bnum + *bcount - prev) % bnum);
	8212	+ }
	8213	+}
	8214	+
	8215	+static void init_reverb_ex2_fft(InfoReverbEX2 *info)
	8216	+{
	8217	+ int i, k, flg = 0;
	8218	+ float div;
	8219	+ int32 bytes, rsrate, cbs;
	8220	+ int32 fnum, ibytes;
	8221	+ char *sample_file = "irfile.wav";
	8222	+ int32 amp = 100;
	8223	+ TCHAR path[FILEPATH_MAX] = {0};
	8224	+
	8225	+ if(ext_reverb_ex2_fftmode == 1)
	8226	+ info->fftmode = 1;
	8227	+ else if(ext_reverb_ex2_fftmode == 2)
	8228	+ info->fftmode = 2;
	8229	+ else
	8230	+ goto error;
	8231	+ if(info->init){
	8232	+ if(info->fm_p != info->fftmode \|\| info->pmr_p != play_mode->rate \|\| info->rt_p != info->revtype)
	8233	+ free_reverb_ex2(info);
	8234	+ else
	8235	+ return;
	8236	+ }
	8237	+ if(play_mode->encoding & PE_MONO)
	8238	+ goto error;
	8239	+
	8240	+ reverb_ex2_read_ini(info->revtype, path, &amp);
	8241	+ if(!(*path)){
	8242	+ flg = 1;
	8243	+ }else{
	8244	+ ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
	8245	+ "SamplingReverb: Trying to load IR %s (type:%s)", path, ini_rev_type_name[info->revtype]);
	8246	+ if(reverb_ex2_import_wave(path, info)){
	8247	+ ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
	8248	+ "SamplingReverb: Can't load IR %s (type:%s)", path, ini_rev_type_name[info->revtype]);
	8249	+ flg = 1;
	8250	+ }
	8251	+ }
	8252	+ if(flg){
	8253	+ ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "SamplingReverb: Trying to load IR %s", sample_file);
	8254	+ amp = 100;
	8255	+ if(reverb_ex2_import_wave(sample_file, info)){
	8256	+ ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "SamplingReverb: ERROR Can't load IR %s", sample_file);
	8257	+ goto error;
	8258	+ }
	8259	+ }
	8260	+
	8261	+ if(info->frame < 1 \|\| info->srate < 1)
	8262	+ goto error;
	8263	+ info->fm_p = info->fftmode;
	8264	+ info->rt_p = info->revtype;
	8265	+ info->pmr_p = play_mode->rate;
	8266	+ switch(ext_reverb_ex2_rsmode){
	8267	+ default:
	8268	+ case 3:
	8269	+ if(play_mode->rate >= 128000){
	8270	+ info->rsmode = 3;
	8271	+ rsrate = play_mode->rate >> 3;
	8272	+ cbs = compute_buffer_size >> 3;
	8273	+ break;
	8274	+ } // else thru
	8275	+ case 2:
	8276	+ if(play_mode->rate >= 64000){
	8277	+ info->rsmode = 2;
	8278	+ rsrate = play_mode->rate >> 2;
	8279	+ cbs = compute_buffer_size >> 2;
	8280	+ break;
	8281	+ } // else thru
	8282	+ case 1:
	8283	+ if(play_mode->rate >= 32000){
	8284	+ info->rsmode = 1;
	8285	+ rsrate = play_mode->rate >> 1;
	8286	+ cbs = compute_buffer_size >> 1;
	8287	+ break;
	8288	+ } // else thru
	8289	+ case 0:
	8290	+ info->rsmode = 0;
	8291	+ rsrate = play_mode->rate;
	8292	+ cbs = compute_buffer_size;
	8293	+ break;
	8294	+ }
	8295	+
	8296	+ // irdata resample (align fragsize
	8297	+ {
	8298	+ double ratio = (double)rsrate / (double)info->srate;
	8299	+ int32 nframe = (double)info->frame * ratio + 0.5;
	8300	+ double rate = 1.0 / ratio; //
	8301	+ float *ndata[2];
	8302	+ int32 fnum, tframe, nbytes, frest;
	8303	+ fnum = nframe / REV_EX2_FRAGSIZE;
	8304	+ frest = nframe % REV_EX2_FRAGSIZE;
	8305	+ fnum = frest ? (fnum + 1) : fnum;
	8306	+ tframe = fnum * REV_EX2_FRAGSIZE;
	8307	+ nbytes = (tframe + 16) * sizeof(float);
	8308	+
	8309	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8310	+ ndata[0] = (float *) aligned_malloc(nbytes, ALIGN_SIZE);
	8311	+ ndata[1] = (float *) aligned_malloc(nbytes, ALIGN_SIZE);
	8312	+#else
	8313	+ ndata[0] = (float *) safe_large_malloc(nbytes);
	8314	+ ndata[1] = (float *) safe_large_malloc(nbytes);
	8315	+#endif
	8316	+ if(!ndata[0] \|\| !ndata[0])
	8317	+ goto error;
	8318	+ memset(ndata[0], 0, nbytes);
	8319	+ memset(ndata[1], 0, nbytes);
	8320	+ if(rate > 1.0){
	8321	+ FilterCoefficients lpf;
	8322	+ set_sample_filter_type(&lpf, FILTER_LPF6);
	8323	+ set_sample_filter_ext_rate(&lpf, info->srate);
	8324	+ set_sample_filter_freq(&lpf, rsrate * 0.9);
	8325	+ recalc_filter(&lpf);
	8326	+ for (i = 0; i < info->frame; i++){
	8327	+ DATA_T in0 = info->irdata[0][i];
	8328	+ DATA_T in1 = info->irdata[1][i];
	8329	+ sample_filter_stereo(&lpf, &in0, &in1);
	8330	+ info->irdata[0][i] = in0;
	8331	+ info->irdata[1][i] = in1;
	8332	+ }
	8333	+ }
	8334	+ if(rate == 1.0){
	8335	+ memcpy(ndata[0], info->irdata[0], nframe * sizeof(float));
	8336	+ memcpy(ndata[1], info->irdata[1], nframe * sizeof(float));
	8337	+ }else if(rate == 8.0)
	8338	+ do_reverb_ex2_resample_ds8(info->irdata[0], info->irdata[1], ndata[0], ndata[1], info->frame >> 3);
	8339	+ else if(rate == 4.0)
	8340	+ do_reverb_ex2_resample_ds4(info->irdata[0], info->irdata[1], ndata[0], ndata[1], info->frame >> 2);
	8341	+ else if(rate == 2.0)
	8342	+ do_reverb_ex2_resample_ds2(info->irdata[0], info->irdata[1], ndata[0], ndata[1], info->frame >> 1);
	8343	+ else if(rate > 4.0){
	8344	+ do_reverb_ex2_resample_ds4(info->irdata[0], info->irdata[1], info->irdata[0], info->irdata[1], info->frame >> 2);
	8345	+ do_reverb_ex2_resample_ov2(info->irdata[0], info->irdata[1], ndata[0], ndata[1], nframe, rate * DIV_4);
	8346	+ }else if(rate > 2.0){
	8347	+ do_reverb_ex2_resample_ds2(info->irdata[0], info->irdata[1], info->irdata[0], info->irdata[1], info->frame >> 1);
	8348	+ do_reverb_ex2_resample_ov2(info->irdata[0], info->irdata[1], ndata[0], ndata[1], nframe, rate * DIV_2);
	8349	+ }else if(rate > 1.0)
	8350	+ do_reverb_ex2_resample_ov2(info->irdata[0], info->irdata[1], ndata[0], ndata[1], nframe, rate);
	8351	+ else
	8352	+ do_reverb_ex2_resample(info->irdata[0], info->irdata[1], ndata[0], ndata[1], nframe, rate);
	8353	+ for(i = 0; i < 2; i++){
	8354	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8355	+ if(info->irdata[i] != NULL){ aligned_free(info->irdata[i]); info->irdata[i] = NULL; }
	8356	+#else
	8357	+ if(info->irdata[i] != NULL){ safe_free(info->irdata[i]); info->irdata[i] = NULL; }
	8358	+#endif
	8359	+ }
	8360	+ info->frame = nframe;
	8361	+ info->srate = rsrate;
	8362	+ info->irdata[0] = ndata[0];
	8363	+ info->irdata[1] = ndata[1];
	8364	+ }
	8365	+ // DC
	8366	+ {
	8367	+ FilterCoefficients hpf;
	8368	+ set_sample_filter_type(&hpf, FILTER_HPF6);
	8369	+ set_sample_filter_ext_rate(&hpf, info->srate);
	8370	+ set_sample_filter_freq(&hpf, 5);
	8371	+ recalc_filter(&hpf);
	8372	+ for (i = 0; i < info->frame; i++){
	8373	+ DATA_T in0 = info->irdata[0][i];
	8374	+ DATA_T in1 = info->irdata[1][i];
	8375	+ sample_filter_stereo(&hpf, &in0, &in1);
	8376	+ info->irdata[0][i] = in0;
	8377	+ info->irdata[1][i] = in1;
	8378	+ }
	8379	+ }
	8380	+ //
	8381	+ div = 1.0 / (double)(REV_EX2_FRAGSIZE * 2);
	8382	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8383	+ {
	8384	+ __m128 vdiv = _mm_set1_ps(div);
	8385	+ for (i = 0; i < info->frame; i += 4){
	8386	+ MM_LS_MUL_PS(&info->irdata[0][i], vdiv);
	8387	+ MM_LS_MUL_PS(&info->irdata[1][i], vdiv);
	8388	+ }
	8389	+ }
	8390	+#else
	8391	+ for (i = 0; i < info->frame; i++){
	8392	+ info->irdata[0][i] *= div;
	8393	+ info->irdata[1][i] *= div;
	8394	+ }
	8395	+#endif
	8396	+ // create buffers
	8397	+ fnum = info->frame / REV_EX2_FRAGSIZE;
	8398	+ bytes = sizeof(float) * (REV_EX2_FRAGSIZE + 8);
	8399	+ ibytes = sizeof(int32) * REV_EX2_FRAGSIZE;
	8400	+ for(i = 0; i < 2; i++){
	8401	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8402	+ info->rvs[i] = (float ) aligned_malloc(bytes 2, ALIGN_SIZE);
	8403	+ info->rs[i] = (float ) aligned_malloc(bytes 2, ALIGN_SIZE);
	8404	+ info->is[i] = (float ) aligned_malloc(bytes 2, ALIGN_SIZE);
	8405	+ info->ss[i] = (float ) aligned_malloc(bytes 2, ALIGN_SIZE);
	8406	+ info->os[i] = (float ) aligned_malloc(bytes 2, ALIGN_SIZE);
	8407	+ info->fs[i] = (float ) aligned_malloc(bytes 2, ALIGN_SIZE);
	8408	+ info->fi[i] = (float ) aligned_malloc(bytes 2 * fnum, ALIGN_SIZE);
	8409	+ info->bd[i] = (float ) aligned_malloc(bytes 2 * fnum, ALIGN_SIZE);
	8410	+ info->ios[i] = (float ) aligned_malloc(bytes 3, ALIGN_SIZE);
	8411	+#else
	8412	+ info->rvs[i] = (float ) safe_large_malloc(bytes 2);
	8413	+ info->rs[i] = (float ) safe_large_malloc(bytes 2);
	8414	+ info->is[i] = (float ) safe_large_malloc(bytes 2);
	8415	+ info->ss[i] = (float ) safe_large_malloc(bytes 2);
	8416	+ info->os[i] = (float ) safe_large_malloc(bytes 2);
	8417	+ info->fs[i] = (float ) safe_large_malloc(bytes 2);
	8418	+ info->ios[i] = (float ) safe_large_malloc(bytes 3);
	8419	+ info->fi[i] = (float ) safe_large_malloc(bytes 2 * fnum);
	8420	+ info->bd[i] = (float ) safe_large_malloc(bytes 2 * fnum);
	8421	+#endif
	8422	+ if(!info->rvs[i] \|\| !info->rs[i] \|\| !info->is[i] \|\| !info->ss[i] \|\| !info->os[i]
	8423	+ \|\| !info->fs[i] \|\| !info->fi[i] \|\| !info->bd[i] \|\| !info->ios[i]
	8424	+ ){
	8425	+ goto error;
	8426	+ }
	8427	+ memset(info->rvs[i], 0, bytes * 2);
	8428	+ memset(info->rs[i], 0, bytes * 2);
	8429	+ memset(info->is[i], 0, bytes * 2);
	8430	+ memset(info->ss[i], 0, bytes * 2);
	8431	+ memset(info->os[i], 0, bytes * 2);
	8432	+ memset(info->fs[i], 0, bytes * 2);
	8433	+ memset(info->fi[i], 0, bytes * 2 * fnum);
	8434	+ memset(info->bd[i], 0, bytes * 2 * fnum);
	8435	+ memset(info->ios[i], 0, bytes * 3);
	8436	+ }
	8437	+ // sin table
	8438	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8439	+ info->sint = (float *) aligned_malloc(bytes, ALIGN_SIZE);
	8440	+#else
	8441	+ info->sint = (float *) safe_large_malloc(bytes);
	8442	+#endif
	8443	+ if(!info->sint)
	8444	+ goto error;
	8445	+ memset(info->sint, 0, bytes);
	8446	+ for(i = 0; i < REV_EX2_FRAGSIZE; i++){
	8447	+ const double rad = M_PI * 2.0 / REV_EX2_FRAGSIZE;
	8448	+ info->sint[i] = (float)((double)sin(rad * i));
	8449	+ }
	8450	+ // impulse
	8451	+ for(i = 0; i < fnum; i++){
	8452	+ int32 fofs = REV_EX2_FRAGSIZE * i;
	8453	+ int32 riofs = REV_EX2_FFTSIZE * i;
	8454	+ do_reverb_ex2_R2HC(info->irdata[0] + fofs, info->fi[0] + riofs, info->sint);
	8455	+ do_reverb_ex2_R2HC(info->irdata[1] + fofs, info->fi[1] + riofs, info->sint);
	8456	+ }
	8457	+ info->fnum = fnum;
	8458	+ // create input/output buffers
	8459	+ info->bsize = compute_buffer_size;
	8460	+ bytes = (compute_buffer_size + 8) * sizeof(float); // + 8 for simd
	8461	+ for(k = 0; k < 2; k++){
	8462	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8463	+ info->buf[k] = (float ) aligned_malloc(bytes 2, ALIGN_SIZE);
	8464	+ info->tbuf[k] = (float *) aligned_malloc(bytes, ALIGN_SIZE);
	8465	+#else
	8466	+ info->buf[k] = (float ) safe_large_malloc(bytes 2);
	8467	+ info->tbuf[k] = (float *) safe_large_malloc(bytes);
	8468	+#endif
	8469	+ if(!info->buf[k] \|\| !info->tbuf[k])
	8470	+ goto error;
	8471	+ memset(info->buf[k], 0, bytes * 2);
	8472	+ memset(info->tbuf[k], 0, bytes);
	8473	+ }
	8474	+
	8475	+#if defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8476	+ if(compute_thread_ready < 2){
	8477	+ info->thread = 0;
	8478	+ goto thru_thread;
	8479	+ }
	8480	+ info->thread = 2;
	8481	+ info->ithread = compute_thread_ready >= 3 ? 1 : 0;
	8482	+ if(set_effect_sub_thread(do_reverb_ex2_thread, info, info->thread + info->ithread)){
	8483	+ info->thread = 0;
	8484	+ goto thru_thread;
	8485	+ }
	8486	+thru_thread:
	8487	+#endif // defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8488	+ info->levelrv = (double)amp * DIV_100 * info->level * ext_reverb_ex2_level * REV_EX2_LEVEL * REV_EX2_FFT_LEVEL * M_31BIT;
	8489	+ info->scount[0] = 0;
	8490	+ info->scount[1] = 0;
	8491	+ info->bdcount[0] = 0;
	8492	+ info->bdcount[1] = 0;
	8493	+ info->bcount = 0;
	8494	+ info->tcount = 0;
	8495	+ info->init = 1;
	8496	+ return;
	8497	+error:
	8498	+ free_reverb_ex2(info);
	8499	+ info->init = 0;
	8500	+ return;
	8501	+}
	8502	+
	8503	+static void do_reverb_ex2_fft_process1(int32 ofs, int32 count, int32 ch, InfoReverbEX2 *info)
	8504	+{
	8505	+ int32 i;
	8506	+ int32 bcount = info->bcount ? 0 : info->bsize;
	8507	+ float *input = info->buf[ch] + ofs + bcount;
	8508	+ float *output = info->tbuf[ch] + ofs;
	8509	+ const int32 fbyte = sizeof(float) * REV_EX2_FRAGSIZE;
	8510	+ const int32 f2byte = sizeof(float) * REV_EX2_FRAGSIZE * 2;
	8511	+ const int32 cbyte = sizeof(float) * count;
	8512	+ const int32 ribyte = sizeof(float) * REV_EX2_FFTSIZE;
	8513	+ float rvsc, rsc;
	8514	+
	8515	+ if(info->scount[ch] == 0){
	8516	+ memset(info->fs[ch], 0, ribyte);
	8517	+ memset(info->ss[ch], 0, ribyte);
	8518	+ memset(info->rvs[ch] + REV_EX2_FRAGSIZE - 1, 0, sizeof(float) * (REV_EX2_FRAGSIZE + 1));
	8519	+ for(i = 1; i < info->fnum; i++){
	8520	+ float *bd0 = do_reverb_ex2_delay(info->is[ch], i - 1, info->bd[ch], &info->bdcount[ch], info->fnum);
	8521	+ do_reverb_ex2_mul(bd0, info->fi[ch] + REV_EX2_FFTSIZE * i, info->ss[ch]);
	8522	+ }
	8523	+ }
	8524	+ memset(info->os[ch], 0, fbyte);
	8525	+ memcpy(info->fs[ch] + info->scount[ch], input, cbyte);
	8526	+ memcpy(info->os[ch] + info->scount[ch], input, cbyte);
	8527	+ do_reverb_ex2_R2HC(info->os[ch], info->is[ch], info->sint);
	8528	+ do_reverb_ex2_mul(info->is[ch], info->fi[ch], info->ss[ch]);
	8529	+ memset(info->rvs[ch], 0, fbyte);
	8530	+ do_reverb_ex2_HC2R(info->ss[ch], info->rvs[ch], info->sint);
	8531	+ rvsc = info->rvs[ch] + info->scount[ch];
	8532	+ rsc = info->rs[ch] + info->scount[ch];
	8533	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8534	+ for(i = 0; i < count; i += 4)
	8535	+ _mm_storeu_ps(&output[i], _mm_add_ps(_mm_loadu_ps(&rvsc[i]), _mm_loadu_ps(&rsc[i])));
	8536	+#else
	8537	+ for(i = 0; i < count; i++)
	8538	+ output[i] = rvsc[i] + rsc[i];
	8539	+#endif
	8540	+ info->scount[ch] += count;
	8541	+ if(info->scount[ch] == REV_EX2_FRAGSIZE){
	8542	+ const int32 fbyte2 = sizeof(float) * (REV_EX2_FRAGSIZE - 1);
	8543	+ do_reverb_ex2_R2HC(info->fs[ch], info->is[ch], info->sint);
	8544	+ memcpy(info->rs[ch], info->rvs[ch] + REV_EX2_FRAGSIZE, sizeof(float) * (REV_EX2_FRAGSIZE - 1));
	8545	+ info->scount[ch] = 0;
	8546	+ }
	8547	+}
	8548	+
	8549	+static void do_reverb_ex2_fft_process2(int32 count, int32 ch, InfoReverbEX2 *info)
	8550	+{
	8551	+ int32 i, k;
	8552	+ int32 bcount = info->bcount ? 0 : info->bsize;
	8553	+ float *input = info->buf[ch] + bcount;
	8554	+ float *output = info->tbuf[ch];
	8555	+ const int32 fbyte = sizeof(float) * REV_EX2_FRAGSIZE;
	8556	+ const int32 f2byte = sizeof(float) * REV_EX2_FRAGSIZE * 2;
	8557	+ const int32 cbyte = sizeof(float) * count;
	8558	+ const int32 ribyte = sizeof(float) * REV_EX2_FFTSIZE;
	8559	+
	8560	+ memcpy(info->ios[ch] + info->scount[ch] + REV_EX2_FRAGSIZE, input, cbyte);
	8561	+ if((info->scount[ch] + count) >= REV_EX2_FRAGSIZE) {
	8562	+ do_reverb_ex2_R2HC(info->ios[ch] + REV_EX2_FRAGSIZE, info->is[ch], info->sint);
	8563	+ memset(info->ss[ch], 0, ribyte);
	8564	+ for(i = 1; i < info->fnum; i++){
	8565	+ float *bd0 = do_reverb_ex2_delay(info->is[ch], i - 1, info->bd[ch], &info->bdcount[ch], info->fnum);
	8566	+ do_reverb_ex2_mul(bd0, info->fi[ch] + REV_EX2_FFTSIZE * i, info->ss[ch]);
	8567	+ }
	8568	+ do_reverb_ex2_HC2R(info->ss[ch], info->rvs[ch], info->sint);
	8569	+ memcpy(info->ios[ch] + REV_EX2_FRAGSIZE, info->rvs[ch], fbyte);
	8570	+ memcpy(info->rvs[ch], info->rvs[ch] + REV_EX2_FRAGSIZE, fbyte);
	8571	+ memset(info->rvs[ch] + REV_EX2_FRAGSIZE - 1, 0, sizeof(float) * (REV_EX2_FRAGSIZE + 1));
	8572	+ }
	8573	+ memcpy(output, info->ios[ch] + info->scount[ch], cbyte);
	8574	+ info->scount[ch] += count;
	8575	+ if(info->scount[ch] >= REV_EX2_FRAGSIZE) {
	8576	+ memcpy(info->ios[ch], info->ios[ch] + REV_EX2_FRAGSIZE, f2byte);
	8577	+ info->scount[ch] -= REV_EX2_FRAGSIZE;
	8578	+ }
	8579	+ return;
	8580	+}
	8581	+
	8582	+static void do_reverb_ex2_fft_process(int32 count, int32 ch, InfoReverbEX2 *info)
	8583	+{
	8584	+ if(info->fftmode == 1){ // process1
	8585	+ int32 cursor = REV_EX2_FRAGSIZE - info->scount[ch];
	8586	+ if(cursor >= count){
	8587	+ do_reverb_ex2_fft_process1(0, count, ch, info);
	8588	+ }else{
	8589	+ do_reverb_ex2_fft_process1(0, cursor, ch, info);
	8590	+ do_reverb_ex2_fft_process1(cursor, count - cursor, ch, info);
	8591	+ }
	8592	+ }else if(info->fftmode == 2){ // process2
	8593	+ do_reverb_ex2_fft_process2(count, ch, info);
	8594	+ }
	8595	+}
	8596	+
	8597	+static void do_reverb_ex2_fft_rsmode0_in(DATA_T buf, int32 count, InfoReverbEX2 info)
	8598	+{
	8599	+ int32 i, k;
	8600	+ int32 bcount = info->bcount ? info->bsize : 0;
	8601	+ float *ibuf0 = info->buf[0] + bcount;
	8602	+ float *ibuf1 = info->buf[1] + bcount;
	8603	+
7285	8604	#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8605	+ {
	8606	+ const __m128 vcnv = _mm_set1_ps(DIV_31BIT);
7286	8607	for (i = 0, k = 0; i < count; i += 8, k += 4){
7287	8608	__m128 tmp0, tmp1, tmp2, tmp3;
7288		- // in
7289	8609	tmp0 = _mm_cvtpd_ps(_mm_load_pd(&buf[i]));
7290	8610	tmp1 = _mm_cvtpd_ps(_mm_load_pd(&buf[i + 2]));
7291	8611	tmp2 = _mm_cvtpd_ps(_mm_load_pd(&buf[i + 4]));
7292	8612	tmp3 = _mm_cvtpd_ps(_mm_load_pd(&buf[i + 6]));
7293	8613	tmp0 = _mm_shuffle_ps(tmp0, tmp1, 0x44);
7294		- tmp2 = _mm_shuffle_ps(tmp2, tmp3, 0x44);
7295		- _mm_store_ps(&info->tbuf[0][k], _mm_shuffle_ps(tmp0, tmp2, 0x88));
7296		- _mm_store_ps(&info->tbuf[1][k], _mm_shuffle_ps(tmp0, tmp2, 0xdd));
	8614	+ tmp2 = _mm_shuffle_ps(tmp2, tmp3, 0x44);
	8615	+ tmp1 = _mm_shuffle_ps(tmp0, tmp2, 0x88);
	8616	+ tmp3 = _mm_shuffle_ps(tmp0, tmp2, 0xdd);
	8617	+ tmp1 = _mm_mul_ps(tmp1, vcnv);
	8618	+ tmp3 = _mm_mul_ps(tmp3, vcnv);
	8619	+ _mm_store_ps(&ibuf0[k], tmp1);
	8620	+ _mm_store_ps(&ibuf1[k], tmp3);
7297	8621	}
	8622	+ }
7298	8623	#else
7299		- for (i = 0, k = 0; i < count; i++, k++){
7300		- info->tbuf[0][k] = buf[i];
7301		- i++;
7302		- info->tbuf[1][k] = buf[i];
7303		- k++;
	8624	+ {
	8625	+ const FLOAT_T cnv = DIV_31BIT;
	8626	+ for(i = 0, k = 0; i < count; i += 2, k++){
	8627	+ ibuf0[k] = (FLOAT_T)buf[i ] * cnv;
	8628	+ ibuf1[k] = (FLOAT_T)buf[i + 1] * cnv;
7304	8629	}
	8630	+ }
7305	8631	#endif
7306		-#if defined(REV_IR_4T)
7307		- go_effect_sub_thread(do_reverb_ex2_thread, info, 4);
7308		-#else
7309		- go_effect_sub_thread(do_reverb_ex2_thread, info, 2);
7310		-#endif
	8632	+}
	8633	+
	8634	+static void do_reverb_ex2_fft_rsmode1_in(DATA_T buf, int32 count, InfoReverbEX2 info)
	8635	+{
	8636	+ int32 i, k;
	8637	+ int32 bcount = info->bcount ? info->bsize : 0;
	8638	+ float *ibuf0 = info->buf[0] + bcount;
	8639	+ float *ibuf1 = info->buf[1] + bcount;
	8640	+
7311	8641	#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
7312		- for (i = 0, k = 0; i < count; i += 8, k += 4){
7313		- __m128 tmp0, tmp1, tmp2, tmp3;
7314		- // out
7315		- tmp1 = _mm_load_ps(&info->tbuf[2][k]);
7316		- tmp3 = _mm_load_ps(&info->tbuf[3][k]);
7317		- tmp0 = _mm_unpacklo_ps(tmp1, tmp3);
7318		- tmp2 = _mm_unpackhi_ps(tmp1, tmp3);
7319		- _mm_store_pd(&buf[i], _mm_cvtps_pd(tmp0));
7320		- _mm_store_pd(&buf[i + 2], _mm_cvtps_pd(_mm_shuffle_ps(tmp0, tmp0, 0x4e)));
7321		- _mm_store_pd(&buf[i + 4], _mm_cvtps_pd(tmp2));
7322		- _mm_store_pd(&buf[i + 6], _mm_cvtps_pd(_mm_shuffle_ps(tmp2, tmp2, 0x4e)));
	8642	+ {
	8643	+ const __m128 vcvt = _mm_set1_ps(DIV_31BIT * DIV_2);
	8644	+ for(i = 0, k = 0; i < count; i += 16, k += 4){
	8645	+ __m128d vin0 = _mm_load_pd(&buf[i ]);
	8646	+ __m128d vin2 = _mm_load_pd(&buf[i + 2]);
	8647	+ __m128d vin4 = _mm_load_pd(&buf[i + 4]);
	8648	+ __m128d vin6 = _mm_load_pd(&buf[i + 6]);
	8649	+ __m128d vin8 = _mm_load_pd(&buf[i + 8]);
	8650	+ __m128d vin10 = _mm_load_pd(&buf[i + 10]);
	8651	+ __m128d vin12 = _mm_load_pd(&buf[i + 12]);
	8652	+ __m128d vin14 = _mm_load_pd(&buf[i + 14]);
	8653	+ __m128d vt0 = _mm_add_pd(vin0, vin2);
	8654	+ __m128d vt1 = _mm_add_pd(vin4, vin6);
	8655	+ __m128d vt2 = _mm_add_pd(vin8, vin10);
	8656	+ __m128d vt3 = _mm_add_pd(vin12, vin14);
	8657	+ __m128 vo00 = _mm_cvtpd_ps(_mm_shuffle_pd(vt0, vt1, 0x0));
	8658	+ __m128 vo01 = _mm_cvtpd_ps(_mm_shuffle_pd(vt0, vt1, 0x3));
	8659	+ __m128 vo10 = _mm_cvtpd_ps(_mm_shuffle_pd(vt2, vt3, 0x0));
	8660	+ __m128 vo11 = _mm_cvtpd_ps(_mm_shuffle_pd(vt2, vt3, 0x3));
	8661	+ __m128 vo0 = _mm_mul_ps(_mm_shuffle_ps(vo00, vo10, 0x44), vcvt);
	8662	+ __m128 vo1 = _mm_mul_ps(_mm_shuffle_ps(vo01, vo11, 0x44), vcvt);
	8663	+ _mm_store_ps(&ibuf0[k], vo0);
	8664	+ _mm_store_ps(&ibuf1[k], vo1);
7323	8665	}
	8666	+ }
7324	8667	#else
7325		- for (i = 0, k = 0; i < count; i++, k++){
7326		- buf[i] = info->tbuf[2][k];
7327		- i++;
7328		- buf[i] = info->tbuf[3][k];
	8668	+ {
	8669	+ const FLOAT_T cnv = DIV_31BIT * DIV_4;
	8670	+ for(i = 0, k = 0; i < count; i += 8, k++){
	8671	+ ibuf0[k] = (FLOAT_T)(buf[i ] + buf[i + 2] + buf[i + 4] + buf[i + 6]) * cnv;
	8672	+ ibuf1[k] = (FLOAT_T)(buf[i + 1] + buf[i + 3] + buf[i + 5] + buf[i + 7]) * cnv;
7329	8673	}
	8674	+ }
7330	8675	#endif
7331		- return;
	8676	+}
	8677	+
	8678	+static void do_reverb_ex2_fft_rsmode2_in(DATA_T buf, int32 count, InfoReverbEX2 info)
	8679	+{
	8680	+ int32 i, k;
	8681	+ int32 bcount = info->bcount ? info->bsize : 0;
	8682	+ float *ibuf0 = info->buf[0] + bcount;
	8683	+ float *ibuf1 = info->buf[1] + bcount;
	8684	+
	8685	+#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8686	+ {
	8687	+ const __m128d vcvt = _mm_set1_pd(DIV_31BIT * DIV_4);
	8688	+ for(i = 0, k = 0; i < count; i += 16, k += 2){
	8689	+ __m128d vin0 = _mm_load_pd(&buf[i ]);
	8690	+ __m128d vin2 = _mm_load_pd(&buf[i + 2]);
	8691	+ __m128d vin4 = _mm_load_pd(&buf[i + 4]);
	8692	+ __m128d vin6 = _mm_load_pd(&buf[i + 6]);
	8693	+ __m128d vin8 = _mm_load_pd(&buf[i + 8]);
	8694	+ __m128d vin10 = _mm_load_pd(&buf[i + 10]);
	8695	+ __m128d vin12 = _mm_load_pd(&buf[i + 12]);
	8696	+ __m128d vin14 = _mm_load_pd(&buf[i + 14]);
	8697	+ __m128d vt0 = _mm_mul_pd(_mm_add_pd(_mm_add_pd(vin0, vin2), _mm_add_pd(vin4, vin6)), vcvt);
	8698	+ __m128d vt1 = _mm_mul_pd(_mm_add_pd(_mm_add_pd(vin8, vin10), _mm_add_pd(vin12, vin14)), vcvt);
	8699	+ __m128 vo0 = _mm_cvtpd_ps(_mm_shuffle_pd(vt0, vt1, 0x0));
	8700	+ __m128 vo1 = _mm_cvtpd_ps(_mm_shuffle_pd(vt0, vt1, 0x3));
	8701	+ _mm_storel_pi((__m64 *)&ibuf0[k], vo0);
	8702	+ _mm_storel_pi((__m64 *)&ibuf1[k], vo1);
	8703	+ }
	8704	+ }
	8705	+#else
	8706	+ {
	8707	+ const FLOAT_T cnv = DIV_31BIT * DIV_4;
	8708	+ for(i = 0, k = 0; i < count; i += 8, k++){
	8709	+ ibuf0[k] = (FLOAT_T)(buf[i ] + buf[i + 2] + buf[i + 4] + buf[i + 6]) * cnv;
	8710	+ ibuf1[k] = (FLOAT_T)(buf[i + 1] + buf[i + 3] + buf[i + 5] + buf[i + 7]) * cnv;
	8711	+ }
7332	8712	}
	8713	+#endif
	8714	+}
	8715	+
	8716	+static void do_reverb_ex2_fft_rsmode3_in(DATA_T buf, int32 count, InfoReverbEX2 info)
	8717	+{
	8718	+ int32 i, k;
	8719	+ int32 bcount = info->bcount ? info->bsize : 0;
	8720	+ float *ibuf0 = info->buf[0] + bcount;
	8721	+ float *ibuf1 = info->buf[1] + bcount;
7333	8722
7334	8723	#if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
7335		-// 2set/1ch
7336		- for (i = 0; i < count; i += 4){
7337		- __m128 sumL1 = _mm_setzero_ps();
7338		- __m128 sumR1 = _mm_setzero_ps();
7339		- __m128 sumL2 = _mm_setzero_ps();
7340		- __m128 sumR2 = _mm_setzero_ps();
7341		- __m128 tmp0, tmp2, tmp1, tmp3, vir0, vir1;
7342		- __m128 sum0, sum1, sum2, sum3;
7343		- int32 w1, w2;
7344		-
7345		- w1 = info->wcount;
7346		- --info->wcount;
7347		- if(info->wcount < 0)
7348		- info->wcount += info->frame;
7349		- w2 = info->wcount;
7350		- --info->wcount;
7351		- if(info->wcount < 0)
7352		- info->wcount += info->frame;
7353		- info->buf[0][w1] = buf[i];
7354		- info->buf[1][w1] = buf[i + 1];
7355		- info->buf[0][w1 + info->frame] = buf[i];
7356		- info->buf[1][w1 + info->frame] = buf[i + 1];
7357		- info->buf[0][w2] = buf[i + 2];
7358		- info->buf[1][w2] = buf[i + 3];
7359		- info->buf[0][w2 + info->frame] = buf[i + 2];
7360		- info->buf[1][w2 + info->frame] = buf[i + 3];
7361		- // FMAループの最後のw1w2重複部分は事前にirdata最後に0を追加することで回避
7362		- for (k = 0; k < info->frame; k += 4){
7363		- int32 r1 = w1 + k;
7364		- int32 r2 = w2 + k;
7365		- __m128 vir0 = _mm_load_ps(&info->irdata[0][k]);
7366		- __m128 vir1 = _mm_load_ps(&info->irdata[1][k]);
7367		- sumL1 = MM_FMA_PS(_mm_loadu_ps(&info->buf[0][r1]), vir0, sumL1);
7368		- sumR1 = MM_FMA_PS(_mm_loadu_ps(&info->buf[1][r1]), vir1, sumR1);
7369		- sumL2 = MM_FMA_PS(_mm_loadu_ps(&info->buf[0][r2]), vir0, sumL2);
7370		- sumR2 = MM_FMA_PS(_mm_loadu_ps(&info->buf[1][r2]), vir1, sumR2);
7371		- }
7372		- // sumL1 v0,v1,v2,v3 // sumR1 v4,v5,v6,v7 // sumL2 v8,v9,v10,v11 // sumR3 v12,v13,v14,v15
7373		- tmp0 = _mm_shuffle_ps(sumL1, sumR1, 0x44); // v0,v1,v4,v5
7374		- tmp2 = _mm_shuffle_ps(sumL1, sumR1, 0xEE); // v2,v3,v6,v7
7375		- tmp1 = _mm_shuffle_ps(sumL2, sumR2, 0x44); // v8,v9,v12,v13
7376		- tmp3 = _mm_shuffle_ps(sumL2, sumR2, 0xEE); // v10,v11,v14,v15
7377		- sum0 = _mm_shuffle_ps(tmp0, tmp1, 0x88); // v0,v4,v8,v12
7378		- sum1 = _mm_shuffle_ps(tmp0, tmp1, 0xDD); // v1,v5,v9,v13
7379		- sum2 = _mm_shuffle_ps(tmp2, tmp3, 0x88); // v2,v6,v10,v14
7380		- sum3 = _mm_shuffle_ps(tmp2, tmp3, 0xDD); // v3,v7,v11,v15
7381		- sum0 = _mm_add_ps(sum0, sum1);
7382		- sum2 = _mm_add_ps(sum2, sum3);
7383		- sum0 = _mm_add_ps(sum0, sum2); // v0123,v4567,v89AB,vCDEF
7384		- sum1 = _mm_shuffle_ps(sum0, sum0, 0x4e);
7385		- _mm_store_pd(&buf[i], _mm_cvtps_pd(sum0));
7386		- _mm_store_pd(&buf[i + 2], _mm_cvtps_pd(sum1));
	8724	+ {
	8725	+ const __m128d vcvt = _mm_set1_pd(DIV_31BIT * DIV_8);
	8726	+ for(i = 0, k = 0; i < count; i += 16, k++){
	8727	+#if (USE_X86_EXT_INTRIN >= 9)
	8728	+ __m256d yvin0 = _mm256_load_pd(&buf[i ]);
	8729	+ __m256d yvin4 = _mm256_load_pd(&buf[i + 4]);
	8730	+ __m256d yvin8 = _mm256_load_pd(&buf[i + 8]);
	8731	+ __m256d yvin12 = _mm256_load_pd(&buf[i + 12]);
	8732	+ __m256d yvt = _mm256_add_pd(_mm256_add_pd(yvin0, yvin4), _mm256_add_pd(yvin8, yvin12));
	8733	+ __m128d vt = _mm_mul_pd(_mm_add_pd(
	8734	+ _mm256_extractf128_pd(yvt, 0x0), _mm256_extractf128_pd(yvt, 0x1)
	8735	+ ), vcvt);
	8736	+#else
	8737	+ __m128d vin0 = _mm_load_pd(&buf[i ]);
	8738	+ __m128d vin2 = _mm_load_pd(&buf[i + 2]);
	8739	+ __m128d vin4 = _mm_load_pd(&buf[i + 4]);
	8740	+ __m128d vin6 = _mm_load_pd(&buf[i + 6]);
	8741	+ __m128d vin8 = _mm_load_pd(&buf[i + 8]);
	8742	+ __m128d vin10 = _mm_load_pd(&buf[i + 10]);
	8743	+ __m128d vin12 = _mm_load_pd(&buf[i + 12]);
	8744	+ __m128d vin14 = _mm_load_pd(&buf[i + 14]);
	8745	+ __m128d vt = _mm_mul_pd(_mm_add_pd(
	8746	+ _mm_add_pd(_mm_add_pd(vin0, vin2), _mm_add_pd(vin4, vin6)),
	8747	+ _mm_add_pd(_mm_add_pd(vin8, vin10), _mm_add_pd(vin12, vin14))
	8748	+ ), vcvt);
	8749	+#endif
	8750	+ __m128 vo = _mm_cvtpd_ps(vt);
	8751	+ ibuf0[k] = MM_EXTRACT_F32(vo, 0);
	8752	+ ibuf1[k] = MM_EXTRACT_F32(vo, 1);
	8753	+ }
7387	8754	}
7388	8755	#else
7389		- for (i = 0; i < count; i++){
7390		- float sumL = 0, sumR = 0;
7391		- int32 w = info->wcount;
7392		- --info->wcount;
7393		- if(info->wcount < 0)
7394		- info->wcount += info->frame;
7395		- info->buf[0][w] = buf[i];
7396		- info->buf[1][w] = buf[i + 1];
7397		- info->buf[0][w + info->frame] = buf[i];
7398		- info->buf[1][w + info->frame] = buf[i + 1];
7399		- for (k = 0; k < info->frame; k++){
7400		- int32 r = w + k;
7401		- sumL += info->buf[0][r] * info->irdata[0][k];
7402		- sumR += info->buf[1][r] * info->irdata[1][k];
7403		- }
7404		- buf[i] = sumL;
7405		- i++;
7406		- buf[i] = sumR;
	8756	+ {
	8757	+ const FLOAT_T cnv = DIV_31BIT * DIV_8;
	8758	+ for(i = 0, k = 0; i < count; i += 16, k++){
	8759	+ ibuf0[k] = (FLOAT_T)(
	8760	+ buf[i ] + buf[i + 2] + buf[i + 4] + buf[i + 6] +
	8761	+ buf[i + 8] + buf[i + 10] + buf[i + 12] + buf[i + 14]
	8762	+ ) * cnv;
	8763	+ ibuf1[k] = (FLOAT_T)(
	8764	+ buf[i + 1] + buf[i + 3] + buf[i + 5] + buf[i + 7] +
	8765	+ buf[i + 9] + buf[i + 11] + buf[i + 13] + buf[i + 15]
	8766	+ ) * cnv;
	8767	+ }
	8768	+ }
	8769	+#endif
	8770	+}
	8771	+
	8772	+static void do_reverb_ex2_fft_pre_process(DATA_T buf, int32 count, InfoReverbEX2 info)
	8773	+{
	8774	+ switch(info->rsmode){
	8775	+ case 0: do_reverb_ex2_fft_rsmode0_in(buf, count, info); break;
	8776	+ case 1: do_reverb_ex2_fft_rsmode1_in(buf, count, info); break;
	8777	+ case 2: do_reverb_ex2_fft_rsmode2_in(buf, count, info); break;
	8778	+ case 3: do_reverb_ex2_fft_rsmode3_in(buf, count, info); break;
7407	8779	}
	8780	+}
	8781	+
	8782	+#if defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8783	+static void do_reverb_ex2_fft_thread(int thread_num, void *info2)
	8784	+{
	8785	+ InfoReverbEX2 info = (InfoReverbEX2 )info2;
	8786	+
	8787	+ if(thread_num >= (info->thread + info->ithread))
	8788	+ return;
	8789	+ if(info->ithread){
	8790	+ if(thread_num == info->thread){
	8791	+ do_reverb_ex2_fft_pre_process(info->ptr, info->count, info);
	8792	+ return;
	8793	+ }
	8794	+ }else if(thread_num == 0){
	8795	+ do_reverb_ex2_fft_pre_process(info->ptr, info->count, info);
	8796	+ }
	8797	+ do_reverb_ex2_fft_process(info->tcount, thread_num, info);
	8798	+}
	8799	+#endif
	8800	+
	8801	+static void do_reverb_ex2_fft(DATA_T buf, int32 count, InfoReverbEX2 info)
	8802	+{
	8803	+ int32 i, k;
	8804	+
	8805	+ info->ptr = buf;
	8806	+ info->count = count;
	8807	+ info->tcount = count >> (1 + info->rsmode);
	8808	+#if defined(MULTI_THREAD_COMPUTE2) && defined(DATA_T_DOUBLE) && defined(FLOAT_T_DOUBLE)
	8809	+ if(info->thread){
	8810	+ go_effect_sub_thread(do_reverb_ex2_thread, info, info->thread + info->ithread);
	8811	+ }else
7408	8812	#endif
	8813	+ {
	8814	+ do_reverb_ex2_fft_pre_process(buf, count, info);
	8815	+ do_reverb_ex2_fft_process(info->tcount, 0, info);
	8816	+ do_reverb_ex2_fft_process(info->tcount, 1, info);
	8817	+ }
	8818	+ info->bcount = 1 - info->bcount;
	8819	+ do_reverb_ex2_post_process(buf, count, info);
7409	8820	}
7410	8821
7411	8822	#endif
7412	8823
7413	8824
7414	8825
	8826	+
7415	8827	/* */
7416	8828	/* Plate Reverberator */
7417	8829	/* */

		@@ -17325,76 +18737,15 @@ static void CALLINGCONV do_ch_reverb_ex(DATA_T *buf, int32 count, struct reverb_
17325	18737	do_reverb_ex(buf, count, info);
17326	18738	}
17327	18739
17328		-#ifdef REV_EX2
17329	18740	static void setup_ch_reverb_ex2(InfoReverbEX2 *info)
17330	18741	{
17331	18742	info->mode = CH_STEREO;
17332		-
17333		- switch(reverb_status_gs.character){
17334		- case 0: // room1
17335		- info->height = 3.0; // m
17336		- info->width = 5.0; // m
17337		- info->depth = 7.0; // m
17338		- info->rev_damp_freq = 17000.0; // Hz
17339		- info->rev_damp_type = FILTER_LPF6;
17340		- info->rev_damp_bal = 0.5;
17341		- info->er_level = 0.50;
17342		- info->rev_level = 0.50;
17343		- info->density = 1.0;
17344		- break;
17345		- case 1: // room2
17346		- info->height = 4.0; // m
17347		- info->width = 8.0; // m
17348		- info->depth = 10.0; // m
17349		- info->rev_damp_freq = 15000.0; // Hz
17350		- info->rev_damp_type = FILTER_LPF6;
17351		- info->rev_damp_bal = 0.85;
17352		- info->er_level = 0.45;
17353		- info->rev_level = 0.55;
17354		- info->density = 0.75;
17355		- break;
17356		- case 2: // room3
17357		- info->height = 8.0; // m
17358		- info->width = 12.0; // m
17359		- info->depth = 15.0; // m
17360		- info->rev_damp_freq = 13000.0; // Hz
17361		- info->rev_damp_type = FILTER_LPF6;
17362		- info->rev_damp_bal = 1.0;
17363		- info->er_level = 0.55;
17364		- info->rev_level = 0.45;
17365		- break;
17366		- case 3: // hall1
17367		- info->height = 12.0; // m
17368		- info->width = 14.0; // m
17369		- info->depth = 20.0; // m
17370		- info->rev_damp_freq = 11000.0; // Hz
17371		- info->rev_damp_type = FILTER_LPF6x2;
17372		- info->rev_damp_bal = 0.75;
17373		- info->er_level = 0.50;
17374		- info->rev_level = 0.50;
17375		- info->density = 1.0;
17376		- break;
17377		- default:
17378		- case 4: // hall2
17379		- info->height = 16.0; // m
17380		- info->width = 18.0; // m
17381		- info->depth = 31.0; // m
17382		- info->rev_damp_freq = 9000.0; // Hz
17383		- info->rev_damp_type = FILTER_LPF6x2;
17384		- info->rev_damp_bal = 0.95;
17385		- info->er_level = 0.45;
17386		- info->rev_level = 0.55;
17387		- info->density = 0.75;
17388		- break;
17389		- }
	18743	+ info->revtype = clip_int(reverb_status_gs.character, 0, 5);
17390	18744	info->er_time_ms = reverb_status_gs.pre_delay_time;
17391	18745	info->er_damp_freq = HF_damp_freq_table_gs[0x7F];
17392	18746	info->rev_time_sec = reverb_time_table[reverb_status_gs.time];
17393	18747	info->rev_feedback = 0.0; // reverb_status_gs.delay_feedback
17394		- info->density = 1.0;
17395	18748	info->level = calc_gs_level(reverb_status_gs.level);
17396		- info->er_level *= info->level;
17397		- info->rev_level *= info->level;
17398	18749	}
17399	18750
17400	18751	static void CALLINGCONV do_ch_reverb_ex2(DATA_T buf, int32 count, struct reverb_status_gs_t rs)

		@@ -17410,9 +18761,6 @@ static void CALLINGCONV do_ch_reverb_ex2(DATA_T *buf, int32 count, struct reverb
17410	18761	}
17411	18762	do_reverb_ex2(buf, count, info);
17412	18763	}
17413		-#else
17414		-#define do_ch_reverb_ex2 do_ch_reverb_ex
17415		-#endif
17416	18764
17417	18765
17418	18766	#define REVERB_DELAY_TIME_MAX (500.0) // ms // def 476.25 ?

		@@ -17526,7 +18874,11 @@ void init_ch_reverb(void)
17526	18874	/* Old non-freeverb must be initialized for mono reverb not to crash */
17527	18875	switch(reverb_status_gs.character) { /* select reverb algorithm */
17528	18876	case 5: /* Plate Reverb */
17529		- p_do_ch_reverb = do_ch_plate_reverb;
	18877	+ if (opt_reverb_control >= 7 && opt_reverb_control < 9
	18878	+ \|\| opt_reverb_control <= -768 && opt_reverb_control > 1024)
	18879	+ p_do_ch_reverb = do_ch_reverb_ex2;
	18880	+ else
	18881	+ p_do_ch_reverb = do_ch_plate_reverb;
17530	18882	// REV_INP_LEV = reverb_status_gs.info_plate_reverb.wet;
17531	18883	break;
17532	18884	case 6: /* Delay */

		@@ -20968,87 +22320,7 @@ static void conv_gs_reverb(struct insertion_effect_gs_t st, EffectList ef)
20968	22320	Info_GS_Reverb info = (Info_GS_Reverb )ef->info;
20969	22321	InfoFreeverb *rvb = &info->rvb;
20970	22322	InfoReverbEX *rvb2 = &info->rvb2;
20971		-#ifdef REV_EX2
20972		- InfoReverbEX2 *rvb3 = &info->rvb3;
20973		-#endif
20974	22323
20975		-#ifdef REV_EX2
20976		- if((opt_reverb_control >= 7 && opt_reverb_control < 9) \|\| (opt_reverb_control <= -768 && opt_reverb_control > -1024)){
20977		- info->rev_type = 2; // reverb ex2
20978		- rvb3->mode = CH_MIX_STEREO;
20979		- switch(clip_int(st->parameter[0], 0x00, 0x05)){
20980		- case 0: // room1
20981		- rvb3->height = 3.0; // m
20982		- rvb3->width = 5.0; // m
20983		- rvb3->depth = 7.0; // m
20984		- rvb3->rev_damp_type = FILTER_LPF6;
20985		- rvb3->rev_damp_bal = 0.65;
20986		- rvb3->er_level = 0.50;
20987		- rvb3->rev_level = 0.50;
20988		- rvb3->density = 1.0;
20989		- break;
20990		- case 1: // room2
20991		- rvb3->height = 4.0; // m
20992		- rvb3->width = 8.0; // m
20993		- rvb3->depth = 10.0; // m
20994		- rvb3->rev_damp_type = FILTER_LPF6;
20995		- rvb3->rev_damp_bal = 0.99;
20996		- rvb3->er_level = 0.45;
20997		- rvb3->rev_level = 0.55;
20998		- rvb3->density = 0.75;
20999		- break;
21000		- case 2: // stage1
21001		- rvb3->height = 10.0; // m
21002		- rvb3->width = 12.0; // m
21003		- rvb3->depth = 15.0; // m
21004		- rvb3->rev_damp_type = FILTER_LPF6;
21005		- rvb3->rev_damp_bal = 0.85;
21006		- rvb3->er_level = 0.40;
21007		- rvb3->rev_level = 0.60;
21008		- rvb3->density = 0.75;
21009		- break;
21010		- case 3: // stage2
21011		- rvb3->height = 12.0; // m
21012		- rvb3->width = 13.0; // m
21013		- rvb3->depth = 18.0; // m
21014		- rvb3->rev_damp_type = FILTER_LPF6;
21015		- rvb3->rev_damp_bal = 0.95;
21016		- rvb3->er_level = 0.60;
21017		- rvb3->rev_level = 0.40;
21018		- rvb3->density = 1.0;
21019		- break;
21020		- case 4: // hall1
21021		- rvb3->height = 12.0; // m
21022		- rvb3->width = 16.0; // m
21023		- rvb3->depth = 20.0; // m
21024		- rvb3->rev_damp_type = FILTER_LPF6;
21025		- rvb3->rev_damp_bal = 0.65;
21026		- rvb3->er_level = 0.50;
21027		- rvb3->rev_level = 0.50;
21028		- rvb3->density = 1.0;
21029		- break;
21030		- default:
21031		- case 5: // hall2
21032		- rvb3->height = 16.0; // m
21033		- rvb3->width = 20.0; // m
21034		- rvb3->depth = 31.0; // m
21035		- rvb3->rev_damp_type = FILTER_LPF6;
21036		- rvb3->rev_damp_bal = 0.95;
21037		- rvb3->er_level = 0.45;
21038		- rvb3->rev_level = 0.55;
21039		- rvb3->density = 0.75;
21040		- break;
21041		- }
21042		- rvb3->er_time_ms = pre_delay_time_table[st->parameter[1]];
21043		- rvb3->rev_time_sec = reverb_time_table[st->parameter[2]];
21044		- rvb3->rev_damp_freq = HF_damp_freq_table_gs[st->parameter[3]];
21045		- rvb3->er_damp_freq = HF_damp_freq_table_gs[st->parameter[3]];
21046		- rvb3->rev_feedback = 0.0; // reverb_status_gs.delay_feedback
21047		- rvb3->rev_dly_ms = 0;
21048		- rvb3->density = 1.0;
21049		- rvb3->level = 1.0;
21050		- }else
21051		-#endif
21052	22324	if(otd.efx_CustomRevType){
21053	22325	info->rev_type = 1; // reverb ex
21054	22326	rvb2->mode = CH_MIX_STEREO;

		@@ -21151,16 +22423,8 @@ static void do_gs_reverb(DATA_T buf, int32 count, EffectList ef)
21151	22423	Info_GS_Reverb info = (Info_GS_Reverb )ef->info;
21152	22424	InfoFreeverb *rvb = &info->rvb;
21153	22425	InfoReverbEX *rvb2 = &info->rvb2;
21154		-#ifdef REV_EX2
21155		- InfoReverbEX2 *rvb3 = &info->rvb3;
21156		-#endif
21157	22426
21158	22427	send_efx_buffer(ef, buf, count);
21159		-#ifdef REV_EX2
21160		- if(info->rev_type == 2)
21161		- do_reverb_ex2(ef->efx_buf, count, rvb3);
21162		- else
21163		-#endif
21164	22428	if(info->rev_type)
21165	22429	do_reverb_ex(ef->efx_buf, count, rvb2);
21166	22430	else

		@@ -23401,57 +24665,56 @@ static double ins_xg_revchar_to_rt(struct effect_xg_t *st)
23401	24665
23402	24666	static void conv_xg_reverb1(struct effect_xg_t st, EffectList ef)
23403	24667	{
23404		- Info_XG_Reverb1 info = (Info_XG_Reverb1 )ef->info;
	24668	+ Info_XG_Reverb1 info = (Info_XG_Reverb1 )ef->info;
	24669	+ InfoStandardReverb *rvb0 = &info->rvb0;
23405	24670	InfoFreeverb *rvb = &info->rvb;
23406	24671	InfoReverbEX *rvb2 = &info->rvb2;
23407		-#ifdef REV_EX2
23408	24672	InfoReverbEX2 *rvb3 = &info->rvb3;
23409		-#endif
23410	24673	InfoPreFilter *bpf = &info->bpf;
23411	24674
23412	24675	bpf->freqH = eq_freq_table_xg[clip_int(st->param_lsb[3], 0x00, 0x34)];
23413	24676	bpf->freqL = eq_freq_table_xg[clip_int(st->param_lsb[4], 0x22, 0x3C)];
23414	24677	init_pre_bpf(bpf);
23415	24678
23416		-#ifdef REV_EX2
23417		- if((opt_reverb_control >= 7 && opt_reverb_control < 9) \|\| (opt_reverb_control <= -768 && opt_reverb_control > -1024)){
23418		- info->rev_type = 2; // reverb ex2
	24679	+ if(st->connection == XG_CONN_SYSTEM_REVERB){
	24680	+ if((opt_reverb_control >= 7 && opt_reverb_control < 9) \|\|
	24681	+ (opt_reverb_control <= -768 && opt_reverb_control > -1024)){
	24682	+ info->rev_type = 3; // reverb ex2
	24683	+ }else if((opt_reverb_control >= 5 && opt_reverb_control < 7) \|\|
	24684	+ (opt_reverb_control <= -512 && opt_reverb_control > -768)){
	24685	+ info->rev_type = 2; // reverb ex
	24686	+ }else if((opt_reverb_control >= 3 && opt_reverb_control < 5) \|\|
	24687	+ (opt_reverb_control <= -256 && opt_reverb_control > -512)){
	24688	+ info->rev_type = 1; // freeverb
	24689	+ }else
	24690	+ info->rev_type = 0; // standerd reverb
	24691	+ }else{
	24692	+ if(otd.efx_CustomRevType)
	24693	+ info->rev_type = 2;
	24694	+ else
	24695	+ info->rev_type = 1;
	24696	+ }
	24697	+ if(info->rev_type == 3){
23419	24698	if(st->connection == XG_CONN_SYSTEM_REVERB){
23420	24699	rvb3->mode = CH_STEREO;
23421	24700	}else{
23422	24701	rvb3->mode = CH_MIX_STEREO;
23423		- }
	24702	+ }
23424	24703	switch(st->type_msb) {
23425	24704	case 0x01:
23426	24705	switch(st->type_lsb) {
23427	24706	default:
23428	24707	case 0x00:/* Hall 1 */
23429		- rvb3->height = 12.0; // m
23430		- rvb3->width = 14.0; // m
23431		- rvb3->depth = 20.0; // m
23432		- rvb3->rev_damp_type = FILTER_LPF6;
23433		- rvb3->rev_damp_bal = 0.75;
	24708	+ rvb3->revtype = 6;
23434	24709	break;
23435	24710	case 0x01:/* Hall 2 */
23436		- rvb3->height = 16.0; // m
23437		- rvb3->width = 18.0; // m
23438		- rvb3->depth = 27.0; // m
23439		- rvb3->rev_damp_type = FILTER_LPF6;
23440		- rvb3->rev_damp_bal = 0.95;
	24711	+ rvb3->revtype = 7;
23441	24712	break;
23442	24713	case 0x06:/* Hall M */
23443		- rvb3->height = 12.0; // m
23444		- rvb3->width = 16.0; // m
23445		- rvb3->depth = 23.0; // m
23446		- rvb3->rev_damp_type = FILTER_LPF6;
23447		- rvb3->rev_damp_bal = 0.85;
	24714	+ rvb3->revtype = 8;
23448	24715	break;
23449	24716	case 0x07:/* Hall L */
23450		- rvb3->height = 18.0; // m
23451		- rvb3->width = 21.0; // m
23452		- rvb3->depth = 30.0; // m
23453		- rvb3->rev_damp_type = FILTER_LPF6;
23454		- rvb3->rev_damp_bal = 0.85;
	24717	+ rvb3->revtype = 9;
23455	24718	break;
23456	24719	}
23457	24720	break;

		@@ -23459,46 +24722,22 @@ static void conv_xg_reverb1(struct effect_xg_t st, EffectList ef)
23459	24722	switch(st->type_lsb) {
23460	24723	default:
23461	24724	case 0x00:/* Room 1 */
23462		- rvb3->height = 3.0; // m
23463		- rvb3->width = 5.0; // m
23464		- rvb3->depth = 7.0; // m
23465		- rvb3->rev_damp_type = FILTER_LPF6;
23466		- rvb3->rev_damp_bal = 0.5;
	24725	+ rvb3->revtype = 10;
23467	24726	break;
23468	24727	case 0x01:/* Room 2 */
23469		- rvb3->height = 4.0; // m
23470		- rvb3->width = 8.0; // m
23471		- rvb3->depth = 10.0; // m
23472		- rvb3->rev_damp_type = FILTER_LPF6;
23473		- rvb3->rev_damp_bal = 0.75;
	24728	+ rvb3->revtype = 11;
23474	24729	break;
23475	24730	case 0x02:/* Room 3 */
23476		- rvb3->height = 5.0; // m
23477		- rvb3->width = 12.0; // m
23478		- rvb3->depth = 15.0; // m
23479		- rvb3->rev_damp_type = FILTER_LPF6;
23480		- rvb3->rev_damp_bal = 0.95;
	24731	+ rvb3->revtype = 12;
23481	24732	break;
23482	24733	case 0x05:/* Room S */
23483		- rvb3->height = 3.0; // m
23484		- rvb3->width = 4.0; // m
23485		- rvb3->depth = 5.0; // m
23486		- rvb3->rev_damp_type = FILTER_LPF6;
23487		- rvb3->rev_damp_bal = 0.45;
	24734	+ rvb3->revtype = 13;
23488	24735	break;
23489	24736	case 0x06:/* Room M */
23490		- rvb3->height = 4.0; // m
23491		- rvb3->width = 8.0; // m
23492		- rvb3->depth = 10.0; // m
23493		- rvb3->rev_damp_type = FILTER_LPF6;
23494		- rvb3->rev_damp_bal = 0.80;
	24737	+ rvb3->revtype = 14;
23495	24738	break;
23496	24739	case 0x07:/* Room L */
23497		- rvb3->height = 5.0; // m
23498		- rvb3->width = 12.0; // m
23499		- rvb3->depth = 15.0; // m
23500		- rvb3->rev_damp_type = FILTER_LPF6;
23501		- rvb3->rev_damp_bal = 0.98;
	24740	+ rvb3->revtype = 15;
23502	24741	break;
23503	24742	}
23504	24743	break;

		@@ -23506,37 +24745,21 @@ static void conv_xg_reverb1(struct effect_xg_t st, EffectList ef)
23506	24745	switch(st->type_lsb) {
23507	24746	default:
23508	24747	case 0x00:/* Stage 1 */
23509		- rvb3->height = 10.0; // m
23510		- rvb3->width = 12.0; // m
23511		- rvb3->depth = 15.0; // m
23512		- rvb3->rev_damp_type = FILTER_LPF6;
23513		- rvb3->rev_damp_bal = 0.85;
	24748	+ rvb3->revtype = 16;
23514	24749	break;
23515	24750	case 0x01:/* Stage 2 */
23516		- rvb3->height = 12.0; // m
23517		- rvb3->width = 13.0; // m
23518		- rvb3->depth = 18.0; // m
23519		- rvb3->rev_damp_type = FILTER_LPF6;
23520		- rvb3->rev_damp_bal = 0.95;
	24751	+ rvb3->revtype = 17;
23521	24752	break;
23522	24753	}
23523	24754	break;
23524	24755	}
23525	24756	rvb3->rev_time_sec = reverb_time_table_xg[clip_int(st->param_lsb[0], 0x00, 0x45)];
23526		- // rvb3->rev_dif = 0.5 * (10 + clip_int(st->param_lsb[1], 0x00, 0x0a)) * DIV_20;
23527	24757	rvb3->er_time_ms = delay_time_table_xg[clip_int(st->param_lsb[2], 0x00, 0x3F)];
23528	24758	rvb3->rev_dly_ms = delay_time_table_xg[clip_int(st->param_lsb[10], 0x00, 0x3F)];
23529		- rvb3->density = (double)clip_int(st->param_lsb[11], 0x00, 0x04) * DIV_4;
23530		- rvb3->er_level = calc_option_level(clip_int(st->param_lsb[12], 0x01, 0x7F));
23531		- rvb3->rev_level = calc_option_level(127 - clip_int(st->param_lsb[12], 0x01, 0x7F));
23532		- rvb3->rev_damp_freq = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10 * 22000.0;
23533	24759	rvb3->er_damp_freq = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10 * 22000.0;
23534	24760	rvb3->rev_feedback = (double)(clip_int(st->param_lsb[14], 0x01, 0x7F) - 0x40) * DIV_127; //0.125;
23535	24761	rvb3->level = 1.0;
23536		- }else
23537		-#endif
23538		- if(otd.efx_CustomRevType){
23539		- info->rev_type = 1; // reverb ex
	24762	+ }else if(info->rev_type == 2){
23540	24763	if(st->connection == XG_CONN_SYSTEM_REVERB){
23541	24764	rvb2->mode = CH_STEREO;
23542	24765	}else{

		@@ -23643,39 +24866,100 @@ static void conv_xg_reverb1(struct effect_xg_t st, EffectList ef)
23643	24866	}
23644	24867	break;
23645	24868	}
23646		- rvb2->rev_time_sec = reverb_time_table_xg[clip_int(st->param_lsb[0], 0x00, 0x45)];
23647		- // rvb2->rev_dif = 0.5 * (10 + clip_int(st->param_lsb[1], 0x00, 0x0a)) * DIV_20;
23648		- rvb2->er_time_ms = delay_time_table_xg[clip_int(st->param_lsb[2], 0x00, 0x3F)];
23649		- rvb2->rev_dly_ms = delay_time_table_xg[clip_int(st->param_lsb[10], 0x00, 0x3F)];
23650		- rvb2->density = (double)clip_int(st->param_lsb[11], 0x00, 0x04) * DIV_4;
23651		- rvb2->er_level = calc_option_level(clip_int(st->param_lsb[12], 0x01, 0x7F));
23652		- rvb2->rev_level = calc_option_level(127 - clip_int(st->param_lsb[12], 0x01, 0x7F));
23653		- rvb2->rev_damp_freq = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10 * 22000.0;
23654		- rvb2->er_damp_freq = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10 * 22000.0;
23655		- rvb2->rev_feedback = (double)(clip_int(st->param_lsb[14], 0x01, 0x7F) - 0x40) * DIV_127; //0.125;
23656		- rvb2->level = 1.0;
23657		- }else{
23658		-// freeverb
23659		- info->rev_type = 0;
23660		- if(st->connection == XG_CONN_SYSTEM_REVERB){
23661		- rvb->mode = CH_STEREO;
23662		- }else{
23663		- rvb->mode = CH_MIX_STEREO;
23664		- }
23665		- rvb->rev_time_sec = reverb_time_table_xg[clip_int(st->param_lsb[0], 0x00, 0x45)];
23666		- rvb->rev_dif = 0.5 * (10 + clip_int(st->param_lsb[1], 0x00, 0x0a)) * DIV_20;
23667		- rvb->er_time_ms = delay_time_table_xg[clip_int(st->param_lsb[2], 0x00, 0x3F)];
23668		- rvb->rev_dly_ms = delay_time_table_xg[clip_int(st->param_lsb[10], 0x00, 0x3F)];
23669		- // rvb->density = clip_int(st->param_lsb[11], 0x00, 0x04);
23670		- rvb->er_level = calc_option_level(clip_int(st->param_lsb[12], 0x01, 0x7F));
23671		- rvb->rev_level = calc_option_level(127 - clip_int(st->param_lsb[12], 0x01, 0x7F));
23672		- rvb->rev_damp = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10; // initialdamp;
23673		- rvb->er_damp_freq = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10 * 22000.0;
23674		- rvb->rev_feedback = (double)(clip_int(st->param_lsb[14], 0x01, 0x7F) - 0x40) * DIV_127; //0.125;
23675		- rvb->rev_rt = ins_xg_revchar_to_rt(st);
23676		- rvb->rev_roomsize = ins_xg_revchar_to_roomsize(st);
23677		- rvb->rev_wet = ins_xg_revchar_to_level(st);
23678		- rvb->rev_width = initialwidth;
	24869	+ rvb2->rev_time_sec = reverb_time_table_xg[clip_int(st->param_lsb[0], 0x00, 0x45)];
	24870	+ // rvb2->rev_dif = 0.5 * (10 + clip_int(st->param_lsb[1], 0x00, 0x0a)) * DIV_20;
	24871	+ rvb2->er_time_ms = delay_time_table_xg[clip_int(st->param_lsb[2], 0x00, 0x3F)];
	24872	+ rvb2->rev_dly_ms = delay_time_table_xg[clip_int(st->param_lsb[10], 0x00, 0x3F)];
	24873	+ rvb2->density = (double)clip_int(st->param_lsb[11], 0x00, 0x04) * DIV_4;
	24874	+ rvb2->er_level = calc_option_level(clip_int(st->param_lsb[12], 0x01, 0x7F));
	24875	+ rvb2->rev_level = calc_option_level(127 - clip_int(st->param_lsb[12], 0x01, 0x7F));
	24876	+ rvb2->rev_damp_freq = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10 * 22000.0;
	24877	+ rvb2->er_damp_freq = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10 * 22000.0;
	24878	+ rvb2->rev_feedback = (double)(clip_int(st->param_lsb[14], 0x01, 0x7F) - 0x40) * DIV_127; //0.125;
	24879	+ rvb2->level = 1.0;
	24880	+ }else if(info->rev_type == 1){
	24881	+// freeverb
	24882	+ if(st->connection == XG_CONN_SYSTEM_REVERB){
	24883	+ rvb->mode = CH_STEREO;
	24884	+ }else{
	24885	+ rvb->mode = CH_MIX_STEREO;
	24886	+ }
	24887	+ rvb->rev_time_sec = reverb_time_table_xg[clip_int(st->param_lsb[0], 0x00, 0x45)];
	24888	+ rvb->rev_dif = 0.5 * (10 + clip_int(st->param_lsb[1], 0x00, 0x0a)) * DIV_20;
	24889	+ rvb->er_time_ms = delay_time_table_xg[clip_int(st->param_lsb[2], 0x00, 0x3F)];
	24890	+ rvb->rev_dly_ms = delay_time_table_xg[clip_int(st->param_lsb[10], 0x00, 0x3F)];
	24891	+ // rvb->density = clip_int(st->param_lsb[11], 0x00, 0x04);
	24892	+ rvb->er_level = calc_option_level(clip_int(st->param_lsb[12], 0x01, 0x7F));
	24893	+ rvb->rev_level = calc_option_level(127 - clip_int(st->param_lsb[12], 0x01, 0x7F));
	24894	+ rvb->rev_damp = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10; // initialdamp;
	24895	+ rvb->er_damp_freq = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10 * 22000.0;
	24896	+ rvb->rev_feedback = (double)(clip_int(st->param_lsb[14], 0x01, 0x7F) - 0x40) * DIV_127; //0.125;
	24897	+ rvb->rev_rt = ins_xg_revchar_to_rt(st);
	24898	+ rvb->rev_roomsize = ins_xg_revchar_to_roomsize(st);
	24899	+ rvb->rev_wet = ins_xg_revchar_to_level(st);
	24900	+ rvb->rev_width = initialwidth;
	24901	+ }else{ // StandardReverb
	24902	+ int type;
	24903	+ if(st->connection == XG_CONN_SYSTEM_REVERB){
	24904	+ rvb0->mode = CH_STEREO;
	24905	+ }else{
	24906	+ rvb0->mode = CH_MIX_STEREO;
	24907	+ }
	24908	+ switch(st->type_msb) {
	24909	+ case 0x01:
	24910	+ switch(st->type_lsb) {
	24911	+ default:
	24912	+ case 0x00:/* Hall 1 */
	24913	+ case 0x06:/* Hall M */
	24914	+ type = 3;
	24915	+ break;
	24916	+ case 0x01:/* Hall 2 */
	24917	+ case 0x07:/* Hall L */
	24918	+ type = 4;
	24919	+ break;
	24920	+ }
	24921	+ break;
	24922	+ case 0x02:
	24923	+ switch(st->type_lsb) {
	24924	+ default:
	24925	+ case 0x00:/* Room 1 */
	24926	+ case 0x05:/* Room S */
	24927	+ type = 0;
	24928	+ break;
	24929	+ case 0x01:/* Room 2 */
	24930	+ case 0x06:/* Room M */
	24931	+ type = 1;
	24932	+ break;
	24933	+ case 0x02:/* Room 3 */
	24934	+ case 0x07:/* Room L */
	24935	+ type = 2;
	24936	+ break;
	24937	+ }
	24938	+ break;
	24939	+ case 0x03:
	24940	+ switch(st->type_lsb) {
	24941	+ default:
	24942	+ case 0x00:/* Stage 1 */
	24943	+ type = 2;
	24944	+ break;
	24945	+ case 0x01:/* Stage 2 */
	24946	+ type = 3;
	24947	+ break;
	24948	+ }
	24949	+ break;
	24950	+ }
	24951	+ rvb0->rev_time_sec = reverb_time_table_xg[clip_int(st->param_lsb[0], 0x00, 0x45)];
	24952	+ rvb0->rev_rt = gs_revchar_to_rt(type);
	24953	+ // rvb0->rev_wet = (double)reverb_status_gs.level * DIV_127 * gs_revchar_to_level(reverb_status_gs.character);
	24954	+ rvb0->rev_wet = calc_option_level(127 - clip_int(st->param_lsb[12], 0x01, 0x7F))
	24955	+ * gs_revchar_to_level(type);
	24956	+ rvb0->rev_roomsize = gs_revchar_to_roomsize(type);
	24957	+ rvb0->rev_width = 0.125;
	24958	+ rvb0->rev_damp = 0.5;
	24959	+ rvb0->rev_feedback = 0.125;
	24960	+ rvb0->rev_level = 1.0;
	24961	+ rvb0->er_time_ms = delay_time_table_xg[clip_int(st->param_lsb[2], 0x00, 0x3F)];
	24962	+ rvb0->er_level = 0.25;
23679	24963	}
23680	24964	info->rev_dry = calc_dry_xg(st->param_lsb[9], st);
23681	24965	info->rev_wet = calc_wet_xg(st->param_lsb[9], st);

		@@ -23684,25 +24968,23 @@ static void conv_xg_reverb1(struct effect_xg_t st, EffectList ef)
23684	24968
23685	24969	static void do_xg_reverb1(DATA_T buf, int32 count, EffectList ef)
23686	24970	{
23687		- Info_XG_Reverb1 info = (Info_XG_Reverb1 )ef->info;
	24971	+ Info_XG_Reverb1 info = (Info_XG_Reverb1 )ef->info;
	24972	+ InfoStandardReverb *rvb0 = &info->rvb0;
23688	24973	InfoFreeverb *rvb = &info->rvb;
23689	24974	InfoReverbEX *rvb2 = &info->rvb2;
23690		-#ifdef REV_EX2
23691	24975	InfoReverbEX2 *rvb3 = &info->rvb3;
23692		-#endif
23693	24976	InfoPreFilter *bpf = &info->bpf;
23694	24977
23695	24978	send_efx_buffer(ef, buf, count);
23696	24979	do_pre_bpf(ef->efx_buf, count, bpf);
23697		-#ifdef REV_EX2
23698		- if(info->rev_type == 2)
	24980	+ if(info->rev_type == 3)
23699	24981	do_reverb_ex2(ef->efx_buf, count, rvb3);
23700		- else
23701		-#endif
23702		- if(info->rev_type)
	24982	+ else if(info->rev_type == 2)
23703	24983	do_reverb_ex(ef->efx_buf, count, rvb2);
23704		- else
	24984	+ else if(info->rev_type)
23705	24985	do_freeverb(ef->efx_buf, count, rvb);
	24986	+ else
	24987	+ do_standard_reverb(buf, count, rvb0);
23706	24988	return_efx_buffer(ef, buf, count, info->rev_wet, info->rev_dry, info->rev_level);
23707	24989	}
23708	24990

		@@ -23710,40 +24992,82 @@ static void conv_xg_plate(struct effect_xg_t st, EffectList ef)
23710	24992	{
23711	24993	Info_XG_Plate info = (Info_XG_Plate )ef->info;
23712	24994	InfoPlateReverb *rvb = &info->rvb;
	24995	+ InfoReverbEX2 *rvb3 = &info->rvb3;
23713	24996	InfoPreFilter *bpf = &info->bpf;
23714	24997
23715	24998	bpf->freqH = eq_freq_table_xg[clip_int(st->param_lsb[3], 0x00, 0x34)];
23716	24999	bpf->freqL = eq_freq_table_xg[clip_int(st->param_lsb[4], 0x22, 0x3C)];
23717	25000	init_pre_bpf(bpf);
23718		-
23719		- if(st->connection == XG_CONN_SYSTEM_REVERB){
23720		- rvb->mode = CH_STEREO;
	25001	+
	25002	+ if(st->connection == XG_CONN_SYSTEM_REVERB){
	25003	+ if((opt_reverb_control >= 7 && opt_reverb_control < 9) \|\|
	25004	+ (opt_reverb_control <= -768 && opt_reverb_control > -1024)){
	25005	+ info->rev_type = 1; // reverb ex2
	25006	+ }else
	25007	+ info->rev_type = 0; // plate
23721	25008	}else{
23722		- rvb->mode = CH_MIX_STEREO;
	25009	+ info->rev_type = 0; // plate
	25010	+ }
	25011	+ if(info->rev_type){
	25012	+ if(st->connection == XG_CONN_SYSTEM_REVERB){
	25013	+ rvb3->mode = CH_STEREO;
	25014	+ }else{
	25015	+ rvb3->mode = CH_MIX_STEREO;
	25016	+ }
	25017	+ switch(st->type_msb) {
	25018	+ case 0x04:
	25019	+ switch(st->type_lsb) {
	25020	+ default:
	25021	+ case 0x00:/* Plate */
	25022	+ rvb3->revtype = 18;
	25023	+ break;
	25024	+ case 0x07:/* GM Plate */
	25025	+ rvb3->revtype = 19;
	25026	+ break;
	25027	+ }
	25028	+ break;
	25029	+ }
	25030	+ rvb3->rev_time_sec = reverb_time_table_xg[clip_int(st->param_lsb[0], 0x00, 0x45)];
	25031	+ rvb3->er_time_ms = delay_time_table_xg[clip_int(st->param_lsb[2], 0x00, 0x3F)];
	25032	+ rvb3->rev_dly_ms = delay_time_table_xg[clip_int(st->param_lsb[10], 0x00, 0x3F)];
	25033	+ rvb3->er_damp_freq = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10 * 22000.0;
	25034	+ rvb3->rev_feedback = (double)(clip_int(st->param_lsb[14], 0x01, 0x7F) - 0x40) * DIV_127; //0.125;
	25035	+ rvb3->level = 1.0;
	25036	+ }else{
	25037	+ if(st->connection == XG_CONN_SYSTEM_REVERB){
	25038	+ rvb->mode = CH_STEREO;
	25039	+ }else{
	25040	+ rvb->mode = CH_MIX_STEREO;
	25041	+ }
	25042	+ rvb->rev_time_sec = reverb_time_table_xg[clip_int(st->param_lsb[0], 0x00, 0x45)];
	25043	+ rvb->rev_diff = 0.5 * (10 + clip_int(st->param_lsb[1], 0x00, 0x0a)) * DIV_20;
	25044	+ rvb->er_time_ms = delay_time_table_xg[clip_int(st->param_lsb[2], 0x00, 0x3F)];
	25045	+ // rvb->rev_delay = delay_time_table_xg[clip_int(st->param_lsb[10], 0x00, 0x3F)];
	25046	+ // rvb->density = clip_int(st->param_lsb[11], 0x00, 0x04);
	25047	+ rvb->er_level = calc_option_level(clip_int(st->param_lsb[12], 0x01, 0x7F));
	25048	+ rvb->rev_level = calc_option_level(127 - clip_int(st->param_lsb[12], 0x01, 0x7F));
	25049	+ rvb->rev_damp = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10; // initialdamp;
	25050	+ rvb->rev_feedback = (double)(clip_int(st->param_lsb[14], 0x01, 0x7F) - 0x40) * DIV_127; //0.125;
	25051	+ rvb->rev_wet = 1.0;
23723	25052	}
23724		- rvb->rev_time_sec = reverb_time_table_xg[clip_int(st->param_lsb[0], 0x00, 0x45)];
23725		- rvb->rev_diff = 0.5 * (10 + clip_int(st->param_lsb[1], 0x00, 0x0a)) * DIV_20;
23726		- rvb->er_time_ms = delay_time_table_xg[clip_int(st->param_lsb[2], 0x00, 0x3F)];
23727		-// rvb->rev_delay = delay_time_table_xg[clip_int(st->param_lsb[10], 0x00, 0x3F)];
23728		-// rvb->density = clip_int(st->param_lsb[11], 0x00, 0x04);
23729		- rvb->er_level = calc_option_level(clip_int(st->param_lsb[12], 0x01, 0x7F));
23730		- rvb->rev_level = calc_option_level(127 - clip_int(st->param_lsb[12], 0x01, 0x7F));
23731		- rvb->rev_damp = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10; // initialdamp;
23732		- rvb->rev_feedback = (double)(clip_int(st->param_lsb[14], 0x01, 0x7F) - 0x40) * DIV_127; //0.125;
23733		- rvb->rev_wet = 1.0;
23734	25053	info->rev_dry = calc_dry_xg(st->param_lsb[9], st);
23735	25054	info->rev_wet = calc_wet_xg(st->param_lsb[9], st);
23736	25055	info->rev_level = 1.0;
23737	25056	}
	25057	+
23738	25058	static void do_xg_plate(DATA_T buf, int32 count, EffectList ef)
23739	25059	{
23740	25060	Info_XG_Plate info = (Info_XG_Plate )ef->info;
23741	25061	InfoPlateReverb *rvb = &info->rvb;
	25062	+ InfoReverbEX2 *rvb3 = &info->rvb3;
23742	25063	InfoPreFilter *bpf = &info->bpf;
23743	25064
23744	25065	send_efx_buffer(ef, buf, count);
23745	25066	do_pre_bpf(ef->efx_buf, count, bpf);
23746		- do_plate_reverb(ef->efx_buf, count, rvb);
	25067	+ if(info->rev_type)
	25068	+ do_reverb_ex2(ef->efx_buf, count, rvb3);
	25069	+ else
	25070	+ do_plate_reverb(ef->efx_buf, count, rvb);
23747	25071	return_efx_buffer(ef, buf, count, info->rev_wet, info->rev_dry, info->rev_level);
23748	25072	}
23749	25073

		@@ -24017,21 +25341,36 @@ static void do_xg_gate_reverb(DATA_T buf, int32 count, EffectList ef)
24017	25341
24018	25342	static void conv_xg_reverb2(struct effect_xg_t st, EffectList ef)
24019	25343	{
24020		- Info_XG_Reverb2 info = (Info_XG_Reverb2 )ef->info;
	25344	+ Info_XG_Reverb2 info = (Info_XG_Reverb2 )ef->info;
	25345	+ InfoStandardReverb *rvb0 = &info->rvb0;
24021	25346	InfoFreeverb *rvb = &info->rvb;
24022	25347	InfoReverbEX *rvb2 = &info->rvb2;
24023		-#ifdef REV_EX2
24024	25348	InfoReverbEX2 *rvb3 = &info->rvb3;
24025		-#endif
24026	25349	InfoPreFilter *bpf = &info->bpf;
24027		-
	25350	+
24028	25351	bpf->freqH = eq_freq_table_xg[clip_int(st->param_lsb[3], 0x00, 0x34)];
24029	25352	bpf->freqL = eq_freq_table_xg[clip_int(st->param_lsb[4], 0x22, 0x3C)];
24030	25353	init_pre_bpf(bpf);
24031		-
24032		-#ifdef REV_EX2
24033		- if((opt_reverb_control >= 7 && opt_reverb_control < 9) \|\| (opt_reverb_control <= -768 && opt_reverb_control > -1024)){
24034		- info->rev_type = 2; // reverb ex2
	25354	+
	25355	+ if(st->connection == XG_CONN_SYSTEM_REVERB){
	25356	+ if((opt_reverb_control >= 7 && opt_reverb_control < 9) \|\|
	25357	+ (opt_reverb_control <= -768 && opt_reverb_control > -1024)){
	25358	+ info->rev_type = 3; // reverb ex2
	25359	+ }else if((opt_reverb_control >= 5 && opt_reverb_control < 7) \|\|
	25360	+ (opt_reverb_control <= -512 && opt_reverb_control > -768)){
	25361	+ info->rev_type = 2; // reverb ex
	25362	+ }else if((opt_reverb_control >= 3 && opt_reverb_control < 5) \|\|
	25363	+ (opt_reverb_control <= -256 && opt_reverb_control > -512)){
	25364	+ info->rev_type = 1; // freeverb
	25365	+ }else
	25366	+ info->rev_type = 0; // standerd reverb
	25367	+ }else{
	25368	+ if(otd.efx_CustomRevType)
	25369	+ info->rev_type = 2;
	25370	+ else
	25371	+ info->rev_type = 1;
	25372	+ }
	25373	+ if(info->rev_type == 3){
24035	25374	if(st->connection == XG_CONN_SYSTEM_REVERB){
24036	25375	rvb3->mode = CH_STEREO;
24037	25376	}else{

		@@ -24040,38 +25379,25 @@ static void conv_xg_reverb2(struct effect_xg_t st, EffectList ef)
24040	25379	switch(st->type_msb) {
24041	25380	default:
24042	25381	case 0x10:/* White Room */
24043		- rvb3->rev_damp_type = FILTER_LPF6;
	25382	+ rvb3->revtype = 20;
24044	25383	break;
24045	25384	case 0x11:/* Tunnel */
24046		- rvb3->rev_damp_type = FILTER_LPF6x2;
	25385	+ rvb3->revtype = 21;
24047	25386	break;
24048	25387	case 0x12:/* Canyon */
24049		- rvb3->rev_damp_type = FILTER_LPF6;
	25388	+ rvb3->revtype = 22;
24050	25389	break;
24051	25390	case 0x13:/* Basement */
24052		- rvb3->rev_damp_type = FILTER_LPF6;
	25391	+ rvb3->revtype = 23;
24053	25392	break;
24054	25393	}
24055	25394	rvb3->rev_time_sec = reverb_time_table_xg[clip_int(st->param_lsb[0], 0x00, 0x45)];
24056		- // rvb3->rev_dif = 0.5 * (10 + clip_int(st->param_lsb[1], 0x00, 0x0a)) * DIV_20;
24057	25395	rvb3->er_time_ms = delay_time_table_xg[clip_int(st->param_lsb[2], 0x00, 0x3F)];
24058		- rvb3->width = reverb_width_height_table_xg[clip_int(st->param_lsb[5], 0x00, 37)];
24059		- rvb3->height = reverb_width_height_table_xg[clip_int(st->param_lsb[6], 0x00, 73)];
24060		- rvb3->depth = reverb_width_height_table_xg[clip_int(st->param_lsb[7], 0x00, 104)];
24061		- rvb3->rev_damp_bal = (double)clip_int(st->param_lsb[8], 0x00, 30) * DIV_30;
24062		- // rvb3->rev_wall = reverb_width_height_table_xg[clip_int(st->param_lsb[8], 0x00, 30)];
24063	25396	rvb3->rev_dly_ms = delay_time_table_xg[clip_int(st->param_lsb[10], 0x00, 0x3F)];
24064		- rvb3->density = (double)clip_int(st->param_lsb[11], 0x00, 0x04) * DIV_4;
24065		- rvb3->er_level = calc_option_level(clip_int(st->param_lsb[12], 0x01, 0x7F));
24066		- rvb3->rev_level = calc_option_level(127 - clip_int(st->param_lsb[12], 0x01, 0x7F));
24067		- rvb3->rev_damp_freq = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10 * 22000.0;
24068	25397	rvb3->er_damp_freq = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10 * 22000.0;
24069	25398	rvb3->rev_feedback = (double)(clip_int(st->param_lsb[14], 0x01, 0x7F) - 0x40) * DIV_127; //0.125;
24070		- rvb3->level = 1.0;
24071		- }else
24072		-#endif
24073		- if(otd.efx_CustomRevType){
24074		- info->rev_type = 1; // reverb ex
	25399	+ rvb3->level = 1.0;
	25400	+ }else if(info->rev_type == 2){
24075	25401	if(st->connection == XG_CONN_SYSTEM_REVERB){
24076	25402	rvb2->mode = CH_STEREO;
24077	25403	}else{

		@@ -24108,8 +25434,7 @@ static void conv_xg_reverb2(struct effect_xg_t st, EffectList ef)
24108	25434	rvb2->er_damp_freq = (double)clip_int(st->param_lsb[13], 0x01, 0x0A) * DIV_10 * 22000.0;
24109	25435	rvb2->rev_feedback = (double)(clip_int(st->param_lsb[14], 0x01, 0x7F) - 0x40) * DIV_127; //0.125;
24110	25436	rvb2->level = 1.0;
24111		- }else{
24112		- info->rev_type = 0; // freeverb
	25437	+ }else if(info->rev_type == 1){
24113	25438	if(st->connection == XG_CONN_SYSTEM_REVERB){
24114	25439	rvb->mode = CH_STEREO;
24115	25440	}else{

		@@ -24132,6 +25457,40 @@ static void conv_xg_reverb2(struct effect_xg_t st, EffectList ef)
24132	25457	* DIV_1600); // max 6222.408
24133	25458	rvb->rev_wet = ins_xg_revchar_to_level(st);
24134	25459	rvb->rev_width = initialwidth;
	25460	+ }else{ // StandardReverb
	25461	+ int type;
	25462	+ if(st->connection == XG_CONN_SYSTEM_REVERB){
	25463	+ rvb0->mode = CH_STEREO;
	25464	+ }else{
	25465	+ rvb0->mode = CH_MIX_STEREO;
	25466	+ }
	25467	+ switch(st->type_msb) {
	25468	+ default:
	25469	+ case 0x10:/* White Room */
	25470	+ type = 0;
	25471	+ break;
	25472	+ case 0x11:/* Tunnel */
	25473	+ type = 2;
	25474	+ break;
	25475	+ case 0x12:/* Canyon */
	25476	+ type = 4;
	25477	+ break;
	25478	+ case 0x13:/* Basement */
	25479	+ type = 4;
	25480	+ break;
	25481	+ }
	25482	+ rvb0->rev_time_sec = reverb_time_table_xg[clip_int(st->param_lsb[0], 0x00, 0x45)];
	25483	+ rvb0->rev_rt = gs_revchar_to_rt(type);
	25484	+ // rvb0->rev_wet = (double)reverb_status_gs.level * DIV_127 * gs_revchar_to_level(reverb_status_gs.character);
	25485	+ rvb0->rev_wet = calc_option_level(127 - clip_int(st->param_lsb[12], 0x01, 0x7F))
	25486	+ * gs_revchar_to_level(type);
	25487	+ rvb0->rev_roomsize = gs_revchar_to_roomsize(type);
	25488	+ rvb0->rev_width = 0.125;
	25489	+ rvb0->rev_damp = 0.5;
	25490	+ rvb0->rev_feedback = 0.125;
	25491	+ rvb0->rev_level = 1.0;
	25492	+ rvb0->er_time_ms = delay_time_table_xg[clip_int(st->param_lsb[2], 0x00, 0x3F)];
	25493	+ rvb0->er_level = 0.25;
24135	25494	}
24136	25495	info->rev_dry = calc_dry_xg(st->param_lsb[9], st);
24137	25496	info->rev_wet = calc_wet_xg(st->param_lsb[9], st);

		@@ -24141,24 +25500,22 @@ static void conv_xg_reverb2(struct effect_xg_t st, EffectList ef)
24141	25500	static void do_xg_reverb2(DATA_T buf, int32 count, EffectList ef)
24142	25501	{
24143	25502	Info_XG_Reverb2 info = (Info_XG_Reverb2 )ef->info;
	25503	+ InfoStandardReverb *rvb0 = &info->rvb0;
24144	25504	InfoFreeverb *rvb = &info->rvb;
24145	25505	InfoReverbEX *rvb2 = &info->rvb2;
24146		-#ifdef REV_EX2
24147	25506	InfoReverbEX2 *rvb3 = &info->rvb3;
24148		-#endif
24149	25507	InfoPreFilter *bpf = &info->bpf;
24150	25508
24151	25509	send_efx_buffer(ef, buf, count);
24152	25510	do_pre_bpf(ef->efx_buf, count, bpf);
24153		-#ifdef REV_EX2
24154		- if(info->rev_type == 2)
	25511	+ if(info->rev_type == 3)
24155	25512	do_reverb_ex2(ef->efx_buf, count, rvb3);
24156		- else
24157		-#endif
24158		- if(info->rev_type)
	25513	+ else if(info->rev_type == 2)
24159	25514	do_reverb_ex(ef->efx_buf, count, rvb2);
24160		- else
	25515	+ else if(info->rev_type)
24161	25516	do_freeverb(ef->efx_buf, count, rvb);
	25517	+ else
	25518	+ do_standard_reverb(buf, count, rvb0);
24162	25519	return_efx_buffer(ef, buf, count, info->rev_wet, info->rev_dry, info->rev_level);
24163	25520	}
24164	25521

		@@ -25189,7 +26546,7 @@ static void conv_xg_auto_wah(struct effect_xg_t st, EffectList ef)
25189	26546	//aw->drive = (double)st->param_lsb[10] * DIV_127;
25190	26547	info->dry = calc_dry_xg(st->param_lsb[9], st);
25191	26548	info->wet = calc_wet_xg(st->param_lsb[9], st);
25192		- od->mode = CH_MIX_MONO;
	26549	+ od->mode = st->param_lsb[10] == 0 ? CH_NONE : CH_MIX_MONO;
25193	26550	od->od_type = 1;
25194	26551	od->amp_type = 0;
25195	26552	od->cab_type = 0;

		@@ -25464,8 +26821,8 @@ static void conv_xg_touch_wah1(struct effect_xg_t st, EffectList ef)
25464	26821	aw->lfo_sw = 0; // off
25465	26822	aw->rate = 0.0;
25466	26823	info->dry = calc_dry_xg(st->param_lsb[9], st);
25467		- info->wet = calc_wet_xg(st->param_lsb[9], st);
25468		- od->mode = CH_MIX_MONO;
	26824	+ info->wet = calc_wet_xg(st->param_lsb[9], st);
	26825	+ od->mode = st->param_lsb[10] == 0 ? CH_NONE : CH_MIX_MONO;
25469	26826	od->od_type = 1;
25470	26827	od->amp_type = 0;
25471	26828	od->cab_type = 0;

		@@ -25621,7 +26978,7 @@ static void conv_xg_touch_wah2(struct effect_xg_t st, EffectList ef)
25621	26978	eq->low_gain = clip_int(st->param_lsb[6] - 64, -12, 12);
25622	26979	eq->high_freq = eq_freq_table_xg[clip_int(st->param_lsb[7], 28, 58)];
25623	26980	eq->high_gain = clip_int(st->param_lsb[8] - 64, -12, 12);
25624		- od->mode = CH_MIX_MONO;
	26981	+ od->mode = st->param_lsb[10] == 0 ? CH_NONE : CH_MIX_MONO;
25625	26982	od->od_type = 0;
25626	26983	od->amp_type = 0;
25627	26984	od->cab_type = 0;

		@@ -28204,88 +29561,8 @@ static void conv_sd_reverb(struct mfx_effect_sd_t st, EffectList ef)
28204	29561	Info_SD_Reverb info = (Info_SD_Reverb )ef->info;
28205	29562	InfoFreeverb *rvb = &info->rvb;
28206	29563	InfoReverbEX *rvb2 = &info->rvb2;
28207		-#ifdef REV_EX2
28208		- InfoReverbEX2 *rvb3 = &info->rvb3;
28209		-#endif
28210	29564	InfoEQ2 *eq = &info->eq;
28211	29565
28212		-#ifdef REV_EX2
28213		- if((opt_reverb_control >= 7 && opt_reverb_control < 9) \|\| (opt_reverb_control <= -768 && opt_reverb_control > -1024)){
28214		- info->rev_type = 2; // reverb ex2
28215		- rvb3->mode = CH_MIX_STEREO;
28216		- switch(clip_int(st->parameter[0], 0x00, 0x05)){
28217		- case 0: // room1
28218		- rvb3->height = 3.0; // m
28219		- rvb3->width = 5.0; // m
28220		- rvb3->depth = 7.0; // m
28221		- rvb3->rev_damp_type = FILTER_LPF6;
28222		- rvb3->rev_damp_bal = 0.65;
28223		- rvb3->er_level = 0.50;
28224		- rvb3->rev_level = 0.50;
28225		- rvb3->density = 1.0;
28226		- break;
28227		- case 1: // room2
28228		- rvb3->height = 4.0; // m
28229		- rvb3->width = 8.0; // m
28230		- rvb3->depth = 10.0; // m
28231		- rvb3->rev_damp_type = FILTER_LPF6;
28232		- rvb3->rev_damp_bal = 0.99;
28233		- rvb3->er_level = 0.45;
28234		- rvb3->rev_level = 0.55;
28235		- rvb3->density = 0.75;
28236		- break;
28237		- case 2: // stage1
28238		- rvb3->height = 10.0; // m
28239		- rvb3->width = 12.0; // m
28240		- rvb3->depth = 15.0; // m
28241		- rvb3->rev_damp_type = FILTER_LPF6;
28242		- rvb3->rev_damp_bal = 0.85;
28243		- rvb3->er_level = 0.40;
28244		- rvb3->rev_level = 0.60;
28245		- rvb3->density = 0.75;
28246		- break;
28247		- case 3: // stage2
28248		- rvb3->height = 12.0; // m
28249		- rvb3->width = 13.0; // m
28250		- rvb3->depth = 18.0; // m
28251		- rvb3->rev_damp_type = FILTER_LPF6;
28252		- rvb3->rev_damp_bal = 0.95;
28253		- rvb3->er_level = 0.60;
28254		- rvb3->rev_level = 0.40;
28255		- rvb3->density = 1.0;
28256		- break;
28257		- case 4: // hall1
28258		- rvb3->height = 12.0; // m
28259		- rvb3->width = 16.0; // m
28260		- rvb3->depth = 20.0; // m
28261		- rvb3->rev_damp_type = FILTER_LPF6;
28262		- rvb3->rev_damp_bal = 0.65;
28263		- rvb3->er_level = 0.50;
28264		- rvb3->rev_level = 0.50;
28265		- rvb3->density = 1.0;
28266		- break;
28267		- default:
28268		- case 5: // hall2
28269		- rvb3->height = 16.0; // m
28270		- rvb3->width = 20.0; // m
28271		- rvb3->depth = 31.0; // m
28272		- rvb3->rev_damp_type = FILTER_LPF6;
28273		- rvb3->rev_damp_bal = 0.95;
28274		- rvb3->er_level = 0.45;
28275		- rvb3->rev_level = 0.55;
28276		- rvb3->density = 0.75;
28277		- break;
28278		- }
28279		- rvb3->er_time_ms = pre_delay_time_table[st->parameter[1]];
28280		- rvb3->rev_time_sec = reverb_time_table[clip_int(st->parameter[2], 0, 127)];
28281		- rvb3->rev_damp_freq = EQ_FREQb_SD(st->parameter[3]);
28282		- rvb3->er_damp_freq = EQ_FREQb_SD(st->parameter[3]);
28283		- rvb3->rev_feedback = 0.0; // reverb_status_gs.delay_feedback
28284		- rvb3->rev_dly_ms = 0;
28285		- rvb3->density = 1.0;
28286		- rvb3->level = 1.0;
28287		- }else
28288		-#endif
28289	29566	if(otd.efx_CustomRevType){
28290	29567	info->rev_type = 1; // reverb ex
28291	29568	rvb2->mode = CH_MIX_STEREO;

		@@ -28393,17 +29670,9 @@ static void do_sd_reverb(DATA_T buf, int32 count, EffectList ef)
28393	29670	Info_SD_Reverb info = (Info_SD_Reverb )ef->info;
28394	29671	InfoFreeverb *rvb = &info->rvb;
28395	29672	InfoReverbEX *rvb2 = &info->rvb2;
28396		-#ifdef REV_EX2
28397		- InfoReverbEX2 *rvb3 = &info->rvb3;
28398		-#endif
28399	29673	InfoEQ2 *eq = &info->eq;
28400	29674
28401	29675	send_efx_buffer(ef, buf, count);
28402		-#ifdef REV_EX2
28403		- if(info->rev_type == 2)
28404		- do_reverb_ex2(ef->efx_buf, count, rvb3);
28405		- else
28406		-#endif
28407	29676	if(info->rev_type)
28408	29677	do_reverb_ex(ef->efx_buf, count, rvb2);
28409	29678	else

		@@ -32066,90 +33335,43 @@ static float HF_damp_freq_table_sd[6] = {4000, 5000, 6400, 8000, 10000, 12500,};
32066	33335	static void conv_sd_reverb1(struct mfx_effect_sd_t st, EffectList ef)
32067	33336	{
32068	33337	Info_SD_Rev_Reverb info = (Info_SD_Rev_Reverb )ef->info;
	33338	+ InfoStandardReverb *rvb0 = &info->rvb0;
32069	33339	InfoFreeverb *rvb = &info->rvb;
32070	33340	InfoReverbEX *rvb2 = &info->rvb2;
32071		-#ifdef REV_EX2
32072	33341	InfoReverbEX2 *rvb3 = &info->rvb3;
32073		-#endif
32074		-
32075		-#ifdef REV_EX2
	33342	+
32076	33343	if((opt_reverb_control >= 7 && opt_reverb_control < 9) \|\| (opt_reverb_control <= -768 && opt_reverb_control > -1024)){
32077	33344	info->rev_type = 2; // reverb ex2
32078	33345	rvb3->mode = CH_STEREO;
32079	33346	switch(clip_int(st->parameter[0], 0x00, 0x05)){
32080	33347	case 0: // room1
32081		- rvb3->height = 3.0; // m
32082		- rvb3->width = 5.0; // m
32083		- rvb3->depth = 7.0; // m
32084		- rvb3->rev_damp_type = FILTER_LPF6;
32085		- rvb3->rev_damp_bal = 0.65;
32086		- rvb3->er_level = 0.50;
32087		- rvb3->rev_level = 0.50;
32088		- rvb3->density = 1.0;
	33348	+ rvb3->revtype = 24;
32089	33349	break;
32090	33350	case 1: // room2
32091		- rvb3->height = 4.0; // m
32092		- rvb3->width = 8.0; // m
32093		- rvb3->depth = 10.0; // m
32094		- rvb3->rev_damp_type = FILTER_LPF6;
32095		- rvb3->rev_damp_bal = 0.99;
32096		- rvb3->er_level = 0.45;
32097		- rvb3->rev_level = 0.55;
32098		- rvb3->density = 0.75;
	33351	+ rvb3->revtype = 25;
32099	33352	break;
32100	33353	case 2: // stage1
32101		- rvb3->height = 10.0; // m
32102		- rvb3->width = 12.0; // m
32103		- rvb3->depth = 15.0; // m
32104		- rvb3->rev_damp_type = FILTER_LPF6;
32105		- rvb3->rev_damp_bal = 0.85;
32106		- rvb3->er_level = 0.40;
32107		- rvb3->rev_level = 0.60;
32108		- rvb3->density = 0.75;
	33354	+ rvb3->revtype = 26;
32109	33355	break;
32110	33356	case 3: // stage2
32111		- rvb3->height = 12.0; // m
32112		- rvb3->width = 13.0; // m
32113		- rvb3->depth = 18.0; // m
32114		- rvb3->rev_damp_type = FILTER_LPF6;
32115		- rvb3->rev_damp_bal = 0.95;
32116		- rvb3->er_level = 0.60;
32117		- rvb3->rev_level = 0.40;
32118		- rvb3->density = 1.0;
	33357	+ rvb3->revtype = 27;
32119	33358	break;
32120	33359	case 4: // hall1
32121		- rvb3->height = 12.0; // m
32122		- rvb3->width = 16.0; // m
32123		- rvb3->depth = 20.0; // m
32124		- rvb3->rev_damp_type = FILTER_LPF6;
32125		- rvb3->rev_damp_bal = 0.65;
32126		- rvb3->er_level = 0.50;
32127		- rvb3->rev_level = 0.50;
32128		- rvb3->density = 1.0;
	33360	+ rvb3->revtype = 28;
32129	33361	break;
32130	33362	default:
32131	33363	case 5: // hall2
32132		- rvb3->height = 16.0; // m
32133		- rvb3->width = 20.0; // m
32134		- rvb3->depth = 31.0; // m
32135		- rvb3->rev_damp_type = FILTER_LPF6;
32136		- rvb3->rev_damp_bal = 0.95;
32137		- rvb3->er_level = 0.45;
32138		- rvb3->rev_level = 0.55;
32139		- rvb3->density = 0.75;
	33364	+ rvb3->revtype = 29;
32140	33365	break;
32141	33366	}
32142	33367	rvb3->er_time_ms = rev_sd_type_predelay(st->parameter[0]);
32143	33368	rvb3->rev_time_sec = reverb_time_table[clip_int(st->parameter[1], 0, 127)];
32144		- rvb3->rev_damp_freq = EQ_FREQb_SD(st->parameter[2]);
32145	33369	rvb3->er_damp_freq = EQ_FREQb_SD(st->parameter[2]);
32146	33370	rvb3->rev_feedback = 0.0; // reverb_status_gs.delay_feedback
32147	33371	rvb3->rev_dly_ms = 0;
32148		- rvb3->density = 1.0;
32149	33372	rvb3->level = 1.0;
32150	33373	}else
32151		-#endif
32152		- if(otd.efx_CustomRevType){
	33374	+ if((opt_reverb_control >= 5 && opt_reverb_control < 7) \|\| (opt_reverb_control <= -512 && opt_reverb_control > -768)){
32153	33375	info->rev_type = 1; // reverb ex
32154	33376	rvb2->mode = CH_STEREO;
32155	33377	switch(clip_int(st->parameter[0], 0x00, 0x05)){

		@@ -32223,7 +33445,8 @@ static void conv_sd_reverb1(struct mfx_effect_sd_t st, EffectList ef)
32223	33445	rvb2->rev_dly_ms = 0;
32224	33446	rvb2->density = 1.0;
32225	33447	rvb2->level = 1.0;
32226		- }else{
	33448	+ }else
	33449	+ if((opt_reverb_control >= 3 && opt_reverb_control < 5) \|\| (opt_reverb_control <= -256 && opt_reverb_control > -512)){
32227	33450	// freeverb
32228	33451	info->rev_type = 0;
32229	33452	rvb->mode = CH_STEREO;

		@@ -32240,47 +33463,69 @@ static void conv_sd_reverb1(struct mfx_effect_sd_t st, EffectList ef)
32240	33463	rvb->rev_dly_ms = 0;
32241	33464	rvb->rev_level = 0.65;
32242	33465	rvb->rev_dif = 1.0;
	33466	+ }else{ // StandardReverb
	33467	+ int type;
	33468	+ info->rev_type = 0;
	33469	+ rvb3->mode = CH_STEREO;
	33470	+ switch(clip_int(st->parameter[0], 0x00, 0x05)){
	33471	+ case 0: // room1
	33472	+ type = 0;
	33473	+ break;
	33474	+ case 1: // room2
	33475	+ type = 1;
	33476	+ break;
	33477	+ case 2: // stage1
	33478	+ type = 2;
	33479	+ break;
	33480	+ case 3: // stage2
	33481	+ type = 3;
	33482	+ break;
	33483	+ case 4: // hall1
	33484	+ type = 3;
	33485	+ break;
	33486	+ default:
	33487	+ case 5: // hall2
	33488	+ type = 4;
	33489	+ break;
	33490	+ }
	33491	+ rvb0->rev_time_sec = reverb_time_table[clip_int(st->parameter[1], 0, 127)];
	33492	+ rvb0->rev_rt = gs_revchar_to_rt(type);
	33493	+ rvb0->rev_wet = gs_revchar_to_level(type);
	33494	+ rvb0->rev_roomsize = gs_revchar_to_roomsize(type);
	33495	+ rvb0->rev_width = 0.125;
	33496	+ rvb0->rev_damp = 0.5;
	33497	+ rvb0->rev_feedback = 0.125;
	33498	+ rvb0->rev_level = 1.0;
	33499	+ rvb0->er_time_ms = rev_sd_type_predelay(st->parameter[0]);
	33500	+ rvb0->er_level = 0.25;
32243	33501	}
32244	33502	}
32245	33503
32246	33504	static void conv_sd_reverb2(struct mfx_effect_sd_t st, EffectList ef)
32247	33505	{
32248	33506	Info_SD_Rev_Reverb info = (Info_SD_Rev_Reverb )ef->info;
	33507	+ InfoStandardReverb *rvb0 = &info->rvb0;
32249	33508	InfoFreeverb *rvb = &info->rvb;
32250	33509	InfoReverbEX *rvb2 = &info->rvb2;
32251		-#ifdef REV_EX2
32252	33510	InfoReverbEX2 *rvb3 = &info->rvb3;
32253		-#endif
32254		-
32255		-#ifdef REV_EX2
	33511	+
32256	33512	if((opt_reverb_control >= 7 && opt_reverb_control < 9) \|\| (opt_reverb_control <= -768 && opt_reverb_control > -1024)){
32257		- info->rev_type = 2; // reverb ex2
	33513	+ info->rev_type = 3; // reverb ex2
32258	33514	rvb3->mode = CH_STEREO;
	33515	+ switch(*reverb_status_sd.type) {
	33516	+ case 0x02: rvb3->revtype = 30; break;
	33517	+ case 0x03: rvb3->revtype = 31; break;
	33518	+ case 0x04: rvb3->revtype = 32; break;
	33519	+ }
32259	33520	rvb3->er_time_ms = pre_delay_time_table[clip_int(st->parameter[0], 0, 127)];
32260	33521	rvb3->rev_time_sec = reverb_time_table[clip_int(st->parameter[1], 0, 127)];
32261		- rvb3->height = 2.25 + 1.25 * clip_int(st->parameter[2], 1, 8); // m
32262		- rvb3->width = 4.0 + 2.5 * clip_int(st->parameter[2], 1, 8); // m
32263		- rvb3->depth = 4.0 + 2.75 * clip_int(st->parameter[2], 1, 8); // m
32264		- // st->parameter[3] // hicut freq
32265		- rvb3->density = 0.5 + clip_int(st->parameter[4], 0, 127) * DIV_256;
32266		- // st->parameter[5] diffusion
32267		- // st->parameter[6] lf damp freq
32268		- // st->parameter[7] lf damp gain
32269		- rvb3->rev_damp_freq = HF_damp_freq_table_sd[clip_int(st->parameter[8], 0, 5)];
32270	33522	rvb3->er_damp_freq = HF_damp_freq_table_sd[clip_int(st->parameter[8], 0, 5)];
32271		- // st->parameter[9] hf damp gain
32272		- rvb3->rev_damp_type = FILTER_LPF6;
32273		- rvb3->rev_damp_bal = 0.95;
32274		- rvb3->er_level = 0.45;
32275		- rvb3->rev_level = 0.55;
32276	33523	rvb3->rev_feedback = 0.0;
32277	33524	rvb3->rev_dly_ms = 0;
32278		- rvb3->density = 1.0;
32279	33525	rvb3->level = 1.0;
32280	33526	}else
32281		-#endif
32282		- if(otd.efx_CustomRevType){
32283		- info->rev_type = 1; // reverb ex
	33527	+ if((opt_reverb_control >= 5 && opt_reverb_control < 7) \|\| (opt_reverb_control <= -512 && opt_reverb_control > -768)){
	33528	+ info->rev_type = 2; // reverb ex
32284	33529	rvb2->mode = CH_STEREO;
32285	33530	rvb2->er_time_ms = pre_delay_time_table[clip_int(st->parameter[0], 0, 127)];
32286	33531	rvb2->rev_time_sec = reverb_time_table[clip_int(st->parameter[1], 0, 127)];

		@@ -32303,8 +33548,10 @@ static void conv_sd_reverb2(struct mfx_effect_sd_t st, EffectList ef)
32303	33548	rvb2->rev_dly_ms = 0;
32304	33549	rvb2->density = 1.0;
32305	33550	rvb2->level = 1.0;
32306		- }else{
	33551	+ }else
	33552	+ if((opt_reverb_control >= 3 && opt_reverb_control < 5) \|\| (opt_reverb_control <= -256 && opt_reverb_control > -512)){
32307	33553	// freeverb
	33554	+ info->rev_type = 1;
32308	33555	info->rev_type = 0;
32309	33556	rvb->mode = CH_STEREO;
32310	33557	rvb->er_time_ms = pre_delay_time_table[clip_int(st->parameter[0], 0, 127)];

		@@ -32320,89 +33567,70 @@ static void conv_sd_reverb2(struct mfx_effect_sd_t st, EffectList ef)
32320	33567	rvb->rev_dly_ms = 0;
32321	33568	rvb->rev_level = 0.55;
32322	33569	rvb->rev_dif = 1.0;
	33570	+ }else{ // StandardReverb
	33571	+ int type;
	33572	+ info->rev_type = 0;
	33573	+ rvb3->mode = CH_STEREO;
	33574	+ switch(*reverb_status_sd.type) {
	33575	+ case 0x02: type = 2; break;
	33576	+ case 0x03: type = 4; break;
	33577	+ case 0x04: type = 4; break;
	33578	+ }
	33579	+ rvb0->rev_time_sec = reverb_time_table[clip_int(st->parameter[1], 0, 127)];
	33580	+ rvb0->rev_rt = gs_revchar_to_rt(type);
	33581	+ rvb0->rev_wet = gs_revchar_to_level(type);
	33582	+ rvb0->rev_roomsize = gs_revchar_to_roomsize(type);
	33583	+ rvb0->rev_width = 0.125;
	33584	+ rvb0->rev_damp = 0.5;
	33585	+ rvb0->rev_feedback = 0.125;
	33586	+ rvb0->rev_level = 1.0;
	33587	+ rvb0->er_time_ms = pre_delay_time_table[clip_int(st->parameter[0], 0, 127)];
	33588	+ rvb0->er_level = 0.25;
32323	33589	}
32324	33590	}
32325	33591
32326	33592	static void conv_sd_gm2_reverb(struct mfx_effect_sd_t st, EffectList ef)
32327	33593	{
32328	33594	Info_SD_Rev_Reverb info = (Info_SD_Rev_Reverb )ef->info;
	33595	+ InfoStandardReverb *rvb0 = &info->rvb0;
32329	33596	InfoFreeverb *rvb = &info->rvb;
32330	33597	InfoReverbEX *rvb2 = &info->rvb2;
32331		-#ifdef REV_EX2
32332	33598	InfoReverbEX2 *rvb3 = &info->rvb3;
32333		-#endif
32334	33599	int type = (st->parameter[0] >= 3) ? (st->parameter[0] + 1) : st->parameter[0];
32335	33600
32336		-#ifdef REV_EX2
32337	33601	if((opt_reverb_control >= 7 && opt_reverb_control < 9) \|\| (opt_reverb_control <= -768 && opt_reverb_control > -1024)){
32338		- info->rev_type = 2; // reverb ex2
	33602	+ info->rev_type = 3; // reverb ex2
32339	33603	rvb3->mode = CH_STEREO;
32340	33604	switch(clip_int(type, 0x00, 0x05)){
32341	33605	case 0: // small room1
32342		- rvb3->height = 3.0; // m
32343		- rvb3->width = 4.5; // m
32344		- rvb3->depth = 6.0; // m
32345		- rvb3->rev_damp_type = FILTER_LPF6;
32346		- rvb3->rev_damp_bal = 0.65;
32347		- rvb3->er_level = 0.50;
32348		- rvb3->rev_level = 0.50;
32349		- rvb3->density = 1.0;
	33606	+ rvb3->revtype = 33;
32350	33607	break;
32351	33608	case 1: // medium room2
32352		- rvb3->height = 4.0; // m
32353		- rvb3->width = 8.0; // m
32354		- rvb3->depth = 10.0; // m
32355		- rvb3->rev_damp_type = FILTER_LPF6;
32356		- rvb3->rev_damp_bal = 0.99;
32357		- rvb3->er_level = 0.45;
32358		- rvb3->rev_level = 0.55;
32359		- rvb3->density = 0.75;
	33609	+ rvb3->revtype = 34;
32360	33610	break;
32361	33611	case 2: // large room1
32362		- rvb3->height = 4.0; // m
32363		- rvb3->width = 13.0; // m
32364		- rvb3->depth = 16.0; // m
32365		- rvb3->rev_damp_type = FILTER_LPF6;
32366		- rvb3->rev_damp_bal = 0.85;
32367		- rvb3->er_level = 0.40;
32368		- rvb3->rev_level = 0.60;
32369		- rvb3->density = 0.75;
	33612	+ rvb3->revtype = 35;
32370	33613	break;
32371	33614	case 3: // medium hall
32372		- case 4: // medium hall
32373		- rvb3->height = 12.0; // m
32374		- rvb3->width = 13.0; // m
32375		- rvb3->depth = 19.0; // m
32376		- rvb3->rev_damp_type = FILTER_LPF6;
32377		- rvb3->rev_damp_bal = 0.65;
32378		- rvb3->er_level = 0.50;
32379		- rvb3->rev_level = 0.50;
32380		- rvb3->density = 1.0;
	33615	+ rvb3->revtype = 36;
32381	33616	break;
32382	33617	default:
32383		- case 5: // large hall
32384		- rvb3->height = 15.0; // m
32385		- rvb3->width = 20.0; // m
32386		- rvb3->depth = 31.0; // m
32387		- rvb3->rev_damp_type = FILTER_LPF6;
32388		- rvb3->rev_damp_bal = 0.85;
32389		- rvb3->er_level = 0.45;
32390		- rvb3->rev_level = 0.55;
32391		- rvb3->density = 0.75;
	33618	+ case 4: // large hall
	33619	+ rvb3->revtype = 37;
	33620	+ break;
	33621	+ case 5: // plate
	33622	+ rvb3->revtype = 38;
32392	33623	break;
32393	33624	}
32394	33625	rvb3->er_time_ms = rev_sd_type_predelay(type);
32395	33626	rvb3->rev_time_sec = reverb_time_table[clip_int(st->parameter[1], 0, 127)];
32396		- rvb3->rev_damp_freq = 8000;
32397		- rvb3->er_damp_freq = 8000;
	33627	+ rvb3->er_damp_freq = 18000;
32398	33628	rvb3->rev_feedback = 0.0; // reverb_status_gs.delay_feedback
32399	33629	rvb3->rev_dly_ms = 0;
32400		- rvb3->density = 1.0;
32401	33630	rvb3->level = 1.0;
32402	33631	}else
32403		-#endif
32404		- if(otd.efx_CustomRevType){
32405		- info->rev_type = 1; // reverb ex
	33632	+ if((opt_reverb_control >= 5 && opt_reverb_control < 7) \|\| (opt_reverb_control <= -512 && opt_reverb_control > -768)){
	33633	+ info->rev_type = 2; // reverb ex
32406	33634	rvb2->mode = CH_STEREO;
32407	33635	switch(clip_int(type, 0x00, 0x05)){
32408	33636	case 0: // room1

		@@ -32467,9 +33695,10 @@ static void conv_sd_gm2_reverb(struct mfx_effect_sd_t st, EffectList ef)
32467	33695	rvb2->rev_dly_ms = 0;
32468	33696	rvb2->density = 1.0;
32469	33697	rvb2->level = 1.0;
32470		- }else{
	33698	+ }else
	33699	+ if((opt_reverb_control >= 3 && opt_reverb_control < 5) \|\| (opt_reverb_control <= -256 && opt_reverb_control > -512)){
32471	33700	// freeverb
32472		- info->rev_type = 0;
	33701	+ info->rev_type = 1;
32473	33702	rvb->mode = CH_STEREO;
32474	33703	rvb->er_time_ms = rev_sd_type_predelay(type);
32475	33704	rvb->rev_rt = ins_gs_revchar_to_rt(clip_int(type, 0x00, 0x05));

		@@ -32484,45 +33713,86 @@ static void conv_sd_gm2_reverb(struct mfx_effect_sd_t st, EffectList ef)
32484	33713	rvb->rev_dly_ms = 0;
32485	33714	rvb->rev_level = 0.65;
32486	33715	rvb->rev_dif = 1.0;
	33716	+ }else{ // StandardReverb
	33717	+ info->rev_type = 0;
	33718	+ rvb3->mode = CH_STEREO;
	33719	+ rvb0->rev_time_sec = reverb_time_table[clip_int(st->parameter[1], 0, 127)];
	33720	+ rvb0->rev_rt = gs_revchar_to_rt(type);
	33721	+ rvb0->rev_wet = gs_revchar_to_level(type);
	33722	+ rvb0->rev_roomsize = gs_revchar_to_roomsize(type);
	33723	+ rvb0->rev_width = 0.125;
	33724	+ rvb0->rev_damp = 0.5;
	33725	+ rvb0->rev_feedback = 0.125;
	33726	+ rvb0->rev_level = 1.0;
	33727	+ rvb0->er_time_ms = rev_sd_type_predelay(type);
	33728	+ rvb0->er_level = 0.25;
32487	33729	}
32488	33730	}
32489	33731
32490	33732	static void conv_sd_plate1(struct mfx_effect_sd_t st, EffectList ef)
32491	33733	{
32492	33734	Info_SD_Rev_Plate info = (Info_SD_Rev_Plate )ef->info;
32493		- InfoPlateReverb *rvb = &info->rvb;
32494		-
32495		- rvb->mode = CH_STEREO;
32496		- rvb->er_time_ms = pre_delay_time_table[clip_int(st->parameter[0], 0, 127)];
32497		- rvb->rev_time_sec = reverb_time_table[clip_int(st->parameter[1], 0, 127)];
32498		- rvb->rev_diff = 0.5 * (10 + clip_int(st->parameter[2], 0, 8)) * DIV_20;
32499		- // st->parameter[3] high cut
32500		- // st->parameter[4] density
32501		- // st->parameter[5] diffusion
32502		- // st->parameter[6] lf damp freq
32503		- // st->parameter[7] lf damp gain
32504		- rvb->rev_damp = HF_damp_freq_table_sd[clip_int(st->parameter[8], 0, 5)] / 22050.0; // initialdamp;
32505		- // st->parameter[9] hf damp gain
32506		- rvb->er_level = 0.25;
32507		- rvb->rev_level = 0.75;
32508		- rvb->rev_feedback = 0; //0.125;
32509		- rvb->rev_wet = 1.0;
	33735	+ InfoPlateReverb *rvb = &info->rvb;
	33736	+ InfoReverbEX2 *rvb3 = &info->rvb3;
	33737	+
	33738	+ if((opt_reverb_control >= 7 && opt_reverb_control < 9) \|\| (opt_reverb_control <= -768 && opt_reverb_control > -1024)){
	33739	+ info->rev_type = 1; // reverb ex2
	33740	+ rvb3->mode = CH_STEREO;
	33741	+ rvb3->revtype = 32; // srv plate
	33742	+ rvb3->er_time_ms = pre_delay_time_table[clip_int(st->parameter[0], 0, 127)];
	33743	+ rvb3->rev_time_sec = reverb_time_table[clip_int(st->parameter[1], 0, 127)];
	33744	+ rvb3->er_damp_freq = 18000;
	33745	+ rvb3->rev_feedback = 0.0; // reverb_status_gs.delay_feedback
	33746	+ rvb3->rev_dly_ms = 0;
	33747	+ rvb3->level = 1.0;
	33748	+ }else{
	33749	+ info->rev_type = 0;
	33750	+ rvb->mode = CH_STEREO;
	33751	+ rvb->er_time_ms = pre_delay_time_table[clip_int(st->parameter[0], 0, 127)];
	33752	+ rvb->rev_time_sec = reverb_time_table[clip_int(st->parameter[1], 0, 127)];
	33753	+ rvb->rev_diff = 0.5 * (10 + clip_int(st->parameter[2], 0, 8)) * DIV_20;
	33754	+ // st->parameter[3] high cut
	33755	+ // st->parameter[4] density
	33756	+ // st->parameter[5] diffusion
	33757	+ // st->parameter[6] lf damp freq
	33758	+ // st->parameter[7] lf damp gain
	33759	+ rvb->rev_damp = HF_damp_freq_table_sd[clip_int(st->parameter[8], 0, 5)] / 22050.0; // initialdamp;
	33760	+ // st->parameter[9] hf damp gain
	33761	+ rvb->er_level = 0.25;
	33762	+ rvb->rev_level = 0.75;
	33763	+ rvb->rev_feedback = 0; //0.125;
	33764	+ rvb->rev_wet = 1.0;
	33765	+ }
32510	33766	}
32511	33767
32512	33768	static void conv_sd_gm2_plate(struct mfx_effect_sd_t st, EffectList ef)
32513	33769	{
32514	33770	Info_SD_Rev_Plate info = (Info_SD_Rev_Plate )ef->info;
32515		- InfoPlateReverb *rvb = &info->rvb;
32516		-
32517		- rvb->mode = CH_STEREO;
32518		- rvb->rev_time_sec = reverb_time_table[clip_int(st->parameter[1], 0, 127)];
32519		- rvb->rev_diff = 0.5 * (10 + 5) * DIV_20;
32520		- rvb->er_time_ms = 5.0;
32521		- rvb->rev_damp = 8000.0 / 22050.0; // initialdamp;
32522		- rvb->er_level = 0.25;
32523		- rvb->rev_level = 0.75;
32524		- rvb->rev_feedback = 0; //0.125;
32525		- rvb->rev_wet = 1.0;
	33771	+ InfoPlateReverb *rvb = &info->rvb;
	33772	+ InfoReverbEX2 *rvb3 = &info->rvb3;
	33773	+
	33774	+ if((opt_reverb_control >= 7 && opt_reverb_control < 9) \|\| (opt_reverb_control <= -768 && opt_reverb_control > -1024)){
	33775	+ info->rev_type = 1; // reverb ex2
	33776	+ rvb3->mode = CH_STEREO;
	33777	+ rvb3->revtype = 38; // gm2 plate
	33778	+ rvb3->er_time_ms = pre_delay_time_table[clip_int(st->parameter[0], 0, 127)];
	33779	+ rvb3->rev_time_sec = reverb_time_table[clip_int(st->parameter[1], 0, 127)];
	33780	+ rvb3->er_damp_freq = 18000;
	33781	+ rvb3->rev_feedback = 0.0; // reverb_status_gs.delay_feedback
	33782	+ rvb3->rev_dly_ms = 0;
	33783	+ rvb3->level = 1.0;
	33784	+ }else{
	33785	+ info->rev_type = 0;
	33786	+ rvb->mode = CH_STEREO;
	33787	+ rvb->rev_time_sec = reverb_time_table[clip_int(st->parameter[1], 0, 127)];
	33788	+ rvb->rev_diff = 0.5 * (10 + 5) * DIV_20;
	33789	+ rvb->er_time_ms = 5.0;
	33790	+ rvb->rev_damp = 8000.0 / 22050.0; // initialdamp;
	33791	+ rvb->er_level = 0.25;
	33792	+ rvb->rev_level = 0.75;
	33793	+ rvb->rev_feedback = 0; //0.125;
	33794	+ rvb->rev_wet = 1.0;
	33795	+ }
32526	33796	}
32527	33797
32528	33798	static void conv_sd_delay2(struct mfx_effect_sd_t st, EffectList ef)

		@@ -32542,30 +33812,32 @@ static void conv_sd_delay2(struct mfx_effect_sd_t st, EffectList ef)
32542	33812
32543	33813	static void do_sd_reverb1(DATA_T buf, int32 count, EffectList ef)
32544	33814	{
32545		- Info_SD_Rev_Reverb info = (Info_SD_Rev_Reverb )ef->info;
	33815	+ Info_SD_Rev_Reverb info = (Info_SD_Rev_Reverb )ef->info;
	33816	+ InfoStandardReverb *rvb0 = &info->rvb0;
32546	33817	InfoFreeverb *rvb = &info->rvb;
32547	33818	InfoReverbEX *rvb2 = &info->rvb2;
32548		-#ifdef REV_EX2
32549	33819	InfoReverbEX2 *rvb3 = &info->rvb3;
32550		-#endif
32551		-
32552		-#ifdef REV_EX2
32553		- if(info->rev_type == 2)
32554		- do_reverb_ex2(buf, count, rvb3);
32555		- else
32556		-#endif
32557		- if(info->rev_type)
32558		- do_reverb_ex(buf, count, rvb2);
	33820	+
	33821	+ if(info->rev_type == 3)
	33822	+ do_reverb_ex2(ef->efx_buf, count, rvb3);
	33823	+ else if(info->rev_type == 2)
	33824	+ do_reverb_ex(ef->efx_buf, count, rvb2);
	33825	+ else if(info->rev_type)
	33826	+ do_freeverb(ef->efx_buf, count, rvb);
32559	33827	else
32560		- do_freeverb(buf, count, rvb);
	33828	+ do_standard_reverb(buf, count, rvb0);
32561	33829	}
32562	33830
32563	33831	static void do_sd_plate1(DATA_T buf, int32 count, EffectList ef)
32564	33832	{
32565	33833	Info_SD_Rev_Plate info = (Info_SD_Rev_Plate )ef->info;
32566	33834	InfoPlateReverb *rvb = &info->rvb;
32567		-
32568		- do_plate_reverb(buf, count, rvb);
	33835	+ InfoReverbEX2 *rvb3 = &info->rvb3;
	33836	+
	33837	+ if(info->rev_type)
	33838	+ do_reverb_ex2(ef->efx_buf, count, rvb3);
	33839	+ else
	33840	+ do_plate_reverb(buf, count, rvb);
32569	33841	}
32570	33842
32571	33843	static void do_sd_delay2(DATA_T buf, int32 count, EffectList ef)

--- a/timidity/effect.h

+++ b/timidity/effect.h

		@@ -702,25 +702,22 @@ typedef struct _InfoReverbEX{
702	702	} InfoReverbEX;
703	703
704	704
705		-#define REV_EX2
706		-//#define InfoReverbEX2 InfoReverbEX
707		-
	705	+//#define REV_EX2_FFT
708	706	typedef struct _InfoReverbEX2{
709		- int8 mode, flt_type;
710		- double rev_dly_ms, rev_time_sec, rev_width, rev_damp, rev_level, rev_feedback, rev_wet;
711		- double height, width, depth, rev_damp_freq, rev_damp_type, rev_damp_bal, density;
712		- double er_time_ms, er_level, level, er_damp_freq, er_roomsize;
713		- FLOAT_T levelrv, leveler, feedback, flt_dry, flt_wet, rv_feedback[REV_EX_UNITS], st_sprd, in_level, levelap;
714		- int32 levelrvi, leveleri, feedbacki, flt_dryi, flt_weti, rv_feedbacki[REV_EX_UNITS], st_sprdi, in_leveli, levelapi;
715		- // IR rev
716		- int8 init;
717		- int32 frame, srate, wcount, wcycle, rcycle;
718		- float irdata[2], buf[2];
719		- // thread
720		- int8 thread;
721		- int32 tcount, twcount[4]; // max 4thread
722		- float tbuf[4]; // in2,out*2
723		- float *buf2[2];
	707	+ int8 mode;
	708	+ int32 revtype;
	709	+ double er_time_ms, er_damp_freq, rev_dly_ms, rev_time_sec, rev_feedback, level;
	710	+ FLOAT_T levelrv;
	711	+ int8 init, thread, ithread, rsmode, fftmode, fm_p;
	712	+ int32 frame, srate, count, tcount, bsize, bcount, tbcount, pmr_p, rt_p;
	713	+ float irdata[2], buf[2], tbuf[2]; // buf:delay(in)2 , tbuf:out*2
	714	+ FLOAT_T rsfb[2];
	715	+ DATA_T *ptr;
	716	+#if defined(REV_EX2_FFT) // fft
	717	+ int32 fnum, scount[2], bdcount[2];
	718	+ float fs[2], ss[2], rvs[2], rs[2], is[2], os[2], fi[2], bd[2], *ios[2];
	719	+ float *sint;
	720	+#endif
724	721	} InfoReverbEX2;
725	722
726	723

		@@ -1264,9 +1261,6 @@ typedef struct {
1264	1261	// InfoReverb rvb;
1265	1262	InfoFreeverb rvb;
1266	1263	InfoReverbEX rvb2;
1267		-#ifdef REV_EX2
1268		- InfoReverbEX2 rvb3;
1269		-#endif
1270	1264	int rev_type;
1271	1265	} Info_GS_Reverb;
1272	1266

		@@ -1556,12 +1550,10 @@ typedef struct {
1556	1550	double rev_level, rev_wet, rev_dry;
1557	1551	int32 leveli;
1558	1552	InfoPreFilter bpf;
1559		-// InfoReverb rvb;
	1553	+ InfoStandardReverb rvb0;
1560	1554	InfoFreeverb rvb;
1561	1555	InfoReverbEX rvb2;
1562		-#ifdef REV_EX2
1563	1556	InfoReverbEX2 rvb3;
1564		-#endif
1565	1557	int rev_type;
1566	1558	} Info_XG_Reverb1;
1567	1559

		@@ -1571,6 +1563,8 @@ typedef struct {
1571	1563	InfoPreFilter bpf;
1572	1564	// InfoReverb rvb;
1573	1565	InfoPlateReverb rvb;
	1566	+ InfoReverbEX2 rvb3;
	1567	+ int rev_type;
1574	1568	} Info_XG_Plate;
1575	1569
1576	1570	typedef struct {

		@@ -1627,12 +1621,10 @@ typedef struct {
1627	1621	double rev_level, rev_wet, rev_dry;
1628	1622	int32 leveli;
1629	1623	InfoPreFilter bpf;
1630		-// InfoReverb rvb;
	1624	+ InfoStandardReverb rvb0;
1631	1625	InfoFreeverb rvb;
1632	1626	InfoReverbEX rvb2;
1633		-#ifdef REV_EX2
1634	1627	InfoReverbEX2 rvb3;
1635		-#endif
1636	1628	int rev_type;
1637	1629	} Info_XG_Reverb2;
1638	1630

		@@ -2156,17 +2148,18 @@ typedef struct {
2156	2148	int8 rev_type;
2157	2149	double level;
2158	2150	int32 leveli;
	2151	+ InfoStandardReverb rvb0;
2159	2152	InfoFreeverb rvb;
2160	2153	InfoReverbEX rvb2;
2161		-#ifdef REV_EX2
2162	2154	InfoReverbEX2 rvb3;
2163		-#endif
2164	2155	} Info_SD_Rev_Reverb;
2165	2156
2166	2157	typedef struct {
2167	2158	double level;
2168	2159	int32 leveli;
2169	2160	InfoPlateReverb rvb;
	2161	+ InfoReverbEX2 rvb3;
	2162	+ int rev_type;
2170	2163	} Info_SD_Rev_Plate;
2171	2164
2172	2165	typedef struct {

		@@ -2338,9 +2331,6 @@ typedef struct {
2338	2331	// InfoReverb rvb;
2339	2332	InfoFreeverb rvb;
2340	2333	InfoReverbEX rvb2;
2341		-#ifdef REV_EX2
2342		- InfoReverbEX2 rvb3;
2343		-#endif
2344	2334	int rev_type;
2345	2335	InfoEQ2 eq;
2346	2336	} Info_SD_Reverb;

		@@ -2760,9 +2750,7 @@ EXTERN struct reverb_status_gs_t
2760	2750	InfoPlateReverb info_plate_reverb;
2761	2751	InfoFreeverb info_freeverb;
2762	2752	InfoReverbEX info_reverb_ex;
2763		-#ifdef REV_EX2
2764	2753	InfoReverbEX2 info_reverb_ex2;
2765		-#endif
2766	2754	InfoDelay3 info_reverb_delay;
2767	2755	InfoPreFilter lpf;
2768	2756	} reverb_status_gs;

		@@ -3053,6 +3041,10 @@ extern int ext_reverb_ex_ap_num;
3053	3041	//extern int ext_reverb_ex_ap_type;
3054	3042	extern int ext_reverb_ex_mod;
3055	3043
	3044	+extern double ext_reverb_ex2_level;
	3045	+extern int ext_reverb_ex2_rsmode;
	3046	+extern int ext_reverb_ex2_fftmode;
	3047	+
3056	3048	extern double ext_plate_reverb_level;
3057	3049	extern double ext_plate_reverb_time;
3058	3050

--- a/timidity/instrum.c

+++ b/timidity/instrum.c

		@@ -930,6 +930,7 @@ static void apply_bank_parameter(Instrument ip, ToneBankElement tone)
930	930	if (tone->vfxnum[k])
931	931	for (i = 0; i < ip->samples; i++) {
932	932	sp = &ip->sample[i];
	933	+ sp->vfxe_num = tone->vfxe_num;
933	934	if (tone->vfxnum[k] == 1) {
934	935	for (j = 0; j < VOICE_EFFECT_PARAM_NUM; j++)
935	936	sp->vfx[k][j] = tone->vfx[k][0][j];

		@@ -2455,6 +2456,7 @@ static void init_tone_bank_element(ToneBankElement *tone)
2455	2456	tone->def_pan = -1;
2456	2457	tone->sample_pan = -1;
2457	2458	tone->sample_width = -1;
	2459	+ tone->vfxe_num = 0;
2458	2460	}
2459	2461
2460	2462	///r

--- a/timidity/instrum.h

+++ b/timidity/instrum.h

		@@ -73,6 +73,7 @@ typedef struct _Sample {
73	73	int lpf_type;
74	74	int32 root_freq_org, sample_rate_org;
75	75	int hpf[HPF_PARAM_NUM];
	76	+ int vfxe_num;
76	77	int vfx[VOICE_EFFECT_NUM][VOICE_EFFECT_PARAM_NUM];
77	78	int8 keep_voice;
78	79	int8 def_pan;

		@@ -192,7 +193,8 @@ typedef struct {
192	193	int vibfcnum, vibampnum, vibdelaynum, vibfreqnum, vibsweepnum, vibpitchnum;
193	194	int16 vibfc, vibamp, vibdelay, vibfreq, vibsweep, vibpitch;
194	195	// other
195		- int8 reverb_send, chorus_send, delay_send;
	196	+ int8 reverb_send, chorus_send, delay_send;
	197	+ int vfxe_num;
196	198	int vfxnum[VOICE_EFFECT_NUM];
197	199	int **vfx[VOICE_EFFECT_NUM];
198	200	int is_preset;

--- a/timidity/int_synth.c

+++ b/timidity/int_synth.c

		@@ -6585,8 +6585,6 @@ void compute_voice_mms(int v, DATA_T *ptr, int32 count)
6585	6585
6586	6586
6587	6587	///// init / free
6588		-int cfg_flg_int_synth_scc = 0;
6589		-int cfg_flg_int_synth_mms = 0;
6590	6588
6591	6589	void free_int_synth_preset(void)
6592	6590	{

		@@ -6626,60 +6624,15 @@ void free_int_synth_preset(void)
6626	6624
6627	6625	void free_int_synth(void)
6628	6626	{
6629		- int i;
6630		-
6631	6627	free_int_synth_preset();
6632	6628	free_is_editor_preset();
6633	6629	la_pcm_data_load_flg = 0;
6634		-
6635		- if (voice) {
6636		- for(i = 0; i < max_voices; i++) {
6637		- Voice *vp = voice + i;
6638		-
6639		- if(!vp)
6640		- return;
6641		- if(vp->scc){
6642		- free(vp->scc);
6643		- vp->scc = NULL;
6644		- }
6645		- if(vp->mms){
6646		- free(vp->mms);
6647		- vp->mms = NULL;
6648		- }
6649		-
6650		- }
6651		- }
6652		- cfg_flg_int_synth_scc = 0;
6653		- cfg_flg_int_synth_mms = 0;
6654	6630	}
6655	6631
6656	6632	void init_int_synth(void)
6657	6633	{
6658		- int i;
6659		-
6660	6634	set_sample_rate();
6661	6635	init_int_synth_lite();
6662		-
6663		- if (voice) {
6664		- for(i = 0; i < max_voices; i++) {
6665		- Voice *vp = voice + i;
6666		-
6667		- if(!vp)
6668		- continue;
6669		- if(cfg_flg_int_synth_scc && !vp->scc){
6670		- vp->scc = (InfoIS_SCC *)safe_malloc(sizeof(InfoIS_SCC));
6671		- if(!vp->scc)
6672		- continue;
6673		- memset(vp->scc, 0, sizeof(InfoIS_SCC));
6674		- }
6675		- if(cfg_flg_int_synth_mms && !vp->mms){
6676		- vp->mms = (InfoIS_MMS *)safe_malloc(sizeof(InfoIS_MMS));
6677		- if(!vp->mms)
6678		- continue;
6679		- memset(vp->mms, 0, sizeof(InfoIS_MMS));
6680		- }
6681		- }
6682		- }
6683	6636	}
6684	6637
6685	6638

--- a/timidity/int_synth.h

+++ b/timidity/int_synth.h

		@@ -358,8 +358,6 @@ extern void damper_int_synth_mms(int v, int8 damper);
358	358	extern void compute_voice_mms(int v, DATA_T *ptr, int32 count);
359	359
360	360	/************** interface function internal synth **************/
361		-extern int cfg_flg_int_synth_scc;
362		-extern int cfg_flg_int_synth_mms;
363	361	extern void free_int_synth_preset(void);
364	362	extern void free_int_synth(void);
365	363	extern void init_int_synth(void);

--- a/timidity/loadsndfontini.h

+++ b/timidity/loadsndfontini.h

		@@ -304,6 +304,10 @@
304	304	//ext_reverb_ex_rv_type = MyIni_GetInt32(sec, "Ext_EX_RV_Type", 1);
305	305	//ext_reverb_ex_ap_type = MyIni_GetInt32(sec, "Ext_EX_AP_Type", 0);
306	306	ext_reverb_ex_mod = MyIni_GetInt32(sec, "Ext_EX_Mod", 0);
	307	+ // reverb ex2
	308	+ ext_reverb_ex2_level = MyIni_GetFloat32(sec, "Ext_SR_Level", 1.0);
	309	+ ext_reverb_ex2_rsmode = MyIni_GetInt32(sec, "Ext_SR_RS_Mode", 3);
	310	+ ext_reverb_ex2_fftmode = MyIni_GetInt32(sec, "Ext_SR_FFT_Mode", 0);
307	311	// plate reverb
308	312	ext_plate_reverb_level = MyIni_GetFloat32(sec, "Ext_Plate_Level", 1.0);
309	313	ext_plate_reverb_level = MyIniParamRange(ext_plate_reverb_level, 0.001, 8.0);

--- a/timidity/mix.c

+++ b/timidity/mix.c

		@@ -166,7 +166,6 @@ void free_mix_c(void)
166	166	/************** **************/
167	167
168	168
169		-#ifdef NEW_LEGATO
170	169	static void compute_portament(int v, int32 c)
171	170	{
172	171	Voice *vp = &voice[v];

		@@ -194,30 +193,6 @@ static void compute_portament(int v, int32 c)
194	193	}
195	194	vp->porta_out = vp->porta_pb - vp->porta_note_fine;
196	195	}
197		-#else
198		-static void compute_portament(int v, int32 c)
199		-{
200		- Voice *vp = &voice[v];
201		- int32 d;
202		-
203		- if(!vp->porta_status)
204		- return;
205		- d = vp->porta_dpb * c;
206		- if(d < 1)
207		- d = 1;
208		- if(vp->porta_pb < 0){
209		- if(d > -vp->porta_pb)
210		- d = -vp->porta_pb;
211		- }else{
212		- if(d > vp->porta_pb)
213		- d = -vp->porta_pb;
214		- else
215		- d = -d;
216		- }
217		- if((vp->porta_pb += d) == 0)
218		- vp->porta_status = 0;
219		-}
220		-#endif
221	196
222	197	static inline void update_tremolo(int v)
223	198	{

--- a/timidity/playmidi.c

+++ b/timidity/playmidi.c

		@@ -382,9 +382,7 @@ static double get_play_note_ratio(int, int);
382	382	static int find_voice(MidiEvent *);
383	383	static void finish_note(int i);
384	384	static void update_portamento_controls(int ch);
385		-#ifdef NEW_LEGATO
386	385	static void update_legato_status(int ch);
387		-#endif
388	386	static void update_rpn_map(int ch, int addr, int update_now);
389	387	static void ctl_prog_event(int ch);
390	388	///r

		@@ -465,12 +463,115 @@ int use_vst_channel = 0;
465	463	#endif /* POW2 */
466	464
467	465
468		-
469	466	static inline int clip_int(int val, int min, int max)
470	467	{
471	468	return ((val > max) ? max : (val < min) ? min : val);
472	469	}
473	470
	471	+
	472	+
	473	+#ifdef VOICE_EFFECT
	474	+int cfg_flg_vfx = 0;
	475	+#endif
	476	+#ifdef INT_SYNTH
	477	+int cfg_flg_int_synth_scc = 0;
	478	+int cfg_flg_int_synth_mms = 0;
	479	+#endif
	480	+
	481	+// free voice[]
	482	+void free_voice_pointer(void)
	483	+{
	484	+ int i, j;
	485	+
	486	+ if (!voice)
	487	+ return;
	488	+
	489	+ for(i = 0; i < max_voices; i++) {
	490	+ Voice *vp = voice + i;
	491	+
	492	+ if(!vp)
	493	+ continue;
	494	+#ifdef VOICE_EFFECT
	495	+ for(j = 0; j < VOICE_EFFECT_NUM; j++){
	496	+ if(vp->vfx[j]){
	497	+ free(vp->vfx[j]);
	498	+ vp->vfx[j] = NULL;
	499	+ }
	500	+ }
	501	+#endif
	502	+#ifdef INT_SYNTH
	503	+ if(vp->scc){
	504	+ free(vp->scc);
	505	+ vp->scc = NULL;
	506	+ }
	507	+ if(vp->mms){
	508	+ free(vp->mms);
	509	+ vp->mms = NULL;
	510	+ }
	511	+#endif
	512	+ }
	513	+
	514	+ safe_free(voice);
	515	+ voice = NULL;
	516	+}
	517	+
	518	+// Allocate voice[]
	519	+void init_voice_pointer(void)
	520	+{
	521	+ int i, j, error = 0;
	522	+
	523	+ voice = (Voice*) safe_calloc(max_voices, sizeof(Voice));
	524	+ memset(voice, 0, sizeof(voice));
	525	+ if (!voice)
	526	+ return;
	527	+ for(i = 0; i < max_voices; i++) {
	528	+ Voice *vp = voice + i;
	529	+
	530	+ if(!vp){
	531	+ error++;
	532	+ break;
	533	+ }
	534	+#ifdef VOICE_EFFECT
	535	+ if(cfg_flg_vfx){
	536	+ for(j = 0; j < VOICE_EFFECT_NUM; j++){
	537	+ if(!vp->vfx[j]){
	538	+ vp->vfx[j] = (VoiceEffect *)safe_malloc(sizeof(VoiceEffect));
	539	+ if(!vp->vfx[j]){
	540	+ error++;
	541	+ break;
	542	+ }
	543	+ memset(vp->vfx[j], 0, sizeof(VoiceEffect));
	544	+ }
	545	+ }
	546	+ }
	547	+#endif
	548	+#ifdef INT_SYNTH
	549	+ if(cfg_flg_int_synth_scc && !vp->scc){
	550	+ vp->scc = (InfoIS_SCC *)safe_malloc(sizeof(InfoIS_SCC));
	551	+ if(!vp->scc){
	552	+ error++;
	553	+ break;
	554	+ }
	555	+ memset(vp->scc, 0, sizeof(InfoIS_SCC));
	556	+ }
	557	+ if(cfg_flg_int_synth_mms && !vp->mms){
	558	+ vp->mms = (InfoIS_MMS *)safe_malloc(sizeof(InfoIS_MMS));
	559	+ if(!vp->mms){
	560	+ error++;
	561	+ break;
	562	+ }
	563	+ memset(vp->mms, 0, sizeof(InfoIS_MMS));
	564	+ }
	565	+#endif
	566	+ }
	567	+
	568	+ if(error)
	569	+ free_voice_pointer();
	570	+}
	571	+
	572	+
	573	+
	574	+
474	575	void init_playmidi(void){
475	576	int i, tmp, tmp2;
476	577	#ifdef ALIGN_SIZE

		@@ -618,7 +719,15 @@ void free_playmidi(void)
618	719	ch_buffer[i] = NULL;
619	720	}
620	721	}
621		-#endif
	722	+#endif
	723	+
	724	+#ifdef VOICE_EFFECT
	725	+ if (!voice)
	726	+ return;
	727	+ for(i = 0; i < max_voices; i++) {
	728	+ free_voice_effect(i);
	729	+ }
	730	+#endif
622	731	}
623	732
624	733

		@@ -802,23 +911,6 @@ static void swap_voices(Voice a, Voice b)
802	911	memcpy(b, &swap, sizeof(Voice));
803	912	}
804	913
805		-static void dup_voices(Voice dst, const Voice src)
806		-{
807		-#ifdef VOICE_EFFECT
808		- VoiceEffect backup_vfx[VOICE_EFFECT_NUM];
809		-
810		- /* backup pointer */
811		- memcpy(&backup_vfx, dst->vfx, sizeof(VoiceEffect) * VOICE_EFFECT_NUM);
812		- /* duplicate voice */
813		- memmove(dst, src, sizeof(Voice));
814		- /* restore pointer */
815		- memcpy(dst->vfx, &backup_vfx, sizeof(VoiceEffect) * VOICE_EFFECT_NUM);
816		-#else
817		- /* duplicate voice */
818		- memmove(dst, src, sizeof(Voice));
819		-#endif
820		-}
821		-
822	914	static void reset_voices(void)
823	915	{
824	916	int i;

		@@ -989,18 +1081,12 @@ static void initialize_controllers(int c)
989	1081	channel[c].mono = 0;
990	1082	channel[c].portamento_time_lsb = 0;
991	1083	channel[c].portamento_time_msb = 0;
992		-
993		-#ifdef NEW_LEGATO
994	1084	channel[c].porta_status = 0;
995	1085	channel[c].porta_last_note_fine = -1;
996	1086	channel[c].legato_status = 0;
997	1087	channel[c].legato_flag = 0;
998	1088	channel[c].legato_note = 255;
999	1089	channel[c].legato_note_time = 0;
1000		-#else
1001		- channel[c].legato = -1;
1002		- channel[c].porta_status = 0;
1003		-#endif
1004	1090
1005	1091	set_reverb_level(c, -1);
1006	1092	if(opt_chorus_control == 1)

		@@ -1167,18 +1253,11 @@ static void reset_controllers(int c)
1167	1253	channel[c].sustain = 0;
1168	1254	channel[c].sostenuto = 0;
1169	1255	channel[c].pitchbend = 0x2000;
1170		-#ifdef NEW_LEGATO
1171	1256	channel[c].portamento = 0;
1172	1257	channel[c].portamento_control = -1;
1173	1258	update_portamento_controls(c);
1174	1259	channel[c].legato = -1;
1175	1260	update_legato_status(c);
1176		-#else
1177		- channel[c].portamento = 0;
1178		- channel[c].portamento_control = -1;
1179		- channel[c].last_note_fine = -1;
1180		- update_portamento_controls(c);
1181		-#endif
1182	1261	channel[c].lastlrpn = channel[c].lastmrpn = 0;
1183	1262	channel[c].nrpn = -1;
1184	1263	channel[c].rpn_7f7f_flag = 1;

		@@ -1805,7 +1884,6 @@ void recompute_voice_pitch(int v)
1805	1884	}
1806	1885	}
1807	1886	/* Portamento / Legato */
1808		-#ifdef NEW_LEGATO
1809	1887	if (opt_portamento){
1810	1888	#if (PORTAMENTO_CONTROL_BIT == 13)
1811	1889	tuning += vp->porta_out;

		@@ -1813,15 +1891,6 @@ void recompute_voice_pitch(int v)
1813	1891	tuning += (vp->porta_out << (13 - PORTAMENTO_CONTROL_BIT)); // tuning(13bit)
1814	1892	#endif
1815	1893	}
1816		-#else
1817		- if (vp->porta_status){
1818		-#if (PORTAMENTO_CONTROL_BIT == 13)
1819		- tuning += vp->porta_pb;
1820		-#else
1821		- tuning += (vp->porta_pb << (13 - PORTAMENTO_CONTROL_BIT)); // tuning(13bit)
1822		-#endif
1823		- }
1824		-#endif
1825	1894	/* calc freq / / XG Detune / / GS Pitch Offset Fine */
1826	1895	if (tuning == 0){
1827	1896	if (cp->detune == 1.0 && vp->sample->tune == 1.0 && cp->pitch_offset_fine == 0.0){

		@@ -2113,7 +2182,7 @@ static void recompute_voice_filter2(int v)
2113	2182	Channel *cp = channel + ch;
2114	2183	int val;
2115	2184	FLOAT_T freq, reso, cent, coef = 1.0;
2116		- FilterCoefficients *fc = &(vp->fc2);
	2185	+ FilterCoefficients *fc = &vp->fc2;
2117	2186
2118	2187	if(fc->type == 0) {return;}
2119	2188

		@@ -2152,7 +2221,7 @@ void recompute_voice_filter(int v)
2152	2221	Channel *cp = channel + ch;
2153	2222	int val;
2154	2223	FLOAT_T freq, reso, cent, coef = 1.0, depth1 = 0, depth2 = 0;
2155		- FilterCoefficients *fc = &(vp->fc);
	2224	+ FilterCoefficients *fc = &vp->fc;
2156	2225	Sample *sp = vp->sample;
2157	2226
2158	2227	recompute_voice_filter2(v); // hpf

		@@ -3010,25 +3079,6 @@ void free_voice(int v1)
3010	3079	voice[v1].temper_instant = 0;
3011	3080	}
3012	3081
3013		-///r
3014		-void free_voices(void)
3015		-{
3016		- int i;
3017		-
3018		-// free_int_synth();
3019		- if (voice) {
3020		- for(i = 0; i < max_voices; i++) {
3021		-#ifdef VOICE_EFFECT
3022		- uninit_voice_effect(i);
3023		-#endif
3024		- free_voice(i);
3025		- }
3026		- }
3027		-
3028		- safe_free(voice);
3029		- voice = NULL;
3030		-}
3031		-
3032	3082	static int find_free_voice(void)
3033	3083	{
3034	3084	int i, nv = voices, lowest;

		@@ -3560,7 +3610,6 @@ static void update_modulation_wheel(int ch)
3560	3610	}
3561	3611
3562	3612
3563		-#ifdef NEW_LEGATO
3564	3613	static void drop_portamento(int ch)
3565	3614	{
3566	3615	int i, uv = upper_voices;

		@@ -3907,123 +3956,7 @@ ctl->cmsg(CMSG_INFO,VERB_NORMAL,
3907	3956	#endif
3908	3957	}
3909	3958
3910		-#else //
3911		-static void drop_portamento(int ch)
3912		-{
3913		- int i, uv = upper_voices;
3914		-
3915		- channel[ch].porta_status = 0;
3916		- for(i = 0; i < uv; i++)
3917		- if(voice[i].status != VOICE_FREE &&
3918		- voice[i].channel == ch &&
3919		- voice[i].porta_status)
3920		- {
3921		- voice[i].porta_status = 0;
3922		- // recompute_freq(i);
3923		- recompute_voice_pitch(i);
3924		- }
3925		- //channel[ch].last_note_fine = -1;
3926		-}
3927		-
3928		-static void update_portamento_controls(int ch)
3929		-{
3930		- if(!channel[ch].portamento){
3931		- // \|\| (channel[ch].portamento_time_msb \| channel[ch].portamento_time_lsb) == 0){
3932		- if(channel[ch].porta_status)
3933		- drop_portamento(ch);
3934		- } else {
3935		- const double tuning = PORTAMENTO_TIME_TUNING * 256.0 * 256.0;
3936		- double mt, st;
3937		- mt = midi_time_table[channel[ch].portamento_time_msb & 0x7F] *
3938		- midi_time_table2[channel[ch].portamento_time_lsb & 0x7F] * tuning;
3939		- st = (double)1000.0 / mt; // semitone/sec
3940		- channel[ch].porta_dpb = st * PORTAMENTO_CONTROL_RATIO * div_playmode_rate;
3941		- channel[ch].porta_status = 1;
3942		- }
3943		-}
3944		-
3945		-static void update_portamento_time(int ch)
3946		-{
3947		- int i, uv = upper_voices;
3948		- int dpb;
3949		- int32 ratio;
3950	3959
3951		- update_portamento_controls(ch);
3952		- dpb = channel[ch].porta_dpb;
3953		- ratio = channel[ch].porta_status;
3954		-
3955		- for(i = 0; i < uv; i++)
3956		- {
3957		- if(voice[i].status != VOICE_FREE &&
3958		- voice[i].channel == ch &&
3959		- voice[i].porta_status)
3960		- {
3961		- voice[i].porta_status = ratio;
3962		- voice[i].porta_dpb = dpb;
3963		- // recompute_freq(i);
3964		- recompute_voice_pitch(i);
3965		- }
3966		- }
3967		-}
3968		-
3969		-static void update_legato_controls(int ch)
3970		-{
3971		-#if 1
3972		-// const double ss = 4069.0104166666670; // semitone / sec
3973		- const double ss = 12000.0; // semitone / sec
3974		- channel[ch].porta_dpb = ss * PORTAMENTO_CONTROL_RATIO * div_playmode_rate;
3975		-#else
3976		- const double st = 1.0 / 0.06250 * PORTAMENTO_TIME_TUNING * 0.3 * 256.0 * 256;
3977		- double st = (double)1.0 / mt; // semitone / ms
3978		- channel[ch].porta_dpb = st * PORTAMENTO_CONTROL_RATIO * 1000.0 * div_playmode_rate;
3979		-#endif
3980		- channel[ch].porta_status = 1;
3981		-}
3982		-
3983		-/! initialize portamento or legato for a voice. /
3984		-static void init_voice_portamento(int v)
3985		-{
3986		- Voice *vp = &(voice[v]);
3987		- int ch = vp->channel;
3988		-
3989		- vp->porta_status = 0;
3990		- if(channel[ch].porta_status) {
3991		- vp->porta_status = channel[ch].porta_status;
3992		- vp->porta_dpb = channel[ch].porta_dpb;
3993		- vp->porta_pb = channel[ch].porta_pb;
3994		- if(vp->porta_pb == 0) {vp->porta_status = 0;}
3995		- }
3996		-}
3997		-
3998		-/! initialize portamento or legato for a channel. /
3999		-static void init_channel_portamento(MidiEvent *e)
4000		-{
4001		- int i, ch = e->channel, note = MIDI_EVENT_NOTE(e);
4002		- int32 times, fine = note * PORTAMENTO_CONTROL_RATIO;
4003		-
4004		- if(channel[ch].portamento_control != -1){ // portament_control
4005		- if(!channel[ch].porta_status)
4006		- update_portamento_controls(ch);
4007		- channel[ch].porta_pb = channel[ch].portamento_control * PORTAMENTO_CONTROL_RATIO - fine;
4008		- channel[ch].portamento_control = -1;
4009		- }else if(channel[ch].portamento){
4010		- if(!channel[ch].porta_status)
4011		- update_portamento_controls(ch);
4012		- if(channel[ch].last_note_fine == -1) /* first on */
4013		- channel[ch].last_note_fine = fine;
4014		- channel[ch].porta_pb = channel[ch].last_note_fine - fine;
4015		- }else if(channel[ch].legato){
4016		- if(channel[ch].legato_flag){
4017		- update_legato_controls(ch);
4018		- if(channel[ch].last_note_fine == -1) /* first on */
4019		- channel[ch].last_note_fine = fine;
4020		- channel[ch].porta_pb = channel[ch].last_note_fine - fine;
4021		- }
4022		- channel[ch].legato_flag = 1;
4023		- }
4024		- channel[ch].last_note_fine = fine;
4025		-}
4026		-#endif /* NEW_LEGATO */
4027	3960
4028	3961	///r
4029	3962	static void recompute_amp_envelope_follow(int v, int ch)

		@@ -4380,17 +4313,19 @@ static void init_voice_envelope(int i)
4380	4313	// called mix.c mix_voice() , thread_mix.c mix_voice_thread()
4381	4314	void update_voice(int i)
4382	4315	{
	4316	+ Voice *vp = voice + i;
	4317	+
4383	4318	// 同時処理が必要になったらビットフラグ分岐に変更する可能性があるので定数は2^nにしておく
4384	4319	// playmidi.h /* update_voice options: */
4385		- switch(voice[i].update_voice){
	4320	+ switch(vp->update_voice){
4386	4321	case UPDATE_VOICE_FINISH_NOTE: // finish note
4387		- reset_envelope0_release(&voice[i].amp_env, ENV0_KEEP);
4388		- reset_envelope0_release(&voice[i].mod_env, ENV0_KEEP);
4389		- reset_envelope4_noteoff(&voice[i].pit_env);
	4322	+ reset_envelope0_release(&vp->amp_env, ENV0_KEEP);
	4323	+ reset_envelope0_release(&vp->mod_env, ENV0_KEEP);
	4324	+ reset_envelope4_noteoff(&vp->pit_env);
4390	4325	#ifdef INT_SYNTH
4391		- if(voice[i].sample->inst_type == INST_MMS)
	4326	+ if(vp->sample->inst_type == INST_MMS)
4392	4327	noteoff_int_synth_mms(i);
4393		- else if(voice[i].sample->inst_type == INST_SCC)
	4328	+ else if(vp->sample->inst_type == INST_SCC)
4394	4329	noteoff_int_synth_scc(i);
4395	4330	#endif
4396	4331	#ifdef VOICE_EFFECT

		@@ -4398,16 +4333,16 @@ void update_voice(int i)
4398	4333	#endif
4399	4334	break;
4400	4335	case UPDATE_VOICE_CUT_NOTE: // cut_note
4401		- reset_envelope0_release(&voice[i].amp_env, cut_short_rate);
	4336	+ reset_envelope0_release(&vp->amp_env, cut_short_rate);
4402	4337	break;
4403	4338	case UPDATE_VOICE_CUT_NOTE2: // cut_note2
4404		- reset_envelope0_release(&voice[i].amp_env, cut_short_rate2);
	4339	+ reset_envelope0_release(&vp->amp_env, cut_short_rate2);
4405	4340	break;
4406	4341	case UPDATE_VOICE_KILL_NOTE: // kill_note
4407		- reset_envelope0_release(&voice[i].amp_env, ramp_out_rate);
	4342	+ reset_envelope0_release(&vp->amp_env, ramp_out_rate);
4408	4343	break;
4409	4344	}
4410		- voice[i].update_voice = 0; // flag clear
	4345	+ vp->update_voice = 0; // flag clear
4411	4346	}
4412	4347
4413	4348	// called mix.c mix_voice() , thread_mix.c mix_voice_thread()

		@@ -4636,14 +4571,9 @@ static void note_on(MidiEvent *e)
4636	4571	if(!channel[ch].program_flag) // PCがなかった場合(recompute_bank_paramしてない場合
4637	4572	recompute_bank_parameter_tone(ch);
4638	4573	/* portamento , legato */
4639		-#ifdef NEW_LEGATO
4640	4574	if(opt_portamento)
4641	4575	if(init_channel_portamento(e)) /* portamento , legato */
4642	4576	return;
4643		-#else
4644		- if(opt_portamento)
4645		- init_channel_portamento(e); /* portamento , legato */
4646		-#endif
4647	4577	}
4648	4578
4649	4579	if(! opt_realtime_playing && emu_delay_time > 0)

		@@ -4748,7 +4678,6 @@ static void note_off(MidiEvent *e)
4748	4678	}
4749	4679	}
4750	4680	/* legato */
4751		-#ifdef NEW_LEGATO
4752	4681	if(opt_portamento){
4753	4682	int tmp = note_off_legato(e); // -2:return -1:thru 0<=:change note
4754	4683	if(tmp < -1)

		@@ -4756,10 +4685,6 @@ static void note_off(MidiEvent *e)
4756	4685	else if(tmp >= 0)
4757	4686	note = tmp;
4758	4687	}
4759		-#else
4760		- if(opt_portamento)
4761		- channel[ch].legato_flag = 1;
4762		-#endif
4763	4688
4764	4689	if ((vid = last_vidq(ch, note)) == -1)
4765	4690	return;

		@@ -10732,7 +10657,6 @@ static int apply_controls(void)
10732	10657	case RC_NEXT: /* >>\| */
10733	10658	case RC_REALLY_PREVIOUS: /* \|<< */
10734	10659	case RC_TUNE_END: /* skip */
10735		- // free_voices();
10736	10660	aq_flush(1);
10737	10661	return rc;
10738	10662

--- a/timidity/playmidi.h

+++ b/timidity/playmidi.h

		@@ -378,7 +378,6 @@ typedef struct {
378	378	int pitchbend;
379	379
380	380	/* For portamento */
381		-#ifdef NEW_LEGATO
382	381	int8 portamento, portamento_control;
383	382	uint8 portamento_time_msb, portamento_time_lsb;
384	383	int porta_status;

		@@ -390,16 +389,7 @@ typedef struct {
390	389	int8 legato_flag; /* note-on flag for legato */
391	390	uint8 legato_note, legato_last_note, legato_velo, legato_hist[128];
392	391	int32 legato_note_time;
393		-#else
394		- int8 portamento, portamento_control;
395		- uint8 portamento_time_msb, portamento_time_lsb;
396		- int porta_status;
397		- FLOAT_T porta_dpb;
398		- int32 porta_pb;
399		- int32 last_note_fine;
400		- int8 legato; /* legato footswitch */
401		- int8 legato_flag; /* note-on flag for legato */
402		-#endif
	392	+
403	393	/* For Drum part */
404	394	struct DrumParts *drums[128];
405	395

		@@ -532,27 +522,18 @@ typedef struct {
532	522	FLOAT_T pitchfactor, orig_pitchfactor; /* precomputed pitch bend factor to save some fdiv's */
533	523
534	524	/* for portamento */
535		-#ifdef NEW_LEGATO
536	525	int porta_status;
537	526	FLOAT_T porta_dpb;
538	527	int32 porta_pb, porta_next_pb, porta_out, porta_note_fine;
539		-#else
540		- int porta_status;
541		- FLOAT_T porta_dpb;
542		- int32 porta_pb;
543		-#endif
544	528
545	529	/* for cache */
546	530	struct cache_hash *cache;
547	531
548	532	/* for envelope */
549	533	int delay; /* Note ON delay samples */
550		- int32 modenv_delay;
551	534	int32 mod_update_count;
552	535	int add_delay_cnt;
553	536	Envelope0 amp_env, mod_env;
554		- int32 pit_env_release_count;
555		- FLOAT_T pit_env_release_cent;
556	537	Envelope4 pit_env;
557	538
558	539	/* for amp/mix */

		@@ -583,8 +564,8 @@ typedef struct {
583	564
584	565	/* for voive effect */
585	566	#ifdef VOICE_EFFECT
586		- int voice_effect_flg; // use/nouse
587		- VoiceEffect vfx[VOICE_EFFECT_NUM]; // Voive Effect
	567	+ int vfxe_num;
	568	+ VoiceEffect *vfx[VOICE_EFFECT_NUM]; // Voive Effect
588	569	#endif
589	570
590	571	/* for int synth */

		@@ -902,7 +883,6 @@ extern void playmidi_output_changed(int play_state);
902	883	extern Instrument play_midi_load_instrument(int dr, int bk, int prog, int elm, int elm_max);
903	884	extern void midi_program_change(int ch, int prog);
904	885	extern void free_voice(int v);
905		-extern void free_voices(void);
906	886	//extern void free_reverb_buffer(void);
907	887	extern void play_midi_setup_drums(int ch,int note);
908	888

		@@ -934,4 +914,15 @@ extern void update_voice(int i);
934	914	extern int calc_bend_val(int val);
935	915	extern void kill_all_voices(void);
936	916
	917	+
	918	+#ifdef VOICE_EFFECT
	919	+extern int cfg_flg_vfx;
	920	+#endif
	921	+#ifdef INT_SYNTH
	922	+extern int cfg_flg_int_synth_scc;
	923	+extern int cfg_flg_int_synth_mms;
	924	+#endif
	925	+extern void free_voice_pointer(void);
	926	+extern void init_voice_pointer(void);
	927	+
937	928	#endif /* ___PLAYMIDI_H_ */

--- a/timidity/sndfontini.c

+++ b/timidity/sndfontini.c

		@@ -12,6 +12,8 @@
12	12
13	13	Sample OverrideSample = {0};
14	14	OVERRIDETIMIDITYDATA otd = {0};
	15	+char sfini_path[FILEPATH_MAX] = "";
	16	+
15	17
16	18	#if defined(__W32__)
17	19

		@@ -30,6 +32,7 @@ void timdrvOverrideSFSettingLoad(void)
30	32	fn[strlen(fn) - 1] = 0;
31	33	strlcat(fn, "\\", FILEPATH_MAX);
32	34	strlcat(fn, "timdrv_soundfont.ini", FILEPATH_MAX);
	35	+ memcpy(sfini_path, fn, FILEPATH_MAX);
33	36
34	37	#include "loadsndfontini.h"
35	38	}

		@@ -60,6 +63,7 @@ void OverrideSFSettingLoad(const char *kbini, int size)
60	63	}
61	64	#endif
62	65	strlcat(fn,"soundfont.ini",FILEPATH_MAX);
	66	+ memcpy(sfini_path, fn, FILEPATH_MAX);
63	67	#include "loadsndfontini.h"
64	68	}
65	69

		@@ -83,6 +87,7 @@ void OverrideSFSettingLoad()
83	87	fn[2] = '\0';
84	88	}
85	89	strlcat(fn,"soundfont.ini",FILEPATH_MAX);
	90	+ memcpy(sfini_path, fn, FILEPATH_MAX);
86	91	#include "loadsndfontini.h"
87	92	}
88	93

		@@ -111,6 +116,7 @@ void OverrideSFSettingLoad()
111	116	}
112	117
113	118	strlcat(fn,"soundfont.ini",FILEPATH_MAX);
	119	+ memcpy(sfini_path, fn, FILEPATH_MAX);
114	120
115	121	#include "loadsndfontini.h"
116	122

		@@ -132,6 +138,7 @@ void OverrideSFSettingLoad()
132	138	#endif
133	139	strlcat(fn, PATH_STRING, FILEPATH_MAX);
134	140	strlcat(fn, "soundfont.ini", FILEPATH_MAX);
	141	+ memcpy(sfini_path, fn, FILEPATH_MAX);
135	142	#include "loadsndfontini.h"
136	143	}
137	144

--- a/timidity/sndfontini.h

+++ b/timidity/sndfontini.h

		@@ -95,7 +95,7 @@ typedef struct OverrideTiMidityData {
95	95	short DriverRVolume;
96	96	}OVERRIDETIMIDITYDATA ;
97	97
98		-
	98	+extern char sfini_path[FILEPATH_MAX];
99	99
100	100
101	101	#if defined(WINDRV) \|\| defined(WINDRV_SETUP)

		@@ -170,6 +170,10 @@ extern int ext_reverb_ex_ap_num;
170	170	//extern int ext_reverb_ex_ap_type;
171	171	extern int ext_reverb_ex_mod;
172	172
	173	+extern double ext_reverb_ex2_level;
	174	+extern int ext_reverb_ex2_rsmode;
	175	+extern int ext_reverb_ex2_fftmode;
	176	+
173	177	extern double ext_plate_reverb_level;
174	178	extern double ext_plate_reverb_time;
175	179

--- a/timidity/thread_effect.c

+++ b/timidity/thread_effect.c

		@@ -1885,8 +1885,8 @@ int set_effect_sub_thread(effect_sub_thread_func_t func, void *ptr, int num)
1885	1885	{
1886	1886	//if(!compute_thread_ready) // single thread
1887	1887	// return 1;
1888		- if(compute_thread_ready < 4)
1889		- return 1; //
	1888	+ //if(compute_thread_ready < 4)
	1889	+ // return 1; //
1890	1890	if(!func)
1891	1891	return 1; // error
1892	1892	if(func == est_func0 && ptr == est_ptr0)

--- a/timidity/timidity.c

+++ b/timidity/timidity.c

		@@ -1709,7 +1709,9 @@ static int set_gus_patchconf_opts(const char *name,
1709	1709	if(tone->hpfnum)
1710	1710	free_ptr_list(tone->hpf, tone->hpfnum);
1711	1711	tone->hpf = config_parse_hpfparam(cp, &tone->hpfnum);
	1712	+#ifdef VOICE_EFFECT
1712	1713	}else if (! strcmp(opts, "vfx")){ /* voice effect*/
	1714	+ cfg_flg_vfx = 1;
1713	1715	for (i = 0; i < VOICE_EFFECT_NUM; i++){
1714	1716	if(tone->vfxnum[i]) // already use
1715	1717	continue;

		@@ -1718,8 +1720,10 @@ static int set_gus_patchconf_opts(const char *name,
1718	1720	continue; // error check
1719	1721	}
1720	1722	tone->vfx[i] = config_parse_vfxparam(cp, &tone->vfxnum[i]);
	1723	+ tone->vfxe_num = i + 1;
1721	1724	break;
1722	1725	}
	1726	+#endif
1723	1727	///r
1724	1728	}else {
1725	1729	ctl->cmsg(CMSG_ERROR, VERB_NORMAL,

		@@ -2273,6 +2277,14 @@ MAIN_INTERFACE int read_config_file(const char *name, int self, int allow_missin
2273	2277	char basedir = NULL, sep = NULL;
2274	2278	char *onmemory = NULL;
2275	2279
	2280	+#ifdef VOICE_EFFECT
	2281	+ cfg_flg_vfx = 0;
	2282	+#endif
	2283	+#ifdef INT_SYNTH
	2284	+ cfg_flg_int_synth_mms = 0;
	2285	+ cfg_flg_int_synth_scc = 0;
	2286	+#endif
	2287	+
2276	2288	if (rcf_count > 50)
2277	2289	{
2278	2290	ctl->cmsg(CMSG_ERROR, VERB_NORMAL,

		@@ -8535,9 +8547,8 @@ MAIN_INTERFACE void timidity_init_player(void)
8535	8547	initialize_resampler_coeffs();
8536	8548
8537	8549	/* Allocate voice[] */
8538		- free_voices();
8539		- safe_free(voice);
8540		- voice = (Voice*) safe_calloc(max_voices, sizeof(Voice));
	8550	+ free_voice_pointer();
	8551	+ init_voice_pointer();
8541	8552
8542	8553	/* Set play mode parameters */
8543	8554	if(opt_output_rate != 0)

		@@ -9266,7 +9277,7 @@ int main(int argc, char **argv)
9266	9277	#ifdef INT_SYNTH
9267	9278	free_int_synth();
9268	9279	#endif // INT_SYNTH
9269		- free_voices();
	9280	+ free_voice_pointer();
9270	9281	uninitialize_resampler_coeffs();
9271	9282	for (i = 0; i < MAX_CHANNELS; i++)
9272	9283	free_drum_effect(i);

		@@ -9380,7 +9391,7 @@ static void w32_exit(void)
9380	9391	#ifdef INT_SYNTH
9381	9392	free_int_synth();
9382	9393	#endif // INT_SYNTH
9383		- free_voices();
	9394	+ free_voice_pointer();
9384	9395	uninitialize_resampler_coeffs();
9385	9396	for (i = 0; i < MAX_CHANNELS; i++)
9386	9397	free_drum_effect(i);

--- a/timidity/timidity.h

+++ b/timidity/timidity.h

		@@ -445,7 +445,6 @@
445	445	///r
446	446	#define VOICE_EFFECT
447	447	#define INT_SYNTH
448		-#define NEW_LEGATO
449	448	//#define ENABLE_SFZ
450	449	//#define ENABLE_DLS
451	450

--- a/timidity/voice_effect.c

+++ b/timidity/voice_effect.c

		@@ -2791,113 +2791,81 @@ struct _VFX_Engine vfx_engine[] = {
2791	2791	};
2792	2792
2793	2793
	2794	+/************** interface function VFX **************/
	2795	+
	2796	+// 初期化/終了処理のシンプルにするため InfoVFX_@の固定サイズバファを使用してinit_vfx()の中ではallocしない
	2797	+// なので今のところ uninit_vfx()は不要
2794	2798
2795	2799	void free_voice_effect(int v)
2796	2800	{
2797	2801	int i;
2798	2802
2799	2803	for(i = 0; i < VOICE_EFFECT_NUM; i++){
2800		- VoiceEffect *vfx = &voice[v].vfx[i];
	2804	+ VoiceEffect *vfx = voice[v].vfx[i];
2801	2805
2802		- if(vfx->engine == &(vfx_engine[VFX_NONE]))
	2806	+ if(!vfx)
2803	2807	continue;
2804		- vfx->engine->uninit_vfx(v, vfx);
2805		- vfx->engine = &(vfx_engine[VFX_NONE]);
2806		- safe_free(vfx->info);
2807		- vfx->info = NULL;
	2808	+ if (vfx->info) {
	2809	+ safe_free(vfx->info);
	2810	+ vfx->info = NULL;
	2811	+ }
2808	2812	}
2809		- voice[v].voice_effect_flg = 0;
	2813	+ voice[v].vfxe_num = 0;
2810	2814	}
2811	2815
2812	2816	void init_voice_effect(int v)
2813	2817	{
2814		- int i, j, error = 0, flg = 0;
	2818	+ int i, flg = 0;
2815	2819
2816		- for(i = 0; i < VOICE_EFFECT_NUM; i++){
2817		- VoiceEffect *vfx = &voice[v].vfx[i];
2818		-
2819		- // param[0] = effect type
2820		- memset(&(vfx->param), 0, sizeof(int) * VOICE_EFFECT_PARAM_NUM);
2821		- vfx->engine = NULL;
2822		- for(j = 0; j < VOICE_EFFECT_PARAM_NUM; j++){
2823		- vfx->param[j] = voice[v].sample->vfx[i][j];
2824		- }
2825		- if(vfx->param[0] < 0 \|\| vfx->param[0] >= VFX_LIST_MAX)
2826		- vfx->param[0] = 0;
2827		-
2828		- for(j = 0; vfx_engine[j].type != -1; j++) {
2829		- if (vfx_engine[j].type == vfx->param[0]) {
2830		- vfx->engine = &(vfx_engine[j]);
2831		- break;
2832		- }
2833		- }
2834		- if (vfx->engine == NULL) { // error
2835		- error = 1;
	2820	+ for(i = 0; i < voice[v].sample->vfxe_num; i++){
	2821	+ VoiceEffect *vfx = voice[v].vfx[i];
	2822	+ int num = voice[v].sample->vfx[i][0]; // [0] = effect type
	2823	+
	2824	+ if(num <= VFX_NONE \|\| num >= VFX_LIST_MAX)
2836	2825	break;
2837		- }
	2826	+ memcpy(vfx->param, voice[v].sample->vfx[i], sizeof(int) * VOICE_EFFECT_PARAM_NUM);
	2827	+ vfx->engine = &(vfx_engine[vfx->param[0]]);
2838	2828	if (vfx->info) {
2839	2829	safe_free(vfx->info);
2840	2830	vfx->info = NULL;
2841	2831	}
2842		- if(vfx->param[0] == 0) // effect_none
2843		- continue;
2844	2832	vfx->info = safe_large_malloc(vfx->engine->info_size);
2845	2833	memset(vfx->info, 0, vfx->engine->info_size);
2846	2834	vfx->engine->init_vfx(v, vfx);
2847		- flg += 1; // effect on
	2835	+ flg = i + 1; // effect on
2848	2836	}
2849		- voice[v].voice_effect_flg = flg ? 1 : 0;
2850		- if(error)
2851		- free_voice_effect(v);
	2837	+ voice[v].vfxe_num = flg;
2852	2838	}
2853	2839
2854	2840	void uninit_voice_effect(int v)
2855	2841	{
2856		- int i;
2857		-
2858		- if(!voice[v].voice_effect_flg)
2859		- return;
2860		- free_voice_effect(v);
	2842	+ voice[v].vfxe_num = 0;
2861	2843	}
2862	2844
2863	2845	void noteoff_voice_effect(int v)
2864	2846	{
2865	2847	int i;
2866	2848
2867		- if(!voice[v].voice_effect_flg)
2868		- return;
2869		- for(i = 0; i < VOICE_EFFECT_NUM; i++){
2870		- voice[v].vfx[i].engine->noteoff_vfx(v, &voice[v].vfx[i]);
2871		- }
	2849	+ for(i = 0; i < voice[v].vfxe_num; i++)
	2850	+ voice[v].vfx[i]->engine->noteoff_vfx(v, voice[v].vfx[i]);
2872	2851	}
2873	2852
2874	2853	void damper_voice_effect(int v, int8 damper)
2875	2854	{
2876	2855	int i;
2877	2856
2878		- if(!voice[v].voice_effect_flg)
2879		- return;
2880		- for(i = 0; i < VOICE_EFFECT_NUM; i++){
2881		- voice[v].vfx[i].engine->damper_vfx(v, &voice[v].vfx[i], damper);
2882		- }
	2857	+ for(i = 0; i < voice[v].vfxe_num; i++)
	2858	+ voice[v].vfx[i]->engine->damper_vfx(v, voice[v].vfx[i], damper);
2883	2859	}
2884	2860
2885	2861	void voice_effect(int v, DATA_T *sp, int32 count)
2886	2862	{
2887	2863	int i;
2888		-
2889		- if(!voice[v].voice_effect_flg)
2890		- return;
2891		- for(i = 0; i < VOICE_EFFECT_NUM; i++){
2892		- voice[v].vfx[i].engine->do_vfx(v, &voice[v].vfx[i], sp, count);
2893		- }
	2864	+
	2865	+ for(i = 0; i < voice[v].vfxe_num; i++)
	2866	+ voice[v].vfx[i]->engine->do_vfx(v, voice[v].vfx[i], sp, count);
2894	2867	}
2895	2868
2896		-
2897		-
2898		-
2899		-
2900		-
2901	2869	#undef POW2
2902	2870
2903	2871

--- a/timw32g/timw32g.vcxproj

+++ b/timw32g/timw32g.vcxproj

		@@ -90,8 +90,8 @@
90	90	<LibraryPath Condition="'$(Configuration)\|$(Platform)'=='Release\|x64'">$(VCInstallDir)atlmfc\lib\amd64;$(VCInstallDir)lib\amd64;$(WindowsSdkDir)lib\x64;$(FrameworkSDKDir)\lib\x64;$(WindowsSdkDir)\lib\x64;C:\Program Files\Microsoft SDKs\Windows\v7.1\Lib\x64;</LibraryPath>
91	91	<LibraryPath Condition="'$(Configuration)\|$(Platform)'=='Debug\|Win32'">$(VCInstallDir)lib;$(VCInstallDir)atlmfc\lib;$(WindowsSdkDir)lib;$(FrameworkSDKDir)\lib;$(DXSDK_DIR)\ILib\x86;</LibraryPath>
92	92	<LibraryPath Condition="'$(Configuration)\|$(Platform)'=='Debug\|x64'">$(VCInstallDir)atlmfc\lib\amd64;$(VCInstallDir)lib\amd64;$(WindowsSdkDir)lib\x64;$(FrameworkSDKDir)\lib\x64;$(WindowsSdkDir)\lib\x64;C:\Program Files\Microsoft SDKs\Windows\v7.1\Lib\x64;</LibraryPath>
93		- <TargetName Condition="'$(Configuration)\|$(Platform)'=='Release\|Win32'">timw32g_c222</TargetName>
94		- <TargetName Condition="'$(Configuration)\|$(Platform)'=='Release\|x64'">timw32g_x64_c222</TargetName>
	93	+ <TargetName Condition="'$(Configuration)\|$(Platform)'=='Release\|Win32'">timw32g_c223</TargetName>
	94	+ <TargetName Condition="'$(Configuration)\|$(Platform)'=='Release\|x64'">timw32g_x64_c223</TargetName>
95	95	<TargetName Condition="'$(Configuration)\|$(Platform)'=='Debug\|x64'">$(ProjectName)_x64</TargetName>
96	96	</PropertyGroup>
97	97	<ItemDefinitionGroup Condition="'$(Configuration)\|$(Platform)'=='Debug\|Win32'">

--- a/twsyng/twsyng.vcxproj

+++ b/twsyng/twsyng.vcxproj

		@@ -81,8 +81,8 @@
81	81	<IntDir Condition="'$(Configuration)\|$(Platform)'=='Debug\|x64'">$(Configuration)\</IntDir>
82	82	<LinkIncremental Condition="'$(Configuration)\|$(Platform)'=='Debug\|Win32'">true</LinkIncremental>
83	83	<LinkIncremental Condition="'$(Configuration)\|$(Platform)'=='Debug\|x64'">true</LinkIncremental>
84		- <TargetName Condition="'$(Configuration)\|$(Platform)'=='Release\|Win32'">twsyng_c222</TargetName>
85		- <TargetName Condition="'$(Configuration)\|$(Platform)'=='Release\|x64'">twsyng_x64_c222</TargetName>
	84	+ <TargetName Condition="'$(Configuration)\|$(Platform)'=='Release\|Win32'">twsyng_c223</TargetName>
	85	+ <TargetName Condition="'$(Configuration)\|$(Platform)'=='Release\|x64'">twsyng_x64_c223</TargetName>
86	86	<LibraryPath Condition="'$(Configuration)\|$(Platform)'=='Release\|x64'">$(VCInstallDir)lib\amd64;$(VCInstallDir)atlmfc\lib\amd64;$(WindowsSdkDir)lib\x64;C:\Program Files\Microsoft SDKs\Windows\v7.1\Lib\x64;</LibraryPath>
87	87	<TargetName Condition="'$(Configuration)\|$(Platform)'=='Debug\|x64'">$(ProjectName)_x64</TargetName>
88	88	<LibraryPath Condition="'$(Configuration)\|$(Platform)'=='Debug\|x64'">$(LibraryPath);$(VSInstallDir);$(VSInstallDir)lib\amd64;$(WindowsSdkDir)lib\x64;</LibraryPath>

Show on old repository browser