timidity/int_synth.c

   1 /*
   2     TiMidity++ -- MIDI to WAVE converter and player
   3     Copyright (C) 1999-2002 Masanao Izumo <mo@goice.co.jp>
   4     Copyright (C) 1995 Tuukka Toivonen <tt@cgs.fi>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19
  20 */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif /* HAVE_CONFIG_H */
  25 #include <stdlib.h>
  26 #include <math.h>
  27
  28 #ifndef NO_STRING_H
  29 #include <string.h>
  30 #else
  31 #include <strings.h>
  32 #endif
  33
  34 #include "interface.h"
  35 #include "timidity.h"
  36 #include "instrum.h"
  37 #include "common.h"
  38
  39 #include "controls.h"
  40 #include "filter.h"
  41 #include "instrum.h"
  42 #include "output.h"
  43 #include "playmidi.h"
  44 #include "resample.h"
  45 #include "tables.h"
  46 #include "int_synth.h"
  47
  48 #include "thread.h"
  49
  50 #define MYINI_LIBRARY_DEFIND_VAR
  51 #include "myini.h"
  52
  53 #if defined(IA_W32GUI) || defined(IA_W32G_SYN) || defined(KBTIM) || defined(WINVSTI)
  54 #pragma comment(lib, "shlwapi.lib")
  55 #include <shlwapi.h>
  56 #endif
  57
  58 /*
  59 timidity\82Ì\93®\8dì\82Ì\82½\82ßSample\90Ý\92è\82Æ\89¹\90F\90Ý\92è\82ð\83\8d\81[\83h
  60 Sample\90Ý\92è\82Í extract_hoge_file(file, preset_number)\82Å\83\8d\81[\83h
  61 \89¹\90F\90Ý\92è\82Íextract\82Åini\82©\82ç\83\8d\81[\83h
  62 SCC/MMS\82Í\95K\97v\82È\95ª\82¾\82¯\83\8d\81[\83h SCC_DATA\82ÍSCC/MMS\8b¤\92Ê\82È\82Ì\82Å\91S\83\8d\81[\83h LA_DATA\82ÍMMS\82Ìextract\8f\89\89ñ\82Å\83\8d\81[\83h
  63 */
  64
  65 int32 opt_int_synth_sine = 0;
  66 int32 opt_int_synth_rate = 0;
  67 int32 opt_int_synth_update = 0;
  68
  69
  70 #ifdef INT_SYNTH
  71
  72 #ifndef POW2
  73 #if 1 // lite
  74 #define POW2(val) exp((float)(M_LN2 * val))
  75 #else // precision
  76 #define POW2(val) pow(2.0, val)
  77 #endif
  78 #endif /* POW2 */
  79
  80 static IS_RS_DATA_T is_resample_buffer[AUDIO_BUFFER_SIZE + 8]; // + 8 oversampling
  81
  82 // la pcm
  83 static int la_pcm_data_load_flg = 0; //
  84 //MT32
  85 #define MT32_PCM_ROM_SIZE (512 * 1024) // rom 512kB
  86 #define MT32_PCM_SIZE (MT32_PCM_ROM_SIZE / 2) // rom 512kB 16bit 262144sample
  87 static FLOAT_T mt32_pcm_data[MT32_PCM_SIZE + 1];
  88 static Info_PCM mt32_pcm_inf[MT32_DATA_MAX];
  89 // CM32L
  90 #define CM32L_PCM_ROM_SIZE (1024 * 1024) // rom 1MB
  91 #define CM32L_PCM_SIZE (CM32L_PCM_ROM_SIZE / 2) // rom 1MB 16bit 524288sample
  92 static FLOAT_T cm32l_pcm_data[CM32L_PCM_SIZE + 1];
  93 static Info_PCM cm32l_pcm_inf[CM32L_DATA_MAX];
  94 //#define PCM_FILE_OUT // convert signed 32bit PCM RAW out
  95 #define LA_CONTROL_ROM_SIZE (64 * 1024) // rom 64kB
  96
  97
  98 const char *osc_wave_name[];
  99
 100
 101
 102 //////// synth lite mode
 103
 104 static int thru_count_mlt = 1;
 105
 106 static void init_int_synth_lite(void)
 107 {
 108         if(opt_int_synth_update >= 100){
 109                 thru_count_mlt = 100;
 110         }else if(opt_int_synth_update <= 1){
 111                 thru_count_mlt = 1;
 112         }
 113 }
 114
 115
 116
 117 //////// synth sample rate (resample
 118
 119 const FLOAT_T is_output_level = (FLOAT_T)M_15BIT;
 120 static int32 prev_opt_int_synth_rate = -2;
 121 static FLOAT_T is_sample_rate = 0;
 122 static FLOAT_T div_is_sample_rate = 0;
 123 static FLOAT_T is_sample_rate_ms = 0;
 124
 125 const int32 is_fraction = (1L << FRACTION_BITS);
 126 const FLOAT_T div_is_fraction = (FLOAT_T)1.0 / (FLOAT_T)(1L << FRACTION_BITS);
 127 const int is_rs_buff_offset = 2; // linear
 128 const int is_rs_over_sampling = 2; // normal 2~8 // optimize x2
 129 static FLOAT_T div_is_rs_over_sampling = 1.0;
 130 static int is_rs_mode = 0;
 131 static int32 is_rs_increment = (1L << FRACTION_BITS);
 132
 133 static void set_sample_rate(void)
 134 {
 135         FLOAT_T resample_ratio = 1.0;
 136
 137         div_is_rs_over_sampling = 1.0 / (FLOAT_T)is_rs_over_sampling;
 138
 139         if(opt_int_synth_rate == 0 || opt_int_synth_rate == play_mode->rate){
 140                 is_rs_mode = 0; // no resample
 141                 is_sample_rate = play_mode->rate;
 142                 div_is_sample_rate = div_playmode_rate;
 143                 is_sample_rate_ms = playmode_rate_ms;
 144                 resample_ratio = 1.0;
 145                 is_rs_increment = is_fraction;
 146         }else if(opt_int_synth_rate < 0){
 147                 is_rs_mode = 1; // up resample , play_mode->rate / 2
 148                 is_sample_rate = play_mode->rate / 2;
 149                 div_is_sample_rate = 1.0 / is_sample_rate;
 150                 is_sample_rate_ms = is_sample_rate * DIV_1000;
 151                 resample_ratio = is_sample_rate * div_playmode_rate * div_is_rs_over_sampling;
 152                 is_rs_increment = resample_ratio * is_fraction;
 153         }else if(opt_int_synth_rate < play_mode->rate){
 154                 is_rs_mode = 1; // up resample
 155                 is_sample_rate = opt_int_synth_rate;
 156                 div_is_sample_rate = 1.0 / is_sample_rate;
 157                 is_sample_rate_ms = is_sample_rate * DIV_1000;
 158                 resample_ratio = is_sample_rate * div_playmode_rate * div_is_rs_over_sampling;
 159                 is_rs_increment = resample_ratio * is_fraction;
 160         }else{
 161                 is_rs_mode = 2; // down resample
 162                 is_sample_rate = opt_int_synth_rate;
 163                 div_is_sample_rate = 1.0 / is_sample_rate;
 164                 is_sample_rate_ms = is_sample_rate * DIV_1000;
 165                 resample_ratio = is_sample_rate * div_playmode_rate * div_is_rs_over_sampling;
 166                 is_rs_increment = resample_ratio * is_fraction;
 167         }
 168         if(is_rs_mode){
 169                 if((compute_buffer_size * resample_ratio + 1) * is_rs_over_sampling >= AUDIO_BUFFER_SIZE){ // mono is_resample_buffer[] size
 170                         is_rs_mode = 0; // no resample
 171                         is_sample_rate = play_mode->rate;
 172                         div_is_sample_rate = div_playmode_rate;
 173                         is_sample_rate_ms = playmode_rate_ms;
 174                         is_rs_increment = is_fraction;
 175                 }
 176         }
 177 }
 178
 179 static inline void is_resample_init(Info_Resample *rs)
 180 {
 181         rs->rs_count = 0;
 182         rs->offset = 0;
 183         rs->data[0] = 0;
 184         rs->data[1] = 0;
 185 }
 186
 187
 188 static inline void is_resample_pre(Info_Resample *rs, IS_RS_DATA_T *rs_buf, int32 count)
 189 {
 190         rs->rs_count = (rs->offset + is_rs_increment * count * is_rs_over_sampling) >> FRACTION_BITS;
 191         rs_buf[0] = rs->data[0];
 192         rs_buf[1] = rs->data[1];
 193 }
 194
 195 #if 1 // optimize over sampling x2
 196
 197 static inline void is_resample_core(Info_Resample *rs, DATA_T *is_buf, IS_RS_DATA_T *rs_buf, int32 count)
 198 {
 199         int32 i = 0;
 200         int32 rs_ofs = rs->offset;
 201 #if !(defined(_MSC_VER) || defined(MSC_VER))
 202         int32 *ofsp1, *ofsp2;
 203 #endif
 204
 205 #if (USE_X86_EXT_INTRIN >= 3) && defined(IS_RS_DATA_T_FLOAT) // double\82à\8eg\82¦\82é\82¯\82Ç\82â\82â\92x\82¢\82Ì\82Åfloat\82Ì\82Ý
 206         { // offset:int32*4, resamp:float*4
 207         const int32 is_rs_count_mask = ~(0x1);
 208         const int32 count2 = count & is_rs_count_mask;
 209         const __m128 vec_divf = _mm_set1_ps(div_is_fraction), vec_divo = _mm_set1_ps(DIV_15BIT), vec_div2 = _mm_set1_ps(DIV_2);
 210         const __m128i vinc = _mm_set1_epi32(is_rs_increment * 4), vfmask = _mm_set1_epi32((int32)FRACTION_MASK);
 211         const __m128i vinc2 = _mm_set_epi32(0, is_rs_increment, is_rs_increment * 2, is_rs_increment * 3);
 212         __m128i vofs = _mm_sub_epi32(_mm_set1_epi32(rs_ofs), vinc2);
 213         const __m128 vmout = _mm_set1_ps(is_output_level);
 214
 215 #if (USE_X86_EXT_INTRIN >= 8)
 216         // \8dÅ\93K\89»\83\8c\81[\83g = (\83\8d\81[\83h\83f\81[\83^\90\94 - \8f\89\8aú\83I\83t\83Z\83b\83g\8f¬\90\94\95\94\82Ì\8dÅ\91å\92l(1\96¢\96\9e) - \95â\8aÔ\83|\83C\83\93\83g\90\94(linear\82Í1) ) / \83I\83t\83Z\83b\83g\83f\81[\83^\90\94
 217         // \83\8d\81[\83h\83f\81[\83^\90\94\82Í_mm_permutevar_ps\82Ì\95Ï\8a·\8cã\82Ì(float)\82Ì4\83Z\83b\83g\82É\82È\82é
 218         const int32 opt_inc1 = (1 << FRACTION_BITS) * (4 - 1 - 1) / 4; // (float*4) * 1\83Z\83b\83g
 219         const __m128i vvar1 = _mm_set1_epi32(1);
 220         if(is_rs_increment < opt_inc1){ // 1\83Z\83b\83g
 221         for(; i < count2; i += 2) {
 222         __m128 vfp, vv1, vv2, vec_out, tmp1;
 223         __m128i vofsi1, vofsi2, vofsf, vofsib, vofsub1, vofsub2;
 224         int32 ofs0;
 225         vofs = _mm_add_epi32(vofs, vinc);
 226         vofsi1 = _mm_srli_epi32(vofs, FRACTION_BITS);
 227         vofsi2 = _mm_add_epi32(vofsi1, vvar1);
 228         vofsf = _mm_and_si128(vofs, vfmask);
 229         vfp = _mm_mul_ps(_mm_cvtepi32_ps(vofsf), vec_divf); // int32 to float // calc fp
 230         ofs0 = _mm_cvtsi128_si32(vofsi1);
 231 #if defined(IS_RS_DATA_T_DOUBLE)
 232         tmp1 = _mm256_cvtpd_ps(_mm256_loadu_pd(&rs_buf[ofs0])); // \83\8d\81[\83h
 233 #else // defined(IS_RS_DATA_T_FLOAT)
 234         tmp1 = _mm_loadu_ps(&rs_buf[ofs0]); // \83\8d\81[\83h
 235 #endif // !(defined(_MSC_VER) || defined(MSC_VER))
 236         vofsib = _mm_shuffle_epi32(vofsi1, 0x0);
 237         vofsub1 = _mm_sub_epi32(vofsi1, vofsib);
 238         vofsub2 = _mm_sub_epi32(vofsi2, vofsib);
 239         vv1 = _mm_permutevar_ps(tmp1, vofsub1); // v1 ofsi
 240         vv2 = _mm_permutevar_ps(tmp1, vofsub2); // v2 ofsi+1
 241         vec_out = MM_FMA_PS(_mm_sub_ps(vv2, vv1), vfp, vv1); // out
 242         // down sampling
 243         vec_out = _mm_add_ps(_mm_shuffle_ps(vec_out, vec_out, 0xD8), _mm_shuffle_ps(vec_out, vec_out, 0x8D)); // [0+1,2+3,2+0,3+1]=[0,2,1,3]+[1,3,0,2]
 244         vec_out = _mm_mul_ps(vec_out , vec_div2);
 245         // output 2
 246 #if     defined(DATA_T_DOUBLE)
 247         _mm_storeu_pd(&is_buf[i], _mm_cvtps_pd(vec_out));
 248 #elif defined(DATA_T_FLOAT)
 249         _mm_storel_ps(&is_buf[i], vec_out);
 250 #else // DATA_T_INT32
 251         vec_out = _mm_mul_ps(vec_out, vmout);
 252         _mm_storeu_si128((__m128i *)&is_buf[i], _mm_cvtps_epi32(vec_out)); // only L64bit
 253 #endif // DATA_T_INT32
 254         rs_ofs = MM_EXTRACT_EPI32(vofs, 0x3);
 255         }
 256         }else
 257 #endif
 258         for(; i < count2; i += 2) {
 259         __m128 vfp, vv1, vv2, tmp1, tmp2, tmp3, tmp4, vec_out;
 260         __m128i vofsi, vofsf;
 261         vofs = _mm_add_epi32(vofs, vinc);
 262         vofsi = _mm_srli_epi32(vofs, FRACTION_BITS);
 263         vofsf = _mm_and_si128(vofs, vfmask);
 264         vfp = _mm_mul_ps(_mm_cvtepi32_ps(vofsf), vec_divf); // int32 to float // calc fp
 265 #if !(defined(_MSC_VER) || defined(MSC_VER))
 266         ofsp1 = (int32 *)vofsi;
 267 #if defined(IS_RS_DATA_T_DOUBLE)
 268         tmp1 = _mm_cvtpd_ps(_mm_loadu_pd(&rs_buf[ofsp1[0]])); // ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 269         tmp2 = _mm_cvtpd_ps(_mm_loadu_pd(&rs_buf[ofsp1[1]])); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 270         tmp3 = _mm_cvtpd_ps(_mm_loadu_pd(&rs_buf[ofsp1[2]])); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 271         tmp4 = _mm_cvtpd_ps(_mm_loadu_pd(&rs_buf[ofsp1[3]])); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 272         tmp1 = _mm_shuffle_ps(tmp1, tmp2, 0x44);
 273         tmp3 = _mm_shuffle_ps(tmp3, tmp4, 0x44);
 274 #else // defined(IS_RS_DATA_T_FLOAT)
 275         tmp1 = _mm_loadl_pi(tmp1, (__m64 *)&rs_buf[ofsp1[0]]); // L64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 276         tmp1 = _mm_loadh_pi(tmp1, (__m64 *)&rs_buf[ofsp1[1]]); // H64bit \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 277         tmp3 = _mm_loadl_pi(tmp3, (__m64 *)&rs_buf[ofsp1[2]]); // L64bit \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 278         tmp3 = _mm_loadh_pi(tmp3, (__m64 *)&rs_buf[ofsp1[3]]); // H64bit \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 279 #endif
 280 #else
 281 #if defined(IS_RS_DATA_T_DOUBLE)
 282         tmp1 = _mm_cvtpd_ps(_mm_loadu_pd(&rs_buf[vofsi.m128i_i32[0]])); // ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 283         tmp2 = _mm_cvtpd_ps(_mm_loadu_pd(&rs_buf[vofsi.m128i_i32[1]])); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 284         tmp3 = _mm_cvtpd_ps(_mm_loadu_pd(&rs_buf[vofsi.m128i_i32[2]])); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 285         tmp4 = _mm_cvtpd_ps(_mm_loadu_pd(&rs_buf[vofsi.m128i_i32[3]])); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à
 286         tmp1 = _mm_shuffle_ps(tmp1, tmp2, 0x44);
 287         tmp3 = _mm_shuffle_ps(tmp3, tmp4, 0x44);
 288 #else // defined(IS_RS_DATA_T_FLOAT)
 289         tmp1 = _mm_loadl_pi(tmp1, (__m64 *)&rs_buf[vofsi.m128i_i32[0]]); // L64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 290         tmp1 = _mm_loadh_pi(tmp1, (__m64 *)&rs_buf[vofsi.m128i_i32[1]]); // H64bit \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 291         tmp3 = _mm_loadl_pi(tmp3, (__m64 *)&rs_buf[vofsi.m128i_i32[2]]); // L64bit \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 292         tmp3 = _mm_loadh_pi(tmp3, (__m64 *)&rs_buf[vofsi.m128i_i32[3]]); // H64bit \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 293 #endif
 294 #endif // !(defined(_MSC_VER) || defined(MSC_VER))
 295         vv1 = _mm_shuffle_ps(tmp1, tmp3, 0x88); // v1[0,1,2,3]  // ofsi\82Ív1\82É
 296         vv2 = _mm_shuffle_ps(tmp1, tmp3, 0xdd); // v2[0,1,2,3]  // ofsi+1\82Ív2\82É\88Ú\93®
 297         vec_out = MM_FMA_PS(_mm_sub_ps(vv2, vv1), vfp, vv1);
 298         // down sampling
 299         vec_out = _mm_add_ps(_mm_shuffle_ps(vec_out, vec_out, 0xD8), _mm_shuffle_ps(vec_out, vec_out, 0x8D)); // [0+1,2+3,2+0,3+1]=[0,2,1,3]+[1,3,0,2]
 300         vec_out = _mm_mul_ps(vec_out , vec_div2);
 301         // output 2
 302 #if     defined(DATA_T_DOUBLE)
 303         _mm_storeu_pd(&is_buf[i], _mm_cvtps_pd(vec_out));
 304 #elif defined(DATA_T_FLOAT)
 305         _mm_storel_ps(&is_buf[i], vec_out);
 306 #else // DATA_T_INT32
 307         vec_out = _mm_mul_ps(vec_out, vmout);
 308         _mm_storeu_si128((__m128i *)&is_buf[i], _mm_cvtps_epi32(vec_out)); // only L64bit
 309 #endif // DATA_T_INT32
 310         }
 311         rs_ofs = MM_EXTRACT_EPI32(vofs, 0x3);
 312         }
 313
 314 #elif (USE_X86_EXT_INTRIN >= 3) && defined(IS_RS_DATA_T_DOUBLE)
 315         { // offset:int32*4, resamp:double*2*2
 316         const int32 is_rs_count_mask = ~(0x1);
 317         const int32 count2 = count & is_rs_count_mask;
 318         const __m128d vec_divf = _mm_set1_pd(div_is_fraction), vec_divo = _mm_set1_pd(DIV_15BIT), vec_div2 = _mm_set1_pd(DIV_2);
 319         const __m128i vinc = _mm_set1_epi32(is_rs_increment * 4), vfmask = _mm_set1_epi32((int32)FRACTION_MASK);
 320         const __m128i vinc2 = _mm_set_epi32(0, is_rs_increment, is_rs_increment * 2, is_rs_increment * 3);
 321         __m128i vofs = _mm_sub_epi32(_mm_set1_epi32(rs_ofs), vinc2);
 322         const __m128d vmout = _mm_set1_pd(is_output_level);
 323         for(; i < count2; i += 2) {
 324         __m128d vfp1, vfp2, vv11, vv12, vv21, vv22, tmp1, tmp2, tmp3, tmp4, vec_out1, vec_out2;
 325         __m128i vofsi, vofsf;
 326         vofs = _mm_add_epi32(vofs, vinc);
 327         vofsi = _mm_srli_epi32(vofs, FRACTION_BITS);
 328         vofsf = _mm_and_si128(vofs, vfmask);
 329         vfp1 = _mm_mul_pd(_mm_cvtepi32_pd(vofsf), vec_divf); // int32 to double // calc fp
 330         vfp2 = _mm_mul_pd(_mm_cvtepi32_pd(_mm_shuffle_epi32(vofsf, 0x4E)), vec_divf); // int32 to double // calc fp
 331 #if !(defined(_MSC_VER) || defined(MSC_VER))
 332         ofsp1 = (int32 *)vofsi;
 333         tmp1 = _mm_loadu_pd(&rs_buf[ofsp1[0]]); // ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 334         tmp2 = _mm_loadu_pd(&rs_buf[ofsp1[1]]); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 335         tmp3 = _mm_loadu_pd(&rs_buf[ofsp1[2]]); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 336         tmp4 = _mm_loadu_pd(&rs_buf[ofsp1[3]]); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 337 #else
 338         tmp1 = _mm_loadu_pd(&rs_buf[vofsi.m128i_i32[0]]); // ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 339         tmp2 = _mm_loadu_pd(&rs_buf[vofsi.m128i_i32[1]]); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 340         tmp3 = _mm_loadu_pd(&rs_buf[vofsi.m128i_i32[2]]); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 341         tmp4 = _mm_loadu_pd(&rs_buf[vofsi.m128i_i32[3]]); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à
 342 #endif // !(defined(_MSC_VER) || defined(MSC_VER))
 343         vv11 = _mm_shuffle_pd(tmp1, tmp2, 0x00); // v1[0,1] // ofsi\82Ív1\82É
 344         vv21 = _mm_shuffle_pd(tmp1, tmp2, 0x03); // v2[0,1] // ofsi+1\82Ív2\82É\88Ú\93®
 345         vv12 = _mm_shuffle_pd(tmp3, tmp4, 0x00); // v1[2,3] // ofsi\82Ív1\82É
 346         vv22 = _mm_shuffle_pd(tmp3, tmp4, 0x03); // v2[2,3] // ofsi+1\82Ív2\82É\88Ú\93®
 347         vec_out1 = MM_FMA_PD(_mm_sub_pd(vv21, vv11), vfp1, vv11); // out[0,1]
 348         vec_out2 = MM_FMA_PD(_mm_sub_pd(vv22, vv12), vfp2, vv12); // out[2,3]
 349         // down sampling
 350         vec_out1 = _mm_add_pd(_mm_shuffle_pd(vec_out1, vec_out2, 0x0), _mm_shuffle_pd(vec_out1, vec_out2, 0x3)); // [0+1,2+3]=[0,2]+[1,3]
 351         vec_out1 = _mm_mul_pd(vec_out1 , vec_div2);
 352         // output 2
 353 #if     defined(DATA_T_DOUBLE)
 354         _mm_storeu_pd(&is_buf[i], vec_out1);
 355 #elif defined(DATA_T_FLOAT)
 356         _mm_storel_pi(&is_buf[i], _mm_shuffle_ps(_mm_cvtpd_ps(vec_out1), _mm_cvtpd_ps(vec_out2), 0x44)); // 2set
 357 #else // DATA_T_INT32
 358         _mm_storeu_si128((__m128i *)&is_buf[i], _mm_cvtpd_epi32(_mm_mul_pd(vec_out1, vmout))); // L64bit
 359 #endif // DATA_T_INT32
 360         }
 361         rs_ofs = MM_EXTRACT_EPI32(vofs, 0x3);
 362         }
 363
 364 #elif (USE_X86_EXT_INTRIN >= 2)
 365         { // offset:int32*4, resamp:float*4, output:*2
 366         const int32 is_rs_count_mask = ~(0x1);
 367         int32 count2 = count & is_rs_count_mask;
 368         __m128 vec_divf = _mm_set1_ps((float)div_is_fraction), vec_div2 = _mm_set1_ps(DIV_2);
 369         __m128 vec_out;
 370         const __m128 vmout = _mm_set1_ps(is_output_level);
 371         for(; i < count2; i += 2) {
 372         int32 ofsi;
 373         __m128 vec_out, vv1, vv2, vfp;
 374 #if defined(IS_RS_DATA_T_DOUBLE)
 375         ALIGN float tmp1[4], tmp2[4], tmpfp[4];
 376         ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 377         tmp1[0] = (float)rs_buf[ofsi], tmp2[0] = (float)rs_buf[++ofsi], tmpfp[0] = (float)(rs_ofs & FRACTION_MASK);
 378         ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 379         tmp1[1] = (float)rs_buf[ofsi], tmp2[1] = (float)rs_buf[++ofsi], tmpfp[1] = (float)(rs_ofs & FRACTION_MASK);
 380         ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 381         tmp1[2] = (float)rs_buf[ofsi], tmp2[2] = (float)rs_buf[++ofsi], tmpfp[2] = (float)(rs_ofs & FRACTION_MASK);
 382         ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 383         tmp1[3] = (float)rs_buf[ofsi], tmp2[3] = (float)rs_buf[++ofsi], tmpfp[3] = (float)(rs_ofs & FRACTION_MASK);
 384         vv1 = _mm_load_ps(tmp1);
 385         vv2 = _mm_load_ps(tmp2);
 386         vfp = _mm_load_ps(tmpfp);
 387 #else // defined(IS_RS_DATA_T_FLOAT)
 388         ALIGN float tmpfp[4];
 389         __m128 tmp1, tmp2, tmp3, tmp4;
 390         ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 391         tmpfp[0] = (float)(rs_ofs & FRACTION_MASK);
 392         tmp1 = _mm_loadu_ps(&rs_buf[ofsi]); // L64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 393         tmp1 = _mm_loadl_pi(tmp1, (__m64 *)&rs_buf[ofsi]); // L64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 394         ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 395         tmpfp[1] = (float)(rs_ofs & FRACTION_MASK);
 396         tmp1 = _mm_loadh_pi(tmp1, (__m64 *)&rs_buf[ofsi]); // H64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 397         ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 398         tmpfp[2] = (float)(rs_ofs & FRACTION_MASK);
 399         tmp3 = _mm_loadl_pi(tmp3, (__m64 *)&rs_buf[ofsi]); // L64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 400         ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 401         tmpfp[3] = (float)(rs_ofs & FRACTION_MASK);
 402         tmp3 = _mm_loadh_pi(tmp3, (__m64 *)&rs_buf[ofsi]); // H64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 403         vv1 = _mm_shuffle_ps(tmp1, tmp3, 0x88); // v1[0,1,2,3]  // ofsi\82Ív1\82É
 404         vv2 = _mm_shuffle_ps(tmp1, tmp3, 0xdd); // v2[0,1,2,3]  // ofsi+1\82Ív2\82É\88Ú\93®
 405         vfp = _mm_load_ps(tmpfp);
 406 #endif
 407         vec_out = MM_FMA_PS(_mm_sub_ps(vv2, vv1), _mm_mul_ps(vfp, vec_divf), vv1);
 408         // down sampling
 409         vec_out = _mm_add_ps(_mm_shuffle_ps(vec_out, vec_out, 0xD8), _mm_shuffle_ps(vec_out, vec_out, 0x8D));
 410         vec_out = _mm_mul_ps(vec_out , vec_div2);
 411         // output 2
 412 #if defined(DATA_T_DOUBLE)
 413         {
 414         ALIGN float out[4];
 415         _mm_storeu_ps(out, vec_out);
 416         is_buf[i] = (DATA_T)out[0];
 417         is_buf[i + 1] = (DATA_T)out[2];
 418         }
 419 #elif defined(DATA_T_FLOAT)
 420         _mm_storel_pi(&is_buf[i], vec_out);
 421 #else // DATA_T_IN32
 422         vec_out = _mm_mul_ps(vec_out, vmout);
 423         is_buf[i] = _mm_cvt_ss2si(vec_out);
 424         is_buf[i + 1] = _mm_cvt_ss2si(_mm_shuffle_ps(vec_out, vec_out, 0xe5));
 425 #endif // DATA_T_INT32
 426         }
 427         }
 428
 429 #endif // USE_X86_EXT_INTRIN
 430
 431         { // offset:int32*2, resamp:FLOAT_T*2, output:*1
 432                 int32 ofsi, ofsf;
 433                 FLOAT_T v11, v21, v12, v22, fp1, fp2, out1, out2;
 434                 int32 ofsi2, ofsf2;
 435
 436                 for (; i < count; i++){
 437                         rs_ofs += is_rs_increment;
 438                         ofsi = rs_ofs >> FRACTION_BITS;
 439                         ofsf = rs_ofs & FRACTION_MASK;
 440                         rs_ofs += is_rs_increment;
 441                         ofsi2 = rs_ofs >> FRACTION_BITS;
 442                         ofsf2 = rs_ofs & FRACTION_MASK;
 443                         fp1 = (FLOAT_T)ofsf * div_is_fraction;
 444                         fp2 = (FLOAT_T)ofsf2 * div_is_fraction;
 445                         v11 = rs_buf[ofsi], v21 = rs_buf[ofsi + 1], fp1 = (FLOAT_T)ofsf * div_is_fraction;
 446                         v12 = rs_buf[ofsi], v22 = rs_buf[ofsi + 1], fp2 = (FLOAT_T)ofsf * div_is_fraction;
 447                         out1 = v11 + (v21 - v11) * fp1;
 448                         out2 = v12 + (v22 - v12) * fp2;
 449                         // down sampling
 450                         out1 = (out1 + out2) * DIV_2;
 451                         // output 1
 452 #if defined(DATA_T_DOUBLE) || defined(DATA_T_FLOAT)
 453                         is_buf[i] = out1;
 454 #else // DATA_T_INT32
 455                         is_buf[i] = out1 * is_output_level;
 456 #endif // DATA_T_INT32
 457                 }
 458
 459                 //
 460                 ofsi = rs_ofs >> FRACTION_BITS;
 461                 rs->offset = rs_ofs & FRACTION_MASK;
 462 #if (USE_X86_EXT_INTRIN >= 3) && defined(IS_RS_DATA_T_DOUBLE)
 463                 _mm_storeu_pd(rs->data, _mm_loadu_pd(&rs_buf[ofsi]));
 464 #elif (USE_X86_EXT_INTRIN >= 2) && defined(IS_RS_DATA_T_FLOAT)
 465                 {
 466                 __m128 vtmp;
 467                 _mm_storel_pi(rs->data, _mm_loadl_pi(vtmp, (__m64 *)&rs_buf[ofsi]));
 468                 }
 469 #else
 470                 rs->data[0] = rs_buf[ofsi];
 471                 rs->data[1] = rs_buf[ofsi + 1]; // interpolate
 472 #endif
 473         }
 474 }
 475
 476 #else // normal over sampling x2~x8
 477
 478 static void is_resample_down_sampling(DATA_T *ptr, int32 count)
 479 {
 480         int32 i;
 481
 482         switch(is_rs_over_sampling){
 483         case 0:
 484                 break;
 485 #if 1 // optimize
 486         case 2:
 487                 for(i = 0; i < count; i++){
 488                         int ofs = i * 2;
 489                         FLOAT_T tmp = ptr[ofs] + ptr[ofs + 1];
 490                         ptr[i] = tmp * DIV_2;
 491                 }
 492                 break;
 493         case 4:
 494 #if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE)
 495                 { // 4samples
 496                         const __m128d divn = _mm_set1_pd(DIV_4);
 497                         for(i = 0; i < count; i += 4){
 498                                 int32 ofs = i * 4;
 499                                 __m128d sum1 = _mm_load_pd(&ptr[ofs + 0]);
 500                                 __m128d sum2 = _mm_load_pd(&ptr[ofs + 2]);
 501                                 __m128d sum3 = _mm_load_pd(&ptr[ofs + 4]);
 502                                 __m128d sum4 = _mm_load_pd(&ptr[ofs + 6]);
 503                                 __m128d sum5 = _mm_load_pd(&ptr[ofs + 8]);
 504                                 __m128d sum6 = _mm_load_pd(&ptr[ofs + 10]);
 505                                 __m128d sum7 = _mm_load_pd(&ptr[ofs + 12]);
 506                                 __m128d sum8 = _mm_load_pd(&ptr[ofs + 14]);
 507                                 // ([1,2] [3,4]) ([5,6] [7,8])
 508                                 sum1 = _mm_add_pd(sum1, sum2);
 509                                 sum3 = _mm_add_pd(sum3, sum4);
 510                                 sum5 = _mm_add_pd(sum5, sum6);
 511                                 sum7 = _mm_add_pd(sum7, sum8);
 512                                 sum2 = _mm_shuffle_pd(sum1, sum1, 0x1); // [v0v1] -> [v1v0]
 513                                 sum4 = _mm_shuffle_pd(sum3, sum3, 0x1); // [v0v1] -> [v1v0]
 514                                 sum6 = _mm_shuffle_pd(sum5, sum5, 0x1); // [v0v1] -> [v1v0]
 515                                 sum8 = _mm_shuffle_pd(sum7, sum7, 0x1); // [v0v1] -> [v1v0]
 516                                 sum1 = _mm_add_pd(sum1, sum2); // v0=v0+v1 v1=v1+v0
 517                                 sum3 = _mm_add_pd(sum3, sum4); // v0=v0+v1 v1=v1+v0
 518                                 sum5 = _mm_add_pd(sum5, sum6); // v0=v0+v1 v1=v1+v0
 519                                 sum7 = _mm_add_pd(sum7, sum8); // v0=v0+v1 v1=v1+v0
 520                                 sum1 = _mm_shuffle_pd(sum1, sum3, 0x0);
 521                                 sum5 = _mm_shuffle_pd(sum5, sum7, 0x0);
 522                                 sum1 = _mm_mul_pd(sum1, divn);
 523                                 sum5 = _mm_mul_pd(sum5, divn);
 524                                 _mm_store_pd(&ptr[i    ], sum1);
 525                                 _mm_store_pd(&ptr[i + 2], sum5);
 526                         }
 527                 }
 528 #else
 529                 for(i = 0; i < count; i++){
 530                         int32 ofs = i * 4;
 531                         FLOAT_T tmp = ptr[ofs + 0] + ptr[ofs + 1] + ptr[ofs + 2] + ptr[ofs + 3];
 532                         ptr[i] = tmp * DIV_4;
 533                 }
 534 #endif
 535                 break;
 536         case 8:
 537 #if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE)
 538                 { // 4samples
 539                         const __m128d divn = _mm_set1_pd(DIV_8);
 540                         for(i = 0; i < count; i += 4){
 541                                 int32 ofs = i * 8;
 542                                 __m128d sum1 = _mm_load_pd(&ptr[ofs + 0]);
 543                                 __m128d sum2 = _mm_load_pd(&ptr[ofs + 2]);
 544                                 __m128d sum3 = _mm_load_pd(&ptr[ofs + 4]);
 545                                 __m128d sum4 = _mm_load_pd(&ptr[ofs + 6]);
 546                                 __m128d sum5 = _mm_load_pd(&ptr[ofs + 8]);
 547                                 __m128d sum6 = _mm_load_pd(&ptr[ofs + 10]);
 548                                 __m128d sum7 = _mm_load_pd(&ptr[ofs + 12]);
 549                                 __m128d sum8 = _mm_load_pd(&ptr[ofs + 14]);
 550                                 __m128d sum9 = _mm_load_pd(&ptr[ofs + 16]);
 551                                 __m128d sum10 = _mm_load_pd(&ptr[ofs + 18]);
 552                                 __m128d sum11 = _mm_load_pd(&ptr[ofs + 20]);
 553                                 __m128d sum12 = _mm_load_pd(&ptr[ofs + 22]);
 554                                 __m128d sum13 = _mm_load_pd(&ptr[ofs + 24]);
 555                                 __m128d sum14 = _mm_load_pd(&ptr[ofs + 26]);
 556                                 __m128d sum15 = _mm_load_pd(&ptr[ofs + 28]);
 557                                 __m128d sum16 = _mm_load_pd(&ptr[ofs + 30]);
 558                                 // ([1,2,3,4] [5,6,7,8]) ([9,10,11,12] [13,14,15,16])
 559                                 sum1 = _mm_add_pd(sum1, sum2);
 560                                 sum3 = _mm_add_pd(sum3, sum4);
 561                                 sum5 = _mm_add_pd(sum5, sum6);
 562                                 sum7 = _mm_add_pd(sum7, sum8);
 563                                 sum9 = _mm_add_pd(sum9, sum10);
 564                                 sum11 = _mm_add_pd(sum11, sum12);
 565                                 sum13 = _mm_add_pd(sum13, sum14);
 566                                 sum15 = _mm_add_pd(sum15, sum16);
 567                                 sum1 = _mm_add_pd(sum1, sum3);
 568                                 sum5 = _mm_add_pd(sum5, sum7);
 569                                 sum9 = _mm_add_pd(sum9, sum11);
 570                                 sum13 = _mm_add_pd(sum13, sum15);
 571                                 sum2 = _mm_shuffle_pd(sum1, sum1, 0x1); // [v0v1] -> [v1v0]
 572                                 sum6 = _mm_shuffle_pd(sum5, sum5, 0x1); // [v0v1] -> [v1v0]
 573                                 sum10 = _mm_shuffle_pd(sum9, sum9, 0x1); // [v0v1] -> [v1v0]
 574                                 sum14 = _mm_shuffle_pd(sum13, sum13, 0x1); // [v0v1] -> [v1v0]
 575                                 sum1 = _mm_add_pd(sum1, sum2); // v0=v0+v1 v1=v1+v0
 576                                 sum5 = _mm_add_pd(sum5, sum6); // v0=v0+v1 v1=v1+v0
 577                                 sum9 = _mm_add_pd(sum9, sum10); // v0=v0+v1 v1=v1+v0
 578                                 sum13 = _mm_add_pd(sum13, sum14); // v0=v0+v1 v1=v1+v0
 579                                 sum1 = _mm_shuffle_pd(sum1, sum5, 0x0);
 580                                 sum9 = _mm_shuffle_pd(sum9, sum13, 0x0);
 581                                 sum1 = _mm_mul_pd(sum1, divn);
 582                                 sum9 = _mm_mul_pd(sum9, divn);
 583                                 _mm_store_pd(&ptr[i    ], sum1);
 584                                 _mm_store_pd(&ptr[i + 2], sum9);
 585                         }
 586                 }
 587 #else
 588                 for(i = 0; i < count; i++){
 589                         int32 ofs = i * 8;
 590                         FLOAT_T tmp = ptr[ofs + 0] + ptr[ofs + 1] + ptr[ofs + 2] + ptr[ofs + 3]
 591                                 + ptr[ofs + 4] + ptr[ofs + 5] + ptr[ofs + 6] + ptr[ofs + 7];
 592                         ptr[i] = tmp * DIV_8;
 593                 }
 594 #endif
 595                 break;
 596         case 16:
 597 #if (USE_X86_EXT_INTRIN >= 3) && defined(DATA_T_DOUBLE)
 598                 { // 2sample
 599                         const __m128d divn = _mm_set1_pd(DIV_16);
 600                         for(i = 0; i < count; i += 2){
 601                                 int32 ofs = i * 16;
 602                                 __m128d sum1 = _mm_load_pd(&ptr[ofs + 0]);
 603                                 __m128d sum2 = _mm_load_pd(&ptr[ofs + 2]);
 604                                 __m128d sum3 = _mm_load_pd(&ptr[ofs + 4]);
 605                                 __m128d sum4 = _mm_load_pd(&ptr[ofs + 6]);
 606                                 __m128d sum5 = _mm_load_pd(&ptr[ofs + 8]);
 607                                 __m128d sum6 = _mm_load_pd(&ptr[ofs + 10]);
 608                                 __m128d sum7 = _mm_load_pd(&ptr[ofs + 12]);
 609                                 __m128d sum8 = _mm_load_pd(&ptr[ofs + 14]);
 610                                 __m128d sum9 = _mm_load_pd(&ptr[ofs + 16]);
 611                                 __m128d sum10 = _mm_load_pd(&ptr[ofs + 18]);
 612                                 __m128d sum11 = _mm_load_pd(&ptr[ofs + 20]);
 613                                 __m128d sum12 = _mm_load_pd(&ptr[ofs + 22]);
 614                                 __m128d sum13 = _mm_load_pd(&ptr[ofs + 24]);
 615                                 __m128d sum14 = _mm_load_pd(&ptr[ofs + 26]);
 616                                 __m128d sum15 = _mm_load_pd(&ptr[ofs + 28]);
 617                                 __m128d sum16 = _mm_load_pd(&ptr[ofs + 30]);
 618                                 // ([1,2,3,4,5,6,7,8] [9,10,11,12,13,14,15,16])
 619                                 sum1 = _mm_add_pd(sum1, sum2);
 620                                 sum3 = _mm_add_pd(sum3, sum4);
 621                                 sum5 = _mm_add_pd(sum5, sum6);
 622                                 sum7 = _mm_add_pd(sum7, sum8);
 623                                 sum9 = _mm_add_pd(sum9, sum10);
 624                                 sum11 = _mm_add_pd(sum11, sum12);
 625                                 sum13 = _mm_add_pd(sum13, sum14);
 626                                 sum15 = _mm_add_pd(sum15, sum16);
 627                                 sum1 = _mm_add_pd(sum1, sum3);
 628                                 sum5 = _mm_add_pd(sum5, sum7);
 629                                 sum9 = _mm_add_pd(sum9, sum11);
 630                                 sum13 = _mm_add_pd(sum13, sum15);
 631                                 sum1 = _mm_add_pd(sum1, sum5);
 632                                 sum9 = _mm_add_pd(sum9, sum13);
 633                                 sum2 = _mm_shuffle_pd(sum1, sum1, 0x1); // [v0v1] -> [v1v0]
 634                                 sum10 = _mm_shuffle_pd(sum9, sum9, 0x1); // [v0v1] -> [v1v0]
 635                                 sum1 = _mm_add_pd(sum1, sum2); // v0=v0+v1 v1=v1+v0
 636                                 sum9 = _mm_add_pd(sum9, sum10); // v0=v0+v1 v1=v1+v0
 637                                 sum1 = _mm_shuffle_pd(sum1, sum9, 0x0);
 638                                 sum1 = _mm_mul_pd(sum1, divn);
 639                                 _mm_store_pd(&ptr[i], sum1);
 640                         }
 641                 }
 642 #else
 643                 for(i = 0; i < count; i++){
 644                         int32 ofs = i * 16;
 645                         FLOAT_T tmp = ptr[ofs + 0] + ptr[ofs + 1] + ptr[ofs + 2] + ptr[ofs + 3]
 646                                 + ptr[ofs + 4] + ptr[ofs + 5] + ptr[ofs + 6] + ptr[ofs + 7]
 647                                 + ptr[ofs + 8] + ptr[ofs + 9] + ptr[ofs + 10] + ptr[ofs + 11]
 648                                 + ptr[ofs + 12] + ptr[ofs + 13] + ptr[ofs + 14] + ptr[ofs + 15];
 649                         ptr[i] = tmp * DIV_16;
 650                 }
 651 #endif
 652                 break;
 653 #else
 654         default:
 655                 for(i = 0; i < count; i++){
 656                         int ofs = i * is_rs_over_sampling;
 657                         FLOAT_T tmp = 0.0
 658                         for(j = 0; j < is_rs_over_sampling; j++){
 659                                 tmp += ptr[ofs + j];
 660                         }
 661                         ptr[i] = tmp * div_is_rs_over_sampling;
 662                 }
 663                 break;
 664 #endif
 665         }
 666 }
 667
 668 static inline void is_resample_core(Info_Resample *rs, DATA_T *is_buf, IS_RS_DATA_T *rs_buf, int32 count)
 669 {
 670         int32 i = 0;
 671         int32 rs_ofs = rs->offset;
 672 #if !(defined(_MSC_VER) || defined(MSC_VER))
 673         int32 *ofsp1, *ofsp2;
 674 #endif
 675
 676 #if (USE_X86_EXT_INTRIN >= 3) && defined(IS_RS_DATA_T_FLOAT) // SSE2~
 677         { // offset:int32*4, resamp:float*4
 678         const int32 is_rs_count_mask = ~(0x3);
 679         int32 count2 = (count * is_rs_over_sampling) & is_rs_count_mask;
 680         const __m128 vec_divf = _mm_set1_ps(div_is_fraction), vec_divo = _mm_set1_pd(DIV_15BIT);
 681         const __m128i vinc = _mm_set1_epi32(is_rs_increment * 4), vfmask = _mm_set1_epi32((int32)FRACTION_MASK);
 682         const __m128i vinc2 = _mm_set_epi32(0, is_rs_increment, is_rs_increment * 2, is_rs_increment * 3);
 683         __m128i vofs = _mm_sub_epi32(_mm_set1_epi32(rs_ofs), vinc);
 684         for(; i < count2; i += 4) {
 685         __m128 vfp, vv1, vv2, tmp1, tmp2, tmp3, tmp4, vec_out;
 686         __m128i vofsi, vosfsf;
 687         vofs = _mm_add_epi32(vofs, vinc);
 688         vofsi = _mm_srli_epi32(vofs, FRACTION_BITS);
 689         vosfsf = _mm_and_si128(vofs, vfmask);
 690         vfp = _mm_mul_ps(_mm_cvtepi32_ps(vosfsf), vec_divf); // int32 to float // calc fp
 691 #if !(defined(_MSC_VER) || defined(MSC_VER))
 692         ofsp1 = (int32 *)vofsi;
 693         tmp1 = _mm_loadl_pi(tmp1, (__m64 *)&rs_buf[ofsp1[0]]); // L64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 694         tmp1 = _mm_loadh_pi(tmp1, (__m64 *)&rs_buf[ofsp1[1]]); // H64bit \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 695         tmp3 = _mm_loadl_pi(tmp3, (__m64 *)&rs_buf[ofsp1[2]]); // L64bit \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 696         tmp3 = _mm_loadh_pi(tmp3, (__m64 *)&rs_buf[ofsp1[3]]); // H64bit \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 697 #else
 698         tmp1 = _mm_loadl_pi(tmp1, (__m64 *)&rs_buf[vofsi.m128i_i32[0]]); // L64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 699         tmp1 = _mm_loadh_pi(tmp1, (__m64 *)&rs_buf[vofsi.m128i_i32[1]]); // H64bit \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 700         tmp3 = _mm_loadl_pi(tmp3, (__m64 *)&rs_buf[vofsi.m128i_i32[2]]); // L64bit \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 701         tmp3 = _mm_loadh_pi(tmp3, (__m64 *)&rs_buf[vofsi.m128i_i32[3]]); // H64bit \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 702 #endif // !(defined(_MSC_VER) || defined(MSC_VER))
 703         vv1 = _mm_shuffle_ps(tmp1, tmp3, 0x88); // v1[0,1,2,3]  // ofsi\82Ív1\82É
 704         vv2 = _mm_shuffle_ps(tmp1, tmp3, 0xdd); // v2[0,1,2,3]  // ofsi+1\82Ív2\82É\88Ú\93®
 705         vec_out = MM_FMA_PS(_mm_sub_ps(vv2, vv1), vfp, vv1);
 706 #if     defined(DATA_T_DOUBLE)
 707         _mm_storeu_pd(&is_buf[i], _mm_cvtps_pd(vec_out));
 708         _mm_storeu_pd(&is_buf[i + 2], _mm_cvtps_pd(_mm_movehl_ps(vec_out, vec_out)));
 709 #elif defined(DATA_T_FLOAT)
 710         _mm_storeu_ps(&is_buf[i], vec_out);
 711 #else // DATA_T_INT32
 712         vec_out = _mm_mul_ps(vec_out, _mm_set1_ps(is_output_level));
 713         _mm_storeu_si128((__m128i *)&is_buf[i], _mm_cvtps_epi32(vec_out));
 714 #endif // DATA_T_INT32
 715         }
 716         rs_ofs = MM_EXTRACT_EPI32(vofs, 0x3);
 717         }
 718
 719 #elif (USE_X86_EXT_INTRIN >= 3) && defined(IS_RS_DATA_T_DOUBLE)
 720         { // offset:int32*4, resamp:double*2*2
 721         const int32 is_rs_count_mask = ~(0x3);
 722         const int32 count2 = (count * is_rs_over_sampling) & is_rs_count_mask;
 723         const __m128d vec_divf = _mm_set1_pd(div_is_fraction), vec_divo = _mm_set1_pd(DIV_15BIT);
 724         const __m128i vinc = _mm_set1_epi32(is_rs_increment * 4), vfmask = _mm_set1_epi32((int32)FRACTION_MASK);
 725         const __m128i vinc2 = _mm_set_epi32(0, is_rs_increment, is_rs_increment * 2, is_rs_increment * 3);
 726         __m128i vofs = _mm_sub_epi32(_mm_set1_epi32(rs_ofs), vinc2);
 727         for(; i < count2; i += 4) {
 728         __m128d vfp1, vfp2, vv11, vv12, vv21, vv22, tmp1, tmp2, tmp3, tmp4, vec_out1, vec_out2;
 729         __m128i vofsi, vosfsf;
 730         vofs = _mm_add_epi32(vofs, vinc);
 731         vofsi = _mm_srli_epi32(vofs, FRACTION_BITS);
 732         vosfsf = _mm_and_si128(vofs, vfmask);
 733         vfp1 = _mm_mul_pd(_mm_cvtepi32_pd(vosfsf), vec_divf); // int32 to double // calc fp
 734         vfp2 = _mm_mul_pd(_mm_cvtepi32_pd(_mm_shuffle_epi32(vosfsf, 0x4E)), vec_divf); // int32 to double // calc fp
 735 #if !(defined(_MSC_VER) || defined(MSC_VER))
 736         ofsp1 = (int32 *)vofsi;
 737         tmp1 = _mm_loadu_pd(&rs_buf[ofsp1[0]]); // ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 738         tmp2 = _mm_loadu_pd(&rs_buf[ofsp1[1]]); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 739         tmp3 = _mm_loadu_pd(&rs_buf[ofsp1[2]]); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 740         tmp4 = _mm_loadu_pd(&rs_buf[ofsp1[3]]); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 741 #else
 742         tmp1 = _mm_loadu_pd(&rs_buf[vofsi.m128i_i32[0]]); // ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 743         tmp2 = _mm_loadu_pd(&rs_buf[vofsi.m128i_i32[1]]); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 744         tmp3 = _mm_loadu_pd(&rs_buf[vofsi.m128i_i32[2]]); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à\93¯\82¶
 745         tmp4 = _mm_loadu_pd(&rs_buf[vofsi.m128i_i32[3]]); // \8e\9f\8eü\83T\83\93\83v\83\8b\82à
 746 #endif // !(defined(_MSC_VER) || defined(MSC_VER))
 747         vv11 = _mm_shuffle_pd(tmp1, tmp2, 0x00); // v1[0,1] // ofsi\82Ív1\82É
 748         vv21 = _mm_shuffle_pd(tmp1, tmp2, 0x03); // v2[0,1] // ofsi+1\82Ív2\82É\88Ú\93®
 749         vv12 = _mm_shuffle_pd(tmp3, tmp4, 0x00); // v1[2,3] // ofsi\82Ív1\82É
 750         vv22 = _mm_shuffle_pd(tmp3, tmp4, 0x03); // v2[2,3] // ofsi+1\82Ív2\82É\88Ú\93®
 751         vec_out1 = MM_FMA_PD(_mm_sub_pd(vv21, vv11), vfp1, vv11);
 752         vec_out2 = MM_FMA_PD(_mm_sub_pd(vv22, vv12), vfp2, vv12);
 753 #if     defined(DATA_T_DOUBLE)
 754         _mm_storeu_pd(&is_buf[i], vec_out1);
 755         _mm_storeu_pd(&is_buf[i + 2], vec_out2);
 756 #elif defined(DATA_T_FLOAT)
 757         _mm_storeu_ps(&is_buf[i], _mm_shuffle_ps(_mm_cvtpd_ps(vec_out1), _mm_cvtpd_ps(vec_out2), 0x44));
 758 #else // DATA_T_INT32
 759         {
 760         __m128d vmout = _mm_set1_pd(is_output_level);
 761         __m128i vec_out21 = _mm_cvtpd_epi32(_mm_mul_pd(vec_out1, vmout)); // L64bit
 762         __m128i vec_out22 = _mm_shuffle_epi32(_mm_cvtpd_epi32(_mm_mul_pd(vec_out2, vmout)), 0x4e);// H64bit
 763         _mm_storeu_si128((__m128i *)&is_buf[i], _mm_or_si128(vec_out21, vec_out22));
 764         }
 765 #endif // DATA_T_INT32
 766         }
 767         rs_ofs = MM_EXTRACT_EPI32(vofs, 0x3);
 768         }
 769
 770 #elif (USE_X86_EXT_INTRIN >= 2)
 771         { // offset:int32*4, resamp:float*4
 772         const int32 is_rs_count_mask = ~(0x3);
 773         int32 count2 = (count * is_rs_over_sampling) & is_rs_count_mask;
 774         __m128 vec_divf = _mm_set1_ps((float)div_is_fraction);
 775         for(; i < count2; i += 4) {
 776                 int32 ofsi;
 777                 __m128 vec_out, vv1, vv2, vfp;
 778 #if defined(IS_RS_DATA_T_DOUBLE)
 779                 ALIGN float tmp1[4], tmp2[4], tmpfp[4];
 780                 ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 781                 tmp1[0] = (float)rs_buf[ofsi], tmp2[0] = (float)rs_buf[++ofsi], tmpfp[0] = (float)(rs_ofs & FRACTION_MASK);
 782                 ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 783                 tmp1[1] = (float)rs_buf[ofsi], tmp2[1] = (float)rs_buf[++ofsi], tmpfp[1] = (float)(rs_ofs & FRACTION_MASK);
 784                 ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 785                 tmp1[2] = (float)rs_buf[ofsi], tmp2[2] = (float)rs_buf[++ofsi], tmpfp[2] = (float)(rs_ofs & FRACTION_MASK);
 786                 ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 787                 tmp1[3] = (float)rs_buf[ofsi], tmp2[3] = (float)rs_buf[++ofsi], tmpfp[3] = (float)(rs_ofs & FRACTION_MASK);
 788                 vv1 = _mm_load_ps(tmp1);
 789                 vv2 = _mm_load_ps(tmp2);
 790                 vfp = _mm_load_ps(tmpfp);
 791 #else // defined(IS_RS_DATA_T_FLOAT)
 792                 ALIGN float tmpfp[4];
 793                 __m128 tmp1, tmp2, tmp3, tmp4;
 794                 ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 795                 tmpfp[0] = (float)(rs_ofs & FRACTION_MASK);
 796                 tmp1 = _mm_loadu_ps(&rs_buf[ofsi]); // L64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 797                 tmp1 = _mm_loadl_pi(tmp1, (__m64 *)&rs_buf[ofsi]); // L64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 798                 ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 799                 tmpfp[1] = (float)(rs_ofs & FRACTION_MASK);
 800                 tmp1 = _mm_loadh_pi(tmp1, (__m64 *)&rs_buf[ofsi]); // H64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 801                 ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 802                 tmpfp[2] = (float)(rs_ofs & FRACTION_MASK);
 803                 tmp3 = _mm_loadl_pi(tmp3, (__m64 *)&rs_buf[ofsi]); // L64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 804                 ofsi = (rs_ofs += is_rs_increment) >> FRACTION_BITS;
 805                 tmpfp[3] = (float)(rs_ofs & FRACTION_MASK);
 806                 tmp3 = _mm_loadh_pi(tmp3, (__m64 *)&rs_buf[ofsi]); // H64bit ofsi\82Æofsi+1\82ð\83\8d\81[\83h
 807                 vv1 = _mm_shuffle_ps(tmp1, tmp3, 0x88); // v1[0,1,2,3]  // ofsi\82Ív1\82É
 808                 vv2 = _mm_shuffle_ps(tmp1, tmp3, 0xdd); // v2[0,1,2,3]  // ofsi+1\82Ív2\82É\88Ú\93®
 809                 vfp = _mm_load_ps(tmpfp);
 810 #endif
 811 #if defined(DATA_T_DOUBLE)
 812                 {
 813                 ALIGN float out[4];
 814                 _mm_storeu_ps(out, MM_FMA_PS(_mm_sub_ps(vv2, vv1), _mm_mul_ps(vfp, vec_divf), vv1));
 815                 is_buf[i] = (DATA_T)out[0];
 816                 is_buf[i + 1] = (DATA_T)out[1];
 817                 is_buf[i + 2] = (DATA_T)out[2];
 818                 is_buf[i + 3] = (DATA_T)out[3];
 819                 }
 820 #elif defined(DATA_T_FLOAT)
 821                 _mm_storeu_ps(&is_buf[i], MM_FMA_PS(_mm_sub_ps(vv2, vv1), _mm_mul_ps(vfp, vec_divf), vv1));
 822 #else // DATA_T_IN32
 823                 {
 824                 vec_out = MM_FMA_PS(_mm_sub_ps(vv2, vv1), _mm_mul_ps(vfp, vec_divf), vv1);
 825                 vec_out = _mm_mul_ps(vec_out, _mm_seti_ps(is_output_level));
 826                 is_buf[i] = _mm_cvt_ss2si(vec_out);
 827                 is_buf[i + 1] = _mm_cvt_ss2si(_mm_shuffle_ps(vec_out, vec_out, 0xe5));
 828                 is_buf[i + 2] = _mm_cvt_ss2si(_mm_shuffle_ps(vec_out, vec_out, 0xea));
 829                 is_buf[i + 3] = _mm_cvt_ss2si(_mm_shuffle_ps(vec_out, vec_out, 0xff));
 830                 }
 831 #endif // DATA_T_INT32
 832         }
 833         }
 834
 835 #endif // USE_X86_EXT_INTRIN
 836
 837         {
 838                 int32 ofsi, ofsf;
 839                 FLOAT_T v1, v2, fp;
 840                 for (; i < (count * is_rs_over_sampling); i++){
 841                         rs_ofs += is_rs_increment;
 842                         ofsi = rs_ofs >> FRACTION_BITS;
 843                         ofsf = rs_ofs & FRACTION_MASK;
 844                         fp = (FLOAT_T)ofsf * div_is_fraction;
 845                         v1 = rs_buf[ofsi], v2 = rs_buf[ofsi + 1];
 846 #if defined(DATA_T_DOUBLE) || defined(DATA_T_FLOAT)
 847                         is_buf[i] = v1 + (v2 - v1) * fp;
 848 #else // DATA_T_INT32
 849                         is_buf[i] = (v1 + (v2 - v1) * fp) * is_output_level;
 850 #endif // DATA_T_INT32
 851                 }
 852
 853                 //
 854                 ofsi = rs_ofs >> FRACTION_BITS;
 855                 rs->offset = rs_ofs & FRACTION_MASK;
 856 #if (USE_X86_EXT_INTRIN >= 3) && defined(IS_RS_DATA_T_DOUBLE)
 857                 _mm_storeu_pd(rs->data, _mm_loadu_pd(&rs_buf[ofsi]));
 858 #elif (USE_X86_EXT_INTRIN >= 3) && defined(IS_RS_DATA_T_FLOAT)
 859                 {
 860                 __m128 vtmp;
 861                 _mm_storel_pi(rs->data, _mm_loadl_pi(vtmp, (__m64 *)&rs_buf[ofsi]));
 862                 }
 863 #else
 864                 rs->data[0] = rs_buf[ofsi];
 865                 rs->data[1] = rs_buf[ofsi + 1]; // interpolate
 866 #endif
 867                 is_resample_down_sampling(is_buf, count);
 868         }
 869 }
 870
 871
 872 #endif // over sampling
 873
 874
 875
 876
 877 //////// LA ROM
 878 // mt32emu Code
 879
 880 const FLOAT_T la_base_freq = 442.0 / 440.0 * 261.626; // mt32_master_tuning / timidity_master_tuning * timidity_note60
 881 const FLOAT_T la_sample_rate = 32000;
 882 const LA_Ctrl_ROM_Map LA_Ctrl_ROM_Maps[7] = {
 883         // ID    IDc IDbytes                     PCMmap  PCMc  tmbrA   tmbrAO, tmbrAC tmbrB   tmbrBO, tmbrBC tmbrR   trC  rhythm  rhyC  rsrv    panpot  prog    rhyMax  patMax  sysMax  timMax
 884         {0x4014, 22, "\000 ver1.04 14 July 87 ", 0x3000,  128, 0x8000, 0x0000, 0x00, 0xC000, 0x4000, 0x00, 0x3200,  30, 0x73A6,  85,  0x57C7, 0x57E2, 0x57D0, 0x5252, 0x525E, 0x526E, 0x520A},
 885         {0x4014, 22, "\000 ver1.05 06 Aug, 87 ", 0x3000,  128, 0x8000, 0x0000, 0x00, 0xC000, 0x4000, 0x00, 0x3200,  30, 0x7414,  85,  0x57C7, 0x57E2, 0x57D0, 0x5252, 0x525E, 0x526E, 0x520A},
 886         {0x4014, 22, "\000 ver1.06 31 Aug, 87 ", 0x3000,  128, 0x8000, 0x0000, 0x00, 0xC000, 0x4000, 0x00, 0x3200,  30, 0x7414,  85,  0x57D9, 0x57F4, 0x57E2, 0x5264, 0x5270, 0x5280, 0x521C},
 887         {0x4010, 22, "\000 ver1.07 10 Oct, 87 ", 0x3000,  128, 0x8000, 0x0000, 0x00, 0xC000, 0x4000, 0x00, 0x3200,  30, 0x73fe,  85,  0x57B1, 0x57CC, 0x57BA, 0x523C, 0x5248, 0x5258, 0x51F4}, // MT-32 revision 1
 888         {0x4010, 22, "\000verX.XX  30 Sep, 88 ", 0x3000,  128, 0x8000, 0x0000, 0x00, 0xC000, 0x4000, 0x00, 0x3200,  30, 0x741C,  85,  0x57E5, 0x5800, 0x57EE, 0x5270, 0x527C, 0x528C, 0x5228}, // MT-32 Blue Ridge mod
 889         {0x2205, 22, "\000CM32/LAPC1.00 890404", 0x8100,  256, 0x8000, 0x8000, 0x00, 0x8080, 0x8000, 0x00, 0x8500,  64, 0x8580,  85,  0x4F65, 0x4F80, 0x4F6E, 0x48A1, 0x48A5, 0x48BE, 0x48D5},
 890         {0x2205, 22, "\000CM32/LAPC1.02 891205", 0x8100,  256, 0x8000, 0x8000, 0x01,  0x8080, 0x8000, 0x01,  0x8500,  64, 0x8580,  85,  0x4F93, 0x4FAE, 0x4F9C, 0x48CB, 0x48CF, 0x48E8, 0x48FF}  // CM-32L
 891         // (Note that all but CM-32L ROM actually have 86 entries for rhythmTemp)
 892 };
 893
 894 const char *la_pcm_data_name[] = {
 895         "Acoustic Bass Drum",
 896         "Acoustic Snare Drum",
 897         "Electric Snare Drum",
 898         "Acoustic Tom-Tom",
 899         "Closed Hi-Hat Attack",
 900         "Open Hi-Hat Tail",
 901         "Crash Cymbal Attack",
 902         "Crash Cymbal Tail",
 903         "Ride Cymbal Attack",
 904         "Rim Shot",
 905         "Hand Clap",
 906         "Mute Conga",
 907         "High Conga",
 908         "Bongo",
 909         "Cowbell",
 910         "Tambourine",
 911         "Agogo Bell",
 912         "Claves",
 913         "Timbale",
 914         "Cabassa",
 915         "Acoustic Piano",
 916         "Ham & Organ Attack",
 917         "Trombone",
 918         "Trumpet",
 919         "Breath Noise",
 920         "Clarinet",
 921         "Flute",
 922         "Steamer",
 923         "Shaku-Hachi",
 924         "Alto Sax",
 925         "Baritone Sax",
 926         "Marimba",
 927         "Vibraphone",
 928         "Xylophone",
 929         "Windbell",
 930         "Fretless Bass",
 931         "Slap Bass Attack",
 932         "Slap Bass Tail",
 933         "Acoustic Bass",
 934         "Gut Guitar",
 935         "Steel Guitar",
 936         "Pizzicato Strings",
 937         "Harp",
 938         "Harpsichord",
 939         "Contrabass",
 940         "Violin",
 941         "Timpani",
 942         "Orchestra Hit",
 943         "Indian Flute",
 944         "Ham & Organ Loop",
 945         "Bell",
 946         "Telephone",
 947         "Ethnic",
 948         "Stainless Steel",
 949         "Loop 01 Acoustic Bass Drum",
 950         "Loop 02 Acoustic Snare Drum",
 951         "Loop 03 Electric Snare Drum",
 952         "Loop 04 Acoustic Tom-Tom",
 953         "Loop 05 Closed Hi-Hat Attack",
 954         "Loop 06 Crash Cymbal Attack",
 955         "Loop 07 Ride Cymbal Attack",
 956         "Loop 08 Ride Cymbal Attack short",
 957         "Loop 09 Rim Shot",
 958         "Loop 10 Hand Clap",
 959         "Loop 11 Mute Conga",
 960         "Loop 12 High Conga",
 961         "Loop 13 Bongo",
 962         "Loop 14 Cowbell",
 963         "Loop 15 Tambourine ",
 964         "Loop 16 Agogo Bell",
 965         "Loop 17 Claves",
 966         "Loop 18 Timbale ",
 967         "Loop 19 Cabassa",
 968         "Loop 20 Acoustic Piano",
 969         "Loop 21 Ham & Organ Attack",
 970         "Loop 22 Trombone",
 971         "Loop 23 Trumpet ",
 972         "Loop 24 Clarinet",
 973         "Loop 25 Flute",
 974         "Loop 26 Steamer",
 975         "Loop 27 Shaku-Hachi",
 976         "Loop 28 Alto Sax",
 977         "Loop 29 Baritone Sax",
 978         "Loop 30 Marimba",
 979         "Loop 31 Vibraphone",
 980         "Loop 32 Xylophone",
 981         "Loop 33 Windbell",
 982         "Loop 34 Fretless Bass",
 983         "Loop 35 Slap Bass Attack",
 984         "Loop 36 Acoustic Bass",
 985         "Loop 37 Gut Guitar",
 986         "Loop 38 Steel Guitar",
 987         "Loop 39 Pizzicato Strings",
 988         "Loop 40 Harp",
 989         "Loop 41 Contrabass",
 990         "Loop 42 Violin",
 991         "Loop 43 Timpani",
 992         "Loop 44 Orchestra Hit",
 993         "Loop 45 Indian Flute",
 994         "Loop 46 ",
 995         "Loop 47 ",
 996         "Loop 48 ",
 997         "Loop 49 ",
 998         "Loop 50 ",
 999         "Loop 51 ",
1000         "Loop 52 ",
1001         "Loop 53 ",
1002         "Loop 54 ",
1003         "Loop 55 ",
1004         "Loop 56 ",
1005         "Loop 57 ",
1006         "Loop 58 ",
1007         "Loop 59 ",
1008         "Loop 60 ",
1009         "Loop 61 ",
1010         "Loop 62 ",
1011         "Loop 63 ",
1012         "Loop 64 ",
1013         "Loop 65 ",
1014         "Loop 66 ",
1015         "Loop 67 ",
1016         "Loop 68 ",
1017         "Loop 69 ",
1018         "Loop 70 ",
1019         "Loop 71 ",
1020         "Loop 72 ",
1021         "Loop 73 ",
1022         "Loop 74 ",
1023         "Laughing",
1024         "Applause",
1025         "Windchime",
1026         "Crash",
1027         "Train",
1028         "Rain",
1029         "Birds",
1030         "Stream",
1031         "Creaking",
1032         "Screaming",
1033         "Punch",
1034         "Footsteps",
1035         "Door",
1036         "Engine Start",
1037         "Jet",
1038         "Pistol",
1039         "Horse",
1040         "Thunder",
1041         "Bubble",
1042         "Heartbeat",
1043         "Car-pass ",
1044         "Car-stop",
1045         "Siren",
1046         "Helicopter",
1047         "Dog",
1048         "Wave 153",
1049         "Wave 154",
1050         "Machinegun",
1051         "Starship",
1052         "Loop Laughing",
1053         "Loop Applause",
1054         "Loop Windchime",
1055         "Loop Crash",
1056         "Loop Train",
1057         "Loop Rain",
1058         "Loop Birds",
1059         "Loop Stream",
1060         "Loop Creaking",
1061         "Loop Screaming",
1062         "Loop Punch",
1063         "Loop Footsteps",
1064         "Loop Door",
1065         "Loop Engine Start",
1066         "Loop Jet",
1067         "Loop Pistol",
1068         "Loop Horse",
1069         "Loop Thunder",
1070         "Loop Bubble",
1071         "Loop Heartbeat",
1072         "Loop Engine",
1073         "Loop Car-stop",
1074         "Loop Siren",
1075         "Loop Helicopter",
1076         "Loop Dog",
1077         "Loop 153",
1078         "Loop 154",
1079         "Loop Machinegun",
1080         "Loop Starship",
1081         "Wave 186 Loop",
1082         "Wave 187 Loop",
1083         "Wave 188 Loop",
1084         "Wave 189 Loop",
1085         "Wave 190 Loop",
1086         "Wave 191 Loop",
1087         "Wave 192 Loop",
1088         "Wave 193 Loop",
1089         "Wave 194 Loop",
1090         "Wave 195 Loop",
1091         "Wave 196 Loop",
1092         "Wave 197 Loop",
1093         "Wave 198 Loop",
1094         "Wave 199 Loop",
1095         "Wave 200 Loop",
1096         "Wave 201 Loop",
1097         "Wave 202 Loop",
1098         "Wave 203 Loop",
1099         "Wave 204 Loop",
1100         "Wave 205 Loop",
1101         "Wave 206 Loop",
1102         "Wave 207 Loop",
1103         "Wave 208 Loop",
1104         "Wave 209 Loop",
1105         "Wave 210 Loop",
1106         "Wave 211 Loop",
1107         "Wave 212 Loop",
1108         "Wave 213 Loop",
1109         "Wave 214 Loop",
1110         "Wave 215 Loop",
1111         "Wave 216 Loop",
1112         "Wave 217 Loop",
1113         "Wave 218 Loop",
1114         "Wave 219 Loop",
1115         "Wave 220 Loop",
1116         "Wave 221 Loop",
1117         "Wave 222 Loop",
1118         "Wave 223 Loop",
1119         "Wave 224 Loop",
1120         "Wave 225 Loop",
1121         "Wave 226",
1122         "Wave 227",
1123         "Wave 228",
1124         "Wave 229",
1125         "Wave 230",
1126         "Wave 231",
1127         "Wave 232",
1128         "Wave 233",
1129         "Wave 234",
1130         "Wave 235",
1131         "Wave 236",
1132         "Wave 237",
1133         "Wave 238",
1134         "Wave 239",
1135         "Wave 240",
1136         "Wave 241",
1137         "Wave 242",
1138         "Wave 243",
1139         "Wave 244",
1140         "Wave 245",
1141         "Wave 246",
1142         "Wave 247",
1143         "Wave 248",
1144         "Wave 249",
1145         "Wave 250",
1146         "Wave 251",
1147         "Wave 252",
1148         "Wave 253",
1149         "Wave 254",
1150         "Wave 255",
1151 };
1152
1153 static void la_ctrl_rom_conv(struct timidity_file *tf, Info_PCM *inf, int rom_size)
1154 {
1155         uint8 *ctrl_rom = NULL;
1156         LA_Ctrl_ROM_Map *ctrl_map = NULL;
1157         LA_Ctrl_ROM_PCM_Struct *tps = NULL;
1158         int i, pitch;
1159         FLOAT_T frq;
1160
1161         ctrl_rom = (uint8 *)safe_malloc(LA_CONTROL_ROM_SIZE);
1162         if(!ctrl_rom)
1163                 return;
1164         memset(ctrl_rom, 0, LA_CONTROL_ROM_SIZE);
1165         if(!tf_read(ctrl_rom, 1, LA_CONTROL_ROM_SIZE, tf)){
1166                 safe_free(ctrl_rom);
1167                 return;
1168         }
1169         for (i = 0; i < sizeof(LA_Ctrl_ROM_Maps) / sizeof(LA_Ctrl_ROM_Maps[0]); i++) {
1170                 if (memcmp(&ctrl_rom[LA_Ctrl_ROM_Maps[i].idPos], LA_Ctrl_ROM_Maps[i].idBytes, LA_Ctrl_ROM_Maps[i].idLen) == 0) {
1171                         ctrl_map = (LA_Ctrl_ROM_Map *)&LA_Ctrl_ROM_Maps[i];
1172                         break;
1173                 }
1174         }
1175         memset(inf, 0, sizeof(Info_PCM) * ctrl_map->pcmCount);
1176         tps = (LA_Ctrl_ROM_PCM_Struct *)&ctrl_rom[ctrl_map->pcmTable];
1177         for (i = 0; i < ctrl_map->pcmCount; i++) {
1178                 uint32 rAddr = tps[i].pos * 0x800;
1179                 uint32 rLen = 0x800 << ((tps[i].len & 0x70) >> 4);
1180                 if (rAddr + rLen > rom_size) {
1181                         return; // Control ROM error
1182                 }
1183                 inf[i].loop = (tps[i].len & 0x80) != 0;
1184                 inf[i].ofs_start = rAddr;
1185                 inf[i].ofs_end = rAddr + rLen;
1186                 inf[i].loop_start = rAddr;
1187                 inf[i].loop_end = rAddr + rLen;
1188                 inf[i].loop_length = rLen;
1189                 pitch = (int32)((((int32)tps[i].pitchMSB) << 8) | (int32)tps[i].pitchLSB) - 20480;
1190                 frq = pow(2.0, (FLOAT_T)(-pitch) * DIV_12BIT) * la_base_freq; // c5=20480 , +1oct=-4096 12bit
1191                 inf[i].root_freq = frq;
1192                 inf[i].div_root_freq = 1.0 / frq; // 1/root_freq
1193                 inf[i].sample_rate = la_sample_rate;
1194         }
1195         safe_free(ctrl_rom);
1196 }
1197
1198 static void la_pcm_rom_conv(struct timidity_file *tf, FLOAT_T *buf, int rom_size, int pcm_size)
1199 {
1200         uint8 *pcm_rom = NULL;
1201         int i = 0, j = 0;
1202 //      FLOAT_T maxamp = 0;
1203
1204         pcm_rom = (uint8 *)safe_malloc(rom_size);
1205         if(!pcm_rom)
1206                 return;
1207         memset(pcm_rom, 0, rom_size);
1208         if(!tf_read(pcm_rom, 1, rom_size, tf)){
1209                 safe_free(pcm_rom);
1210                 return;
1211         }
1212         for (;;) {
1213                 int16 s = 0, c = 0;
1214                 int16 e = 0;
1215                 int u, z = 15;
1216                 int order[16] = {0, 9, 1 ,2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 8};
1217                 FLOAT_T expval, vol;
1218
1219                 s = pcm_rom[j++];
1220                 c = pcm_rom[j++];
1221                 for(u = 0; u < 15; u++) {
1222                         int bit;
1223
1224                         if((order[u] < 8) && (order[u] >= 0)) {
1225                                 bit = (s >> (7-order[u])) & 0x1;
1226                         } else {
1227                                 if(order[u] >= 8) {
1228                                         bit = (c >> (7 - (order[u] - 8))) & 0x1;
1229                                 } else {
1230                                         bit = 0;
1231                                 }
1232                         }
1233                         e = e | (bit << z);
1234                         --z;
1235                 }
1236                 if(e < 0)
1237                         expval = -32767 - e;
1238                 else
1239                         expval = -e;
1240                 vol = pow(pow((expval * DIV_15BIT), 32.0), DIV_3);
1241                 if (e > 0)
1242                         vol = -vol;
1243                 //expval = fabs(vol);
1244                 //if(expval > maxamp)
1245                 //      maxamp = expval;
1246                 // test maxamp=0.99934915035888361
1247                 //buf[i] = (int)(vol * M_23BIT) * DIV_23BIT; //
1248                 buf[i] = vol;
1249                 i++;
1250                 if(i >= pcm_size)
1251                         break; // error
1252                 if(j >= rom_size)
1253                         break; // error
1254         }
1255         buf[pcm_size] = 0; // for interpolation
1256         safe_free(pcm_rom);
1257 }
1258
1259 void load_la_rom(void)
1260 {
1261         struct timidity_file *tf;
1262
1263         if(la_pcm_data_load_flg)
1264                 return;
1265         la_pcm_data_load_flg = 1;
1266         // MT32 ctrl
1267         if (tf = open_file("MT32_CONTROL.ROM", 1, OF_NORMAL)){
1268                 la_ctrl_rom_conv(tf, mt32_pcm_inf, MT32_PCM_ROM_SIZE);
1269                 close_file(tf);
1270         }
1271         // MT32 pcm
1272         if (tf = open_file("MT32_PCM.ROM", 1, OF_NORMAL)){
1273                 la_pcm_rom_conv(tf, mt32_pcm_data, MT32_PCM_ROM_SIZE, MT32_PCM_SIZE);
1274                 close_file(tf);
1275         }
1276         // CM32L ctrl
1277         if (tf = open_file("CM32L_CONTROL.ROM", 1, OF_NORMAL)){
1278                 la_ctrl_rom_conv(tf, cm32l_pcm_inf, CM32L_PCM_ROM_SIZE);
1279                 close_file(tf);
1280         }
1281         // CM32L pcm
1282         if (tf = open_file("CM32L_PCM.ROM", 1, OF_NORMAL)){
1283                 la_pcm_rom_conv(tf, cm32l_pcm_data, CM32L_PCM_ROM_SIZE, CM32L_PCM_SIZE);
1284                 close_file(tf);
1285         }
1286 }
1287
1288
1289
1290
1291 //////// load setting (int_synth.ini
1292
1293 //// SCC data
1294 static void config_parse_scc_data(const char *cp, Preset_IS *set, int setting)
1295 {
1296         const char *p, *px;
1297         int i, tmp;
1298
1299         /* count num */
1300         p = cp;
1301         /* init */
1302         for (i = 0; i < SCC_DATA_LENGTH + 1; i++){
1303                 set->scc_data_int[setting][i] = 0; // init param
1304                 set->scc_data[setting][i] = 0; // init param
1305         }
1306         /* regist */
1307         for (i = 0; i < SCC_DATA_LENGTH; i++, p++) {
1308                 if (*p == ':')
1309                         continue;
1310                 tmp = atoi(p);
1311                 if(tmp >= 128)
1312                         tmp = 128;
1313                 else if(tmp < -128)
1314                         tmp = -128;
1315                 set->scc_data_int[setting][i] = (int16)tmp;
1316                 set->scc_data[setting][i] = (double)tmp * DIV_128;
1317                 if (! (p = strchr(p, ':')))
1318                         break;
1319         }
1320         set->scc_data[setting][SCC_DATA_LENGTH] = set->scc_data[setting][0]; // for interpolation
1321 }
1322
1323 #if 0
1324 //// MT32 data
1325 static void config_parse_mt32_data(const char *cp, Preset_IS *set, int setting)
1326 {
1327         const char *p, *px;
1328         int i, tmp;
1329         FLOAT_T frq = 261.626; // note60
1330         FLOAT_T div_frq = 1.0 / frq;
1331
1332         /* count num */
1333         p = cp;
1334         /* init */
1335         // loop 0:off 1:on, ofs_start, ofs_end, loop_start, loop_end, sample_rate [Hz], root_freq [0.001Hz]
1336         mt32_pcm_inf[setting].loop = 0;
1337         mt32_pcm_inf[setting].ofs_start = 0;
1338         mt32_pcm_inf[setting].ofs_end = 0;
1339         mt32_pcm_inf[setting].loop_start = 0;
1340         mt32_pcm_inf[setting].loop_end = 0;
1341         mt32_pcm_inf[setting].sample_rate = 32000;
1342         mt32_pcm_inf[setting].root_freq = frq;
1343         mt32_pcm_inf[setting].div_root_freq = div_frq; // 1/root_freq
1344         /* regist */
1345         for (i = 0; i < 7; i++, p++) {
1346                 if (*p == ':')
1347                         continue;
1348                 tmp = atoi(p);
1349                 if(tmp < 0)
1350                         break;
1351                 switch(i){
1352                 case 0:
1353                         mt32_pcm_inf[setting].loop = tmp;
1354                         break;
1355                 case 1:
1356                         mt32_pcm_inf[setting].ofs_start = tmp;
1357                         mt32_pcm_inf[setting].loop_start = tmp;
1358                         break;
1359                 case 2:
1360                         mt32_pcm_inf[setting].ofs_end = tmp;
1361                         mt32_pcm_inf[setting].loop_end = tmp;
1362                         break;
1363                 case 3:
1364                         if(tmp == 0)
1365                                 break;
1366                         tmp *= DIV_1000;
1367                         mt32_pcm_inf[setting].root_freq = tmp;
1368                         mt32_pcm_inf[setting].div_root_freq = 1.0 / (double)tmp;
1369                         break;
1370                 default:
1371                         break;
1372                 }
1373                 if (! (p = strchr(p, ':')))
1374                         break;
1375         }
1376 }
1377
1378 //// CM32L data
1379 static void config_parse_cm32l_data(const char *cp, Preset_IS *set, int setting)
1380 {
1381         const char *p, *px;
1382         int i, tmp;
1383         FLOAT_T frq = 261.626; // note60
1384         FLOAT_T div_frq = 1.0 / frq;
1385
1386         /* count num */
1387         p = cp;
1388         /* init */
1389         // loop 0:off 1:on, ofs_start, ofs_end, loop_start, loop_end, sample_rate [Hz], root_freq [0.001Hz]
1390         cm32l_pcm_inf[setting].loop = 0;
1391         cm32l_pcm_inf[setting].ofs_start = 0;
1392         cm32l_pcm_inf[setting].ofs_end = 0;
1393         cm32l_pcm_inf[setting].loop_start = 0;
1394         cm32l_pcm_inf[setting].loop_end = 0;
1395         cm32l_pcm_inf[setting].sample_rate = 32000;
1396         cm32l_pcm_inf[setting].root_freq = frq;
1397         cm32l_pcm_inf[setting].div_root_freq = div_frq; // 1/root_freq
1398         /* regist */
1399         for (i = 0; i < 7; i++, p++) {
1400                 if (*p == ':')
1401                         continue;
1402                 tmp = atoi(p);
1403                 if(tmp < 0)
1404                         break;
1405                 switch(i){
1406                 case 0:
1407                         cm32l_pcm_inf[setting].loop = tmp;
1408                         break;
1409                 case 1:
1410                         cm32l_pcm_inf[setting].ofs_start = tmp;
1411                         break;
1412                 case 2:
1413                         cm32l_pcm_inf[setting].ofs_end = tmp;
1414                         break;
1415                 case 3:
1416                         cm32l_pcm_inf[setting].loop_start = tmp;
1417                         break;
1418                 case 4:
1419                         cm32l_pcm_inf[setting].loop_end = tmp;
1420                         break;
1421                 case 5:
1422                         cm32l_pcm_inf[setting].sample_rate = tmp;
1423                         break;
1424                 case 6:
1425                         if(tmp == 0)
1426                                 break;
1427                         tmp *= DIV_1000;
1428                         cm32l_pcm_inf[setting].root_freq = tmp;
1429                         cm32l_pcm_inf[setting].div_root_freq = 1.0 / (double)tmp;
1430                         break;
1431                 default:
1432                         break;
1433                 }
1434                 if (! (p = strchr(p, ':')))
1435                         break;
1436         }
1437 }
1438 #endif
1439
1440 //// SCC
1441 static void config_parse_scc_param(const char *cp, Preset_IS *set, int setting)
1442 {
1443         const char *p, *px;
1444         int i, tmp;
1445
1446         /* count num */
1447         p = cp;
1448         /* init */
1449         for (i = 0; i < SCC_PARAM_MAX; i++)
1450                 set->scc_setting[setting]->param[i] = 0; // init param
1451         /* regist */
1452         for (i = 0; i < SCC_PARAM_MAX; i++, p++) {
1453                 if (*p == ':')
1454                         continue;
1455                 set->scc_setting[setting]->param[i] = atoi(p);
1456                 if (! (p = strchr(p, ':')))
1457                         break;
1458         }
1459 }
1460
1461 static void config_parse_scc_osc(const char *cp, Preset_IS *set, int setting)
1462 {
1463         const char *p, *px;
1464         int i, tmp;
1465
1466         /* count num */
1467         p = cp;
1468         /* init */
1469         for (i = 0; i < SCC_OSC_MAX; i++)
1470                 set->scc_setting[setting]->osc[i] = 0; // init param
1471         /* regist */
1472         for (i = 0; i < SCC_OSC_MAX; i++, p++) {
1473                 if (*p == ':')
1474                         continue;
1475                 set->scc_setting[setting]->osc[i] = atoi(p);
1476                 if (! (p = strchr(p, ':')))
1477                         break;
1478         }
1479 }
1480
1481 static void config_parse_scc_amp(const char *cp, Preset_IS *set, int setting)
1482 {
1483         const char *p, *px;
1484         int i, tmp;
1485
1486         /* count num */
1487         p = cp;
1488         /* init */
1489         for (i = 0; i < SCC_AMP_MAX; i++)
1490                 set->scc_setting[setting]->amp[i] = 0; // init param
1491         /* regist */
1492         for (i = 0; i < SCC_AMP_MAX; i++, p++) {
1493                 if (*p == ':')
1494                         continue;
1495                 set->scc_setting[setting]->amp[i] = atoi(p);
1496                 if (! (p = strchr(p, ':')))
1497                         break;
1498         }
1499 }
1500
1501 static void config_parse_scc_pitch(const char *cp, Preset_IS *set, int setting)
1502 {
1503         const char *p, *px;
1504         int i, tmp;
1505
1506         /* count num */
1507         p = cp;
1508         /* init */
1509         for (i = 0; i < SCC_PITCH_MAX; i++)
1510                 set->scc_setting[setting]->pitch[i] = 0; // init param
1511         /* regist */
1512         for (i = 0; i < SCC_PITCH_MAX; i++, p++) {
1513                 if (*p == ':')
1514                         continue;
1515                 set->scc_setting[setting]->pitch[i] = atoi(p);
1516                 if (! (p = strchr(p, ':')))
1517                         break;
1518         }
1519 }
1520
1521 static void config_parse_scc_ampenv(const char *cp, Preset_IS *set, int setting)
1522 {
1523         const char *p, *px;
1524         int i, tmp;
1525
1526         /* count num */
1527         p = cp;
1528         /* init */
1529         for (i = 0; i < SCC_ENV_PARAM; i++)
1530                 set->scc_setting[setting]->ampenv[i] = 0; // init param
1531         set->scc_setting[setting]->ampenv[2] = 100; // init param
1532         /* regist */
1533         for (i = 0; i < SCC_ENV_PARAM; i++, p++) {
1534                 if (*p == ':')
1535                         continue;
1536                 set->scc_setting[setting]->ampenv[i] = atoi(p);
1537                 if (! (p = strchr(p, ':')))
1538                         break;
1539         }
1540 }
1541
1542 static void config_parse_scc_pitenv(const char *cp, Preset_IS *set, int setting)
1543 {
1544         const char *p, *px;
1545         int i, tmp;
1546
1547         /* count num */
1548         p = cp;
1549         /* init */
1550         for (i = 0; i < SCC_ENV_PARAM; i++)
1551                 set->scc_setting[setting]->pitenv[i] = 0; // init param
1552         set->scc_setting[setting]->pitenv[2] = 100; // init param
1553         /* regist */
1554         for (i = 0; i < SCC_ENV_PARAM; i++, p++) {
1555                 if (*p == ':')
1556                         continue;
1557                 set->scc_setting[setting]->pitenv[i] = atoi(p);
1558                 if (! (p = strchr(p, ':')))
1559                         break;
1560         }
1561 }
1562
1563 static void config_parse_scc_lfo1(const char *cp, Preset_IS *set, int setting)
1564 {
1565         const char *p, *px;
1566         int i, tmp;
1567
1568         /* count num */
1569         p = cp;
1570         /* init */
1571 //      for (i = 0; i < SCC_LFO_PARAM; i++)
1572 //              set->scc_setting[setting]->lfo1[i] = 0; // init param
1573         set->scc_setting[setting]->lfo1[0] = 0; // init param
1574         set->scc_setting[setting]->lfo1[1] = 0; // init param
1575         set->scc_setting[setting]->lfo1[2] = 0; // init param
1576         set->scc_setting[setting]->lfo1[3] = 200; // init param
1577         /* regist */
1578         for (i = 0; i < SCC_LFO_PARAM; i++, p++) {
1579                 if (*p == ':')
1580                         continue;
1581                 set->scc_setting[setting]->lfo1[i] = atoi(p);
1582                 if (! (p = strchr(p, ':')))
1583                         break;
1584         }
1585 }
1586
1587 static void config_parse_scc_lfo2(const char *cp, Preset_IS *set, int setting)
1588 {
1589         const char *p, *px;
1590         int i, tmp;
1591
1592         /* count num */
1593         p = cp;
1594         /* init */
1595 //      for (i = 0; i < SCC_LFO_PARAM; i++)
1596 //              set->scc_setting[setting]->lfo2[i] = 0; // init param
1597         set->scc_setting[setting]->lfo2[0] = 0; // init param
1598         set->scc_setting[setting]->lfo2[1] = 0; // init param
1599         set->scc_setting[setting]->lfo2[2] = 0; // init param
1600         set->scc_setting[setting]->lfo2[3] = 200; // init param
1601         /* regist */
1602         for (i = 0; i < SCC_LFO_PARAM; i++, p++) {
1603                 if (*p == ':')
1604                         continue;
1605                 set->scc_setting[setting]->lfo2[i] = atoi(p);
1606                 if (! (p = strchr(p, ':')))
1607                         break;
1608         }
1609 }
1610
1611
1612 //// MMS
1613 static void config_parse_mms_op_param(const char *cp, Preset_IS *set, int setting, int op_num)
1614 {
1615         const char *p, *px;
1616         int i, tmp;
1617
1618         /* count num */
1619         p = cp;
1620         /* init */
1621         for (i = 0; i < MMS_OP_PARAM_MAX; i++)
1622                 set->mms_setting[setting]->op_param[op_num][i] = 0; // init param
1623         /* regist */
1624         for (i = 0; i < MMS_OP_PARAM_MAX; i++, p++) {
1625                 if (*p == ':')
1626                         continue;
1627                 set->mms_setting[setting]->op_param[op_num][i] = atoi(p);
1628                 if (! (p = strchr(p, ':')))
1629                         break;
1630         }
1631 }
1632
1633 static void config_parse_mms_op_range(const char *cp, Preset_IS *set, int setting, int op_num)
1634 {
1635         const char *p, *px;
1636         int i, tmp;
1637
1638         /* count num */
1639         p = cp;
1640         /* init */
1641         //for (i = 0; i < MMS_OP_RANGE_MAX; i++)
1642         //      set->mms_setting[setting]->op_range[op_num][i] = -1; // init param
1643         set->mms_setting[setting]->op_range[op_num][0] = 0;
1644         set->mms_setting[setting]->op_range[op_num][1] = 127;
1645         set->mms_setting[setting]->op_range[op_num][2] = 0;
1646         set->mms_setting[setting]->op_range[op_num][3] = 127;
1647         /* regist */
1648         for (i = 0; i < MMS_OP_RANGE_MAX; i++, p++) {
1649                 if (*p == ':')
1650                         continue;
1651                 set->mms_setting[setting]->op_range[op_num][i] = atoi(p);
1652                 if (! (p = strchr(p, ':')))
1653                         break;
1654         }
1655 }
1656
1657 static void config_parse_mms_op_connect(const char *cp, Preset_IS *set, int setting, int op_num)
1658 {
1659         const char *p, *px;
1660         int i, tmp;
1661
1662         /* count num */
1663         p = cp;
1664         /* init */
1665         for (i = 0; i < MMS_OP_CON_MAX; i++)
1666                 set->mms_setting[setting]->op_connect[op_num][i] = -1; // init param
1667         /* regist */
1668         for (i = 0; i < MMS_OP_CON_MAX; i++, p++) {
1669                 if (*p == ':')
1670                         continue;
1671                 set->mms_setting[setting]->op_connect[op_num][i] = atoi(p);
1672                 if (! (p = strchr(p, ':')))
1673                         break;
1674         }
1675 }
1676
1677 static void config_parse_mms_op_osc(const char *cp, Preset_IS *set, int setting, int op_num)
1678 {
1679         const char *p, *px;
1680         int i, tmp;
1681
1682         /* count num */
1683         p = cp;
1684         /* init */
1685         for (i = 0; i < MMS_OP_OSC_MAX; i++)
1686                 set->mms_setting[setting]->op_osc[op_num][i] = 0; // init param
1687         /* regist */
1688         for (i = 0; i < MMS_OP_OSC_MAX; i++, p++) {
1689                 if (*p == ':')
1690                         continue;
1691                 set->mms_setting[setting]->op_osc[op_num][i] = atoi(p);
1692                 if (! (p = strchr(p, ':')))
1693                         break;
1694         }
1695 }
1696
1697 static void config_parse_mms_op_wave(const char *cp, Preset_IS *set, int setting, int op_num)
1698 {
1699         const char *p, *px;
1700         int i, tmp;
1701
1702         /* count num */
1703         p = cp;
1704         /* init */
1705         for (i = 0; i < MMS_OP_WAVE_MAX; i++)
1706                 set->mms_setting[setting]->op_wave[op_num][i] = 0; // init param
1707         /* regist */
1708         for (i = 0; i < MMS_OP_WAVE_MAX; i++, p++) {
1709                 if (*p == ':')
1710                         continue;
1711                 set->mms_setting[setting]->op_wave[op_num][i] = atoi(p);
1712                 if (! (p = strchr(p, ':')))
1713                         break;
1714         }
1715 }
1716
1717 static void config_parse_mms_op_sub(const char *cp, Preset_IS *set, int setting, int op_num)
1718 {
1719         const char *p, *px;
1720         int i, tmp;
1721
1722         /* count num */
1723         p = cp;
1724         /* init */
1725         for (i = 0; i < MMS_OP_SUB_MAX; i++)
1726                 set->mms_setting[setting]->op_sub[op_num][i] = 0; // init param
1727         /* regist */
1728         for (i = 0; i < MMS_OP_SUB_MAX; i++, p++) {
1729                 if (*p == ':')
1730                         continue;
1731                 set->mms_setting[setting]->op_sub[op_num][i] = atoi(p);
1732                 if (! (p = strchr(p, ':')))
1733                         break;
1734         }
1735 }
1736
1737 static void config_parse_mms_op_amp(const char *cp, Preset_IS *set, int setting, int op_num)
1738 {
1739         const char *p, *px;
1740         int i, tmp;
1741
1742         /* count num */
1743         p = cp;
1744         /* init */
1745         for (i = 0; i < MMS_OP_AMP_MAX; i++)
1746                 set->mms_setting[setting]->op_amp[op_num][i] = 0; // init param
1747         /* regist */
1748         for (i = 0; i < MMS_OP_AMP_MAX; i++, p++) {
1749                 if (*p == ':')
1750                         continue;
1751                 set->mms_setting[setting]->op_amp[op_num][i] = atoi(p);
1752                 if (! (p = strchr(p, ':')))
1753                         break;
1754         }
1755 }
1756
1757 static void config_parse_mms_op_pitch(const char *cp, Preset_IS *set, int setting, int op_num)
1758 {
1759         const char *p, *px;
1760         int i, tmp;
1761
1762         /* count num */
1763         p = cp;
1764         /* init */
1765         for (i = 0; i < MMS_OP_PITCH_MAX; i++)
1766                 set->mms_setting[setting]->op_pitch[op_num][i] = 0; // init param
1767         /* regist */
1768         for (i = 0; i < MMS_OP_PITCH_MAX; i++, p++) {
1769                 if (*p == ':')
1770                         continue;
1771                 set->mms_setting[setting]->op_pitch[op_num][i] = atoi(p);
1772                 if (! (p = strchr(p, ':')))
1773                         break;
1774         }
1775 }
1776
1777 static void config_parse_mms_op_width(const char *cp, Preset_IS *set, int setting, int op_num)
1778 {
1779         const char *p, *px;
1780         int i, tmp;
1781
1782         /* count num */
1783         p = cp;
1784         /* init */
1785         for (i = 0; i < MMS_OP_WIDTH_MAX; i++)
1786                 set->mms_setting[setting]->op_width[op_num][i] = 0; // init param
1787         /* regist */
1788         for (i = 0; i < MMS_OP_WIDTH_MAX; i++, p++) {
1789                 if (*p == ':')
1790                         continue;
1791                 set->mms_setting[setting]->op_width[op_num][i] = atoi(p);
1792                 if (! (p = strchr(p, ':')))
1793                         break;
1794         }
1795 }
1796
1797 static void config_parse_mms_op_ampenv(const char *cp, Preset_IS *set, int setting, int op_num)
1798 {
1799         const char *p, *px;
1800         int i, tmp;
1801
1802         /* count num */
1803         p = cp;
1804         /* init */
1805         for (i = 0; i < MMS_OP_ENV_PARAM; i++)
1806                 set->mms_setting[setting]->op_ampenv[op_num][i] = 0; // init param
1807         set->mms_setting[setting]->op_ampenv[op_num][2] = 100; // init param
1808         /* regist */
1809         for (i = 0; i < MMS_OP_ENV_PARAM; i++, p++) {
1810                 if (*p == ':')
1811                         continue;
1812                 set->mms_setting[setting]->op_ampenv[op_num][i] = atoi(p);
1813                 if (! (p = strchr(p, ':')))
1814                         break;
1815         }
1816 }
1817
1818 static void config_parse_mms_op_modenv(const char *cp, Preset_IS *set, int setting, int op_num)
1819 {
1820         const char *p, *px;
1821         int i, tmp;
1822
1823         /* count num */
1824         p = cp;
1825         /* init */
1826         for (i = 0; i < MMS_OP_ENV_PARAM; i++)
1827                 set->mms_setting[setting]->op_modenv[op_num][i] = 0; // init param
1828         set->mms_setting[setting]->op_modenv[op_num][2] = 100; // init param
1829         /* regist */
1830         for (i = 0; i < MMS_OP_ENV_PARAM; i++, p++) {
1831                 if (*p == ':')
1832                         continue;
1833                 set->mms_setting[setting]->op_modenv[op_num][i] = atoi(p);
1834                 if (! (p = strchr(p, ':')))
1835                         break;
1836         }
1837 }
1838
1839 static void config_parse_mms_op_widenv(const char *cp, Preset_IS *set, int setting, int op_num)
1840 {
1841         const char *p, *px;
1842         int i, tmp;
1843
1844         /* count num */
1845         p = cp;
1846         /* init */
1847         for (i = 0; i < MMS_OP_ENV_PARAM; i++)
1848                 set->mms_setting[setting]->op_widenv[op_num][i] = 0; // init param
1849         set->mms_setting[setting]->op_widenv[op_num][2] = 100; // init param
1850         /* regist */
1851         for (i = 0; i < MMS_OP_ENV_PARAM; i++, p++) {
1852                 if (*p == ':')
1853                         continue;
1854                 set->mms_setting[setting]->op_widenv[op_num][i] = atoi(p);
1855                 if (! (p = strchr(p, ':')))
1856                         break;
1857         }
1858 }
1859
1860 static void config_parse_mms_op_pitenv(const char *cp, Preset_IS *set, int setting, int op_num)
1861 {
1862         const char *p, *px;
1863         int i, tmp;
1864
1865         /* count num */
1866         p = cp;
1867         /* init */
1868         for (i = 0; i < MMS_OP_ENV_PARAM; i++)
1869                 set->mms_setting[setting]->op_pitenv[op_num][i] = 0; // init param
1870         set->mms_setting[setting]->op_pitenv[op_num][2] = 100; // init param
1871         /* regist */
1872         for (i = 0; i < MMS_OP_ENV_PARAM; i++, p++) {
1873                 if (*p == ':')
1874                         continue;
1875                 set->mms_setting[setting]->op_pitenv[op_num][i] = atoi(p);
1876                 if (! (p = strchr(p, ':')))
1877                         break;
1878         }
1879 }
1880
1881 static void config_parse_mms_op_ampenv_keyf(const char *cp, Preset_IS *set, int setting, int op_num)
1882 {
1883         const char *p, *px;
1884         int i, tmp;
1885
1886         /* count num */
1887         p = cp;
1888         /* init */
1889         for (i = 0; i < MMS_OP_ENV_PARAM; i++)
1890                 set->mms_setting[setting]->op_ampenv_keyf[op_num][i] = 0; // init param
1891         /* regist */
1892         for (i = 0; i < MMS_OP_ENV_PARAM; i++, p++) {
1893                 if (*p == ':')
1894                         continue;
1895                 set->mms_setting[setting]->op_ampenv_keyf[op_num][i] = atoi(p);
1896                 if (! (p = strchr(p, ':')))
1897                         break;
1898         }
1899 }
1900
1901 static void config_parse_mms_op_modenv_keyf(const char *cp, Preset_IS *set, int setting, int op_num)
1902 {
1903         const char *p, *px;
1904         int i, tmp;
1905
1906         /* count num */
1907         p = cp;
1908         /* init */
1909         for (i = 0; i < MMS_OP_ENV_PARAM; i++)
1910                 set->mms_setting[setting]->op_modenv_keyf[op_num][i] = 0; // init param
1911         /* regist */
1912         for (i = 0; i < MMS_OP_ENV_PARAM; i++, p++) {
1913                 if (*p == ':')
1914                         continue;
1915                 set->mms_setting[setting]->op_modenv_keyf[op_num][i] = atoi(p);
1916                 if (! (p = strchr(p, ':')))
1917                         break;
1918         }
1919 }
1920
1921 static void config_parse_mms_op_widenv_keyf(const char *cp, Preset_IS *set, int setting, int op_num)
1922 {
1923         const char *p, *px;
1924         int i, tmp;
1925
1926         /* count num */
1927         p = cp;
1928         /* init */
1929         for (i = 0; i < MMS_OP_ENV_PARAM; i++)
1930                 set->mms_setting[setting]->op_widenv_keyf[op_num][i] = 0; // init param
1931         /* regist */
1932         for (i = 0; i < MMS_OP_ENV_PARAM; i++, p++) {
1933                 if (*p == ':')
1934                         continue;
1935                 set->mms_setting[setting]->op_widenv_keyf[op_num][i] = atoi(p);
1936                 if (! (p = strchr(p, ':')))
1937                         break;
1938         }
1939 }
1940
1941 static void config_parse_mms_op_pitenv_keyf(const char *cp, Preset_IS *set, int setting, int op_num)
1942 {
1943         const char *p, *px;
1944         int i, tmp;
1945
1946         /* count num */
1947         p = cp;
1948         /* init */
1949         for (i = 0; i < MMS_OP_ENV_PARAM; i++)
1950                 set->mms_setting[setting]->op_pitenv_keyf[op_num][i] = 0; // init param
1951         /* regist */
1952         for (i = 0; i < MMS_OP_ENV_PARAM; i++, p++) {
1953                 if (*p == ':')
1954                         continue;
1955                 set->mms_setting[setting]->op_pitenv_keyf[op_num][i] = atoi(p);
1956                 if (! (p = strchr(p, ':')))
1957                         break;
1958         }
1959 }
1960
1961 static void config_parse_mms_op_ampenv_velf(const char *cp, Preset_IS *set, int setting, int op_num)
1962 {
1963         const char *p, *px;
1964         int i, tmp;
1965
1966         /* count num */
1967         p = cp;
1968         /* init */
1969         for (i = 0; i < MMS_OP_ENV_PARAM; i++)
1970                 set->mms_setting[setting]->op_ampenv_velf[op_num][i] = 0; // init param
1971         /* regist */
1972         for (i = 0; i < MMS_OP_ENV_PARAM; i++, p++) {
1973                 if (*p == ':')
1974                         continue;
1975                 set->mms_setting[setting]->op_ampenv_velf[op_num][i] = atoi(p);
1976                 if (! (p = strchr(p, ':')))
1977                         break;
1978         }
1979 }
1980
1981 static void config_parse_mms_op_modenv_velf(const char *cp, Preset_IS *set, int setting, int op_num)
1982 {
1983         const char *p, *px;
1984         int i, tmp;
1985
1986         /* count num */
1987         p = cp;
1988         /* init */
1989         for (i = 0; i < MMS_OP_ENV_PARAM; i++)
1990                 set->mms_setting[setting]->op_modenv_velf[op_num][i] = 0; // init param
1991         /* regist */
1992         for (i = 0; i < MMS_OP_ENV_PARAM; i++, p++) {
1993                 if (*p == ':')
1994                         continue;
1995                 set->mms_setting[setting]->op_modenv_velf[op_num][i] = atoi(p);
1996                 if (! (p = strchr(p, ':')))
1997                         break;
1998         }
1999 }
2000
2001 static void config_parse_mms_op_widenv_velf(const char *cp, Preset_IS *set, int setting, int op_num)
2002 {
2003         const char *p, *px;
2004         int i, tmp;
2005
2006         /* count num */
2007         p = cp;
2008         /* init */
2009         for (i = 0; i < MMS_OP_ENV_PARAM; i++)
2010                 set->mms_setting[setting]->op_widenv_velf[op_num][i] = 0; // init param
2011         /* regist */
2012         for (i = 0; i < MMS_OP_ENV_PARAM; i++, p++) {
2013                 if (*p == ':')
2014                         continue;
2015                 set->mms_setting[setting]->op_widenv_velf[op_num][i] = atoi(p);
2016                 if (! (p = strchr(p, ':')))
2017                         break;
2018         }
2019 }
2020
2021 static void config_parse_mms_op_pitenv_velf(const char *cp, Preset_IS *set, int setting, int op_num)
2022 {
2023         const char *p, *px;
2024         int i, tmp;
2025
2026         /* count num */
2027         p = cp;
2028         /* init */
2029         for (i = 0; i < MMS_OP_ENV_PARAM; i++)
2030                 set->mms_setting[setting]->op_pitenv_velf[op_num][i] = 0; // init param
2031         /* regist */
2032         for (i = 0; i < MMS_OP_ENV_PARAM; i++, p++) {
2033                 if (*p == ':')
2034                         continue;
2035                 set->mms_setting[setting]->op_pitenv_velf[op_num][i] = atoi(p);
2036                 if (! (p = strchr(p, ':')))
2037                         break;
2038         }
2039 }
2040
2041 static void config_parse_mms_op_lfo1(const char *cp, Preset_IS *set, int setting, int op_num)
2042 {
2043         const char *p, *px;
2044         int i, tmp;
2045
2046         /* count num */
2047         p = cp;
2048         /* init */
2049 //      for (i = 0; i < MMS_OP_LFO_PARAM; i++)
2050 //              set->mms_setting[setting]->op_lfo1[op_num][i] = 0; // init param
2051         set->mms_setting[setting]->op_lfo1[op_num][0] = 0; // init param
2052         set->mms_setting[setting]->op_lfo1[op_num][1] = 0; // init param
2053         set->mms_setting[setting]->op_lfo1[op_num][2] = 0; // init param
2054         set->mms_setting[setting]->op_lfo1[op_num][3] = 200; // init param
2055         /* regist */
2056         for (i = 0; i < MMS_OP_LFO_PARAM; i++, p++) {
2057                 if (*p == ':')
2058                         continue;
2059                 set->mms_setting[setting]->op_lfo1[op_num][i] = atoi(p);
2060                 if (! (p = strchr(p, ':')))
2061                         break;
2062         }
2063 }
2064
2065 static void config_parse_mms_op_lfo2(const char *cp, Preset_IS *set, int setting, int op_num)
2066 {
2067         const char *p, *px;
2068         int i, tmp;
2069
2070         /* count num */
2071         p = cp;
2072         /* init */
2073 //      for (i = 0; i < MMS_OP_LFO_PARAM; i++)
2074 //              set->mms_setting[setting]->op_lfo2[op_num][i] = 0; // init param
2075         set->mms_setting[setting]->op_lfo2[op_num][0] = 0; // init param
2076         set->mms_setting[setting]->op_lfo2[op_num][1] = 0; // init param
2077         set->mms_setting[setting]->op_lfo2[op_num][2] = 0; // init param
2078         set->mms_setting[setting]->op_lfo2[op_num][3] = 200; // init param
2079         /* regist */
2080         for (i = 0; i < MMS_OP_LFO_PARAM; i++, p++) {
2081                 if (*p == ':')
2082                         continue;
2083                 set->mms_setting[setting]->op_lfo2[op_num][i] = atoi(p);
2084                 if (! (p = strchr(p, ':')))
2085                         break;
2086         }
2087 }
2088
2089 static void config_parse_mms_op_lfo3(const char *cp, Preset_IS *set, int setting, int op_num)
2090 {
2091         const char *p, *px;
2092         int i, tmp;
2093
2094         /* count num */
2095         p = cp;
2096         /* init */
2097 //      for (i = 0; i < MMS_OP_LFO_PARAM; i++)
2098 //              set->mms_setting[setting]->op_lfo3[op_num][i] = 0; // init param
2099         set->mms_setting[setting]->op_lfo3[op_num][0] = 0; // init param
2100         set->mms_setting[setting]->op_lfo3[op_num][1] = 0; // init param
2101         set->mms_setting[setting]->op_lfo3[op_num][2] = 0; // init param
2102         set->mms_setting[setting]->op_lfo3[op_num][3] = 200; // init param
2103         /* regist */
2104         for (i = 0; i < MMS_OP_LFO_PARAM; i++, p++) {
2105                 if (*p == ':')
2106                         continue;
2107                 set->mms_setting[setting]->op_lfo3[op_num][i] = atoi(p);
2108                 if (! (p = strchr(p, ':')))
2109                         break;
2110         }
2111 }
2112
2113 static void config_parse_mms_op_lfo4(const char *cp, Preset_IS *set, int setting, int op_num)
2114 {
2115         const char *p, *px;
2116         int i, tmp;
2117
2118         /* count num */
2119         p = cp;
2120         /* init */
2121 //      for (i = 0; i < MMS_OP_LFO_PARAM; i++)
2122 //              set->mms_setting[setting]->op_lfo4[op_num][i] = 0; // init param
2123         set->mms_setting[setting]->op_lfo4[op_num][0] = 0; // init param
2124         set->mms_setting[setting]->op_lfo4[op_num][1] = 0; // init param
2125         set->mms_setting[setting]->op_lfo4[op_num][2] = 0; // init param
2126         set->mms_setting[setting]->op_lfo4[op_num][3] = 200; // init param
2127         /* regist */
2128         for (i = 0; i < MMS_OP_LFO_PARAM; i++, p++) {
2129                 if (*p == ':')
2130                         continue;
2131                 set->mms_setting[setting]->op_lfo4[op_num][i] = atoi(p);
2132                 if (! (p = strchr(p, ':')))
2133                         break;
2134         }
2135 }
2136
2137 static void config_parse_mms_op_filter(const char *cp, Preset_IS *set, int setting, int op_num)
2138 {
2139         const char *p, *px;
2140         int i, tmp;
2141
2142         /* count num */
2143         p = cp;
2144         /* init */
2145         for (i = 0; i < MMS_OP_FLT_PARAM; i++)
2146                 set->mms_setting[setting]->op_filter[op_num][i] = 0; // init param
2147         /* regist */
2148         for (i = 0; i < MMS_OP_FLT_PARAM; i++, p++) {
2149                 if (*p == ':')
2150                         continue;
2151                 set->mms_setting[setting]->op_filter[op_num][i] = atoi(p);
2152                 if (! (p = strchr(p, ':')))
2153                         break;
2154         }
2155 }
2156
2157 static void config_parse_mms_op_cutoff(const char *cp, Preset_IS *set, int setting, int op_num)
2158 {
2159         const char *p, *px;
2160         int i, tmp;
2161
2162         /* count num */
2163         p = cp;
2164         /* init */
2165         for (i = 0; i < MMS_OP_CUT_PARAM; i++)
2166                 set->mms_setting[setting]->op_cutoff[op_num][i] = 0; // init param
2167         /* regist */
2168         for (i = 0; i < MMS_OP_CUT_PARAM; i++, p++) {
2169                 if (*p == ':')
2170                         continue;
2171                 set->mms_setting[setting]->op_cutoff[op_num][i] = atoi(p);
2172                 if (! (p = strchr(p, ':')))
2173                         break;
2174         }
2175 }
2176
2177 static void conv_preset_envelope_param(int max, int32 *env, int16 *velf, int16 *keyf)
2178 {
2179         int i;
2180
2181         for(i = 6; i < max; i++)
2182                 if(env[i] != 0) return; // use env_ext param
2183         // env1 to env2
2184         env[13] = env[4]; // offdelay
2185         env[12] = env[4]; // delay
2186         env[11] = 0; // release3 level
2187         env[10] = 0; // release3 time
2188         env[9] = 0; // release2 level
2189         env[8] = 0; // release2 time
2190         env[7] = 0; // release1 level
2191         env[6] = env[3]; // release1 time
2192         env[5] = env[2]; // decay level
2193         env[4] = env[1]; // decay time
2194         env[3] = 100; // offset hold level
2195         env[2] = 0; // hold time
2196         env[1] = 100; // atk level
2197         env[0] = env[0]; // atk time
2198         // velf1 to velf2
2199         if(!velf) return; // scc not define velf/keyf
2200         velf[13] = 0;
2201         velf[12] = 0;
2202         velf[11] = 0; // release3 level
2203         velf[10] = 0; // release3 time
2204         velf[9] = 0; // release2 level
2205         velf[8] = 0; // release2 time
2206         velf[7] = 0; // release1 level
2207         velf[6] = velf[3]; // release1 time
2208         velf[5] = velf[2]; // decay level (sustain level
2209         velf[4] = velf[1]; // decay time
2210         velf[3] = 0; // hold level
2211         velf[2] = 0; // hold time
2212         velf[1] = 0; // atk level
2213         velf[0] = velf[0]; // atk time
2214         // keyf1 to keyf2
2215         if(!keyf) return; // scc not define velf/keyf
2216         keyf[13] = 0;
2217         keyf[12] = 0;
2218         keyf[11] = 0; // release3 level
2219         keyf[10] = 0; // release2 time
2220         keyf[9] = 0; // release2 level
2221         keyf[8] = 0; // release2 time
2222         keyf[7] = 0; // release1 level
2223         keyf[6] = keyf[3]; // release1 time
2224         keyf[5] = keyf[2]; // decay level (sustain level
2225         keyf[4] = keyf[1];
2226         keyf[3] = 0; // hold level
2227         keyf[2] = 0; // hold time
2228         keyf[1] = 0; // atk level
2229         keyf[0] = keyf[0]; // atk time
2230 }
2231
2232 static void load_is_scc_data(INIDATA *ini, Preset_IS *set)
2233 {
2234         LPINISEC sec = NULL;
2235         TCHAR tbf[258] = "";
2236         char *p = NULL;
2237         char name[30] = "";
2238         char name2[30] = "";
2239         int i;
2240
2241         sec = MyIni_GetSection(ini, "SCC_DATA", 0);
2242         for(i = 0; i < SCC_DATA_MAX; i++){
2243                 snprintf(name, sizeof(name), "data_%03d", i); // \8c\85\90\94\8ew\92è
2244                 snprintf(name2, sizeof(name2), "name_%03d", i); // \8c\85\90\94\8ew\92è
2245                 p = MyIni_GetString(sec, name, tbf, 256, "0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0");
2246                 config_parse_scc_data(p, set, i);
2247                 p = MyIni_GetString(sec, name2, tbf, 256, "none");
2248                 if(set->scc_data_name[i] != NULL)
2249                         safe_free(set->scc_data_name[i]);
2250                 set->scc_data_name[i] = safe_strdup(p);
2251         }
2252 }
2253
2254 static void load_is_scc_preset(INIDATA *ini, Preset_IS *set, int preset, int init)
2255 {
2256         LPINISEC sec = NULL;
2257         TCHAR tbf[258] = "";
2258         char *p = NULL;
2259         char name[30] = "";
2260         char name2[30] = "";
2261         void *mem = NULL;
2262         int i = preset;
2263         Preset_SCC *set2 = NULL;
2264
2265         snprintf(name, sizeof(name), "SCC_%03d", i); // \8c\85\90\94\8ew\92è
2266         sec = MyIni_GetSection(ini, name, 0);
2267         if(sec == NULL && !init)
2268                 return;
2269         mem = safe_malloc(sizeof(Preset_SCC));
2270         if(!mem)
2271                 return;
2272         memset(mem, 0, sizeof(Preset_SCC));
2273         set->scc_setting[i] = (Preset_SCC *)mem;
2274         set2 = set->scc_setting[i];
2275         p = MyIni_GetString(sec, "name", tbf, 256, "SCC none");
2276 //      snprintf(name, sizeof(name), "[SCC] %s", p);
2277         if(set->scc_setting[i]->inst_name != NULL)
2278                 safe_free(set->scc_setting[i]->inst_name);
2279 //      scc_setting[i].inst_name = safe_strdup(name);
2280         set->scc_setting[i]->inst_name = safe_strdup(p);
2281         p = MyIni_GetString(sec, "param", tbf, 256, "100:0");
2282         config_parse_scc_param(p, set, i);
2283         p = MyIni_GetString(sec, "osc", tbf, 256, "0:100:0:0");
2284         config_parse_scc_osc(p, set, i);
2285         p = MyIni_GetString(sec, "amp", tbf, 256, "0:0:0");
2286         config_parse_scc_amp(p, set, i);
2287         p = MyIni_GetString(sec, "pitch", tbf, 256, "0:0:0");
2288         config_parse_scc_pitch(p, set, i);
2289 #define IS_SCC_ENV_DEFAULT "0:0:100:0:0:0:0:0:0:0:0:0:0:0"
2290         p = MyIni_GetString(sec, "ampenv", tbf, 256, IS_SCC_ENV_DEFAULT);
2291         config_parse_scc_ampenv(p, set, i);
2292         p = MyIni_GetString(sec, "pitenv", tbf, 256, IS_SCC_ENV_DEFAULT);
2293         config_parse_scc_pitenv(p, set, i);
2294 #define IS_SCC_LFO_DEFAULT "0:0:0:200"
2295         p = MyIni_GetString(sec, "lfo1", tbf, 256, IS_SCC_LFO_DEFAULT);
2296         config_parse_scc_lfo1(p, set, i);
2297         p = MyIni_GetString(sec, "lfo2", tbf, 256, IS_SCC_LFO_DEFAULT);
2298         config_parse_scc_lfo2(p, set, i);
2299         // conv_preset_envelope
2300         conv_preset_envelope_param(SCC_ENV_PARAM, set2->ampenv, NULL, NULL);
2301         conv_preset_envelope_param(SCC_ENV_PARAM, set2->pitenv, NULL, NULL);
2302 }
2303
2304 static void load_is_mms_preset(INIDATA *ini, Preset_IS *set, int preset, int init)
2305 {
2306         LPINISEC sec = NULL;
2307         TCHAR tbf[258] = "";
2308         char *p = NULL;
2309         char name[30] = "";
2310         char name2[30] = "";
2311         void *mem = NULL;
2312         int i = preset, j, k, param;
2313         Preset_MMS *set2 = NULL;
2314
2315         snprintf(name, sizeof(name), "MMS_%03d", i); // \8c\85\90\94\8ew\92è
2316         sec = MyIni_GetSection(ini, name, 0);
2317         if(sec == NULL && !init)
2318                 return;
2319         mem = safe_malloc(sizeof(Preset_MMS));
2320         if(!mem)
2321                 return;
2322         memset(mem, 0, sizeof(Preset_MMS));
2323         set->mms_setting[i] = (Preset_MMS *)mem;
2324         set2 = set->mms_setting[i];
2325         p = MyIni_GetString(sec, "name", tbf, 256, "MMS none");
2326 //      snprintf(name, sizeof(name), "[MMS] %s", p);
2327         if(set->mms_setting[i]->inst_name != NULL)
2328                 safe_free(set->mms_setting[i]->inst_name);
2329 //      set->mms_setting[i].inst_name = safe_strdup(name);
2330         set->mms_setting[i]->inst_name = safe_strdup(p);
2331         set->mms_setting[i]->op_max = MyIni_GetInt32(sec, "op_max", 1);
2332         for(j = 0; j < MMS_OP_MAX; j++){
2333                 snprintf(name, sizeof(name), "op_%d_param", j);
2334                 p = MyIni_GetString(sec, name, tbf, 256, "0");
2335                 config_parse_mms_op_param(p, set, i, j);
2336                 snprintf(name, sizeof(name), "op_%d_range", j);
2337                 p = MyIni_GetString(sec, name, tbf, 256, "0:127:0:127");
2338                 config_parse_mms_op_range(p, set, i, j);
2339                 snprintf(name, sizeof(name), "op_%d_connect", j);
2340                 p = MyIni_GetString(sec, name, tbf, 256, "-1");
2341                 config_parse_mms_op_connect(p, set, i, j);
2342                 snprintf(name, sizeof(name), "op_%d_osc", j);
2343                 p = MyIni_GetString(sec, name, tbf, 256, "0:100:0:0");
2344                 config_parse_mms_op_osc(p, set, i, j);
2345                 snprintf(name, sizeof(name), "op_%d_wave", j);
2346                 p = MyIni_GetString(sec, name, tbf, 256, "0:0:100:0:0:0");
2347                 config_parse_mms_op_wave(p, set, i, j);
2348                 snprintf(name, sizeof(name), "op_%d_sub", j);
2349                 p = MyIni_GetString(sec, name, tbf, 256, "0:0:0:0");
2350                 config_parse_mms_op_sub(p, set, i, j);
2351                 snprintf(name, sizeof(name), "op_%d_amp", j);
2352                 p = MyIni_GetString(sec, name, tbf, 256, "0:0:0:0");
2353                 config_parse_mms_op_amp(p, set, i, j);
2354                 snprintf(name, sizeof(name), "op_%d_pitch", j);
2355                 p = MyIni_GetString(sec, name, tbf, 256, "0:0:0:0");
2356                 config_parse_mms_op_pitch(p, set, i, j);
2357                 snprintf(name, sizeof(name), "op_%d_width", j);
2358                 p = MyIni_GetString(sec, name, tbf, 256, "0:0:0:0");
2359                 config_parse_mms_op_width(p, set, i, j);
2360                 snprintf(name, sizeof(name), "op_%d_filter", j);
2361                 p = MyIni_GetString(sec, name, tbf, 256, "0:0:0:0");
2362                 config_parse_mms_op_filter(p, set, i, j);
2363                 snprintf(name, sizeof(name), "op_%d_cutoff", j);
2364                 p = MyIni_GetString(sec, name, tbf, 256, "0:0:0:0");
2365                 config_parse_mms_op_cutoff(p, set, i, j);
2366 #define IS_MMS_ENV_DEFAULT "0:0:100:0:0:0:0:0:0:0:0:0:0:0"
2367                 snprintf(name, sizeof(name), "op_%d_ampenv", j);
2368                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_ENV_DEFAULT);
2369                 config_parse_mms_op_ampenv(p, set, i, j);
2370                 snprintf(name, sizeof(name), "op_%d_modenv", j);
2371                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_ENV_DEFAULT);
2372                 config_parse_mms_op_modenv(p, set, i, j);
2373                 snprintf(name, sizeof(name), "op_%d_widenv", j);
2374                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_ENV_DEFAULT);
2375                 config_parse_mms_op_widenv(p, set, i, j);
2376                 snprintf(name, sizeof(name), "op_%d_pitenv", j);
2377                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_ENV_DEFAULT);
2378                 config_parse_mms_op_pitenv(p, set, i, j);
2379 #define IS_MMS_ENVF_DEFAULT "0:0:0:0:0:0:0:0:0:0:0:0:0:0"
2380                 snprintf(name, sizeof(name), "op_%d_ampenv_keyf", j);
2381                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_ENVF_DEFAULT);
2382                 config_parse_mms_op_ampenv_keyf(p, set, i, j);
2383                 snprintf(name, sizeof(name), "op_%d_modenv_keyf", j);
2384                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_ENVF_DEFAULT);
2385                 config_parse_mms_op_modenv_keyf(p, set, i, j);
2386                 snprintf(name, sizeof(name), "op_%d_widenv_keyf", j);
2387                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_ENVF_DEFAULT);
2388                 config_parse_mms_op_widenv_keyf(p, set, i, j);
2389                 snprintf(name, sizeof(name), "op_%d_pitenv_keyf", j);
2390                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_ENVF_DEFAULT);
2391                 config_parse_mms_op_pitenv_keyf(p, set, i, j);
2392                 snprintf(name, sizeof(name), "op_%d_ampenv_velf", j);
2393                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_ENVF_DEFAULT);
2394                 config_parse_mms_op_ampenv_velf(p, set, i, j);
2395                 snprintf(name, sizeof(name), "op_%d_modenv_velf", j);
2396                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_ENVF_DEFAULT);
2397                 config_parse_mms_op_modenv_velf(p, set, i, j);
2398                 snprintf(name, sizeof(name), "op_%d_widenv_velf", j);
2399                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_ENVF_DEFAULT);
2400                 config_parse_mms_op_widenv_velf(p, set, i, j);
2401                 snprintf(name, sizeof(name), "op_%d_pitenv_velf", j);
2402                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_ENVF_DEFAULT);
2403                 config_parse_mms_op_pitenv_velf(p, set, i, j);
2404 #define IS_MMS_LFO_DEFAULT "0:0:0:200"
2405                 snprintf(name, sizeof(name), "op_%d_lfo1", j);
2406                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_LFO_DEFAULT);
2407                 config_parse_mms_op_lfo1(p, set, i, j);
2408                 snprintf(name, sizeof(name), "op_%d_lfo2", j);
2409                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_LFO_DEFAULT);
2410                 config_parse_mms_op_lfo2(p, set, i, j);
2411                 snprintf(name, sizeof(name), "op_%d_lfo3", j);
2412                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_LFO_DEFAULT);
2413                 config_parse_mms_op_lfo3(p, set, i, j);
2414                 snprintf(name, sizeof(name), "op_%d_lfo4", j);
2415                 p = MyIni_GetString(sec, name, tbf, 256, IS_MMS_LFO_DEFAULT);
2416                 config_parse_mms_op_lfo4(p, set, i, j);
2417                 // conv_preset_envelop
2418                 conv_preset_envelope_param(MMS_OP_ENV_PARAM, set2->op_ampenv[j], set2->op_ampenv_velf[j], set2->op_ampenv_keyf[j]);
2419                 conv_preset_envelope_param(MMS_OP_ENV_PARAM, set2->op_modenv[j], set2->op_modenv_velf[j], set2->op_modenv_keyf[j]);
2420                 conv_preset_envelope_param(MMS_OP_ENV_PARAM, set2->op_widenv[j], set2->op_widenv_velf[j], set2->op_widenv_keyf[j]);
2421                 conv_preset_envelope_param(MMS_OP_ENV_PARAM, set2->op_pitenv[j], set2->op_pitenv_velf[j], set2->op_pitenv_keyf[j]);
2422         }
2423 }
2424
2425 // type -1:scc/mms 0:scc 1:mms , preset -1:all 0~:num
2426 static void load_int_synth_preset(const char *inifile, Preset_IS *set, int type, int32 preset, int init)
2427 {
2428         INIDATA ini={0};
2429         int i;
2430
2431         MyIni_Load_timidity(&ini, inifile, 1, OF_VERBOSE);
2432         if(!set->scc_data_load){
2433                 set->scc_data_load = 1;
2434                 load_is_scc_data(&ini, set);
2435         }
2436         if(type == IS_INI_TYPE_ALL || type == IS_INI_TYPE_SCC){
2437                 if(preset == IS_INI_PRESET_ALL){
2438                         for(i = 0; i < SCC_SETTING_MAX; i++){
2439                                 if(set->scc_setting[i])
2440                                         continue;
2441                                 load_is_scc_preset(&ini, set, i, init);
2442                         }
2443                 }else if(preset < SCC_SETTING_MAX){
2444                         if(!set->scc_setting[preset])
2445                                 load_is_scc_preset(&ini, set, preset, init);
2446                 }
2447 #ifdef IS_INI_LOAD_BLOCK
2448                 else if(preset > 0){
2449                         int32 block = (preset >> 10) - 1; // 10bit>SETTING_MAX
2450                         int32 min = block * IS_INI_LOAD_BLOCK; // 1block=64or128preset
2451                         int32 max = min + IS_INI_LOAD_BLOCK; // 1block=64or128preset
2452                         if(max > SCC_SETTING_MAX)
2453                                 max = SCC_SETTING_MAX;
2454                         for(i = min; i < max; i++){
2455                                 if(set->scc_setting[i])
2456                                         continue;
2457                                 load_is_scc_preset(&ini, set, i, init);
2458                         }
2459                 }
2460 #endif
2461         }
2462         if(type == IS_INI_TYPE_ALL || type == IS_INI_TYPE_MMS){
2463                 if(preset == IS_INI_PRESET_ALL){
2464                         for(i = 0; i < MMS_SETTING_MAX; i++){
2465                                 if(set->mms_setting[i])
2466                                         continue;
2467                                 load_is_mms_preset(&ini, set, i, init);
2468                         }
2469                 }else if(preset < MMS_SETTING_MAX){
2470                         if(!set->mms_setting[preset])
2471                                 load_is_mms_preset(&ini, set, preset, init);
2472                 }
2473 #ifdef IS_INI_LOAD_BLOCK
2474                 else if(preset > 0){
2475                         int32 block = (preset >> 10) - 1; // 10bit>SETTING_MAX
2476                         int32 min = block * IS_INI_LOAD_BLOCK; // 1block=64or128preset
2477                         int32 max = min + IS_INI_LOAD_BLOCK; // 1block=64or128preset
2478                         if(max > MMS_SETTING_MAX)
2479                                 max = MMS_SETTING_MAX;
2480                         for(i = min; i < max; i++){
2481                                 if(set->mms_setting[i])
2482                                         continue;
2483                                 load_is_mms_preset(&ini, set, i, init);
2484                         }
2485                 }
2486 #endif
2487         }
2488         MyIni_SectionAllClear(&ini);
2489 }
2490
2491
2492
2493
2494 //////// IS_EDITOR
2495 Preset_IS is_editor_preset;
2496 int scc_data_editor_override = 0;
2497 static int16 scc_data_int_edit[2][SCC_DATA_LENGTH]; // 0:working 1:temp
2498 static FLOAT_T scc_data_edit[2][SCC_DATA_LENGTH + 1]; // 0:working 1:temp
2499 int scc_editor_override = 0;
2500 static Preset_SCC scc_setting_edit[2]; // 0:working 1:temp
2501 int mms_editor_override = 0;
2502 static Preset_MMS mms_setting_edit[2]; // 0:working 1:temp
2503
2504 char is_editor_inifile[FILEPATH_MAX] = "";
2505 static char data_name_empty[] = "error\0";
2506
2507
2508 const char *scc_data_editor_load_name(int num)
2509 {
2510         if(num < 0 || num >= SCC_DATA_MAX)
2511                 return data_name_empty;
2512         else
2513                 return is_editor_preset.scc_data_name[num];
2514 }
2515
2516 void scc_data_editor_store_name(int num, const char *name)
2517 {
2518         if(num < 0 || num >= SCC_DATA_MAX)
2519                 return;
2520         if(is_editor_preset.scc_data_name[num] != NULL)
2521                 safe_free(is_editor_preset.scc_data_name[num]);
2522         is_editor_preset.scc_data_name[num] = safe_strdup(name);
2523 }
2524
2525 void scc_data_editor_clear_param(void)
2526 {
2527         memset(scc_data_int_edit[0], 0, sizeof(scc_data_int_edit[0]));
2528         memset(scc_data_edit[0], 0, sizeof(scc_data_edit[0]));
2529 }
2530
2531 int scc_data_editor_get_param(int num)
2532 {
2533         if(num < 0 || num >= SCC_DATA_LENGTH)
2534                 return 0; // error
2535         return scc_data_int_edit[0][num];
2536 }
2537
2538 void scc_data_editor_set_param(int num, int val)
2539 {
2540         if(num < 0 || num >= SCC_DATA_LENGTH)
2541                 return; // error
2542         if(val >= 128)
2543                 val = 128;
2544         else if(val < -128)
2545                 val = -128;
2546         scc_data_int_edit[0][num] = val;
2547         scc_data_edit[0][num] = (double)val * DIV_128;
2548         if(num == 0)
2549                 scc_data_edit[0][SCC_DATA_LENGTH] = scc_data_edit[0][0]; // for interpolation
2550 }
2551
2552 static void scc_data_editor_save_ini(int num)
2553 {
2554         INIDATA ini={0};
2555         TCHAR data[258] = "";
2556         char key1[30] = "";
2557         char key2[30] = "";
2558         int i;
2559
2560         MyIni_Load(&ini, is_editor_inifile);
2561         snprintf(key1, sizeof(key1), "data_%03d", num); // \8c\85\90\94\8ew\92è
2562         snprintf(key2, sizeof(key2), "name_%03d", num); // \8c\85\90\94\8ew\92è
2563         for(i = 0; i < SCC_DATA_LENGTH; i++){
2564                 snprintf(data, sizeof(data), "%s%d:", data, is_editor_preset.scc_data_int[num][i]);
2565         }
2566         MyIni_SetString2(&ini, "SCC_DATA", key2, is_editor_preset.scc_data_name[num]);
2567         MyIni_SetString2(&ini, "SCC_DATA", key1, data);
2568         MyIni_Save(&ini, is_editor_inifile);
2569         MyIni_SectionAllClear(&ini);
2570 }
2571
2572 void scc_data_editor_load_preset(int num)
2573 {
2574         int i;
2575
2576         if(num < 0){
2577                 memcpy(&scc_data_int_edit[0], &scc_data_int_edit[1], sizeof(int16) * (SCC_DATA_LENGTH));
2578                 memcpy(&scc_data_edit[0], &scc_data_edit[1], sizeof(FLOAT_T) * (SCC_DATA_LENGTH + 1));
2579         }else{
2580                 if(num > (SCC_DATA_MAX - 1))
2581                         return; // error
2582                 memcpy(&scc_data_int_edit[0], &is_editor_preset.scc_data_int[num], sizeof(int16) * (SCC_DATA_LENGTH));
2583                 memcpy(&scc_data_edit[0], &is_editor_preset.scc_data[num], sizeof(FLOAT_T) * (SCC_DATA_LENGTH + 1));
2584         }
2585 }
2586
2587 void scc_data_editor_store_preset(int num)
2588 {
2589         int i;
2590
2591         if(num < 0){
2592                 memcpy(&scc_data_int_edit[1], &scc_data_int_edit[0], sizeof(int16) * (SCC_DATA_LENGTH));
2593                 memcpy(&scc_data_edit[1], &scc_data_edit[0], sizeof(FLOAT_T) * (SCC_DATA_LENGTH + 1));
2594                 return;
2595         }else{
2596                 if(num > (SCC_DATA_MAX - 1))
2597                         return; // error
2598                 memcpy(&is_editor_preset.scc_data_int[num], &scc_data_int_edit[0], sizeof(int16) * (SCC_DATA_LENGTH));
2599                 memcpy(&is_editor_preset.scc_data[num], &scc_data_edit[0], sizeof(FLOAT_T) * (SCC_DATA_LENGTH + 1));
2600                 scc_data_editor_save_ini(num);
2601         }
2602 }
2603
2604 const char *scc_editor_load_name(int num)
2605 {
2606         if(num < 0 || num >= SCC_SETTING_MAX)
2607                 return data_name_empty;
2608         else if(!is_editor_preset.scc_setting[num])
2609                 return data_name_empty;
2610         else
2611                 return is_editor_preset.scc_setting[num]->inst_name;
2612 }
2613
2614 void scc_editor_store_name(int num, const char *name)
2615 {
2616         if(num < 0 || num >= SCC_SETTING_MAX)
2617                 return;
2618         else if(!is_editor_preset.scc_setting[num])
2619                 return;
2620         if(is_editor_preset.scc_setting[num]->inst_name != NULL)
2621                 safe_free(is_editor_preset.scc_setting[num]->inst_name);
2622         is_editor_preset.scc_setting[num]->inst_name = safe_strdup(name);
2623 }
2624
2625 const char *scc_editor_load_wave_name(int fnc)
2626 {
2627         int type; // osc_type
2628         int num; // wave_type
2629
2630         if(fnc < 0){ // osc
2631                 num = scc_setting_edit[0].osc[3]; // scc data
2632                 if(num < 0){
2633                         type = 0; // osc_type
2634                         num = OSC_NOISE_LOWBIT;
2635                 }else{
2636                         type = 1; // osc_type
2637                 }
2638         }else switch(fnc){ // lfo1/lfo2
2639                 default:
2640                 case 0:
2641                         type = 0; // osc_type
2642                         num = scc_setting_edit[0].lfo1[2]; // wave_type
2643                         break;
2644                 case 1:
2645                         type = 0; // osc_type
2646                         num = scc_setting_edit[0].lfo2[2]; // wave_type
2647                         break;
2648         }
2649         switch(type){
2650         case 0: // wave
2651                 if(num < 0 || num > OSC_NOISE_LOWBIT)
2652                         return data_name_empty;
2653                 else
2654                         return osc_wave_name[num];
2655         case 1: // scc
2656                 if(num < 0 || num >= SCC_DATA_MAX)
2657                         return data_name_empty;
2658                 else
2659                         return is_editor_preset.scc_data_name[num];
2660         default:
2661                 return data_name_empty;
2662         }
2663 }
2664
2665 void scc_editor_set_default_param(int set_num)
2666 {
2667         int i, num;
2668         Preset_SCC *set = NULL;
2669
2670         if(set_num < 0)
2671                 set = &scc_setting_edit[0];
2672         else if(set_num >= SCC_SETTING_MAX)
2673                 return;
2674         else if(!is_editor_preset.scc_setting[set_num])
2675                 return ;
2676         else
2677                 set = is_editor_preset.scc_setting[set_num];
2678
2679         for(i = 0; i < SCC_PARAM_MAX; i++){
2680                 switch(i){
2681                 case 0:
2682                         num = 100;
2683                         break;
2684                 default:
2685                         num = 0;
2686                         break;
2687                 }
2688                 set->param[i] = num;
2689         }
2690         for(i = 0; i < SCC_OSC_MAX; i++){
2691                 switch(i){
2692                 case 1:
2693                         num = 100;
2694                         break;
2695                 default:
2696                         num = 0;
2697                         break;
2698                 }
2699                 set->osc[i] = num;
2700         }
2701         for(i = 0; i < SCC_AMP_MAX; i++)
2702                 set->amp[i] = 0;
2703         for(i = 0; i < SCC_PITCH_MAX; i++)
2704                 set->pitch[i] = 0;
2705         for(i = 0; i < SCC_ENV_PARAM; i++){
2706                 switch(i){
2707                 case 1:
2708                 case 3:
2709                 case 5:
2710                         num = 100;
2711                         break;
2712                 case 6:
2713                         num = 1;
2714                         break;
2715                 default:
2716                         num = 0;
2717                         break;
2718                 }
2719                 set->ampenv[i] = num;
2720                 set->pitenv[i] = num;
2721         }
2722         for(i = 0; i < SCC_LFO_PARAM; i++){
2723                 set->lfo1[i] = 0;
2724                 set->lfo2[i] = 0;
2725         }
2726 }
2727
2728 int scc_editor_get_param(int type, int num)
2729 {
2730         switch(type){
2731         case 0: return scc_setting_edit[0].param[num];
2732         case 1: return scc_setting_edit[0].osc[num];
2733         case 2: return scc_setting_edit[0].amp[num];
2734         case 3: return scc_setting_edit[0].pitch[num];
2735         case 4: return scc_setting_edit[0].ampenv[num];
2736         case 5: return scc_setting_edit[0].pitenv[num];
2737         case 6: return scc_setting_edit[0].lfo1[num];
2738         case 7: return scc_setting_edit[0].lfo2[num];
2739         default: return 0;
2740         }
2741 }
2742
2743 void scc_editor_set_param(int type, int num, int val)
2744 {
2745         switch(type){
2746         case 0:
2747                 scc_setting_edit[0].param[num] = val;
2748                 return;
2749         case 1:
2750                 scc_setting_edit[0].osc[num] = val;
2751                 return;
2752         case 2:
2753                 scc_setting_edit[0].amp[num] = val;
2754                 return;
2755         case 3:
2756                 scc_setting_edit[0].pitch[num] = val;
2757                 return;
2758         case 4:
2759                 scc_setting_edit[0].ampenv[num] = val;
2760                 return;
2761         case 5:
2762                 scc_setting_edit[0].pitenv[num] = val;
2763                 return;
2764         case 6:
2765                 scc_setting_edit[0].lfo1[num] = val;
2766                 return;
2767         case 7:
2768                 scc_setting_edit[0].lfo2[num] = val;
2769                 return;
2770         }
2771 }
2772
2773 static void scc_editor_delete_ini(int num)
2774 {
2775         INIDATA ini={0};
2776         char sec[30] = "";
2777
2778         MyIni_Load(&ini, is_editor_inifile);
2779         snprintf(sec, sizeof(sec), "SCC_%03d", num); // \8c\85\90\94\8ew\92è
2780         MyIni_DeleteSection(&ini, sec);
2781         MyIni_Save(&ini, is_editor_inifile);
2782         MyIni_SectionAllClear(&ini);
2783 }
2784
2785 static void scc_editor_save_ini(int num)
2786 {
2787         Preset_SCC *setting = NULL;
2788         INIDATA ini={0};
2789         LPINISEC inisec = NULL;
2790         TCHAR data[258] = "";
2791         char sec[30] = "";
2792         int i, flg;
2793
2794         if(!is_editor_preset.scc_setting[num])
2795                 return;
2796         setting = is_editor_preset.scc_setting[num];
2797         MyIni_Load(&ini, is_editor_inifile);
2798         snprintf(sec, sizeof(sec), "SCC_%03d", num); // \8c\85\90\94\8ew\92è
2799         inisec = MyIni_GetSection(&ini, sec, 1);
2800         MyIni_SetString(inisec, "name", setting->inst_name);
2801         // param
2802         for(i = 0; i < SCC_PARAM_MAX; i++){
2803                 snprintf(data, sizeof(data), "%s%d:", data, setting->param[i]);
2804         }
2805         MyIni_SetString(inisec, "param", data);
2806         // osc
2807         memset(data, 0, sizeof(data));
2808         for(i = 0; i < SCC_OSC_MAX; i++){
2809                 snprintf(data, sizeof(data), "%s%d:", data, setting->osc[i]);
2810         }
2811         MyIni_SetString(inisec, "osc", data);
2812         // amp
2813         memset(data, 0, sizeof(data));
2814         flg = 0;
2815         for(i = 0; i < SCC_AMP_MAX; i++){
2816                 if(setting->amp[i]) flg++;
2817                 snprintf(data, sizeof(data), "%s%d:", data, setting->amp[i]);
2818         }
2819         if(flg)
2820                 MyIni_SetString(inisec, "amp", data);
2821         else
2822                 MyIni_DeleteKey(&ini, sec, "amp");
2823         // pitch
2824         memset(data, 0, sizeof(data));
2825         flg = 0;
2826         for(i = 0; i < SCC_PITCH_MAX; i++){
2827                 if(setting->pitch[i]) flg++;
2828                 snprintf(data, sizeof(data), "%s%d:", data, setting->pitch[i]);
2829         }
2830         if(flg)
2831                 MyIni_SetString(inisec, "pitch", data);
2832         else
2833                 MyIni_DeleteKey(&ini, sec, "pitch");
2834         // ampenv
2835         if(setting->ampenv[6] < 1) setting->ampenv[6] = 1;
2836         if(setting->ampenv[0] != 0
2837                 || setting->ampenv[1] != 100
2838                 || setting->ampenv[2] != 0
2839                 || setting->ampenv[3] != 100
2840                 || setting->ampenv[4] != 0
2841                 || setting->ampenv[5] != 100
2842                 || setting->ampenv[6] != 1
2843                 || setting->ampenv[7] != 0
2844                 || setting->ampenv[8] != 0
2845                 || setting->ampenv[9] != 0
2846                 || setting->ampenv[10] != 0
2847                 || setting->ampenv[11] != 0
2848                 || setting->ampenv[12] != 0
2849                 || setting->ampenv[13] != 0
2850                 ){
2851                 memset(data, 0, sizeof(data));
2852                 for(i = 0; i < SCC_ENV_PARAM; i++){
2853                         snprintf(data, sizeof(data), "%s%d:", data, setting->ampenv[i]);
2854                 }
2855                 MyIni_SetString(inisec, "ampenv", data);
2856         }else
2857                 MyIni_DeleteKey(&ini, sec, "ampenv");
2858         // pitenv
2859         if(setting->pitenv[6] < 1) setting->pitenv[6] = 1;
2860         if(setting->pitenv[0] != 0
2861                 || setting->pitenv[1] != 100
2862                 || setting->pitenv[2] != 0
2863                 || setting->pitenv[3] != 100
2864                 || setting->pitenv[4] != 0
2865                 || setting->pitenv[5] != 100
2866                 || setting->pitenv[6] != 1
2867                 || setting->pitenv[7] != 0
2868                 || setting->pitenv[8] != 0
2869                 || setting->pitenv[9] != 0
2870                 || setting->pitenv[10] != 0
2871                 || setting->pitenv[11] != 0
2872                 || setting->pitenv[12] != 0
2873                 || setting->pitenv[13] != 0
2874                 ){
2875                 memset(data, 0, sizeof(data));
2876                 for(i = 0; i < SCC_ENV_PARAM; i++){
2877                         snprintf(data, sizeof(data), "%s%d:", data, setting->pitenv[i]);
2878                 }
2879                 MyIni_SetString(inisec, "pitenv", data);
2880         }else
2881                 MyIni_DeleteKey(&ini, sec, "pitenv");
2882         // lfo1
2883         if(setting->lfo1[0]){
2884                 memset(data, 0, sizeof(data));
2885                 for(i = 0; i < SCC_LFO_PARAM; i++){
2886                         snprintf(data, sizeof(data), "%s%d:", data, setting->lfo1[i]);
2887                 }
2888                 MyIni_SetString(inisec, "lfo1", data);
2889         }else
2890                 MyIni_DeleteKey(&ini, sec, "lfo1");
2891         // lfo2
2892         if(setting->lfo2[0]){
2893                 memset(data, 0, sizeof(data));
2894                 for(i = 0; i < SCC_LFO_PARAM; i++){
2895                         snprintf(data, sizeof(data), "%s%d:", data, setting->lfo2[i]);
2896                 }
2897                 MyIni_SetString(inisec, "lfo2", data);
2898         }else
2899                 MyIni_DeleteKey(&ini, sec, "lfo2");
2900         MyIni_Save(&ini, is_editor_inifile);
2901         MyIni_SectionAllClear(&ini);
2902 }
2903
2904 void scc_editor_delete_preset(int num)
2905 {
2906         if(num < 0 || num > (SCC_SETTING_MAX - 1))
2907                 return; // error
2908         if(!is_editor_preset.scc_setting[num])
2909                 return;
2910         safe_free(is_editor_preset.scc_setting[num]->inst_name);
2911         memset(&is_editor_preset.scc_setting[num], 0, sizeof(Preset_SCC));
2912         scc_editor_delete_ini(num);
2913 }
2914
2915 void scc_editor_load_preset(int num)
2916 {
2917         if(num < 0){
2918                 memcpy(&scc_setting_edit[0], &scc_setting_edit[1], sizeof(Preset_SCC));
2919         }else{
2920                 if(num > (SCC_SETTING_MAX - 1))
2921                         return; // error
2922                 if(!is_editor_preset.scc_setting[num])
2923                         return;
2924                 memcpy(&scc_setting_edit[0], is_editor_preset.scc_setting[num], sizeof(Preset_SCC));
2925         }
2926 }
2927
2928 void scc_editor_store_preset(int num)
2929 {
2930         char *tmp;
2931
2932         if(num < 0){
2933                 memcpy(&scc_setting_edit[1], &scc_setting_edit[0], sizeof(Preset_SCC));
2934         }else{
2935                 if(num > (SCC_SETTING_MAX - 1))
2936                         return; // error
2937                 if(!is_editor_preset.scc_setting[num])
2938                         return;
2939                 tmp = is_editor_preset.scc_setting[num]->inst_name;
2940                 memcpy(is_editor_preset.scc_setting[num], &scc_setting_edit[0], sizeof(Preset_SCC));
2941                 is_editor_preset.scc_setting[num]->inst_name = tmp;
2942                 scc_editor_save_ini(num);
2943         }
2944 }
2945
2946 int calc_random_param(int min, int max)
2947 {
2948         int i, var, mod, center;
2949
2950         if(min < 0){
2951                 center = mod = max > min ? max : min;
2952                 mod = center * 2 + 1;
2953                 for(i = 0; i < 10000; i++){
2954                         var = rand() % (mod) - center;
2955                         if(var >= min && var <= max)
2956                                 return var;
2957                 }
2958         }else{
2959                 mod = max + 1;
2960                 for(i = 0; i < 10000; i++){
2961                         var = rand() % (mod);
2962                         if(var >= min)
2963                                 return var;
2964                 }
2965         }
2966         return 0; // error
2967 }
2968
2969 const char *mms_editor_load_name(int num)
2970 {
2971         if(num < 0 || num >= MMS_SETTING_MAX)
2972                 return data_name_empty;
2973         else if(!is_editor_preset.mms_setting[num])
2974                 return data_name_empty;
2975         else
2976                 return is_editor_preset.mms_setting[num]->inst_name;
2977 }
2978
2979 void mms_editor_store_name(int num, const char *name)
2980 {
2981         if(num < 0 || num >= MMS_SETTING_MAX)
2982                 return;
2983         if(!is_editor_preset.mms_setting[num])
2984                 return;
2985         if(is_editor_preset.mms_setting[num]->inst_name != NULL)
2986                 safe_free(is_editor_preset.mms_setting[num]->inst_name);
2987         is_editor_preset.mms_setting[num]->inst_name = safe_strdup(name);
2988 }
2989
2990 const char *mms_editor_load_wave_name(int op, int fnc)
2991 {
2992         int type; // osc_type
2993         int num; // wave_type
2994
2995         if(fnc < 0){ // osc
2996                 type = mms_setting_edit[0].op_wave[op][0]; // osc_type
2997                 num = mms_setting_edit[0].op_wave[op][1]; // wave_type
2998         }else switch(fnc){ // lfo1~lfo4
2999         default:
3000         case 0:
3001                 type = 0; // osc_type
3002                 num = mms_setting_edit[0].op_lfo1[op][2]; // wave_type
3003                 break;
3004         case 1:
3005                 type = 0; // osc_type
3006                 num = mms_setting_edit[0].op_lfo2[op][2]; // wave_type
3007                 break;
3008         case 2:
3009                 type = 0; // osc_type
3010                 num = mms_setting_edit[0].op_lfo3[op][2]; // wave_type
3011                 break;
3012         case 3:
3013                 type = 0; // osc_type
3014                 num = mms_setting_edit[0].op_lfo4[op][2]; // wave_type
3015                 break;
3016         }
3017         switch(type){
3018         case 0: // wave
3019                 if(num < 0 || num > OSC_NOISE_LOWBIT)
3020                         return data_name_empty;
3021                 else
3022                         return osc_wave_name[num];
3023         case 1: // scc
3024                 if(num < 0 || num >= SCC_DATA_MAX)
3025                         return data_name_empty;
3026                 else
3027                         return is_editor_preset.scc_data_name[num];
3028         case 2: // mt32
3029                 if(num < 0 || num >= MT32_DATA_MAX)
3030                         return data_name_empty;
3031                 else
3032                         return la_pcm_data_name[num];
3033         case 3: // cm32l
3034                 if(num < 0 || num >= CM32L_DATA_MAX)
3035                         return data_name_empty;
3036                 else
3037                         return la_pcm_data_name[num];
3038         default:
3039                 return data_name_empty;
3040         }
3041 }
3042
3043 const char *mms_editor_load_filter_name(int op)
3044 {
3045         int num;
3046
3047         num = mms_setting_edit[0].op_filter[op][0]; // filter_type
3048         if(num < 0 || num > FILTER_HBF_L12L6)
3049                 return data_name_empty;
3050         else
3051                 return filter_name[num];
3052 }
3053
3054 static void mms_editor_set_default_param_op(Preset_MMS *set, int op_num)
3055 {
3056         int i, num;;
3057
3058         for(i = 0; i < MMS_OP_PARAM_MAX; i++){
3059                 switch(i){
3060                 case 1:
3061                 case 2:
3062                         num = 100;
3063                         break;
3064                 default:
3065                         num = 0;
3066                         break;
3067                 }
3068                 set->op_param[op_num][i] = num;
3069         }
3070         for(i = 0; i < MMS_OP_CON_MAX; i++)
3071            set->op_connect[op_num][i] = -1;
3072         for(i = 0; i < MMS_OP_RANGE_MAX; i++){
3073                 switch(i){
3074                 case 1:
3075                 case 3:
3076                         num = 127;
3077                         break;
3078                 default:
3079                         num = 0;
3080                         break;
3081                 }
3082                 set->op_range[op_num][i] = num;
3083         }
3084         for(i = 0; i < MMS_OP_OSC_MAX; i++){
3085                 switch(i){
3086                 case 1:
3087                         num = 100;
3088                         break;
3089                 default:
3090                         num = 0;
3091                         break;
3092                 }
3093                 set->op_osc[op_num][i] = num;
3094         }
3095         for(i = 0; i < MMS_OP_WAVE_MAX; i++){
3096                 switch(i){
3097                 case 2:
3098                         num = 100;
3099                         break;
3100                 default:
3101                         num = 0;
3102                         break;
3103                 }
3104                 set->op_wave[op_num][i] = 0;
3105         }
3106         for(i = 0; i < MMS_OP_SUB_MAX; i++)
3107                 set->op_sub[op_num][i] = 0;
3108         for(i = 0; i < MMS_OP_AMP_MAX; i++)
3109                 set->op_amp[op_num][i] = 0;
3110         for(i = 0; i < MMS_OP_PITCH_MAX; i++)
3111                 set->op_pitch[op_num][i] = 0;
3112         for(i = 0; i < MMS_OP_WIDTH_MAX; i++)
3113                 set->op_width[op_num][i] = 0;
3114         for(i = 0; i < MMS_OP_FLT_PARAM; i++)
3115                 set->op_filter[op_num][i] = 0;
3116         for(i = 0; i < MMS_OP_CUT_PARAM; i++)
3117                 set->op_cutoff[op_num][i] = 0;
3118         for(i = 0; i < MMS_OP_ENV_PARAM; i++){
3119                 switch(i){
3120                 case 1:
3121                 case 3:
3122                 case 5:
3123                         num = 100;
3124                         break;
3125                 case 6:
3126                         num = 1;
3127                         break;
3128                 default:
3129                         num = 0;
3130                         break;
3131                 }
3132                 set->op_ampenv[op_num][i] = num;
3133                 set->op_modenv[op_num][i] = num;
3134                 set->op_widenv[op_num][i] = num;
3135                 set->op_pitenv[op_num][i] = num;
3136                 set->op_ampenv_keyf[op_num][i] = 0;
3137                 set->op_modenv_keyf[op_num][i] = 0;
3138                 set->op_widenv_keyf[op_num][i] = 0;
3139                 set->op_pitenv_keyf[op_num][i] = 0;
3140                 set->op_ampenv_velf[op_num][i] = 0;
3141                 set->op_modenv_velf[op_num][i] = 0;
3142                 set->op_widenv_velf[op_num][i] = 0;
3143                 set->op_pitenv_velf[op_num][i] = 0;
3144         }
3145         for(i = 0; i < MMS_OP_LFO_PARAM; i++){
3146                 set->op_lfo1[op_num][i] = 0;
3147                 set->op_lfo2[op_num][i] = 0;
3148                 set->op_lfo3[op_num][i] = 0;
3149                 set->op_lfo4[op_num][i] = 0;
3150         }
3151 }
3152
3153 void mms_editor_set_default_param(int set_num, int op_num)
3154 {
3155         int i;
3156         Preset_MMS *set = NULL;
3157
3158         if(set_num < 0)
3159                 set = &mms_setting_edit[0];
3160         else if(set_num >= MMS_SETTING_MAX)
3161                 return;
3162         else if(!is_editor_preset.mms_setting[set_num])
3163                 return;
3164         else
3165                 set = is_editor_preset.mms_setting[set_num];
3166         if(op_num < 0){
3167                 set->op_max = 0;
3168                 for(i = 0; i < MMS_OP_MAX; i++)
3169                         mms_editor_set_default_param_op(set, i);
3170         }else if(op_num >= MMS_OP_MAX)
3171                 return;
3172         else
3173                 mms_editor_set_default_param_op(set, op_num);
3174 }
3175
3176 void mms_editor_set_magic_param(void)
3177 {
3178         Preset_MMS *set = &mms_setting_edit[0];
3179         int i, val = 0, tmp, op_max, osc_mode;
3180
3181         mms_editor_set_default_param(-1, -1);
3182         mms_setting_edit[0].op_max = op_max = calc_random_param(2, 6); // for 2~4op
3183         switch(op_max){
3184         case 1:
3185         case 2:
3186                 tmp = 200;
3187                 osc_mode = calc_random_param(0, 1);
3188                 set->op_connect[1][1] = !calc_random_param(0, 4) ? 0 : -1; // feedback op1 to op0 10%
3189                 break;
3190         case 3:
3191                 tmp = 100;
3192                 osc_mode = 0;
3193                 break;
3194         case 4:
3195                 tmp = 75;
3196                 osc_mode = 0;
3197                 break;
3198         default:
3199         case 5:
3200         case 6:
3201                 tmp = 50;
3202                 osc_mode = 0;
3203                 break;
3204         }
3205         for(i = 0; i < op_max; i++){
3206                 set->op_param[i][0] = 3; // pm
3207                 if(i == (op_max - 1)){
3208                         set->op_connect[i][0] = -2;
3209                         set->op_param[i][2] = 70; // lev output
3210                         set->op_sub[i][0] = calc_random_param(20, 60); // velmod
3211                 }else if(!calc_random_param(0, 3)){
3212                         set->op_connect[i][0] = op_max - 1;
3213                         set->op_param[i][2] = 50; // oplv
3214                         set->op_sub[i][0] = calc_random_param(50, 100); // velmod
3215                 }else{
3216                         set->op_connect[i][0] = i + 1;
3217                         set->op_param[i][2] = 100; // oplv
3218                         set->op_sub[i][0] = calc_random_param(50, 100); // velmod
3219                 }
3220                 set->op_param[i][1] = calc_random_param(10, tmp); // modlv
3221         }
3222         // osc wave / scc
3223         if(osc_mode){
3224                 for(i = 0; i < op_max; i++){
3225                         set->op_wave[i][0] = 1;
3226                         set->op_wave[i][1] = calc_random_param(0, 36); // scc
3227                         set->op_osc[i][1] = 100;
3228                 }
3229         }else{
3230                 for(i = 0; i < (op_max - 1); i++){
3231                         set->op_wave[i][0] = 0;
3232                         set->op_wave[i][1] = calc_random_param(0, 1); // sin / tri
3233                 }
3234                 switch(calc_random_param(0, 5)){
3235                 default:
3236                 case 0: // 1x2x3x4x5x6x7x...
3237                         for(i = 0; i < (op_max - 1); i++){
3238                                 set->op_osc[i][1] = (calc_random_param(1, 8) * 100); // % (only %mode
3239                         }
3240                         break;
3241                 case 1: // 2x4x6x8x...
3242                         for(i = 0; i < (op_max - 1); i++){
3243                                 set->op_osc[i][1] = calc_random_param(1, 4) * 200; // % (only %mode
3244                         }
3245                         break;
3246                 case 2: // 1x3x5x7
3247                         for(i = 0; i < (op_max - 1); i++){
3248                                 set->op_osc[i][1] = calc_random_param(1, 4) * 200 - 100; // % (only %mode
3249                         }
3250                         break;
3251                 case 3: // 0.25x
3252                         for(i = 0; i < (op_max - 1); i++){
3253                                 set->op_osc[i][1] = calc_random_param(3, 8 * 4) * 25; // % (only %mode
3254                         }
3255                         break;
3256                 }
3257                 set->op_osc[(op_max - 1)][1] = 100;
3258         }
3259         // ampenv
3260         {
3261                 int atk_min, atk_max, dcy_min, dcy_max;
3262                 switch(calc_random_param(0, 3)){
3263                 default:
3264                 case 0: // fast atk sustain
3265                         atk_min = 50;
3266                         atk_max = 200;
3267                         for(i = 0; i < (op_max - 1); i++){
3268                                 set->op_ampenv[i][0] = atk_max = calc_random_param(atk_min, atk_max);
3269                                 atk_min -= 10;
3270                                 set->op_ampenv[i][1] = 100;
3271                                 set->op_ampenv[i][2] = 0;
3272                                 set->op_ampenv[i][3] = 100;
3273                                 set->op_ampenv[i][4] = 10000;
3274                                 set->op_ampenv[i][5] = 100;
3275                                 set->op_ampenv[i][6] = 10000;
3276                                 set->op_ampenv[i][7] = 0;
3277                         }
3278                         break;
3279                 case 1: // fast atk decay
3280                         atk_min = 50;
3281                         atk_max = 200;
3282                         dcy_min = 300;
3283                         dcy_max = 2500;
3284                         for(i = 0; i < (op_max - 1); i++){
3285                                 set->op_ampenv[i][0] = atk_max = calc_random_param(atk_min, atk_max);
3286                                 atk_min -= 10;
3287                                 set->op_ampenv[i][1] = 100;
3288                                 set->op_ampenv[i][2] = 0;
3289                                 set->op_ampenv[i][3] = 100;
3290                                 set->op_ampenv[i][4] = val = dcy_min = calc_random_param(dcy_min, dcy_max);
3291                                 dcy_max += 100;
3292                                 set->op_ampenv[i][5] = calc_random_param(0, 50);
3293                                 set->op_ampenv[i][6] = val;
3294                                 set->op_ampenv[i][7] = 0;
3295                         }
3296                         break;
3297                 case 2: // slow atk sustain
3298                         atk_min = 300;
3299                         atk_max = 800;
3300                         for(i = 0; i < (op_max - 1); i++){
3301                                 set->op_ampenv[i][0] = atk_max = calc_random_param(atk_min, atk_max);
3302                                 atk_min -= 40;
3303                                 set->op_ampenv[i][1] = 100;
3304                                 set->op_ampenv[i][2] = 0;
3305                                 set->op_ampenv[i][3] = 100;
3306                                 set->op_ampenv[i][4] = 10000;
3307                                 set->op_ampenv[i][5] = 100;
3308                                 set->op_ampenv[i][6] = 10000;
3309                                 set->op_ampenv[i][7] = 0;
3310                         }
3311                         break;
3312                 }
3313                 set->op_ampenv[(op_max - 1)][0] = calc_random_param(10, 50);
3314                 set->op_ampenv[(op_max - 1)][1] = 100;
3315                 set->op_ampenv[(op_max - 1)][2] = 0;
3316                 set->op_ampenv[(op_max - 1)][3] = 100;
3317                 set->op_ampenv[(op_max - 1)][4] = 10000;
3318                 set->op_ampenv[(op_max - 1)][5] = 100;
3319                 set->op_ampenv[(op_max - 1)][6] = 10000;
3320                 set->op_ampenv[(op_max - 1)][7] = 0;
3321         }
3322         // widenv
3323         if(osc_mode == 0 && !calc_random_param(0, 4)){
3324                 set->op_width[0][1] = calc_random_param(50, 99);
3325                 switch(calc_random_param(0, 1)){
3326                 default:
3327                 case 0: // fast down
3328                         set->op_widenv[0][0] = 0;
3329                         set->op_widenv[0][1] = 100;
3330                         set->op_widenv[0][2] = 0;
3331                         set->op_widenv[0][3] = 100;
3332                         set->op_widenv[0][4] = val = calc_random_param(200, 1000);
3333                         set->op_widenv[0][5] = 0;
3334                         set->op_widenv[0][6] = val;
3335                         set->op_widenv[0][7] = 0;
3336                         break;
3337                 case 1: // fast up down
3338                         set->op_widenv[0][0] = val = calc_random_param(200, 400);
3339                         set->op_widenv[0][1] = 100;
3340                         set->op_widenv[0][2] = 0;
3341                         set->op_widenv[0][3] = 100;
3342                         set->op_widenv[0][4] = val = calc_random_param(400, 1000);
3343                         set->op_widenv[0][5] = 0;
3344                         set->op_widenv[0][6] = val;
3345                         set->op_widenv[0][7] = 0;
3346                         break;
3347                 }
3348         }
3349 }
3350
3351 int mms_editor_get_param(int type, int op, int num)
3352 {
3353         switch(type){
3354         case 0: return mms_setting_edit[0].op_max;
3355         case 1: return mms_setting_edit[0].op_range[op][num];
3356         case 2: return mms_setting_edit[0].op_param[op][num];
3357         case 3: return mms_setting_edit[0].op_connect[op][num];
3358         case 4: return mms_setting_edit[0].op_osc[op][num];
3359         case 5: return mms_setting_edit[0].op_wave[op][num];
3360         case 6: return mms_setting_edit[0].op_sub[op][num];
3361         case 7: return mms_setting_edit[0].op_amp[op][num];
3362         case 8: return mms_setting_edit[0].op_pitch[op][num];
3363         case 9: return mms_setting_edit[0].op_width[op][num];
3364         case 10: return mms_setting_edit[0].op_filter[op][num];
3365         case 11: return mms_setting_edit[0].op_cutoff[op][num];
3366         case 12: return mms_setting_edit[0].op_ampenv[op][num];
3367         case 13: return mms_setting_edit[0].op_pitenv[op][num];
3368         case 14: return mms_setting_edit[0].op_widenv[op][num];
3369         case 15: return mms_setting_edit[0].op_modenv[op][num];
3370         case 16: return mms_setting_edit[0].op_ampenv_keyf[op][num];
3371         case 17: return mms_setting_edit[0].op_pitenv_keyf[op][num];
3372         case 18: return mms_setting_edit[0].op_widenv_keyf[op][num];
3373         case 19: return mms_setting_edit[0].op_modenv_keyf[op][num];
3374         case 20: return mms_setting_edit[0].op_ampenv_velf[op][num];
3375         case 21: return mms_setting_edit[0].op_pitenv_velf[op][num];
3376         case 22: return mms_setting_edit[0].op_widenv_velf[op][num];
3377         case 23: return mms_setting_edit[0].op_modenv_velf[op][num];
3378         case 24: return mms_setting_edit[0].op_lfo1[op][num];
3379         case 25: return mms_setting_edit[0].op_lfo2[op][num];
3380         case 26: return mms_setting_edit[0].op_lfo3[op][num];
3381         case 27: return mms_setting_edit[0].op_lfo4[op][num];
3382         default: return 0;
3383         }
3384 }
3385
3386 void mms_editor_set_param(int type, int op, int num, int val)
3387 {
3388         switch(type){
3389         case 0: mms_setting_edit[0].op_max = val > MMS_OP_MAX ? MMS_OP_MAX : val;
3390                 return;
3391         case 1: mms_setting_edit[0].op_range[op][num] = val;
3392                 return;
3393         case 2: mms_setting_edit[0].op_param[op][num] = val;
3394                 return;
3395         case 3: mms_setting_edit[0].op_connect[op][num] = val;
3396                 return;
3397         case 4: mms_setting_edit[0].op_osc[op][num] = val;
3398                 return;
3399         case 5: mms_setting_edit[0].op_wave[op][num] = val;
3400                 return;
3401         case 6: mms_setting_edit[0].op_sub[op][num] = val;
3402                 return;
3403         case 7: mms_setting_edit[0].op_amp[op][num] = val;
3404                 return;
3405         case 8: mms_setting_edit[0].op_pitch[op][num] = val;
3406                 return;
3407         case 9: mms_setting_edit[0].op_width[op][num] = val;
3408                 return;
3409         case 10: mms_setting_edit[0].op_filter[op][num] = val;
3410                 return;
3411         case 11: mms_setting_edit[0].op_cutoff[op][num] = val;
3412                 return;
3413         case 12: mms_setting_edit[0].op_ampenv[op][num] = val;
3414                 return;
3415         case 13: mms_setting_edit[0].op_pitenv[op][num] = val;
3416                 return;
3417         case 14: mms_setting_edit[0].op_widenv[op][num] = val;
3418                 return;
3419         case 15: mms_setting_edit[0].op_modenv[op][num] = val;
3420                 return;
3421         case 16: mms_setting_edit[0].op_ampenv_keyf[op][num] = val;
3422                 return;
3423         case 17: mms_setting_edit[0].op_pitenv_keyf[op][num] = val;
3424                 return;
3425         case 18: mms_setting_edit[0].op_widenv_keyf[op][num] = val;
3426                 return;
3427         case 19: mms_setting_edit[0].op_modenv_keyf[op][num] = val;
3428                 return;
3429         case 20: mms_setting_edit[0].op_ampenv_velf[op][num] = val;
3430                 return;
3431         case 21: mms_setting_edit[0].op_pitenv_velf[op][num] = val;
3432                 return;
3433         case 22: mms_setting_edit[0].op_widenv_velf[op][num] = val;
3434                 return;
3435         case 23: mms_setting_edit[0].op_modenv_velf[op][num] = val;
3436                 return;
3437         case 24: mms_setting_edit[0].op_lfo1[op][num] = val;
3438                 return;
3439         case 25: mms_setting_edit[0].op_lfo2[op][num] = val;
3440                 return;
3441         case 26: mms_setting_edit[0].op_lfo3[op][num] = val;
3442                 return;
3443         case 27: mms_setting_edit[0].op_lfo4[op][num] = val;
3444                 return;
3445         }
3446 }
3447
3448 static void mms_editor_delete_ini(int num)
3449 {
3450         INIDATA ini={0};
3451         char sec[30] = "";
3452
3453         MyIni_Load(&ini, is_editor_inifile);
3454         snprintf(sec, sizeof(sec), "MMS_%03d", num); // \8c\85\90\94\8ew\92è
3455         MyIni_DeleteSection(&ini, sec);
3456         MyIni_Save(&ini, is_editor_inifile);
3457         MyIni_SectionAllClear(&ini);
3458 }
3459
3460 static void mms_editor_save_ini(int num)
3461 {
3462         Preset_MMS *setting = NULL;
3463         INIDATA ini={0};
3464         LPINISEC inisec = NULL;
3465         TCHAR data[258] = "";
3466         char sec[30] = "";
3467         char key[30] = "";
3468         int i, j, flg;
3469
3470         if(!is_editor_preset.mms_setting[num])
3471                 return;
3472         setting = is_editor_preset.mms_setting[num];
3473         MyIni_Load(&ini, is_editor_inifile);
3474         snprintf(sec, sizeof(sec), "MMS_%03d", num); // \8c\85\90\94\8ew\92è
3475         inisec = MyIni_GetSection(&ini, sec, 1);
3476         MyIni_SetString(inisec, "name", setting->inst_name);
3477         MyIni_SetInt32(inisec, "op_max", setting->op_max);
3478         for(j = 0; j < MMS_OP_MAX; j++){
3479                 if(j >= setting->op_max){
3480                         // \8eg\97p\82µ\82È\82¢OP\82Ì\83L\81[\8dí\8f\9c
3481                         snprintf(key, sizeof(key), "op_%d_range", j);
3482                         MyIni_DeleteKey(&ini, sec, key);
3483                         snprintf(key, sizeof(key), "op_%d_param", j);
3484                         MyIni_DeleteKey(&ini, sec, key);
3485                         snprintf(key, sizeof(key), "op_%d_connect", j);
3486                         MyIni_DeleteKey(&ini, sec, key);
3487                         snprintf(key, sizeof(key), "op_%d_osc", j);
3488                         MyIni_DeleteKey(&ini, sec, key);
3489                         snprintf(key, sizeof(key), "op_%d_wave", j);
3490                         MyIni_DeleteKey(&ini, sec, key);
3491                         snprintf(key, sizeof(key), "op_%d_sub", j);
3492                         MyIni_DeleteKey(&ini, sec, key);
3493                         snprintf(key, sizeof(key), "op_%d_amp", j);
3494                         MyIni_DeleteKey(&ini, sec, key);
3495                         snprintf(key, sizeof(key), "op_%d_pitch", j);
3496                         MyIni_DeleteKey(&ini, sec, key);
3497                         snprintf(key, sizeof(key), "op_%d_width", j);
3498                         MyIni_DeleteKey(&ini, sec, key);
3499                         snprintf(key, sizeof(key), "op_%d_filter", j);
3500                         MyIni_DeleteKey(&ini, sec, key);
3501                         snprintf(key, sizeof(key), "op_%d_cutoff", j);
3502                         MyIni_DeleteKey(&ini, sec, key);
3503                         snprintf(key, sizeof(key), "op_%d_ampenv", j);
3504                         MyIni_DeleteKey(&ini, sec, key);
3505                         snprintf(key, sizeof(key), "op_%d_pitenv", j);
3506                         MyIni_DeleteKey(&ini, sec, key);
3507                         snprintf(key, sizeof(key), "op_%d_widenv", j);
3508                         MyIni_DeleteKey(&ini, sec, key);
3509                         snprintf(key, sizeof(key), "op_%d_modenv", j);
3510                         MyIni_DeleteKey(&ini, sec, key);
3511                         snprintf(key, sizeof(key), "op_%d_ampenv_keyf", j);
3512                         MyIni_DeleteKey(&ini, sec, key);
3513                         snprintf(key, sizeof(key), "op_%d_pitenv_keyf", j);
3514                         MyIni_DeleteKey(&ini, sec, key);
3515                         snprintf(key, sizeof(key), "op_%d_widenv_keyf", j);
3516                         MyIni_DeleteKey(&ini, sec, key);
3517                         snprintf(key, sizeof(key), "op_%d_modenv_keyf", j);
3518                         MyIni_DeleteKey(&ini, sec, key);
3519                         snprintf(key, sizeof(key), "op_%d_ampenv_velf", j);
3520                         MyIni_DeleteKey(&ini, sec, key);
3521                         snprintf(key, sizeof(key), "op_%d_pitenv_velf", j);
3522                         MyIni_DeleteKey(&ini, sec, key);
3523                         snprintf(key, sizeof(key), "op_%d_widenv_velf", j);
3524                         MyIni_DeleteKey(&ini, sec, key);
3525                         snprintf(key, sizeof(key), "op_%d_modenv_velf", j);
3526                         MyIni_DeleteKey(&ini, sec, key);
3527                         snprintf(key, sizeof(key), "op_%d_lfo1", j);
3528                         MyIni_DeleteKey(&ini, sec, key);
3529                         snprintf(key, sizeof(key), "op_%d_lfo2", j);
3530                         MyIni_DeleteKey(&ini, sec, key);
3531                         snprintf(key, sizeof(key), "op_%d_lfo3", j);
3532                         MyIni_DeleteKey(&ini, sec, key);
3533                         snprintf(key, sizeof(key), "op_%d_lfo4", j);
3534                         MyIni_DeleteKey(&ini, sec, key);
3535                         break;
3536                 }
3537                 // range
3538                 snprintf(key, sizeof(key), "op_%d_range", j);
3539                 memset(data, 0, sizeof(data));
3540                 for(i = 0; i < MMS_OP_RANGE_MAX; i++){
3541                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_range[j][i]);
3542                 }
3543                 if(setting->op_range[j][0] != 0
3544                         || setting->op_range[j][1] != 127
3545                         || setting->op_range[j][2] != 0
3546                         || setting->op_range[j][3] != 127)
3547                         MyIni_SetString(inisec, key, data);
3548                 else
3549                         MyIni_DeleteKey(&ini, sec, key);
3550                 // param
3551                 snprintf(key, sizeof(key), "op_%d_param", j);
3552                 memset(data, 0, sizeof(data));
3553                 for(i = 0; i < MMS_OP_PARAM_MAX; i++){
3554                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_param[j][i]);
3555                 }
3556                 MyIni_SetString(inisec, key, data);
3557                 // connect
3558                 snprintf(key, sizeof(key), "op_%d_connect", j);
3559                 memset(data, 0, sizeof(data));
3560                 flg = 0;
3561                 for(i = 0; i < MMS_OP_CON_MAX; i++){
3562                         if(setting->op_connect[j][i] != -1) flg++;
3563                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_connect[j][i]);
3564                 }
3565                 if(flg)
3566                         MyIni_SetString(inisec, key, data);
3567                 else
3568                         MyIni_DeleteKey(&ini, sec, key);
3569                 // osc
3570                 snprintf(key, sizeof(key), "op_%d_osc", j);
3571                 memset(data, 0, sizeof(data));
3572                 flg = 0;
3573                 for(i = 0; i < MMS_OP_OSC_MAX; i++){
3574                         if(i == 1){
3575                                 if(setting->op_osc[j][i] != 100) flg++;
3576                         }else
3577                                 if(setting->op_osc[j][i]) flg++;
3578                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_osc[j][i]);
3579                 }
3580                 if(flg)
3581                         MyIni_SetString(inisec, key, data);
3582                 else
3583                         MyIni_DeleteKey(&ini, sec, key);
3584                 // wave
3585                 snprintf(key, sizeof(key), "op_%d_wave", j);
3586                 memset(data, 0, sizeof(data));
3587                 flg = 0;
3588                 for(i = 0; i < MMS_OP_WAVE_MAX; i++){
3589                         if(i == 2){
3590                                 if(setting->op_wave[j][i] != 100) flg++;
3591                         }else
3592                                 if(setting->op_wave[j][i]) flg++;
3593                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_wave[j][i]);
3594                 }
3595                 if(flg)
3596                         MyIni_SetString(inisec, key, data);
3597                 else
3598                         MyIni_DeleteKey(&ini, sec, key);
3599                 // sub
3600                 snprintf(key, sizeof(key), "op_%d_sub", j);
3601                 memset(data, 0, sizeof(data));
3602                 flg = 0;
3603                 for(i = 0; i < MMS_OP_SUB_MAX; i++){
3604                         if(setting->op_sub[j][i]) flg++;
3605                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_sub[j][i]);
3606                 }
3607                 if(flg)
3608                         MyIni_SetString(inisec, key, data);
3609                 else
3610                         MyIni_DeleteKey(&ini, sec, key);
3611                 // amp
3612                 snprintf(key, sizeof(key), "op_%d_amp", j);
3613                 memset(data, 0, sizeof(data));
3614                 flg = 0;
3615                 for(i = 0; i < MMS_OP_AMP_MAX; i++){
3616                         if(setting->op_amp[j][i]) flg++;
3617                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_amp[j][i]);
3618                 }
3619                 if(flg)
3620                         MyIni_SetString(inisec, key, data);
3621                 else
3622                         MyIni_DeleteKey(&ini, sec, key);
3623                 // pitch
3624                 snprintf(key, sizeof(key), "op_%d_pitch", j);
3625                 memset(data, 0, sizeof(data));
3626                 flg = 0;
3627                 for(i = 0; i < MMS_OP_PITCH_MAX; i++){
3628                         if(setting->op_pitch[j][i]) flg++;
3629                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_pitch[j][i]);
3630                 }
3631                 if(flg)
3632                         MyIni_SetString(inisec, key, data);
3633                 else
3634                         MyIni_DeleteKey(&ini, sec, key);
3635                 // width
3636                 snprintf(key, sizeof(key), "op_%d_width", j);
3637                 memset(data, 0, sizeof(data));
3638                 flg = 0;
3639                 for(i = 0; i < MMS_OP_WIDTH_MAX; i++){
3640                         if(setting->op_width[j][i]) flg++;
3641                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_width[j][i]);
3642                 }
3643                 if(flg)
3644                         MyIni_SetString(inisec, key, data);
3645                 else
3646                         MyIni_DeleteKey(&ini, sec, key);
3647                 // filter
3648                 snprintf(key, sizeof(key), "op_%d_filter", j);
3649                 memset(data, 0, sizeof(data));
3650                 flg = 0;
3651                 for(i = 0; i < MMS_OP_FLT_PARAM; i++){
3652                         if(setting->op_filter[j][i]) flg++;
3653                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_filter[j][i]);
3654                 }
3655                 if(flg)
3656                         MyIni_SetString(inisec, key, data);
3657                 else
3658                         MyIni_DeleteKey(&ini, sec, key);
3659                 // cutoff
3660                 snprintf(key, sizeof(key), "op_%d_cutoff", j);
3661                 memset(data, 0, sizeof(data));
3662                 flg = 0;
3663                 for(i = 0; i < MMS_OP_CUT_PARAM; i++){
3664                         if(setting->op_cutoff[j][i]) flg++;
3665                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_cutoff[j][i]);
3666                 }
3667                 if(flg)
3668                         MyIni_SetString(inisec, key, data);
3669                 else
3670                         MyIni_DeleteKey(&ini, sec, key);
3671                 // ampenv
3672                 snprintf(key, sizeof(key), "op_%d_ampenv", j);
3673                 if(setting->op_ampenv[j][6] < 1) setting->op_ampenv[j][6] = 1;
3674                 if(setting->op_ampenv[j][0] != 0
3675                         || setting->op_ampenv[j][1] != 100
3676                         || setting->op_ampenv[j][2] != 0
3677                         || setting->op_ampenv[j][3] != 100
3678                         || setting->op_ampenv[j][4] != 0
3679                         || setting->op_ampenv[j][5] != 100
3680                         || setting->op_ampenv[j][6] != 1
3681                         || setting->op_ampenv[j][7] != 0
3682                         || setting->op_ampenv[j][8] != 0
3683                         || setting->op_ampenv[j][9] != 0
3684                         || setting->op_ampenv[j][10] != 0
3685                         || setting->op_ampenv[j][11] != 0
3686                         || setting->op_ampenv[j][12] != 0
3687                         || setting->op_ampenv[j][13] != 0
3688                         ){
3689                         memset(data, 0, sizeof(data));
3690                         if(setting->op_ampenv[j][6] < 1)
3691                                 setting->op_ampenv[j][6] = 1;
3692                         for(i = 0; i < MMS_OP_ENV_PARAM; i++){
3693                                 snprintf(data, sizeof(data), "%s%d:", data, setting->op_ampenv[j][i]);
3694                         }
3695                         MyIni_SetString(inisec, key, data);
3696                 }else
3697                         MyIni_DeleteKey(&ini, sec, key);
3698                 // pitenv
3699                 snprintf(key, sizeof(key), "op_%d_pitenv", j);
3700                 if(setting->op_pitenv[j][6] < 1) setting->op_pitenv[j][6] = 1;
3701                 if(setting->op_pitenv[j][0] != 0
3702                         || setting->op_pitenv[j][1] != 100
3703                         || setting->op_pitenv[j][2] != 0
3704                         || setting->op_pitenv[j][3] != 100
3705                         || setting->op_pitenv[j][4] != 0
3706                         || setting->op_pitenv[j][5] != 100
3707                         || setting->op_pitenv[j][6] != 1
3708                         || setting->op_pitenv[j][7] != 0
3709                         || setting->op_pitenv[j][8] != 0
3710                         || setting->op_pitenv[j][9] != 0
3711                         || setting->op_pitenv[j][10] != 0
3712                         || setting->op_pitenv[j][11] != 0
3713                         || setting->op_pitenv[j][12] != 0
3714                         || setting->op_pitenv[j][13] != 0
3715                         ){
3716                         memset(data, 0, sizeof(data));
3717                         if(setting->op_pitenv[j][6] < 1) setting->op_pitenv[j][6] = 1;
3718                         for(i = 0; i < MMS_OP_ENV_PARAM; i++){
3719                                 snprintf(data, sizeof(data), "%s%d:", data, setting->op_pitenv[j][i]);
3720                         }
3721                         MyIni_SetString(inisec, key, data);
3722                 }else
3723                         MyIni_DeleteKey(&ini, sec, key);
3724                 // widenv
3725                 snprintf(key, sizeof(key), "op_%d_widenv", j);
3726                 if(setting->op_widenv[j][6] < 1) setting->op_widenv[j][6] = 1;
3727                 if(setting->op_widenv[j][0] != 0
3728                         || setting->op_widenv[j][1] != 100
3729                         || setting->op_widenv[j][2] != 0
3730                         || setting->op_widenv[j][3] != 100
3731                         || setting->op_widenv[j][4] != 0
3732                         || setting->op_widenv[j][5] != 100
3733                         || setting->op_widenv[j][6] != 1
3734                         || setting->op_widenv[j][7] != 0
3735                         || setting->op_widenv[j][8] != 0
3736                         || setting->op_widenv[j][9] != 0
3737                         || setting->op_widenv[j][10] != 0
3738                         || setting->op_widenv[j][11] != 0
3739                         || setting->op_widenv[j][12] != 0
3740                         || setting->op_widenv[j][13] != 0
3741                         ){
3742                         memset(data, 0, sizeof(data));
3743                         if(setting->op_widenv[j][6] < 1) setting->op_widenv[j][6] = 1;
3744                         for(i = 0; i < MMS_OP_ENV_PARAM; i++){
3745                                 snprintf(data, sizeof(data), "%s%d:", data, setting->op_widenv[j][i]);
3746                         }
3747                         MyIni_SetString(inisec, key, data);
3748                 }else
3749                         MyIni_DeleteKey(&ini, sec, key);
3750                 // modenv
3751                 snprintf(key, sizeof(key), "op_%d_modenv", j);
3752                 if(setting->op_modenv[j][6] < 1) setting->op_modenv[j][6] = 1;
3753                 if(setting->op_modenv[j][0] != 0
3754                         || setting->op_modenv[j][1] != 100
3755                         || setting->op_modenv[j][2] != 0
3756                         || setting->op_modenv[j][3] != 100
3757                         || setting->op_modenv[j][4] != 0
3758                         || setting->op_modenv[j][5] != 100
3759                         || setting->op_modenv[j][6] != 1
3760                         || setting->op_modenv[j][7] != 0
3761                         || setting->op_modenv[j][8] != 0
3762                         || setting->op_modenv[j][9] != 0
3763                         || setting->op_modenv[j][10] != 0
3764                         || setting->op_modenv[j][11] != 0
3765                         || setting->op_modenv[j][12] != 0
3766                         || setting->op_modenv[j][13] != 0
3767                         ){
3768                         memset(data, 0, sizeof(data));
3769                         if(setting->op_modenv[j][6] < 1) setting->op_modenv[j][6] = 1;
3770                         for(i = 0; i < MMS_OP_ENV_PARAM; i++){
3771                                 snprintf(data, sizeof(data), "%s%d:", data, setting->op_modenv[j][i]);
3772                         }
3773                         MyIni_SetString(inisec, key, data);
3774                 }else
3775                         MyIni_DeleteKey(&ini, sec, key);
3776                 // ampenv_keyf
3777                 snprintf(key, sizeof(key), "op_%d_ampenv_keyf", j);
3778                 memset(data, 0, sizeof(data));
3779                 flg = 0;
3780                 for(i = 0; i < MMS_OP_ENV_PARAM; i++){
3781                         if(setting->op_ampenv_keyf[j][i]) flg++;
3782                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_ampenv_keyf[j][i]);
3783                 }
3784                 if(flg)
3785                         MyIni_SetString(inisec, key, data);
3786                 else
3787                         MyIni_DeleteKey(&ini, sec, key);
3788                 // pitenv_keyf
3789                 snprintf(key, sizeof(key), "op_%d_pitenv_keyf", j);
3790                 memset(data, 0, sizeof(data));
3791                 flg = 0;
3792                 for(i = 0; i < MMS_OP_ENV_PARAM; i++){
3793                         if(setting->op_pitenv_keyf[j][i]) flg++;
3794                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_pitenv_keyf[j][i]);
3795                 }
3796                 if(flg)
3797                         MyIni_SetString(inisec, key, data);
3798                 else
3799                         MyIni_DeleteKey(&ini, sec, key);
3800                 // widenv_keyf
3801                 snprintf(key, sizeof(key), "op_%d_widenv_keyf", j);
3802                 memset(data, 0, sizeof(data));
3803                 flg = 0;
3804                 for(i = 0; i < MMS_OP_ENV_PARAM; i++){
3805                         if(setting->op_widenv_keyf[j][i]) flg++;
3806                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_widenv_keyf[j][i]);
3807                 }
3808                 if(flg)
3809                         MyIni_SetString(inisec, key, data);
3810                 else
3811                         MyIni_DeleteKey(&ini, sec, key);
3812                 // modenv_keyf
3813                 snprintf(key, sizeof(key), "op_%d_modenv_keyf", j);
3814                 memset(data, 0, sizeof(data));
3815                 flg = 0;
3816                 for(i = 0; i < MMS_OP_ENV_PARAM; i++){
3817                         if(setting->op_modenv_keyf[j][i]) flg++;
3818                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_modenv_keyf[j][i]);
3819                 }
3820                 if(flg)
3821                         MyIni_SetString(inisec, key, data);
3822                 else
3823                         MyIni_DeleteKey(&ini, sec, key);
3824                 // ampenv_velf
3825                 snprintf(key, sizeof(key), "op_%d_ampenv_velf", j);
3826                 memset(data, 0, sizeof(data));
3827                 flg = 0;
3828                 for(i = 0; i < MMS_OP_ENV_PARAM; i++){
3829                         if(setting->op_ampenv_velf[j][i]) flg++;
3830                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_ampenv_velf[j][i]);
3831                 }
3832                 if(flg)
3833                         MyIni_SetString(inisec, key, data);
3834                 else
3835                         MyIni_DeleteKey(&ini, sec, key);
3836                 // pitenv_velf
3837                 snprintf(key, sizeof(key), "op_%d_pitenv_velf", j);
3838                 memset(data, 0, sizeof(data));
3839                 flg = 0;
3840                 for(i = 0; i < MMS_OP_ENV_PARAM; i++){
3841                         if(setting->op_pitenv_velf[j][i]) flg++;
3842                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_pitenv_velf[j][i]);
3843                 }
3844                 if(flg)
3845                         MyIni_SetString(inisec, key, data);
3846                 else
3847                         MyIni_DeleteKey(&ini, sec, key);
3848                 // widenv_velf
3849                 snprintf(key, sizeof(key), "op_%d_widenv_velf", j);
3850                 memset(data, 0, sizeof(data));
3851                 flg = 0;
3852                 for(i = 0; i < MMS_OP_ENV_PARAM; i++){
3853                         if(setting->op_widenv_velf[j][i]) flg++;
3854                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_widenv_velf[j][i]);
3855                 }
3856                 if(flg)
3857                         MyIni_SetString(inisec, key, data);
3858                 else
3859                         MyIni_DeleteKey(&ini, sec, key);
3860                 // modenv_velf
3861                 snprintf(key, sizeof(key), "op_%d_modenv_velf", j);
3862                 memset(data, 0, sizeof(data));
3863                 flg = 0;
3864                 for(i = 0; i < MMS_OP_ENV_PARAM; i++){
3865                         if(setting->op_modenv_velf[j][i]) flg++;
3866                         snprintf(data, sizeof(data), "%s%d:", data, setting->op_modenv_velf[j][i]);
3867                 }
3868                 if(flg)
3869                         MyIni_SetString(inisec, key, data);
3870                 else
3871                         MyIni_DeleteKey(&ini, sec, key);
3872                 // lfo1
3873                 snprintf(key, sizeof(key), "op_%d_lfo1", j);
3874                 if(setting->op_lfo1[j][0] > 0){
3875                         memset(data, 0, sizeof(data));
3876                         for(i = 0; i < MMS_OP_LFO_PARAM; i++){
3877                                 if(setting->op_lfo1[j][i]) flg++;
3878                                 snprintf(data, sizeof(data), "%s%d:", data, setting->op_lfo1[j][i]);
3879                         }
3880                         MyIni_SetString(inisec, key, data);
3881                 }else
3882                         MyIni_DeleteKey(&ini, sec, key);
3883                 // lfo2
3884                 snprintf(key, sizeof(key), "op_%d_lfo2", j);
3885                 if(setting->op_lfo2[j][0] > 0){
3886                         memset(data, 0, sizeof(data));
3887                         for(i = 0; i < MMS_OP_LFO_PARAM; i++){
3888                                 if(setting->op_lfo2[j][i]) flg++;
3889                                 snprintf(data, sizeof(data), "%s%d:", data, setting->op_lfo2[j][i]);
3890                         }
3891                         MyIni_SetString(inisec, key, data);
3892                 }else
3893                         MyIni_DeleteKey(&ini, sec, key);
3894                 // lfo3
3895                 snprintf(key, sizeof(key), "op_%d_lfo3", j);
3896                 if(setting->op_lfo3[j][0] > 0){
3897                         memset(data, 0, sizeof(data));
3898                         for(i = 0; i < MMS_OP_LFO_PARAM; i++){
3899                                 if(setting->op_lfo3[j][i]) flg++;
3900                                 snprintf(data, sizeof(data), "%s%d:", data, setting->op_lfo3[j][i]);
3901                         }
3902                         MyIni_SetString(inisec, key, data);
3903                 }else
3904                         MyIni_DeleteKey(&ini, sec, key);
3905                 // lfo4
3906                 snprintf(key, sizeof(key), "op_%d_lfo4", j);
3907                 if(setting->op_lfo4[j][0] > 0){
3908                         memset(data, 0, sizeof(data));
3909                         for(i = 0; i < MMS_OP_LFO_PARAM; i++){
3910                                 if(setting->op_lfo4[j][i]) flg++;
3911                                 snprintf(data, sizeof(data), "%s%d:", data, setting->op_lfo4[j][i]);
3912                         }
3913                         MyIni_SetString(inisec, key, data);
3914                 }else
3915                         MyIni_DeleteKey(&ini, sec, key);
3916         }
3917         MyIni_Save(&ini, is_editor_inifile);
3918         MyIni_SectionAllClear(&ini);
3919 }
3920
3921 void mms_editor_delete_preset(int num)
3922 {
3923         if(num < 0 || num > (MMS_SETTING_MAX - 1))
3924                 return; // error
3925         if(!is_editor_preset.mms_setting[num])
3926                 return;
3927         safe_free(is_editor_preset.mms_setting[num]->inst_name);
3928         memset(is_editor_preset.mms_setting[num], 0, sizeof(Preset_MMS));
3929         mms_editor_delete_ini(num);
3930 }
3931
3932 void mms_editor_load_preset(int num)
3933 {
3934         if(num < 0){
3935                 memcpy(&mms_setting_edit[0], &mms_setting_edit[1], sizeof(Preset_MMS));
3936         }else{
3937                 if(num > (MMS_SETTING_MAX - 1))
3938                         return; // error
3939                 if(!is_editor_preset.mms_setting[num])
3940                         return;
3941                 memcpy(&mms_setting_edit[0], is_editor_preset.mms_setting[num], sizeof(Preset_MMS));
3942         }
3943 }
3944
3945 void mms_editor_store_preset(int num)
3946 {
3947         char *tmp;
3948
3949         if(num < 0){
3950                 memcpy(&mms_setting_edit[1], &mms_setting_edit[0], sizeof(Preset_MMS));
3951         }else{
3952                 if(num > (MMS_SETTING_MAX - 1))
3953                         return; // error
3954                 if(!is_editor_preset.mms_setting[num])
3955                         return;
3956                 tmp = is_editor_preset.mms_setting[num]->inst_name;
3957                 memcpy(is_editor_preset.mms_setting[num], &mms_setting_edit[0], sizeof(Preset_MMS));
3958                 is_editor_preset.mms_setting[num]->inst_name = tmp;
3959                 mms_editor_save_ini(num);
3960         }
3961 }
3962
3963 const char *is_editor_get_ini_path(void)
3964 {
3965         return (const char *)is_editor_inifile;
3966 }
3967
3968 void is_editor_set_ini_path(const char *name)
3969 {
3970         strcpy(is_editor_inifile, name);
3971 }
3972
3973 void free_is_editor_preset(void)
3974 {
3975         int i;
3976         Preset_IS *set = &is_editor_preset;
3977
3978         safe_free(set->ini_file);
3979         set->ini_file = NULL;
3980         set->scc_data_load = 0;
3981         for (i = 0; i < SCC_DATA_MAX; i++) {
3982                 safe_free(set->scc_data_name[i]);
3983                 set->scc_data_name[i] = NULL;
3984         }
3985         for (i = 0; i < SCC_SETTING_MAX; i++) {
3986                 if(!set->scc_setting[i])
3987                         continue;
3988                 safe_free(set->scc_setting[i]->inst_name);
3989                 set->scc_setting[i]->inst_name = NULL;
3990                 safe_free(set->scc_setting[i]);
3991                 set->scc_setting[i] = NULL;
3992         }
3993         for (i = 0; i < MMS_SETTING_MAX; i++) {
3994                 if(!set->mms_setting[i])
3995                         continue;
3996                 safe_free(set->mms_setting[i]->inst_name);
3997                 set->mms_setting[i]->inst_name = NULL;
3998                 safe_free(set->mms_setting[i]);
3999                 set->mms_setting[i] = NULL;
4000         }
4001         set->next = NULL;
4002 }
4003
4004 void is_editor_load_ini(void)
4005 {
4006         free_is_editor_preset();
4007         scc_data_editor_override = 0;
4008         scc_editor_override = 0;
4009         mms_editor_override = 0;
4010         load_int_synth_preset(is_editor_inifile, &is_editor_preset, IS_INI_TYPE_ALL, IS_INI_PRESET_ALL, IS_INI_PRESET_INIT); // all, init
4011         scc_data_editor_load_preset(0);
4012         scc_data_editor_store_preset(-1);
4013         scc_editor_load_preset(0);
4014         scc_editor_store_preset(-1);
4015         mms_editor_load_preset(0);
4016         mms_editor_store_preset(-1);
4017 }
4018
4019 void init_is_editor_param(void)
4020 {
4021         load_la_rom();
4022         scc_data_editor_override = 0;
4023         scc_editor_override = 0;
4024         mms_editor_override = 0;
4025 }
4026
4027 void uninit_is_editor_param(void)
4028 {
4029         scc_data_editor_override = 0;
4030         scc_editor_override = 0;
4031         mms_editor_override = 0;
4032         free_is_editor_preset();
4033 }
4034
4035
4036
4037
4038
4039
4040
4041
4042
4043
4044 //////// extract
4045
4046
4047 #define IS_ENVRATE_MAX (0x3FFFFFFFL)
4048 #define IS_ENVRATE_MIN (1L)
4049
4050 /* from instrum.c */
4051 static int32 convert_envelope_rate(uint8 rate)
4052 {
4053   int32 r;
4054
4055   r=3-((rate>>6) & 0x3);
4056   r*=3;
4057   r = (int32)(rate & 0x3f) << r; /* 6.9 fixed point */
4058   /* 15.15 fixed point. */
4059   return (((r * 44100) / play_mode->rate) * control_ratio) << ((fast_decay) ? 10 : 9);
4060 }
4061
4062 /* from instrum.c */
4063 static int32 convert_envelope_offset(uint8 offset)
4064 {
4065   /* 15.15 fixed point */
4066   return offset << (7+15);
4067 }
4068
4069 static int32 convert_vibrato_sweep(uint8 sweep, int32 vib_control_ratio)
4070 {
4071   if (!sweep)
4072     return 0;
4073
4074   return (int32)(TIM_FSCALE((double) (vib_control_ratio)
4075                             * SWEEP_TUNING, SWEEP_SHIFT) / (double)(play_mode->rate * sweep));
4076
4077 }
4078
4079 static int32 convert_tremolo_sweep(uint8 sweep)
4080 {
4081   if (!sweep)
4082     return 0;
4083   return ((control_ratio * SWEEP_TUNING) << SWEEP_SHIFT) / (play_mode->rate * sweep);
4084 }
4085
4086 static int32 convert_tremolo_freq_rate(FLOAT_T freq)
4087 {
4088         //  return ((SINE_CYCLE_LENGTH * control_ratio * rate) << RATE_SHIFT) / (TREMOLO_RATE_TUNING * play_mode->rate);
4089         return (FLOAT_T)((SINE_CYCLE_LENGTH * control_ratio) << RATE_SHIFT) * freq * DIV_1000 * div_playmode_rate;
4090 }
4091
4092 static int32 convert_vibrato_freq_rate(FLOAT_T freq)
4093 {
4094   /* Return a suitable vibrato_control_ratio value */
4095         //  return (VIBRATO_RATE_TUNING * play_mode->rate) / (rate * 2 * VIBRATO_SAMPLE_INCREMENTS);
4096         return (play_mode->rate) / (freq * 2 * VIBRATO_SAMPLE_INCREMENTS);
4097 }
4098
4099
4100 static void init_sample_param(Sample *sample)
4101 {
4102         memset(sample, 0, sizeof(Sample));
4103         sample->data = NULL;
4104         sample->data_type = SAMPLE_TYPE_INT16;
4105         sample->data_alloced = 0; // use Preset_SCC Preset_MMS ptr , see instrum.c free_instrument()
4106         sample->loop_start = 0;
4107         sample->loop_end = INT_MAX;
4108         sample->data_length = INT_MAX;
4109         sample->sample_rate = play_mode->rate;
4110         sample->low_key = 0;
4111         sample->high_key = 127;
4112         sample->root_key = 60;
4113         sample->root_freq = freq_table[60];
4114         sample->tune = 1.0;
4115         sample->def_pan = 64;
4116         sample->sample_pan = 0.0;
4117         sample->note_to_use = 0;
4118         sample->volume = 1.0;
4119         sample->cfg_amp = 1.0;
4120         sample->modes = MODES_16BIT | MODES_LOOPING | MODES_SUSTAIN | MODES_ENVELOPE;
4121         sample->low_vel = 0;
4122         sample->high_vel = 127;
4123         sample->tremolo_delay = 0;
4124         sample->tremolo_phase_increment = convert_tremolo_freq_rate(5.0); // Hz
4125         sample->tremolo_sweep_increment = convert_tremolo_sweep(8);
4126         sample->tremolo_depth = 0;
4127         sample->vibrato_delay = 0;
4128         sample->vibrato_control_ratio = convert_vibrato_freq_rate(5.0); // Hz
4129         sample->vibrato_sweep_increment =  convert_vibrato_sweep(8, sample->vibrato_control_ratio);
4130         sample->vibrato_depth = 0;
4131         sample->cutoff_freq = 20000;
4132         sample->cutoff_low_limit = -1;
4133         sample->cutoff_low_keyf = 0; // cent
4134         sample->resonance =  0;
4135         sample->tremolo_to_pitch = 0;
4136         sample->tremolo_to_fc = 0;
4137         sample->modenv_to_pitch = 0;
4138         sample->modenv_to_fc =0;
4139         sample->vel_to_fc = 0;
4140         sample->key_to_fc = 0;
4141         sample->vel_to_resonance = 0;
4142         sample->envelope_velf_bpo = 64;
4143         sample->modenv_velf_bpo = 64;
4144         sample->vel_to_fc_threshold = 64;
4145         sample->key_to_fc_bpo = 60;
4146         sample->scale_freq = 60;
4147         sample->scale_factor = 1024;
4148         sample->sample_type = SF_SAMPLETYPE_MONO;
4149         sample->root_freq_org = 60;
4150         sample->sample_rate_org = play_mode->rate;
4151         sample->sf_sample_link = -1;
4152         sample->sf_sample_index = 0;
4153         sample->lpf_type = -1;
4154         sample->keep_voice = 0;
4155         sample->hpf[0] = -1; // opt_hpf_def
4156         sample->hpf[1] = 10;
4157         sample->hpf[2] = 0;
4158         sample->root_freq_detected = 0;
4159         sample->transpose_detected = 0;
4160         sample->chord = -1;
4161         sample->vibrato_to_amp = 0;
4162         sample->vibrato_to_fc = 0;
4163         sample->pitch_envelope[0] = 0; // 0cent init
4164         sample->pitch_envelope[1] = 0; // 0cent atk
4165         sample->pitch_envelope[2] = 0; // 125ms atk
4166         sample->pitch_envelope[3] = 0; // 0cent dcy1
4167         sample->pitch_envelope[4] = 0; // 125ms dcy1
4168         sample->pitch_envelope[5] = 0; // 0cent dcy2
4169         sample->pitch_envelope[6] = 0; // 125ms dcy3
4170         sample->pitch_envelope[7] = 0; // 0cent rls
4171         sample->pitch_envelope[8] = 0; // 125ms rls
4172         sample->envelope_delay = 0;
4173         sample->envelope_offset[0] = convert_envelope_offset(255);
4174         sample->envelope_rate[0] = IS_ENVRATE_MAX; // instant
4175         sample->envelope_offset[1] = convert_envelope_offset(255);
4176         sample->envelope_rate[1] = IS_ENVRATE_MAX; // instant
4177         sample->envelope_offset[2] = convert_envelope_offset(255);
4178         sample->envelope_rate[2] = IS_ENVRATE_MAX; // instant
4179         sample->envelope_offset[3] = 0;
4180         sample->envelope_rate[3] = convert_envelope_rate(250);
4181         sample->envelope_offset[4] = 0;
4182         sample->envelope_rate[4] = convert_envelope_rate(250);
4183         sample->envelope_offset[5] = 0;
4184         sample->envelope_rate[5] = convert_envelope_rate(250);
4185         sample->modenv_delay = 0;
4186         sample->modenv_offset[0] = convert_envelope_offset(255);
4187         sample->modenv_rate[0] = IS_ENVRATE_MAX; // instant
4188         sample->modenv_offset[1] = convert_envelope_offset(255);
4189         sample->modenv_rate[1] = IS_ENVRATE_MAX; // instant
4190         sample->modenv_offset[2] = convert_envelope_offset(255);
4191         sample->modenv_rate[2] = IS_ENVRATE_MAX; // instant
4192         sample->modenv_offset[3] = 0;
4193         sample->modenv_rate[3] = convert_envelope_rate(1);
4194         sample->modenv_offset[4] = 0;
4195         sample->modenv_rate[4] = convert_envelope_rate(1);
4196         sample->modenv_offset[5] = 0;
4197         sample->modenv_rate[5] = convert_envelope_rate(1);
4198         sample->envelope_keyf[0] = 0;
4199         sample->envelope_keyf[1] = 0;
4200         sample->envelope_keyf[2] = 0;
4201         sample->envelope_keyf[3] = 0;
4202         sample->envelope_keyf[4] = 0;
4203         sample->envelope_keyf[5] = 0;
4204         sample->envelope_velf[0] = 0;
4205         sample->envelope_velf[1] = 0;
4206         sample->envelope_velf[2] = 0;
4207         sample->envelope_velf[3] = 0;
4208         sample->envelope_velf[4] = 0;
4209         sample->envelope_velf[5] = 0;
4210         sample->modenv_keyf[0] = 0;
4211         sample->modenv_keyf[1] = 0;
4212         sample->modenv_keyf[2] = 0;
4213         sample->modenv_keyf[3] = 0;
4214         sample->modenv_keyf[4] = 0;
4215         sample->modenv_keyf[5] = 0;
4216         sample->modenv_velf[0] = 0;
4217         sample->modenv_velf[1] = 0;
4218         sample->modenv_velf[2] = 0;
4219         sample->modenv_velf[3] = 0;
4220         sample->modenv_velf[4] = 0;
4221         sample->modenv_velf[5] = 0;
4222 }
4223
4224
4225 static Preset_IS *is_preset = NULL;
4226
4227 static Preset_IS *load_ini_file(char *ini_file, int type, int preset)
4228 {
4229         int i;
4230         Preset_IS *set = NULL;
4231         Preset_IS *newset = NULL;
4232
4233 #if defined(IS_INI_LOAD_BLOCK)
4234 #if (IS_INI_LOAD_BLOCK == 32)
4235         uint32 block = preset >> 5; // 1block=64preset 32block
4236 #elif (IS_INI_LOAD_BLOCK == 64)
4237         uint32 block = preset >> 6; // 1block=64preset 16block
4238 #elif (IS_INI_LOAD_BLOCK == 128)
4239         uint32 block = preset >> 7; // 1block=128preset 8block
4240 #endif
4241         uint32 bit = 1L << block; // < 32bit
4242         block = (block + 1) << 10; // 10bit > max(SCC_SETTING_MAX MMS_SETTING_MAX)
4243 #endif
4244
4245     for (set = is_preset; set; set = set->next){
4246                 if (set->ini_file && !strcmp(set->ini_file, ini_file)){
4247 #if defined(IS_INI_LOAD_TYPE)
4248                         if(type == IS_INI_TYPE_SCC && !set->scc_load)){
4249                                 load_int_synth_preset(ini_file, set, type, IS_INI_PRESET_ALL, IS_INI_PRESET_NONE);
4250                                 set->scc_load = 1;
4251                         }else (type == IS_INI_TYPE_MMS && !set->mms_load){
4252                                 load_int_synth_preset(ini_file, set, type, IS_INI_PRESET_ALL, IS_INI_PRESET_NONE);
4253                                 set->mms_load = 1;
4254                         }
4255 #elif defined(IS_INI_LOAD_BLOCK) // block\92P\88Ê\83\8d\81[\83h
4256                         if(type == IS_INI_TYPE_SCC && !(set->scc_load & bit)){
4257                                 load_int_synth_preset(ini_file, set, type, block, IS_INI_PRESET_NONE);
4258                                 set->scc_load |= bit;
4259                         }else if(type == IS_INI_TYPE_MMS && !(set->mms_load & bit)){
4260                                 load_int_synth_preset(ini_file, set, type, block, IS_INI_PRESET_NONE);
4261                                 set->mms_load |= bit;
4262                         }
4263 #elif defined(IS_INI_LOAD_PRESET) // preset\92P\88Ê\83\8d\81[\83h
4264                         load_int_synth_preset(ini_file, set, type, preset, IS_INI_PRESET_NONE);
4265 #endif
4266                         return set;
4267                 }
4268         }
4269         newset = (Preset_IS *)safe_malloc(sizeof(Preset_IS));
4270         memset(newset, 0, sizeof(Preset_IS));
4271         if(!is_preset){
4272                 is_preset = newset;
4273         }else{
4274                 for (set = is_preset; set; set = set->next){
4275                         if(!set->next){
4276                                 set->next = newset;
4277                         }
4278                 }
4279         }
4280         newset->ini_file = safe_strdup(ini_file);
4281 #if defined(IS_INI_LOAD_ALL) // \91S\95\94\83\8d\81[\83h
4282         load_int_synth_preset(ini_file, newset, IS_INI_TYPE_ALL, IS_INI_PRESET_ALL, IS_INI_PRESET_NONE); // \91S\95\94\83\8d\81[\83h
4283         newset->scc_load = 1;
4284         newset->mms_load = 1;
4285 #elif defined(IS_INI_LOAD_TYPE)  // type\92P\88Ê\83\8d\81[\83h
4286         load_int_synth_preset(ini_file, newset, type, IS_INI_PRESET_ALL, IS_INI_PRESET_NONE); // type\92P\88Ê\83\8d\81[\83h
4287         if(type == IS_INI_TYPE_SCC)
4288                 newset->scc_load = 1;
4289         else if(type == IS_INI_TYPE_MMS)
4290                 newset->mms_load = 1;
4291 #elif defined(IS_INI_LOAD_BLOCK) // block\92P\88Ê\83\8d\81[\83h
4292         load_int_synth_preset(ini_file, newset, type, block, IS_INI_PRESET_NONE); // preset\92P\88Ê\83\8d\81[\83h
4293         if(type == IS_INI_TYPE_SCC)
4294                 newset->scc_load |= bit;
4295         else if(type == IS_INI_TYPE_MMS)
4296                 newset->mms_load |= bit;
4297 #elif defined(IS_INI_LOAD_PRESET) // preset\92P\88Ê\83\8d\81[\83h
4298         load_int_synth_preset(ini_file, newset, type, preset, IS_INI_PRESET_NONE); // preset\92P\88Ê\83\8d\81[\83h
4299 #endif
4300         return newset;
4301 }
4302
4303 Instrument *extract_scc_file(char *ini_file, int preset)
4304 {
4305         Instrument *inst;
4306         Sample *sample;
4307         Preset_IS *set = NULL;
4308
4309         set = load_ini_file(ini_file, IS_INI_TYPE_SCC, preset);
4310         inst = (Instrument *)safe_malloc(sizeof(Instrument));
4311         memset(inst, 0, sizeof(Instrument));
4312         inst->instname = (char *)safe_malloc(256);
4313         if(!set->scc_setting[preset])
4314                 snprintf(inst->instname, 256, "[SCC] %d: ----", preset);
4315         else
4316                 snprintf(inst->instname, 256, "[SCC] %d: %s", preset, (const char *)set->scc_setting[preset]->inst_name);
4317         inst->type = INST_SCC;
4318         inst->samples = 1;
4319         inst->sample = (Sample *)safe_malloc(sizeof(Sample));
4320         memset(inst->sample, 0, sizeof(Sample));
4321         sample = inst->sample;
4322         init_sample_param(sample);
4323         sample->inst_type = INST_SCC;
4324         sample->sf_sample_index = preset;
4325         sample->data = (sample_t *)set;
4326         return inst;
4327 }
4328
4329 Instrument *extract_mms_file(char *ini_file, int preset)
4330 {
4331         Instrument *inst;
4332         Sample *sample;
4333         Preset_IS *set = NULL;
4334
4335         load_la_rom();
4336         set = load_ini_file(ini_file, IS_INI_TYPE_MMS, preset);
4337         inst = (Instrument *)safe_malloc(sizeof(Instrument));
4338         memset(inst, 0, sizeof(Instrument));
4339         inst->instname = (char *)safe_malloc(256);
4340         if(!set->mms_setting[preset])
4341                 snprintf(inst->instname, 256, "[MMS] %d: ----", preset);
4342         else
4343                 snprintf(inst->instname, 256, "[MMS] %d: %s", preset, (const char *)set->mms_setting[preset]->inst_name);
4344         inst->type = INST_MMS;
4345         inst->samples = 1;
4346         inst->sample = (Sample *)safe_malloc(sizeof(Sample));
4347         memset(inst->sample, 0, sizeof(Sample));
4348         sample = inst->sample;
4349         init_sample_param(sample);
4350         sample->inst_type = INST_MMS;
4351         sample->sf_sample_index = preset;
4352         sample->data = (sample_t *)set;
4353         return inst;
4354 }
4355
4356 void free_int_synth_file(Instrument *ip)
4357 {
4358     safe_free(ip->instname);
4359     ip->instname = NULL;
4360 }
4361
4362
4363
4364
4365
4366
4367 //////// common
4368
4369
4370 // mix 0.0~1.0 (mix=0.0 param1, mix=0.5 param1*0.5+param2*0.5, mix=1.0 param2
4371 static inline double mix_double(double mix, double param1, double param2)
4372 {
4373         return param1 * (1.0 - mix) + param2 * mix;
4374 }
4375
4376
4377 /* OSC */
4378 /*
4379 in  : 0.0 ~ 1.0
4380 out : -1.0 ~ 1.0
4381
4382 zero point offset
4383 sine:+0.25
4384 tria:+0.25
4385 saw1:+0.5
4386 saw2:+0.5
4387 squa:+0.0
4388 */
4389
4390 const char *osc_wave_name[] =
4391 {
4392     "SINE",
4393     "TRIANGULAR",
4394     "SAW1",
4395     "SAW2",
4396     "SQUARE",
4397     "NOISE",
4398     "NOISE_LOWBIT",
4399     "SINE_TABLE",
4400 };
4401
4402 FLOAT_T compute_osc_sine(FLOAT_T in, int32 var)
4403 {
4404         return sin((FLOAT_T)M_PI2 * (in + 0.75));
4405 }
4406
4407 FLOAT_T compute_osc_triangular(FLOAT_T in, int32 var)
4408 {
4409         if(in < 0.5)
4410                 return -1.0 + in * 4.0; // -1.0 + (in - 0.0) * 4.0;
4411         else  //  if(in < 1.0)
4412                 return 1.0 - (in - 0.5) * 4.0;
4413 }
4414
4415 FLOAT_T compute_osc_saw1(FLOAT_T in, int32 var)
4416 {
4417         if(in < 0.5)
4418                 return in * 2.0; // (in - 0.0) * 2.0;
4419         else  //  if(in < 1.0)
4420                 return (in - 1.0) * 2.0;
4421 }
4422
4423 FLOAT_T compute_osc_saw2(FLOAT_T in, int32 var)
4424 {
4425         if(in < 0.5)
4426                 return in * -2.0; // (in - 0.0) * -2.0;
4427         else  //  if(in < 1.0)
4428                 return (in - 1.0) * -2.0;
4429 }
4430
4431 FLOAT_T compute_osc_square(FLOAT_T in, int32 var)
4432 {
4433         if(in < 0.5)
4434                 return 1.0;
4435         else  //  if(in < 1.0)
4436                 return -1.0;
4437 }
4438
4439 FLOAT_T compute_osc_noise(FLOAT_T in, int32 var)
4440 {
4441         return (FLOAT_T)((int32)(rand() & 0x7FFFUL) - M_14BIT) * DIV_14BIT;
4442 }
4443
4444 FLOAT_T compute_osc_noise_lowbit(FLOAT_T in, int32 var)
4445 {
4446         return lookup_noise_lowbit(in, var);
4447 }
4448
4449 FLOAT_T compute_osc_sine_table(FLOAT_T in, int32 var)
4450 {
4451         return lookup2_sine(in + 0.75);
4452 }
4453
4454 FLOAT_T compute_osc_sine_table_linear(FLOAT_T in, int32 var)
4455 {
4456         return lookup2_sine_linear(in + 0.75);
4457 }
4458
4459 compute_osc_t compute_osc[] = {
4460 // cfg sort
4461         compute_osc_sine,
4462         compute_osc_triangular,
4463         compute_osc_saw1,
4464         compute_osc_saw2,
4465         compute_osc_square,
4466         compute_osc_noise,
4467         compute_osc_noise_lowbit,
4468         compute_osc_sine_table,
4469         compute_osc_sine_table_linear,
4470 };
4471
4472 static int check_is_osc_wave_type(int tmpi, int limit)
4473 {
4474         if(tmpi < 0 || tmpi > limit)
4475                 tmpi = 0; // sine
4476         // use table
4477         switch(tmpi){
4478         default:
4479                 return tmpi;
4480         case OSC_SINE:
4481                 switch(opt_int_synth_sine){
4482                 default:
4483                 case 0:
4484                         return OSC_SINE;
4485                 case 1:
4486                         return OSC_SINE_TABLE;
4487                 case 2:
4488                         return OSC_SINE_TABLE_LINEAR;
4489                 }
4490         }
4491 }
4492
4493
4494
4495 /* SCC */
4496 /*
4497 in  : 0.0 ~ 1.0
4498 out : -1.0 ~ 1.0
4499 */
4500
4501 FLOAT_T compute_osc_scc_none(FLOAT_T in, FLOAT_T *data)
4502 {
4503         return data[((int)(in * 32)) & 0x1F]; // 0~31<32
4504 }
4505
4506 FLOAT_T compute_osc_scc_linear(FLOAT_T in, FLOAT_T *data)
4507 {
4508         int32 ofsi;
4509     FLOAT_T v1, v2, fp;
4510
4511         in *= 32;
4512         fp = floor(in);
4513         ofsi = fp;
4514         ofsi &= 0x1F;
4515     v1 = data[ofsi];
4516     v2 = data[ofsi + 1];
4517         return v1 + (v2 - v1) * (in - fp);
4518 }
4519
4520 FLOAT_T compute_osc_scc_sine(FLOAT_T in, FLOAT_T *data)
4521 {
4522         int32 ofsi;
4523     FLOAT_T v1, v2, fp;
4524
4525         in *= 32;
4526         fp = floor(in);
4527         ofsi = fp;
4528 //      fp = 0.5 + sin((in - ofsi - 0.5) * M_PI) * DIV_2;
4529 //      fp = 0.5 + sine_table[(int32)((in - ofsi - 0.5) * M_12BIT) & table_size_mask] * DIV_2;
4530         fp = lookup2_sine_p(in - fp);
4531         ofsi &= 0x1F;
4532     v1 = data[ofsi];
4533     v2 = data[ofsi + 1];
4534     return v1 + (v2 - v1) * fp;
4535 }
4536
4537
4538
4539
4540 /* PCM */
4541 /*
4542 rate : \8aî\8f\80\82É\82È\82é\83T\83\93\83v\83\8b\83J\83E\83\93\83g
4543 pcm_rate : \95Ï\92²\97p\82Ì\83T\83\93\83v\83\8b\83J\83E\83\93\83g
4544 pcm_rate = rate + mod_offset (compute_op_pm()\82Å\82Írt\82É\91\8a\93\96
4545 \95Ï\92²\82µ\82È\82¢\8fê\8d\87\82Í mod_offset = 0 \82È\82Ì\82Å pcm_rate = rate \82ð\83Z\83b\83g
4546 \82Â\82¢\82Å\82Érate\82Ì\92l\88æ\83`\83F\83b\83N
4547 out : -1.0 ~ 1.0
4548 */
4549
4550 static inline FLOAT_T compute_pcm_none(Info_OP *info)
4551 {
4552         FLOAT_T *pcm_data = info->data_ptr;
4553         int32 index = (int32)info->pcm_rate;
4554
4555         if(info->loop_length){ // loop
4556                 if(info->rate >= info->ofs_end) // recompute base rate
4557                         info->rate -= info->loop_length;
4558                 if(index >= info->ofs_end)
4559                         index -= info->loop_length;
4560                 else if(index < info->ofs_start)
4561                         index += info->loop_length;
4562                 return pcm_data[index];
4563         }else{ // non loop
4564                 if(index >= info->ofs_end){
4565                         info->op_flag = 0; // pcm end
4566                         return 0;
4567                 }
4568                 return pcm_data[index];
4569         }
4570 }
4571
4572 static inline FLOAT_T compute_pcm_linear(Info_OP *info)
4573 {
4574         FLOAT_T *pcm_data = info->data_ptr;
4575         int32 index = (int32)info->pcm_rate;
4576         FLOAT_T fp = info->pcm_rate - index;
4577         FLOAT_T v1, v2;
4578
4579         if(info->loop_length){ // loop
4580                 if(info->rate >= info->ofs_end) // recompute base rate
4581                         info->rate -= info->loop_length;
4582                 if(index >= info->ofs_end)
4583                         index -= info->loop_length;
4584                 else if(index < info->ofs_start)
4585                         index += info->loop_length;
4586                 v1 = pcm_data[index];
4587                 if(++index < info->ofs_end)
4588                         v2 = pcm_data[index];
4589                 else // return loop_start
4590                         v2 = pcm_data[info->ofs_start];
4591         }else{ // non loop
4592                 if(index >= info->ofs_end){
4593                         info->op_flag = 0; // pcm end
4594                         return 0;
4595                 }
4596                 v1 = pcm_data[index];
4597                 if(++index < info->ofs_end)
4598                         v2 = pcm_data[index]; // linear interpolation
4599                 else // pcm end // v2 = 0;
4600                         v2 = 0; // linear interpolation
4601         }
4602         return v1 + (v2 - v1) * fp; // linear interpolation
4603 }
4604
4605
4606
4607 /* LFO */
4608 /*
4609 out mode0 = -1.0 ~ 1.0
4610 out mode1 = 0.0 ~ 1.0
4611 */
4612
4613 static void init_lfo(Info_LFO *info, FLOAT_T freq, FLOAT_T delay_ms, int type, FLOAT_T attack_ms, int mode)
4614 {
4615         if(freq <= 0.0){
4616                 info->out = 0.0;
4617                 return;
4618         }
4619         if(freq < 0.001)
4620                 freq = 0.001;
4621         else if(freq > 100.0)
4622                 freq = 40.0; // safe sr>22050,cnt<256
4623         info->freq = freq * div_is_sample_rate;
4624         if(delay_ms < 0)
4625                 delay_ms = 0;
4626         info->delay = delay_ms * is_sample_rate_ms ;
4627         if(attack_ms < 0)
4628                 attack_ms = 0;
4629         init_envelope3(&info->env, 0.0, attack_ms * is_sample_rate_ms);
4630         reset_envelope3(&info->env, 1.0, ENVELOPE_KEEP);
4631         info->osc_ptr = compute_osc[check_is_osc_wave_type(type, OSC_NOISE_LOWBIT)]; // check OSC_LIST
4632         info->mode = mode > 0 ? 1 : 0;
4633         info->rate = 0;
4634         info->cycle = 0;
4635         info->out = 0.0;
4636 }
4637
4638 static void compute_lfo(Info_LFO *info, int32 count)
4639 {
4640         FLOAT_T ov;
4641         if(info->freq <= 0.0)
4642                 return;
4643         if(info->delay > 0){
4644                 info->delay -= count;
4645                 return;
4646         }
4647         info->rate += info->freq * count; // +1 = 1Hz
4648         if(info->rate >= 1.0){
4649                 FLOAT_T ov = floor(info->rate);
4650                 info->rate -= ov; // reset count
4651                 info->cycle += (int32)ov;
4652                 info->cycle &= 0xFFFF;
4653         }
4654         compute_envelope3(&info->env, count);
4655         if(info->mode)
4656                 info->out = (info->osc_ptr(info->rate, info->cycle) + 1.0) * DIV_2 * info->env.vol; // 0.0~<1.0
4657         else
4658                 info->out = info->osc_ptr(info->rate, info->cycle) * info->env.vol; // -1.0~1.0
4659 }
4660
4661
4662
4663 /* OP */
4664 /*
4665
4666 in = -1.0 ~ 1.0
4667 out = -1.0 ~ 1.0
4668 */
4669
4670 static inline void op_filter(FilterCoefficients *fc, FLOAT_T *inout)
4671 {
4672         DATA_T flt = *inout;
4673         sample_filter(fc, &flt);
4674         *inout = flt;
4675 }
4676
4677 #define RESET_OP_RATE \
4678         if(info->sync) { \
4679                 info->sync = 0; \
4680                 info->rate = 0.0; \
4681                 info->cycle = 0; \
4682                 if(info->update_width == 1) info->update_width = 2; \
4683         } else { \
4684                 FLOAT_T ov = floor(info->rate); \
4685                 if(ov != 0.0){ \
4686                         info->rate -= ov; \
4687                         info->cycle += (int32)ov; \
4688                         info->cycle &= 0xFFFF; \
4689                         if(info->update_width == 1) info->update_width = 2; \
4690                 } \
4691         } \
4692
4693 static inline FLOAT_T calc_op_width(Info_OP *info, FLOAT_T rate)
4694 {
4695         if(info->update_width == 2){
4696                 info->update_width = 0;
4697                 info->wave_width1 =     info->req_wave_width1;
4698                 info->rate_width1 =     info->req_rate_width1;
4699                 info->rate_width2 =     info->req_rate_width2;
4700         }
4701         if(info->wave_width1 == 0.5)
4702                 return rate;
4703         else if(rate < info->wave_width1)
4704                 return rate * info->rate_width1;
4705         else
4706                 return 0.5 + (rate - info->wave_width1) * info->rate_width2;
4707 }
4708
4709 static inline void compute_op_output(Info_OP *info, FLOAT_T out)
4710 {
4711         // ptr_connect = out , op->in , dummy
4712 #if (MMS_OP_CON_MAX == 4)
4713         *info->ptr_connect[0] += out;
4714         *info->ptr_connect[1] += out;
4715         *info->ptr_connect[2] += out;
4716         *info->ptr_connect[3] += out;
4717 #else
4718         int j;
4719         for(j = 0; j < MMS_OP_CON_MAX; j++)
4720                 *info->ptr_connect[j] += out;
4721 #endif
4722 }
4723
4724 static inline void compute_op_sync(Info_OP *info)
4725 {
4726         info->rate += info->freq; // +1/sr = 1Hz
4727         if(info->rate < 1.0)
4728                 return;
4729         info->rate -= floor(info->rate); // reset count
4730         // ptr_connect = op->sync , dummy
4731 #if (MMS_OP_CON_MAX == 4)
4732         *info->ptr_connect[0] = 1.0;
4733         *info->ptr_connect[1] = 1.0;
4734         *info->ptr_connect[2] = 1.0;
4735         *info->ptr_connect[3] = 1.0;
4736 #else
4737         int j;
4738         for(j = 0; j < MMS_OP_CON_MAX; j++)
4739                 *info->ptr_connect[j] = 1.0;
4740 #endif
4741 }
4742
4743 static inline void compute_op_clip(Info_OP *info)
4744 {
4745         FLOAT_T in = info->in;
4746
4747         info->in = 0.0; // clear
4748         if(in > info->efx_var1)
4749                 in = info->efx_var1;
4750         else if(in < -info->efx_var1)
4751                 in = -info->efx_var1;
4752         op_filter(&info->fc, &in);
4753         compute_op_output(info, in * info->amp_vol); // include info->op_level
4754 }
4755
4756 static inline void compute_op_lowbit(Info_OP *info)
4757 {
4758         FLOAT_T in = info->in;
4759         int32 tmp;
4760
4761         info->in = 0.0; // clear
4762         tmp = in * info->efx_var1;
4763         in = (FLOAT_T)tmp * info->efx_var2;
4764         op_filter(&info->fc, &in);
4765         compute_op_output(info, in * info->amp_vol); // include info->op_level
4766 }
4767
4768
4769
4770
4771 static inline void compute_op_null(Info_OP *info){}
4772
4773 static inline void compute_op_wave_none(Info_OP *info)
4774 {
4775         FLOAT_T osc, lfo1, lfo2;
4776
4777         info->in = 0.0; // clear
4778         info->rate += info->freq; // +1/sr = 1Hz
4779         RESET_OP_RATE
4780         osc = info->osc_ptr(calc_op_width(info, info->rate), info->cycle);
4781         op_filter(&info->fc, &osc);
4782         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4783 }
4784
4785 static inline void compute_op_wave_fm(Info_OP *info)
4786 {
4787         FLOAT_T osc, rt;
4788         FLOAT_T in = info->in;
4789
4790         info->in = 0.0; // clear
4791         info->rate += info->freq * (1.0 + (FLOAT_T)in * info->mod_level); // +1/sr = 1Hz;
4792         RESET_OP_RATE
4793         osc = info->osc_ptr(calc_op_width(info, info->rate), info->cycle);
4794         op_filter(&info->fc, &osc);
4795         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4796 }
4797
4798 static inline void compute_op_wave_am(Info_OP *info)
4799 {
4800         FLOAT_T osc;
4801         FLOAT_T in = info->in;
4802
4803         info->in = 0.0; // clear
4804         info->rate += info->freq; // +1/sr = 1Hz
4805         RESET_OP_RATE
4806         osc = info->osc_ptr(calc_op_width(info, info->rate), info->cycle);
4807         osc *= (1.0 - ((FLOAT_T)in * DIV_2 + 0.5) * info->mod_level);
4808         op_filter(&info->fc, &osc);
4809         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4810 }
4811
4812 static inline void compute_op_wave_pm(Info_OP *info)
4813 {
4814         FLOAT_T osc, rt;
4815         FLOAT_T in = info->in; //
4816
4817         info->in = 0.0; // clear
4818         info->rate += info->freq; // +1/sr = 1Hz
4819         RESET_OP_RATE
4820         rt = info->rate + ((FLOAT_T)in * info->mod_level); // mod level;
4821         rt -= floor(rt);
4822         osc = info->osc_ptr(calc_op_width(info, rt), info->cycle);
4823         op_filter(&info->fc, &osc);
4824         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4825 }
4826
4827 static inline void compute_op_wave_ampm(Info_OP *info)
4828 {
4829         FLOAT_T osc, rt;
4830         FLOAT_T in = info->in; //
4831
4832         info->in = 0.0; // clear
4833         info->rate += info->freq; // +1/sr = 1Hz
4834         RESET_OP_RATE
4835         rt = info->rate + ((FLOAT_T)in * info->mod_level); // mod level;
4836         rt -= floor(rt);
4837         osc = info->osc_ptr(calc_op_width(info, rt), info->cycle);
4838         osc *= (1.0 - ((FLOAT_T)in * DIV_2 + 0.5) * info->mod_level);
4839         op_filter(&info->fc, &osc);
4840         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4841 }
4842
4843 static inline void compute_op_wave_rm(Info_OP *info)
4844 {
4845         FLOAT_T osc;
4846         FLOAT_T in = info->in;
4847
4848         info->in = 0.0; // clear
4849         info->rate += info->freq; // +1/sr = 1Hz
4850         RESET_OP_RATE
4851         osc = info->osc_ptr(calc_op_width(info, info->rate), info->cycle);
4852         op_filter(&info->fc, &osc);
4853         osc *= 1.0 + (in - 1.0) * info->mod_level; // rm
4854         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4855 }
4856
4857 static inline void compute_op_wave_sync(Info_OP *info)
4858 {
4859         compute_op_sync(info);
4860 }
4861
4862 static inline void compute_op_wave_clip(Info_OP *info)
4863 {
4864         compute_op_clip(info);
4865 }
4866
4867 static inline void compute_op_wave_lowbit(Info_OP *info)
4868 {
4869         compute_op_lowbit(info);
4870 }
4871
4872 static inline void compute_op_scc_none(Info_OP *info)
4873 {
4874         FLOAT_T osc, lfo1, lfo2;
4875
4876         info->in = 0.0; // clear
4877         info->rate += info->freq; // +1/sr = 1Hz
4878         RESET_OP_RATE
4879         osc = info->scc_ptr(calc_op_width(info, info->rate), info->data_ptr);
4880         op_filter(&info->fc, &osc);
4881         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4882 }
4883
4884 static inline void compute_op_scc_fm(Info_OP *info)
4885 {
4886         FLOAT_T osc, rt;
4887         FLOAT_T in = info->in;
4888
4889         info->in = 0.0; // clear
4890         info->rate += info->freq * (1.0 + (FLOAT_T)in * info->mod_level); // +1/sr = 1Hz;
4891         RESET_OP_RATE
4892         osc = info->scc_ptr(calc_op_width(info, info->rate), info->data_ptr);
4893         op_filter(&info->fc, &osc);
4894         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4895 }
4896
4897 static inline void compute_op_scc_am(Info_OP *info)
4898 {
4899         FLOAT_T osc;
4900         FLOAT_T in = info->in;
4901
4902         info->in = 0.0; // clear
4903         info->rate += info->freq; // +1/sr = 1Hz
4904         RESET_OP_RATE
4905         osc = info->scc_ptr(calc_op_width(info, info->rate), info->data_ptr);
4906         osc *= (1.0 - ((FLOAT_T)in * DIV_2 + 0.5) * info->mod_level);
4907         op_filter(&info->fc, &osc);
4908         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4909 }
4910
4911 static inline void compute_op_scc_pm(Info_OP *info)
4912 {
4913         FLOAT_T osc, rt;
4914         FLOAT_T in = info->in; //
4915
4916         info->in = 0.0; // clear
4917         info->rate += info->freq; // +1/sr = 1Hz
4918         RESET_OP_RATE
4919         rt = info->rate + ((FLOAT_T)in * info->mod_level); // mod level;
4920         rt -= floor(rt);
4921         osc = info->scc_ptr(calc_op_width(info, rt), info->data_ptr);
4922         op_filter(&info->fc, &osc);
4923         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4924 }
4925
4926 static inline void compute_op_scc_ampm(Info_OP *info)
4927 {
4928         FLOAT_T osc, rt;
4929         FLOAT_T in = info->in; //
4930
4931         info->in = 0.0; // clear
4932         info->rate += info->freq; // +1/sr = 1Hz
4933         RESET_OP_RATE
4934         rt = info->rate + in * info->mod_level; // mod level;
4935         if(rt >= 1.0)
4936                 rt -= floor(rt);
4937         else if(rt < 0.0)
4938                 rt += floor(rt);
4939         osc = info->scc_ptr(calc_op_width(info, rt), info->data_ptr);
4940         osc *= (1.0 - ((FLOAT_T)in * DIV_2 + 0.5) * info->mod_level);
4941         op_filter(&info->fc, &osc);
4942         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4943 }
4944
4945 static inline void compute_op_scc_rm(Info_OP *info)
4946 {
4947         FLOAT_T osc;
4948         FLOAT_T in = info->in;
4949
4950         info->in = 0.0; // clear
4951         info->rate += info->freq; // +1/sr = 1Hz
4952         RESET_OP_RATE
4953         osc = info->scc_ptr(calc_op_width(info, info->rate), info->data_ptr);
4954         op_filter(&info->fc, &osc);
4955         osc *= 1.0 + (in - 1.0) * info->mod_level; // rm
4956         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4957 }
4958
4959 static inline void compute_op_scc_sync(Info_OP *info)
4960 {
4961         compute_op_sync(info);
4962 }
4963
4964 static inline void compute_op_scc_clip(Info_OP *info)
4965 {
4966         compute_op_clip(info);
4967 }
4968
4969 static inline void compute_op_scc_lowbit(Info_OP *info)
4970 {
4971         compute_op_lowbit(info);
4972 }
4973
4974 static inline void compute_op_pcm_none(Info_OP *info)
4975 {
4976         FLOAT_T osc;
4977
4978         info->in = 0.0; // clear
4979         info->pcm_rate = info->rate += info->freq; // +1/sr*pcm_rate/root_freq = 1Hz
4980         osc = compute_pcm_linear(info);
4981         op_filter(&info->fc, &osc);
4982         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4983 }
4984
4985 static inline void compute_op_pcm_fm(Info_OP *info)
4986 {
4987         FLOAT_T osc;
4988         FLOAT_T in = info->in; //
4989
4990         info->in = 0.0; // clear
4991         info->rate += info->freq * (1.0 + (FLOAT_T)in * info->mod_level); // +1/sr*pcm_rate/root_freq = 1Hz
4992         osc = compute_pcm_linear(info);
4993         op_filter(&info->fc, &osc);
4994         compute_op_output(info, osc * info->amp_vol); // include info->op_level
4995 }
4996
4997 static inline void compute_op_pcm_am(Info_OP *info)
4998 {
4999         FLOAT_T osc;
5000         FLOAT_T in = info->in; //
5001
5002         info->in = 0.0; // clear
5003         info->pcm_rate = info->rate += info->freq; // +1/sr*pcm_rate/root_freq = 1Hz
5004         osc = compute_pcm_linear(info);
5005         op_filter(&info->fc, &osc);
5006         compute_op_output(info, osc * info->amp_vol); // include info->op_level
5007 }
5008
5009 static inline void compute_op_pcm_pm(Info_OP *info)
5010 {
5011         FLOAT_T osc;
5012         FLOAT_T in = info->in; //
5013
5014         info->in = 0.0; // clear
5015         info->rate += info->freq; // +1/sr*pcm_rate/root_freq = 1Hz
5016         info->pcm_rate = info->rate + in * info->mod_level * info->pcm_cycle; // mod level;
5017         osc = compute_pcm_linear(info);
5018         osc *= (1.0 - ((FLOAT_T)in * DIV_2 + 0.5) * info->mod_level);
5019         op_filter(&info->fc, &osc);
5020         compute_op_output(info, osc * info->amp_vol); // include info->op_level
5021 }
5022
5023 static inline void compute_op_pcm_ampm(Info_OP *info)
5024 {
5025         FLOAT_T osc;
5026         FLOAT_T in = info->in; //
5027
5028         info->in = 0.0; // clear
5029         info->rate += info->freq; // +1/sr*pcm_rate/root_freq = 1Hz
5030         info->pcm_rate = info->rate + in * info->mod_level * info->pcm_cycle; // mod level;
5031         osc = compute_pcm_linear(info);
5032         osc *= (1.0 - ((FLOAT_T)in * DIV_2 + 0.5) * info->mod_level);
5033         op_filter(&info->fc, &osc);
5034         compute_op_output(info, osc * info->amp_vol); // include info->op_level
5035 }
5036
5037 static inline void compute_op_pcm_rm(Info_OP *info)
5038 {
5039         FLOAT_T osc;
5040         FLOAT_T in = info->in; //
5041
5042         info->in = 0.0; // clear
5043         info->pcm_rate = info->rate += info->freq; // +1/sr*pcm_rate/root_freq = 1Hz
5044         osc = compute_pcm_linear(info);
5045         op_filter(&info->fc, &osc);
5046         osc *= 1.0 + (in - 1.0) * info->mod_level; // rm
5047         compute_op_output(info, osc * info->amp_vol); // include info->op_level
5048 }
5049
5050 static inline void compute_op_pcm_sync(Info_OP *info)
5051 {
5052         compute_op_sync(info);
5053 }
5054
5055 static inline void compute_op_pcm_clip(Info_OP *info)
5056 {
5057         compute_op_clip(info);
5058 }
5059
5060 static inline void compute_op_pcm_lowbit(Info_OP *info)
5061 {
5062         compute_op_lowbit(info);
5063 }
5064
5065
5066 compute_op_t compute_op[4][OP_LIST_MAX] = {
5067 // cfg sort
5068         {// WAVE
5069                 compute_op_wave_none,
5070                 compute_op_wave_fm,
5071                 compute_op_wave_am,
5072                 compute_op_wave_pm,
5073                 compute_op_wave_ampm,
5074                 compute_op_wave_rm,
5075                 compute_op_wave_sync,
5076                 compute_op_wave_clip,
5077                 compute_op_wave_lowbit,
5078         },{ // SCC
5079                 compute_op_scc_none,
5080                 compute_op_scc_fm,
5081                 compute_op_scc_am,
5082                 compute_op_scc_pm,
5083                 compute_op_scc_ampm,
5084                 compute_op_scc_rm,
5085                 compute_op_scc_sync,
5086                 compute_op_scc_clip,
5087                 compute_op_scc_lowbit,
5088         },{ // MT32
5089                 compute_op_pcm_none,
5090                 compute_op_pcm_fm,
5091                 compute_op_pcm_am,
5092                 compute_op_pcm_pm,
5093                 compute_op_pcm_ampm,
5094                 compute_op_pcm_rm,
5095                 compute_op_pcm_sync,
5096                 compute_op_pcm_clip,
5097                 compute_op_pcm_lowbit,
5098         },{ // CM32L
5099                 compute_op_pcm_none,
5100                 compute_op_pcm_fm,
5101                 compute_op_pcm_am,
5102                 compute_op_pcm_pm,
5103                 compute_op_pcm_ampm,
5104                 compute_op_pcm_rm,
5105                 compute_op_pcm_sync,
5106                 compute_op_pcm_clip,
5107                 compute_op_pcm_lowbit,
5108         },
5109 };
5110
5111
5112
5113 #define COMP_OP_NUM (*com_ptr++)(inf_ptr++)
5114
5115 static inline FLOAT_T compute_op_num0(InfoIS_MMS *info)
5116 {
5117         return 0;
5118 }
5119
5120 static inline FLOAT_T compute_op_num1(InfoIS_MMS *info)
5121 {
5122         info->out = 0.0;
5123         info->op_ptr[0](&info->op[0]);
5124         return info->out;
5125 }
5126
5127 static inline FLOAT_T compute_op_num2(InfoIS_MMS *info)
5128 {
5129         compute_op_t *com_ptr = &info->op_ptr[0];
5130         Info_OP *inf_ptr = &info->op[0];
5131
5132         info->out = 0.0;
5133         COMP_OP_NUM; COMP_OP_NUM;
5134         return info->out;
5135 }
5136
5137 static inline FLOAT_T compute_op_num3(InfoIS_MMS *info)
5138 {
5139         compute_op_t *com_ptr = &info->op_ptr[0];
5140         Info_OP *inf_ptr = &info->op[0];
5141
5142         info->out = 0.0;
5143         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5144         return info->out;
5145 }
5146
5147 static inline FLOAT_T compute_op_num4(InfoIS_MMS *info)
5148 {
5149         compute_op_t *com_ptr = &info->op_ptr[0];
5150         Info_OP *inf_ptr = &info->op[0];
5151
5152         info->out = 0.0;
5153         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5154         return info->out;
5155 }
5156
5157 static inline FLOAT_T compute_op_num5(InfoIS_MMS *info)
5158 {
5159         compute_op_t *com_ptr = &info->op_ptr[0];
5160         Info_OP *inf_ptr = &info->op[0];
5161
5162         info->out = 0.0;
5163         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5164         return info->out;
5165 }
5166
5167 static inline FLOAT_T compute_op_num6(InfoIS_MMS *info)
5168 {
5169         compute_op_t *com_ptr = &info->op_ptr[0];
5170         Info_OP *inf_ptr = &info->op[0];
5171
5172         info->out = 0.0;
5173         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5174         return info->out;
5175 }
5176
5177 static inline FLOAT_T compute_op_num7(InfoIS_MMS *info)
5178 {
5179         compute_op_t *com_ptr = &info->op_ptr[0];
5180         Info_OP *inf_ptr = &info->op[0];
5181
5182         info->out = 0.0;
5183         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5184         return info->out;
5185 }
5186
5187 static inline FLOAT_T compute_op_num8(InfoIS_MMS *info)
5188 {
5189         compute_op_t *com_ptr = &info->op_ptr[0];
5190         Info_OP *inf_ptr = &info->op[0];
5191
5192         info->out = 0.0;
5193         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5194         return info->out;
5195 }
5196
5197 static inline FLOAT_T compute_op_num9(InfoIS_MMS *info)
5198 {
5199         compute_op_t *com_ptr = &info->op_ptr[0];
5200         Info_OP *inf_ptr = &info->op[0];
5201
5202         info->out = 0.0;
5203         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5204         COMP_OP_NUM;
5205         return info->out;
5206 }
5207
5208 static inline FLOAT_T compute_op_num10(InfoIS_MMS *info)
5209 {
5210         compute_op_t *com_ptr = &info->op_ptr[0];
5211         Info_OP *inf_ptr = &info->op[0];
5212
5213         info->out = 0.0;
5214         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5215         COMP_OP_NUM; COMP_OP_NUM;
5216         return info->out;
5217 }
5218
5219 static inline FLOAT_T compute_op_num11(InfoIS_MMS *info)
5220 {
5221         compute_op_t *com_ptr = &info->op_ptr[0];
5222         Info_OP *inf_ptr = &info->op[0];
5223
5224         info->out = 0.0;
5225         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5226         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5227         return info->out;
5228 }
5229
5230 static inline FLOAT_T compute_op_num12(InfoIS_MMS *info)
5231 {
5232         compute_op_t *com_ptr = &info->op_ptr[0];
5233         Info_OP *inf_ptr = &info->op[0];
5234
5235         info->out = 0.0;
5236         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5237         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5238         return info->out;
5239 }
5240
5241 static inline FLOAT_T compute_op_num13(InfoIS_MMS *info)
5242 {
5243         compute_op_t *com_ptr = &info->op_ptr[0];
5244         Info_OP *inf_ptr = &info->op[0];
5245
5246         info->out = 0.0;
5247         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5248         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5249         return info->out;
5250 }
5251
5252 static inline FLOAT_T compute_op_num14(InfoIS_MMS *info)
5253 {
5254         compute_op_t *com_ptr = &info->op_ptr[0];
5255         Info_OP *inf_ptr = &info->op[0];
5256
5257         info->out = 0.0;
5258         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5259         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5260         return info->out;
5261 }
5262
5263 static inline FLOAT_T compute_op_num15(InfoIS_MMS *info)
5264 {
5265         compute_op_t *com_ptr = &info->op_ptr[0];
5266         Info_OP *inf_ptr = &info->op[0];
5267
5268         info->out = 0.0;
5269         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5270         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5271         return info->out;
5272 }
5273
5274 static inline FLOAT_T compute_op_num16(InfoIS_MMS *info)
5275 {
5276         compute_op_t *com_ptr = &info->op_ptr[0];
5277         Info_OP *inf_ptr = &info->op[0];
5278
5279         info->out = 0.0;
5280         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5281         COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM; COMP_OP_NUM;
5282         return info->out;
5283 }
5284
5285 compute_op_num_t compute_op_num[] = {
5286         compute_op_num0,
5287         compute_op_num1,
5288         compute_op_num2,
5289         compute_op_num3,
5290         compute_op_num4,
5291         compute_op_num5,
5292         compute_op_num6,
5293         compute_op_num7,
5294         compute_op_num8,
5295         compute_op_num9,
5296         compute_op_num10,
5297         compute_op_num11,
5298         compute_op_num12,
5299         compute_op_num13,
5300         compute_op_num14,
5301         compute_op_num15,
5302         compute_op_num16,
5303 };
5304
5305
5306
5307
5308 //////// synth
5309
5310
5311
5312 //// SCC
5313 static void set_envelope_param_scc(Envelope0 *env, int32 *envp, int up, int down, FLOAT_T atk_delay)
5314 {
5315         FLOAT_T ofs, cnt, tmpf;
5316
5317         // init
5318         init_envelope0(env);
5319         // ENV0_END_STAGE
5320         env->rate[ENV0_END_STAGE] = (FLOAT_T)ENV0_OFFSET_MAX;
5321         env->offset[ENV0_END_STAGE] = 0;
5322         // ENV0_ATTACK_STAGE
5323         ofs = (FLOAT_T)ENV0_OFFSET_MAX * envp[1] * DIV_100; // env level
5324         cnt = (FLOAT_T)envp[0] * is_sample_rate_ms; // env time
5325         if(cnt == 0.0) {cnt = is_sample_rate_ms;}
5326         if(ofs > ENV0_OFFSET_MAX) {ofs = ENV0_OFFSET_MAX;}
5327         else if(ofs < 1) {ofs = 1;}
5328         env->offset[ENV0_ATTACK_STAGE] = ofs;
5329         env->curve[ENV0_ATTACK_STAGE] = up;
5330         env->rate[ENV0_ATTACK_STAGE] = ofs / cnt;
5331         // ENV0_HOLD_STAGE
5332         ofs = (FLOAT_T)ENV0_OFFSET_MAX * envp[3] * DIV_100; // env level
5333         cnt = (FLOAT_T)envp[2] * is_sample_rate_ms; // env time
5334         if(cnt == 0.0) {cnt = is_sample_rate_ms;}
5335         if(ofs > ENV0_OFFSET_MAX) {ofs = ENV0_OFFSET_MAX;}
5336         else if(ofs < 0) {ofs = 0;}
5337         env->offset[ENV0_HOLD_STAGE] = ofs;
5338         ofs -= env->offset[ENV0_ATTACK_STAGE];
5339         if(ofs == 0.0) {ofs = -1.0; env->count[ENV0_HOLD_STAGE] = cnt;}
5340         env->curve[ENV0_HOLD_STAGE] = (ofs > 0.0) ? up : down;
5341         env->rate[ENV0_HOLD_STAGE] = fabs(ofs) / cnt;
5342         // ENV0_DECAY_STAGE
5343         ofs = (FLOAT_T)ENV0_OFFSET_MAX * envp[5] * DIV_100; // env level
5344         cnt = (FLOAT_T)envp[4] * is_sample_rate_ms; // env time
5345         if(cnt == 0.0) {cnt = is_sample_rate_ms;}
5346         if(ofs > ENV0_OFFSET_MAX) {ofs = ENV0_OFFSET_MAX;}
5347         else if(ofs < 0) {ofs = 0;}
5348         env->offset[ENV0_DECAY_STAGE] = ofs;
5349         ofs -= env->offset[ENV0_HOLD_STAGE];
5350         if(ofs == 0.0) {ofs = -1.0; env->count[ENV0_DECAY_STAGE] = cnt;}
5351         env->curve[ENV0_DECAY_STAGE] = (ofs > 0.0) ? up : down;
5352         env->rate[ENV0_DECAY_STAGE] = fabs(ofs) / cnt;
5353         // ENV0_SUSTAIN_STAGE
5354         env->offset[ENV0_SUSTAIN_STAGE] = 0; // env level
5355         ofs = env->offset[ENV0_HOLD_STAGE];
5356         cnt = (FLOAT_T)600000.0 * is_sample_rate_ms; // env time
5357         env->count[ENV0_SUSTAIN_STAGE] = cnt;
5358         env->curve[ENV0_SUSTAIN_STAGE] = down;
5359         env->rate[ENV0_SUSTAIN_STAGE] = ofs / cnt;
5360         env->follow[ENV0_SUSTAIN_STAGE] = 1.0;
5361         // ENV0_RELEASE1_STAGE
5362         ofs = (FLOAT_T)ENV0_OFFSET_MAX * envp[7] * DIV_100; // env level
5363         cnt = (FLOAT_T)envp[6] * is_sample_rate_ms; // env time
5364         if(cnt == 0.0) {cnt = is_sample_rate_ms;}
5365         if(ofs > ENV0_OFFSET_MAX) {ofs = ENV0_OFFSET_MAX;}
5366         else if(ofs < 0) {ofs = 0;}
5367         env->offset[ENV0_RELEASE1_STAGE] = ofs;
5368         ofs = (FLOAT_T)ENV0_OFFSET_MAX; // release1
5369         env->curve[ENV0_RELEASE1_STAGE] = down;
5370         env->rate[ENV0_RELEASE1_STAGE] = fabs(ofs) / cnt;
5371         // ENV0_RELEASE2_STAGE
5372         ofs = (FLOAT_T)ENV0_OFFSET_MAX * envp[9] * DIV_100; // env level
5373         cnt = (FLOAT_T)envp[8] * is_sample_rate_ms; // env time
5374         if(cnt == 0.0) {cnt = is_sample_rate_ms;}
5375         if(ofs > ENV0_OFFSET_MAX) {ofs = ENV0_OFFSET_MAX;}
5376         else if(ofs < 0) {ofs = 0;}
5377         env->offset[ENV0_RELEASE2_STAGE] = ofs;
5378         ofs -= env->offset[ENV0_RELEASE1_STAGE];
5379         if(ofs == 0.0) {ofs = -1.0; env->count[ENV0_RELEASE2_STAGE] = cnt;}
5380         env->curve[ENV0_RELEASE2_STAGE] = (ofs > 0.0) ? up : down;
5381         env->rate[ENV0_RELEASE2_STAGE] = fabs(ofs) / cnt;
5382         // ENV0_RELEASE3_STAGE
5383         ofs = (FLOAT_T)ENV0_OFFSET_MAX * envp[11] * DIV_100; // env level
5384         cnt = (FLOAT_T)envp[10] * is_sample_rate_ms; // env time
5385         if(cnt == 0.0) {cnt = is_sample_rate_ms;}
5386         if(ofs > ENV0_OFFSET_MAX) {ofs = ENV0_OFFSET_MAX;}
5387         else if(ofs < 0) {ofs = 0;}
5388         env->offset[ENV0_RELEASE3_STAGE] = ofs;
5389         ofs -= env->offset[ENV0_RELEASE2_STAGE];
5390         if(ofs == 0.0) {ofs = -1.0; env->count[ENV0_RELEASE3_STAGE] = cnt;}
5391         env->curve[ENV0_RELEASE3_STAGE] = (ofs > 0.0) ? up : down;
5392         env->rate[ENV0_RELEASE3_STAGE] = fabs(ofs) / cnt;
5393         // ENV0_RELEASE4_STAGE
5394         env->offset[ENV0_RELEASE4_STAGE] = ofs = 0; // env level
5395         cnt = (FLOAT_T)10.0 * is_sample_rate_ms; // env time
5396         ofs -= env->offset[ENV0_RELEASE3_STAGE];
5397         if(ofs == 0.0) {ofs = -1.0;}
5398         env->curve[ENV0_RELEASE4_STAGE] = down;
5399         env->rate[ENV0_RELEASE4_STAGE] = fabs(ofs) / cnt;
5400         // set delay
5401         env->delay = (atk_delay + (FLOAT_T)envp[12]) * is_sample_rate_ms;
5402         env->offdelay = (atk_delay + (FLOAT_T)envp[13]) * is_sample_rate_ms;
5403         // apply
5404         apply_envelope0_param(env);
5405 }
5406
5407 static inline void init_scc_preset(int v, InfoIS_SCC *info, Preset_IS *is_set, int preset)
5408 {
5409         Preset_SCC *set = scc_editor_override ? &scc_setting_edit[0] : is_set->scc_setting[preset];
5410         int tmpi;
5411         FLOAT_T tmpf;
5412
5413         if(set == NULL){
5414                 info->init = 0;
5415                 return;
5416         }
5417         info->init = 1;
5418
5419         // param
5420         tmpi = set->param[0]; // param0= output_level
5421         if(tmpi < 1)
5422                 tmpi = 100;
5423         info->output_level = (FLOAT_T)tmpi * DIV_100;
5424         // osc
5425         tmpi = set->osc[1]; // osc1= freq / mlt
5426         tmpf = set->osc[2]; // osc2=tune cent
5427         tmpf += (FLOAT_T)calc_random_param(-400, 400) * DIV_100; // auto detune
5428         switch(set->osc[0]){ // osc0= mode 0:OSC(%) 1:OSC(ppm) 2:OSC(mHz) 3:OSC(note)
5429         default:
5430         case 0: // var cent
5431                 info->mode = 0;
5432                 if(tmpi < 1)
5433                         tmpi = 100;
5434                 info->freq_mlt = (FLOAT_T)tmpi * DIV_100 * voice[v].sample->tune; // % to mlt
5435                 info->freq_mlt *= POW2(tmpf * DIV_1200); // osc2=tune  // cent to mlt
5436                 info->freq = (FLOAT_T)voice[v].frequency * DIV_1000 * info->freq_mlt;
5437                 break;
5438         case 1: // var ppm
5439                 info->mode = 0;
5440                 if(tmpi < 1)
5441                         tmpi = 1000000;
5442                 info->freq_mlt = (FLOAT_T)tmpi * DIV_1000000 * voice[v].sample->tune; // ppm to mlt
5443                 info->freq_mlt *= POW2(tmpf * DIV_1200); // osc2=tune  // cent to mlt
5444                 info->freq = (FLOAT_T)voice[v].frequency * DIV_1000 * info->freq_mlt;
5445                 break;
5446         case 2: // fix mHz
5447                 info->mode = 1;
5448                 if(tmpi < 1)
5449                         tmpi = 1;
5450                 info->freq_mlt = (FLOAT_T)tmpi * DIV_1000 * voice[v].sample->tune; // mHz to Hz
5451                 info->freq_mlt *= POW2(tmpf * DIV_1200); // osc2=tune  // cent to mlt
5452                 info->freq = info->freq_mlt;
5453                 break;
5454         case 3: // fix note
5455                 info->mode = 1;
5456                 if(tmpi < 0)
5457                         tmpi = 0;
5458                 else if(tmpi > 127)
5459                         tmpi = 127;
5460                 info->freq_mlt = (FLOAT_T)freq_table[tmpi] * DIV_1000 * voice[v].sample->tune; // note to Hz
5461                 info->freq_mlt *= POW2(tmpf * DIV_1200); // osc2=tune  // cent to mlt
5462                 info->freq = info->freq_mlt;
5463                 break;
5464         }
5465         tmpi = set->osc[3]; // osc3= SCC_DATA
5466         if(scc_data_editor_override){ // IS_EDITOR
5467                 info->data_ptr = scc_data_edit[0];
5468         }else if(tmpi < 0){ // noise
5469                 info->data_ptr = NULL;
5470         }else{
5471                 if(tmpi >= SCC_DATA_MAX)
5472                         tmpi = 0;
5473                 info->data_ptr = is_set->scc_data[tmpi];
5474         }
5475         info->rate = 0;
5476         info->cycle = 0;
5477         // amp
5478         tmpi = set->amp[0]; // amp0= lfo1 to amp
5479         if(tmpi < 0)
5480                 tmpi = 0;
5481         else if(tmpi > 100)
5482                 tmpi = 100;
5483         info->lfo_amp = (FLOAT_T)tmpi * DIV_100;
5484         // pitch
5485         info->lfo_pitch = (FLOAT_T)set->pitch[0] * DIV_1200; // pitch0= lfo2 to freq cent
5486         info->env_pitch = (FLOAT_T)set->pitch[1] * DIV_1200; // pitch1= env to freq cent
5487         info->pitch = 1.0;
5488         // ampenv
5489         tmpf = (FLOAT_T)calc_random_param(0, 400) * DIV_100; // attack delay
5490         set_envelope_param_scc(&info->amp_env, set->ampenv, LINEAR_CURVE, DEF_VOL_CURVE, tmpf);
5491         // pitenv
5492         set_envelope_param_scc(&info->pit_env, set->pitenv, LINEAR_CURVE, LINEAR_CURVE, tmpf);
5493         // lfo1
5494         if(info->lfo_amp != 0.0)
5495                 init_lfo(&info->lfo1, (FLOAT_T)set->lfo1[0] * DIV_100, set->lfo1[1], set->lfo1[2], set->lfo1[3], 1);
5496         // lfo2
5497         if(info->lfo_pitch != 0.0)
5498                 init_lfo(&info->lfo2, (FLOAT_T)set->lfo2[0] * DIV_100, set->lfo2[1], set->lfo2[2], set->lfo2[3], 0);
5499         // other
5500         info->scc_flag = 1;
5501         // resample
5502         is_resample_init(&info->rs);
5503
5504         info->thru_count = -1; // init
5505
5506 }
5507
5508 static void noteoff_scc(InfoIS_SCC *info)
5509 {
5510         if(!info->init) return;
5511         reset_envelope0_release(&info->amp_env, ENV0_KEEP);
5512         reset_envelope0_release(&info->pit_env, ENV0_KEEP);
5513 }
5514
5515 static void damper_scc(InfoIS_SCC *info, int8 damper)
5516 {
5517         if(!info->init) return;
5518         reset_envelope0_damper(&info->amp_env, damper);
5519         reset_envelope0_damper(&info->pit_env, damper);
5520 }
5521
5522 static void pre_compute_scc(InfoIS_SCC *info, int v, int32 count)
5523 {
5524         Voice *vp = voice + v;
5525         FLOAT_T amp = 1.0, pitch = 0.0;
5526         int scount, thru_flg;
5527
5528         if(info->scc_flag == 0){ // scc off
5529                 vp->finish_voice = 1;
5530                 return;
5531         }
5532         // amp
5533         compute_envelope0(&info->amp_env, count);
5534         if(!check_envelope0(&info->amp_env)){ // amp_env end
5535                 info->amp_vol = 0.0;
5536                 info->scc_flag = 0; // scc off
5537                 vp->finish_voice = 1;
5538                 return;
5539         }
5540         // thru count
5541         if(thru_count_mlt > 1){
5542                 scount = count * thru_count_mlt;
5543                 if((++info->thru_count) >= thru_count_mlt)
5544                         info->thru_count = 0;
5545                 thru_flg = info->thru_count;
5546         }else{
5547                 scount = count;
5548                 thru_flg = 0;
5549         }
5550         // amp
5551         amp *= info->amp_env.volume;
5552         if(info->lfo_amp > 0.0){
5553                 if(!thru_flg)
5554                         compute_lfo(&info->lfo1, scount);
5555                 amp *= 1.0 - info->lfo1.out * info->lfo_amp;
5556         }
5557         info->amp_vol = floor(amp * 15.0) * DIV_15; // 4bit amp
5558         info->amp_vol *= info->output_level;
5559         if(thru_flg)
5560                 return;
5561
5562         // pitch
5563         if(info->env_pitch != 0.0){
5564                 compute_envelope0(&info->pit_env, scount);
5565                 pitch += info->env_pitch * info->pit_env.volume;
5566         }
5567         if(info->lfo_pitch != 0.0){
5568                 compute_lfo(&info->lfo2, scount);
5569                 pitch += info->lfo_pitch * info->lfo2.out;
5570         }
5571         if(!info->mode)
5572                 info->freq = (FLOAT_T)vp->frequency * DIV_1000 * info->freq_mlt;
5573         else {
5574                 if(vp->pitchfactor)
5575                         info->freq = (FLOAT_T)info->freq_mlt * vp->pitchfactor;
5576                 else
5577                         info->freq = (FLOAT_T)info->freq_mlt;
5578                 info->freq += channel[vp->channel].pitch_offset_fine;
5579         }
5580         info->freq *= POW2(pitch) * div_is_sample_rate; // 1/sr = 1Hz
5581 }
5582
5583 static FLOAT_T compute_scc(InfoIS_SCC *info)
5584 {
5585         info->rate += info->freq; // +1/sr = 1Hz
5586         if(info->data_ptr){
5587                 info->rate -= floor(info->rate);
5588                 return compute_osc_scc_none(info->rate, info->data_ptr) * info->amp_vol;
5589         }else{ // noise
5590                 FLOAT_T ov = floor(info->rate);
5591                 info->rate -= ov;
5592                 info->cycle += (int32)ov;
5593                 info->cycle &= 0xFFFF;
5594                 return lookup_noise_lowbit(info->rate, info->cycle) * info->amp_vol;
5595         }
5596 }
5597
5598 static inline void compute_voice_scc_switch(int v, int32 count, DATA_T *is_buf, IS_RS_DATA_T *rs_buf)
5599 {
5600         Voice *vp = voice + v;
5601         InfoIS_SCC *info = (InfoIS_SCC*)&vp->scc;
5602         int32 i;
5603
5604         if(!info->init){
5605                 memset(is_buf, 0, count * sizeof(DATA_T));
5606         }else if(!is_rs_mode){
5607                 pre_compute_scc(info, v, count);
5608                 for (i = 0; i < count; i++)
5609 #if defined(DATA_T_DOUBLE) || defined(DATA_T_FLOAT)
5610                         is_buf[i] = (DATA_T)compute_scc(info);
5611 #else
5612                         is_buf[i] = (DATA_T)(compute_scc(info) * is_output_level);
5613 #endif
5614         }else{
5615                 IS_RS_DATA_T *rs_buf2 = rs_buf + is_rs_buff_offset;
5616                 Info_Resample *rs = &info->rs;
5617
5618                 is_resample_pre(rs, rs_buf, count);
5619                 pre_compute_scc(info, v, rs->rs_count);
5620                 for (i = 0; i < rs->rs_count; i++)
5621                         rs_buf2[i] = (IS_RS_DATA_T)compute_scc(info);
5622                 is_resample_core(rs, is_buf, rs_buf, count);
5623         }
5624 }
5625
5626
5627
5628 //// MMS
5629 static void set_envelope_param_mms(Envelope0 *env, int32 *envp, int16 *velf, int16 *keyf, int up, int down, FLOAT_T sub_velo, FLOAT_T sub_note)
5630 {
5631         FLOAT_T ofs, cnt;
5632
5633         init_envelope0(env);
5634         env->delay = envp[12] * is_sample_rate_ms;
5635         env->offdelay = envp[13] * is_sample_rate_ms;
5636         // ENV0_END_STAGE
5637         env->rate[ENV0_END_STAGE] = (FLOAT_T)ENV0_OFFSET_MAX;
5638         env->offset[ENV0_END_STAGE] = 0;
5639         // ENV0_ATTACK_STAGE
5640         ofs = (FLOAT_T)ENV0_OFFSET_MAX * envp[1] * DIV_100
5641                 * POW2(((FLOAT_T)sub_velo * velf[1] * DIV_127 * DIV_100) + ((FLOAT_T)sub_note * keyf[1] * DIV_1200)); // env level
5642         cnt = (FLOAT_T)envp[0] * is_sample_rate_ms
5643                 * POW2(((FLOAT_T)sub_velo * velf[0] * DIV_127 * DIV_100) + ((FLOAT_T)sub_note * keyf[0] * DIV_1200)); // env time
5644         if(cnt == 0.0) {cnt = is_sample_rate_ms;}
5645         if(ofs > ENV0_OFFSET_MAX) {ofs = ENV0_OFFSET_MAX;}
5646         else if(ofs < 1) {ofs = 1;}
5647         env->offset[ENV0_ATTACK_STAGE] = ofs;
5648         env->curve[ENV0_ATTACK_STAGE] = up;
5649         env->rate[ENV0_ATTACK_STAGE] = ofs / cnt;
5650         // ENV0_HOLD_STAGE
5651         ofs = (FLOAT_T)ENV0_OFFSET_MAX * envp[3] * DIV_100
5652                 * POW2(((FLOAT_T)sub_velo * velf[3] * DIV_127 * DIV_100) + ((FLOAT_T)sub_note * keyf[3] * DIV_1200)); // env level
5653         cnt = (FLOAT_T)envp[2] * is_sample_rate_ms
5654                 * POW2(((FLOAT_T)sub_velo * velf[2] * DIV_127 * DIV_100) + ((FLOAT_T)sub_note * keyf[2] * DIV_1200)); // env time
5655         if(cnt == 0.0) {cnt = is_sample_rate_ms;}
5656         if(ofs > ENV0_OFFSET_MAX) {ofs = ENV0_OFFSET_MAX;}
5657         else if(ofs < 0) {ofs = 0;}
5658         env->offset[ENV0_HOLD_STAGE] = ofs;
5659         ofs -= env->offset[ENV0_ATTACK_STAGE];
5660         if(ofs == 0.0) {ofs = -1.0; env->count[ENV0_HOLD_STAGE] = cnt;}
5661         env->curve[ENV0_HOLD_STAGE] = (ofs > 0.0) ? up : down;
5662         env->rate[ENV0_HOLD_STAGE] = fabs(ofs) / cnt;
5663         // ENV0_DECAY_STAGE
5664         ofs = (FLOAT_T)ENV0_OFFSET_MAX * envp[5] * DIV_100
5665                 * POW2(((FLOAT_T)sub_velo * velf[5] * DIV_127 * DIV_100) + ((FLOAT_T)sub_note * keyf[5] * DIV_1200)); // env level
5666         cnt = (FLOAT_T)envp[4] * is_sample_rate_ms
5667                 * POW2(((FLOAT_T)sub_velo * velf[4] * DIV_127 * DIV_100) + ((FLOAT_T)sub_note * keyf[4] * DIV_1200)); // env time
5668         if(cnt == 0.0) {cnt = is_sample_rate_ms;}
5669         if(ofs > ENV0_OFFSET_MAX) {ofs = ENV0_OFFSET_MAX;}
5670         else if(ofs < 0) {ofs = 0;}
5671         env->offset[ENV0_DECAY_STAGE] = ofs;
5672         ofs -= env->offset[ENV0_HOLD_STAGE];
5673         if(ofs == 0.0) {ofs = -1.0; env->count[ENV0_DECAY_STAGE] = cnt;}
5674         env->curve[ENV0_DECAY_STAGE] = (ofs > 0.0) ? up : down;
5675         env->rate[ENV0_DECAY_STAGE] = fabs(ofs) / cnt;
5676         // ENV0_SUSTAIN_STAGE
5677         env->offset[ENV0_SUSTAIN_STAGE] = 0; // env level
5678         ofs = env->offset[ENV0_HOLD_STAGE];
5679         cnt = (FLOAT_T)600000.0 * is_sample_rate_ms; // env time
5680         env->count[ENV0_SUSTAIN_STAGE] = cnt;
5681         env->curve[ENV0_SUSTAIN_STAGE] = down;
5682         env->rate[ENV0_SUSTAIN_STAGE] = ofs / cnt;
5683         env->follow[ENV0_SUSTAIN_STAGE] = 1.0;
5684         // ENV0_RELEASE1_STAGE
5685         ofs = (FLOAT_T)ENV0_OFFSET_MAX * envp[7] * DIV_100
5686                 * POW2(((FLOAT_T)sub_velo * velf[7] * DIV_127 * DIV_100) + ((FLOAT_T)sub_note * keyf[7] * DIV_1200)); // env level
5687         cnt = (FLOAT_T)envp[6] * is_sample_rate_ms
5688                 * POW2(((FLOAT_T)sub_velo * velf[6] * DIV_127 * DIV_100) + ((FLOAT_T)sub_note * keyf[6] * DIV_1200)); // env time
5689         if(cnt == 0.0) {cnt = is_sample_rate_ms;}
5690         if(ofs > ENV0_OFFSET_MAX) {ofs = ENV0_OFFSET_MAX;}
5691         else if(ofs < 0) {ofs = 0;}
5692         env->offset[ENV0_RELEASE1_STAGE] = ofs;
5693         ofs = (FLOAT_T)ENV0_OFFSET_MAX; // release1
5694         env->curve[ENV0_RELEASE1_STAGE] = down;
5695         env->rate[ENV0_RELEASE1_STAGE] = fabs(ofs) / cnt;
5696         // ENV0_RELEASE2_STAGE
5697         ofs = (FLOAT_T)ENV0_OFFSET_MAX * envp[9] * DIV_100
5698                 * POW2(((FLOAT_T)sub_velo * velf[9] * DIV_127 * DIV_100) + ((FLOAT_T)sub_note * keyf[9] * DIV_1200)); // env level
5699         cnt = (FLOAT_T)envp[8] * is_sample_rate_ms
5700                 * POW2(((FLOAT_T)sub_velo * velf[8] * DIV_127 * DIV_100) + ((FLOAT_T)sub_note * keyf[8] * DIV_1200)); // env time
5701         if(cnt == 0.0) {cnt = is_sample_rate_ms;}
5702         if(ofs > ENV0_OFFSET_MAX) {ofs = ENV0_OFFSET_MAX;}
5703         else if(ofs < 0) {ofs = 0;}
5704         env->offset[ENV0_RELEASE2_STAGE] = ofs;
5705         ofs -= env->offset[ENV0_RELEASE1_STAGE];
5706         if(ofs == 0.0) {ofs = -1.0; env->count[ENV0_RELEASE2_STAGE] = cnt;}
5707         env->curve[ENV0_RELEASE2_STAGE] = (ofs > 0.0) ? up : down;
5708         env->rate[ENV0_RELEASE2_STAGE] = fabs(ofs) / cnt;
5709         // ENV0_RELEASE3_STAGE
5710         ofs = (FLOAT_T)ENV0_OFFSET_MAX * envp[11] * DIV_100
5711                 * POW2(((FLOAT_T)sub_velo * velf[11] * DIV_127 * DIV_100) + ((FLOAT_T)sub_note * keyf[11] * DIV_1200)); // env level
5712         cnt = (FLOAT_T)envp[10] * is_sample_rate_ms
5713                 * POW2(((FLOAT_T)sub_velo * velf[10] * DIV_127 * DIV_100) + ((FLOAT_T)sub_note * keyf[10] * DIV_1200)); // env time
5714         if(cnt == 0.0) {cnt = is_sample_rate_ms;}
5715         if(ofs > ENV0_OFFSET_MAX) {ofs = ENV0_OFFSET_MAX;}
5716         else if(ofs < 0) {ofs = 0;}
5717         env->offset[ENV0_RELEASE3_STAGE] = ofs;
5718         ofs -= env->offset[ENV0_RELEASE2_STAGE];
5719         if(ofs == 0.0) {ofs = -1.0; env->count[ENV0_RELEASE3_STAGE] = cnt;}
5720         env->curve[ENV0_RELEASE3_STAGE] = (ofs > 0.0) ? up : down;
5721         env->rate[ENV0_RELEASE3_STAGE] = fabs(ofs) / cnt;
5722         // ENV0_RELEASE4_STAGE
5723         env->offset[ENV0_RELEASE4_STAGE] = ofs = 0; // env level
5724         cnt = (FLOAT_T)10.0 * is_sample_rate_ms; // env time
5725         ofs -= env->offset[ENV0_RELEASE3_STAGE];
5726         if(ofs == 0.0) {ofs = -1.0;}
5727         env->curve[ENV0_RELEASE4_STAGE] = down;
5728         env->rate[ENV0_RELEASE4_STAGE] = fabs(ofs) / cnt;
5729
5730         apply_envelope0_param(env);
5731 }
5732
5733 static inline void init_mms_preset(int v, InfoIS_MMS *info, Preset_IS *is_set, int preset)
5734 {
5735         Preset_MMS *set = mms_editor_override ? &mms_setting_edit[0] : is_set->mms_setting[preset];
5736         double delay_cnt, attack_cnt, hold_cnt, decay_cnt, sustain_vol, sustain_cnt, release_cnt;
5737         int note = voice[v].note, velo = voice[v].velocity;
5738         FLOAT_T sub_note = note - 60, sub_velo = 127 - velo, div_velo = (FLOAT_T)velo * DIV_127;
5739         int i, j, tmpi;
5740
5741         if(set == NULL){
5742                 info->init = 0;
5743                 return;
5744         }
5745         info->init = 1;
5746
5747         tmpi = set->op_max; // op max
5748         if(tmpi < 1 || tmpi > MMS_OP_MAX)
5749                 tmpi = 0;
5750         info->op_max = tmpi;
5751         for(i = 0; i < info->op_max; i++){
5752                 Info_OP *info2 = &info->op[i];
5753                 // param
5754                 tmpi = set->op_param[i][0]; // param0 = op mode 0:OSC 1:FM 2:AM 3:PM 4:AMPM 5:RM 6:SYNC (7:CLIP 8:LOWBIT
5755                 if(tmpi < 0 || tmpi >= OP_LIST_MAX)
5756                         tmpi = 0;
5757                 info2->mod_type = tmpi;
5758                 switch(info2->mod_type){
5759                 default:
5760                         tmpi = set->op_param[i][1]; // param1 = mod level %
5761                         if(tmpi < 1)
5762                                 tmpi = 100;
5763                         info2->mod_level = (FLOAT_T)tmpi * DIV_100;
5764                         break;
5765                 case OP_CLIP:
5766                         info2->mod_level = 1.0;
5767                         tmpi = set->op_param[i][1]; // param1 = clip level %
5768                         if(tmpi < 1)
5769                                 tmpi = 100;
5770                         info2->efx_var1 = (FLOAT_T)tmpi * DIV_100;
5771                         break;
5772                 case OP_LOWBIT:
5773                         info2->mod_level = 1.0;
5774                         tmpi = set->op_param[i][1]; // param1 = multiply
5775                         if(tmpi < 2)
5776                                 tmpi = 2;
5777                         info2->efx_var1 = (FLOAT_T)tmpi;
5778                         info2->efx_var2 = 1.0 / info2->efx_var1;
5779                         break;
5780                 }
5781                 tmpi = set->op_param[i][2]; // param2 = op level %
5782                 if(tmpi < 1)
5783                         tmpi = 100;
5784                 info2->op_level = (FLOAT_T)tmpi * DIV_100;
5785                 // range
5786                 if(note < set->op_range[i][0] // range0 = key low
5787                 || note > set->op_range[i][1] // range1 = key hi
5788                 || velo < set->op_range[i][2] // range2 = velo low
5789                 || velo > set->op_range[i][3] // range3 = velo hi
5790                 )
5791                         info2->op_flag = 0; // off
5792                 else
5793                         info2->op_flag = 1; // on
5794                 // connect
5795                 if(info2->mod_type == OP_SYNC){
5796                         for(j = 0; j < MMS_OP_CON_MAX; j++){ // connect0 ~ connect3
5797                                 tmpi = set->op_connect[i][j]; // connect0 = -1:none(def) -2:output 0~7:op num
5798                                 if(tmpi >= 0 && tmpi <= info->op_max)
5799                                         info2->ptr_connect[j] = &info->op[tmpi].sync;
5800                                 else
5801                                         info2->ptr_connect[j] = &info->dummy;   // no connect
5802                         }
5803                 }else{
5804                         for(j = 0; j < MMS_OP_CON_MAX; j++){ // connect0 ~ connect3
5805                                 tmpi = set->op_connect[i][j]; // connect0 = -1:none(def) -2:output 0~7:op num
5806                                 if(tmpi == -2)
5807                                         info2->ptr_connect[j] = &info->out;     // output
5808                                 else if(tmpi <= -1 || tmpi >= info->op_max)
5809                                         info2->ptr_connect[j] = &info->dummy;   // no connect
5810                                 else
5811                                         info2->ptr_connect[j] = &info->op[tmpi].in;
5812                         }
5813                 }
5814                 // osc
5815                 switch(set->op_osc[i][0]){ // osc0= mode 0:OSC(%) 0:OSC(ppm) 1:OSC(mHz) 2:OSC(note)
5816                 default:
5817                 case 0: // var %
5818                         info2->mode = 0;
5819                         tmpi = set->op_osc[i][1]; // osc1= freq / mlt
5820                         if(tmpi < 1)
5821                                 tmpi = 100;
5822                         info2->freq_mlt = (FLOAT_T)tmpi * DIV_100 * voice[v].sample->tune; // % to mlt
5823                         info2->freq_mlt *= POW2((FLOAT_T)set->op_osc[i][2] * DIV_1200); // osc2=tune  // cent to mlt
5824                         info2->freq = (FLOAT_T)voice[v].frequency * DIV_1000 * info2->freq_mlt;
5825                         break;
5826                 case 1: // var ppm
5827                         info2->mode = 0;
5828                         tmpi = set->op_osc[i][1]; // osc1= freq / mlt
5829                         if(tmpi < 1)
5830                                 tmpi = 1000000;
5831                         info2->freq_mlt = (FLOAT_T)tmpi * DIV_1000000 * voice[v].sample->tune; // ppm to mlt
5832                         info2->freq_mlt *= POW2((FLOAT_T)set->op_osc[i][2] * DIV_1200); // osc2=tune  // cent to mlt
5833                         info2->freq = (FLOAT_T)voice[v].frequency * DIV_1000 * info2->freq_mlt;
5834                         break;
5835                 case 2: // fix mHz
5836                         info2->mode = 1;
5837                         tmpi = set->op_osc[i][1]; // osc1= freq / mlt
5838                         if(tmpi < 1)
5839                                 tmpi = 1;
5840                         info2->freq_mlt = (FLOAT_T)tmpi * DIV_1000 * voice[v].sample->tune; // mHz to Hz
5841                         info2->freq_mlt *= POW2((FLOAT_T)set->op_osc[i][2] * DIV_1200); // osc2=tune  // cent to mlt
5842                         info2->freq = info2->freq_mlt;
5843                         break;
5844                 case 3: // fix note
5845                         info2->mode = 1;
5846                         tmpi = set->op_osc[i][1]; // osc1= freq / mlt
5847                         if(tmpi < 0)
5848                                 tmpi = 0;
5849                         else if(tmpi > 127)
5850                                 tmpi = 127;
5851                         info2->freq_mlt = (FLOAT_T)freq_table[tmpi] * DIV_1000 * voice[v].sample->tune; // note to Hz
5852                         info2->freq_mlt *= POW2((FLOAT_T)set->op_osc[i][2] * DIV_1200); // osc2=tune  // cent to mlt
5853                         info2->freq = info2->freq_mlt;
5854                         break;
5855                 }
5856                 // wave
5857                 switch(set->op_wave[i][0]){ // wave0 = osc type 0:wave 1:SCC 2:MT32 3:CM32
5858                 default:
5859                 case MMS_OSC_WAVE:
5860                         info2->osc_type = 0;
5861                         tmpi = set->op_wave[i][1]; // wave1 = wave type  wave 0:sine ~
5862                         info2->wave_type = check_is_osc_wave_type(tmpi, OSC_NOISE_LOWBIT);
5863                         info2->osc_ptr = compute_osc[info2->wave_type];
5864                         tmpi = set->op_wave[i][2]; // wave2 = osc width %
5865                         if(tmpi < 0)
5866                                 tmpi = 0;
5867                         else if(tmpi > 200)
5868                                 tmpi = 200;
5869                         info2->wave_width = (FLOAT_T)tmpi * DIV_200; // width=100%  ratio=50:50=(width/2):(1-width/2)
5870                         tmpi = set->op_wave[i][3]; // wave3 = phase offset % (start rate
5871                         if(tmpi < 0 || tmpi > 99)
5872                                 tmpi = 0;
5873                         info2->rate = (FLOAT_T)tmpi * DIV_100;
5874                         info2->freq_coef = div_is_sample_rate; // +1/sr = 1Hz
5875                         break;
5876                 case MMS_OSC_SCC:
5877                         info2->osc_type = 1;
5878                         tmpi = set->op_wave[i][1]; // wave1 = scc type  , scc number 0~511
5879                         if(tmpi < 0 || tmpi > SCC_DATA_MAX)
5880                                 tmpi = 0;
5881                         info2->wave_type = tmpi;
5882                         info2->data_ptr = is_set->scc_data[tmpi];
5883                         if(scc_data_editor_override) // IS_EDITOR
5884                                 info2->data_ptr = scc_data_edit[0];
5885                         tmpi = set->op_wave[i][2]; // wave2 = wave width %
5886                         if(tmpi < 0 || tmpi > 200)
5887                                 tmpi = 0;
5888                         info2->wave_width = (FLOAT_T)tmpi * DIV_200; // width=100%  ratio=50:50=(width/2):(1-width/2)
5889                         tmpi = set->op_wave[i][3]; // wave3 = phase offset % (start rate
5890                         if(tmpi < 0 || tmpi > 99)
5891                                 tmpi = 0;
5892                         info2->rate = (FLOAT_T)tmpi * DIV_100;
5893                         info2->freq_coef = div_is_sample_rate; // +1/sr = 1Hz
5894                         info2->scc_ptr = compute_osc_scc_linear;
5895                 //      info2->scc_ptr = compute_osc_scc_sine;
5896                         if(!set->op_wave[i][4]) // wave4 \8ag\92£\83t\83\89\83O
5897                                 break;
5898                         switch(set->op_wave[i][5]){ // wave5 = interpoation
5899                         default:
5900                         case 0:
5901                                 info2->scc_ptr = compute_osc_scc_none;
5902                                 break;
5903                         case 1:
5904                                 info2->scc_ptr = compute_osc_scc_linear;
5905                                 break;
5906                         case 2:
5907                                 info2->scc_ptr = compute_osc_scc_sine;
5908                                 break;
5909                         }
5910                         break;
5911                 case MMS_OSC_MT32:
5912                         {
5913                         Info_PCM *pcm_inf;
5914                         info2->osc_type = 2;
5915                         tmpi = set->op_wave[i][1]; // wave1 = pcm type , pcm number 0~
5916                         if(tmpi < 0 || tmpi >= MT32_DATA_MAX)
5917                                 tmpi = 0;
5918                         pcm_inf = &mt32_pcm_inf[tmpi];
5919                         info2->wave_type = tmpi;
5920                         info2->data_ptr = mt32_pcm_data;
5921                         if(pcm_inf->loop){
5922                                 info2->ofs_start = pcm_inf->loop_start;
5923                                 info2->ofs_end = pcm_inf->loop_end;
5924                                 info2->loop_length = pcm_inf->loop_length;
5925                         }else{
5926                                 info2->ofs_start = pcm_inf->ofs_start;
5927                                 info2->ofs_end = pcm_inf->ofs_end;
5928                                 info2->loop_length = 0;
5929                         }
5930                         info2->pcm_cycle = pcm_inf->sample_rate * pcm_inf->div_root_freq; // PCM\82Ì1\8eü\8aú\95ª\91\8a\93\96
5931                         info2->freq_coef = div_is_sample_rate * info2->pcm_cycle; // +1/sr*pcm_rate/root_freq = 1Hz
5932                         info2->rate = pcm_inf->ofs_start;
5933                         }
5934                         break;
5935                 case MMS_OSC_CM32L:
5936                         {
5937                         Info_PCM *pcm_inf;
5938                         info2->osc_type = 3;
5939                         tmpi = set->op_wave[i][1]; // wave1 = pcm type , pcm number 0~
5940                         if(tmpi < 0 || tmpi >= CM32L_DATA_MAX)
5941                                 tmpi = 0;
5942                         pcm_inf = &cm32l_pcm_inf[tmpi];
5943                         info2->wave_type = tmpi;
5944                         info2->data_ptr = cm32l_pcm_data;
5945                         if(pcm_inf->loop){
5946                                 info2->ofs_start = pcm_inf->loop_start;
5947                                 info2->ofs_end = pcm_inf->loop_end;
5948                                 info2->loop_length = pcm_inf->loop_length;
5949                         }else{
5950                                 info2->ofs_start = pcm_inf->ofs_start;
5951                                 info2->ofs_end = pcm_inf->ofs_end;
5952                                 info2->loop_length = 0;
5953                         }
5954                         info2->pcm_cycle = pcm_inf->sample_rate * pcm_inf->div_root_freq; // PCM\82Ì1\8eü\8aú\95ª\91\8a\93\96
5955                         info2->freq_coef = div_is_sample_rate * info2->pcm_cycle; // +1/sr*pcm_rate/root_freq = 1Hz
5956                         info2->rate = pcm_inf->ofs_start;
5957                         }
5958                         break;
5959                 }
5960                 // sub
5961                 tmpi = set->op_sub[i][0]; // sub0= velo to mod_level
5962                 if(tmpi < 1)
5963                         tmpi = 100;
5964                 info2->mod_level *= mix_double(div_velo, tmpi * DIV_100, 1.0); // vel=127 modlv=100% , vel=0 modlv=tmpi%
5965                 tmpi = set->op_sub[i][1]; // sub1= velo to op_level
5966                 if(tmpi < 1)
5967                         tmpi = 100;
5968                 info2->op_level *= mix_double(div_velo, tmpi * DIV_100, 1.0); // vel=127 modlv=100% , vel=0 modlv=tmpi%
5969                 tmpi = set->op_sub[i][2]; // sub2= key to mod_level
5970                 info2->mod_level *= POW2((FLOAT_T)sub_note * tmpi * DIV_1200);
5971                 tmpi = set->op_sub[i][3]; // sub3= key to op_level
5972                 info2->op_level *= POW2((FLOAT_T)sub_note * tmpi * DIV_1200);
5973                 // amp
5974                 tmpi = set->op_amp[i][0]; // amp0= lfo1 to amp
5975                 if(tmpi < 0)
5976                         tmpi = 0;
5977                 else if(tmpi > 100)
5978                         tmpi = 100;
5979                 info2->lfo_amp = (FLOAT_T)tmpi * DIV_100;
5980                 info2->amp_vol = 0.0;
5981                 // pitch
5982                 info2->lfo_pitch = (FLOAT_T)set->op_pitch[i][0] * DIV_1200; // pitch0= lfo2 to freq
5983                 info2->env_pitch = (FLOAT_T)set->op_pitch[i][1] * DIV_1200; // pitch1= pitenv to freq cent
5984                 // width
5985                 if(info2->osc_type <= MMS_OSC_SCC){
5986                         tmpi = set->op_width[i][0]; // width0= lfo3 to wave_width %
5987                         if(tmpi < -200)
5988                                 tmpi = -200;
5989                         else if(tmpi > 200)
5990                                 tmpi = 200;
5991                         info2->lfo_width = (FLOAT_T)tmpi * DIV_200;
5992                         tmpi = set->op_width[i][1]; // width1= widenv to wave_width %
5993                         if(tmpi < -200)
5994                                 tmpi = -200;
5995                         else if(tmpi > 200)
5996                                 tmpi = 200;
5997                         info2->env_width = (FLOAT_T)tmpi * DIV_200;
5998                         tmpi = set->op_width[i][2]; // width2= vel to wave_width %
5999                         if(tmpi < -200)
6000                                 tmpi = -200;
6001                         else if(tmpi > 200)
6002                                 tmpi = 200;
6003                         info2->wave_width += div_velo * (FLOAT_T)tmpi * DIV_200;
6004                         if(info2->wave_width >= 1.0){
6005                                 info2->wave_width = 1.0;
6006                                 info2->req_wave_width1 = info2->wave_width1 = 1.0;
6007                                 info2->req_rate_width1 = info2->rate_width1 = 0.5;
6008                                 info2->req_rate_width2 = info2->rate_width2 = 0.0;
6009                         }else if(info2->wave_width <= 0.0){
6010                                 info2->wave_width = 0.0;
6011                                 info2->req_wave_width1 = info2->wave_width1 = 0.0;
6012                                 info2->req_rate_width1 = info2->rate_width1 = 0.0;
6013                                 info2->req_rate_width2 = info2->rate_width2 = 0.5;
6014                         }else{
6015                                 info2->req_wave_width1 = info2->wave_width1 = info2->wave_width;
6016                                 info2->req_rate_width1 = info2->rate_width1 = 0.5 / (info2->wave_width1);
6017                                 info2->req_rate_width2 = info2->rate_width2 = 0.5 / (1.0 - info2->wave_width1);
6018                         }
6019                 }else{
6020                         info2->lfo_width = 0.0;
6021                         info2->env_width = 0.0;
6022                         info2->req_wave_width1 = info2->wave_width1 = 0.5;
6023                         info2->req_rate_width1 = info2->rate_width1 = 1.0;
6024                         info2->req_rate_width2 = info2->rate_width2 = 1.0;
6025                 }
6026                 // filter
6027                 set_sample_filter_type(&info2->fc, set->op_filter[i][0]); // filter 0 = type
6028                 if(info2->fc.type){
6029                         info2->flt_freq = (FLOAT_T)set->op_filter[i][1]; // filter 1 = freq
6030                         info2->flt_reso = (FLOAT_T)set->op_filter[i][2]; // filter 2 = reso
6031                 // cutoff
6032                         info2->lfo_cutoff = (FLOAT_T)set->op_cutoff[i][0] * DIV_1200; // cutoff 0 = lfo4 to cutoff
6033                         info2->env_cutoff = (FLOAT_T)set->op_cutoff[i][1] * DIV_1200; // cutoff 1 = env to cutoff
6034                         info2->flt_freq *= POW2(((FLOAT_T)sub_velo * set->op_cutoff[i][2] * DIV_127 * DIV_100) // cutoff 2 = vel to cutoff
6035                                 + ((FLOAT_T)sub_note * set->op_cutoff[i][3] * DIV_1200)); // cutoff 3 = key to cutoff
6036                         set_sample_filter_ext_rate(&info2->fc, is_sample_rate);
6037                         set_sample_filter_freq(&info2->fc, info2->flt_freq);
6038                         set_sample_filter_reso(&info2->fc, info2->flt_reso);
6039                 }else{ // filter off
6040                         info2->flt_freq = 0;
6041                         info2->flt_reso = 0;
6042                         info2->env_cutoff = 0.0;
6043                         info2->lfo_cutoff = 0.0;
6044                 }
6045                 // amp_env
6046                 if(info2->mod_type < OP_SYNC){
6047                         info2->amp_env_flg = 1;
6048                         set_envelope_param_mms(&info2->amp_env,
6049                                 set->op_ampenv[i], set->op_ampenv_velf[i], set->op_ampenv_keyf[i],
6050                                 LINEAR_CURVE, DEF_VOL_CURVE, sub_velo, sub_note);
6051                 }else{
6052                         info2->amp_env_flg = 0;
6053                         info2->amp_env.volume = 0.0;
6054                 }
6055                 // pit_env
6056                 if(info2->env_pitch != 0.0){
6057                         info2->pit_env_flg = 1;
6058                         set_envelope_param_mms(&info2->pit_env,
6059                                 set->op_pitenv[i], set->op_pitenv_velf[i], set->op_pitenv_keyf[i],
6060                                 LINEAR_CURVE, LINEAR_CURVE, sub_velo, sub_note);
6061                 }else{
6062                         info2->pit_env_flg = 0;
6063                         info2->pit_env.volume = 0.0;
6064                 }
6065                 // wid_env
6066                 if(info2->env_width != 0.0){
6067                         info2->wid_env_flg = 1;
6068                         set_envelope_param_mms(&info2->wid_env,
6069                                 set->op_widenv[i], set->op_widenv_velf[i], set->op_widenv_keyf[i],
6070                                 LINEAR_CURVE, LINEAR_CURVE, sub_velo, sub_note);
6071                 }else{
6072                         info2->wid_env_flg = 0;
6073                         info2->wid_env.volume = 0.0;
6074                 }
6075                 // mod_env
6076                 if(info2->env_cutoff != 0.0){
6077                         info2->mod_env_flg = 1;
6078                         set_envelope_param_mms(&info2->mod_env,
6079                                 set->op_modenv[i], set->op_modenv_velf[i], set->op_modenv_keyf[i],
6080                                 SF2_CONVEX, SF2_CONCAVE, sub_velo, sub_note);
6081                 }else{
6082                         info2->mod_env_flg = 0;
6083                         info2->mod_env.volume = 0.0;
6084                 }
6085                 // lfo1
6086                 if(info2->lfo_amp != 0.0){
6087                         info2->lfo1_flg = 1;
6088                         init_lfo(&info2->lfo1, (FLOAT_T)set->op_lfo1[i][0] * DIV_100, set->op_lfo1[i][1], set->op_lfo1[i][2], set->op_lfo1[i][3], 1);
6089                 }else{
6090                         info2->lfo1_flg = 0;
6091                         info2->lfo1.out = 0.0;
6092                 }
6093                 // lfo2
6094                 if(info2->lfo_pitch != 0.0){
6095                         info2->lfo2_flg = 1;
6096                         init_lfo(&info2->lfo2, (FLOAT_T)set->op_lfo2[i][0] * DIV_100, set->op_lfo2[i][1], set->op_lfo2[i][2], set->op_lfo2[i][3], 0);
6097                 }else{
6098                         info2->lfo2_flg = 0;
6099                         info2->lfo2.out = 0.0;
6100                 }
6101                 // lfo3
6102                 if(info2->lfo_width != 0.0){
6103                         info2->lfo3_flg = 1;
6104                         init_lfo(&info2->lfo3, (FLOAT_T)set->op_lfo3[i][0] * DIV_100, set->op_lfo3[i][1], set->op_lfo3[i][2], set->op_lfo3[i][3], 1);
6105                 }else{
6106                         info2->lfo3_flg = 0;
6107                         info2->lfo3.out = 0.0;
6108                 }
6109                 // lfo4
6110                 if(info2->lfo_cutoff != 0.0){
6111                         info2->lfo4_flg = 1;
6112                         init_lfo(&info2->lfo4, (FLOAT_T)set->op_lfo4[i][0] * DIV_100, set->op_lfo4[i][1], set->op_lfo4[i][2], set->op_lfo4[i][3], 1);
6113                 }else{
6114                         info2->lfo4_flg = 0;
6115                         info2->lfo4.out = 0.0;
6116                 }
6117                 // other
6118                 info2->in = info2->sync = 0.0;
6119                 info2->cycle = 0;
6120                 // op_ptr
6121                 if(info2->op_flag)
6122                         info->op_ptr[i] = compute_op[info2->osc_type][info2->mod_type];
6123                 else
6124                         info->op_ptr[i] = compute_op_null;
6125         }
6126         // resample
6127         is_resample_init(&info->rs);
6128         // mms_ptr
6129         info->op_num_ptr = compute_op_num[info->op_max];
6130
6131         info->thru_count = -1; // init
6132
6133 }
6134
6135 static void noteoff_mms(InfoIS_MMS *info)
6136 {
6137         int i;
6138
6139         if(!info->init) return;
6140         for(i = 0; i < info->op_max; i++){
6141                 Info_OP *info2 = &info->op[i];
6142
6143                 if(info2->op_flag == 0) // op off
6144                         continue;
6145                 if(info2->amp_env_flg)
6146                         reset_envelope0_release(&info2->amp_env, ENV0_KEEP);
6147                 if(info2->pit_env_flg)
6148                         reset_envelope0_release(&info2->pit_env, ENV0_KEEP);
6149                 if(info2->wid_env_flg)
6150                         reset_envelope0_release(&info2->wid_env, ENV0_KEEP);
6151                 if(info2->mod_env_flg)
6152                         reset_envelope0_release(&info2->mod_env, ENV0_KEEP);
6153         }
6154 }
6155
6156 static void damper_mms(InfoIS_MMS *info, int8 damper)
6157 {
6158         int i;
6159
6160         if(!info->init) return;
6161         for(i = 0; i < info->op_max; i++){
6162                 Info_OP *info2 = &info->op[i];
6163
6164                 if(info2->op_flag == 0) // op off
6165                         continue;
6166                 if(damper){
6167                         if(info2->amp_env_flg)
6168                                 reset_envelope0_damper(&info2->amp_env, damper);
6169                         if(info2->pit_env_flg)
6170                                 reset_envelope0_damper(&info2->pit_env, damper);
6171                         if(info2->wid_env_flg)
6172                                 reset_envelope0_damper(&info2->wid_env, damper);
6173                         if(info2->mod_env_flg)
6174                                 reset_envelope0_damper(&info2->mod_env, damper);
6175                 }
6176         }
6177 }
6178
6179 static void pre_compute_mms(InfoIS_MMS *info, int v, int32 count)
6180 {
6181         Voice *vp = voice + v;
6182         int i, scount, thru_flg, op_count = 0;
6183
6184         // thru count
6185         if(thru_count_mlt > 1){
6186                 scount = count * thru_count_mlt;
6187                 if((++info->thru_count) >= thru_count_mlt)
6188                         info->thru_count = 0;
6189                 thru_flg = info->thru_count;
6190         }else{
6191                 scount = count;
6192                 thru_flg = 0;
6193         }
6194         for(i = 0; i < info->op_max; i++){
6195                 Info_OP *info2 = &info->op[i];
6196                 FLOAT_T amp = 1.0, pitch = 0.0, cutoff = 0.0, width = 0.0;
6197
6198                 if(info2->op_flag == 0) // op off
6199                         continue;
6200                 // amp
6201                 if(info2->amp_env_flg){
6202                         if(!check_envelope0(&info2->amp_env)){ // amp_env end
6203                                 info2->amp_vol = 0.0;
6204                                 info2->op_flag = 0; // operator turn off
6205                                 info->op_ptr[i] = compute_op_null;
6206                                 continue;
6207                         }
6208                         compute_envelope0(&info2->amp_env, count);
6209                         amp *= info2->amp_env.volume;
6210                 }
6211                 ++op_count;
6212                 if(info2->lfo1_flg){
6213                         if(!thru_flg)
6214                                 compute_lfo(&info2->lfo1, scount);
6215                         amp *= 1.0 - info2->lfo1.out * info2->lfo_amp;
6216                 }
6217                 info2->amp_vol = info2->op_level * amp;
6218
6219                 if(thru_flg)
6220                         continue;
6221
6222                 // pitch
6223                 if(info2->pit_env_flg){
6224                         compute_envelope0(&info2->pit_env, scount);
6225                         pitch += info2->env_pitch * info2->pit_env.volume;
6226                 }
6227                 if(info2->lfo2_flg){
6228                         compute_lfo(&info2->lfo2, scount);
6229                         pitch += info2->lfo_pitch * info2->lfo2.out;
6230                 }
6231                 if(!info2->mode)
6232                         info2->freq = (FLOAT_T)vp->frequency * DIV_1000 * info2->freq_mlt;
6233                 else {
6234                         if(vp->pitchfactor)
6235                                 info2->freq = info2->freq_mlt * vp->pitchfactor;
6236                         else
6237                                 info2->freq = info2->freq_mlt;
6238                         info2->freq += channel[vp->channel].pitch_offset_fine;
6239                 }
6240                 info2->freq *= POW2(pitch) * info2->freq_coef;
6241
6242                 // width
6243                 if(info2->wid_env_flg){
6244                         compute_envelope0(&info2->wid_env, scount);
6245                         width += info2->env_width * info2->wid_env.volume;
6246                 }
6247                 if(info2->lfo3_flg){
6248                         compute_lfo(&info2->lfo3, scount);
6249                         width += info2->lfo_width * info2->lfo3.out;
6250                 }
6251                 if(width != 0.0){
6252                         width += info2->wave_width;
6253                         if(info2->wave_width1 != width){
6254                                 info2->update_width = 1;
6255                                 if(width >= 1.0) {
6256                                         info2->req_wave_width1 = 1.0;
6257                                         info2->req_rate_width1 = 0.5;
6258                                         info2->req_rate_width2 = 0.0;
6259                                 }else if(width <= 0.0) {
6260                                         info2->req_wave_width1 = 0.0;
6261                                         info2->req_rate_width1 = 0.0;
6262                                         info2->req_rate_width2 = 0.5;
6263                                 }else{
6264                                         info2->req_wave_width1 = width;
6265                                         info2->req_rate_width1 = 0.5 / (width);
6266                                         info2->req_rate_width2 = 0.5 / (1.0 - width);
6267                                 }
6268                         }
6269                 }
6270
6271                 // filter // cutoff
6272                 if(info2->mod_env_flg){
6273                         compute_envelope0(&info2->mod_env, scount);
6274                         cutoff += info2->env_cutoff * info2->mod_env.volume;
6275                 }
6276                 if(info2->lfo4_flg){
6277                         compute_lfo(&info2->lfo4, scount);
6278                         cutoff += info2->lfo_cutoff * (1.0 - info2->lfo4.out);
6279                 }
6280                 if(info2->fc.type){
6281                         set_sample_filter_freq(&info2->fc, info2->flt_freq * POW2(cutoff));
6282                         recalc_filter(&info2->fc);
6283                 }
6284         }
6285         if(!op_count) vp->finish_voice = 1;
6286 }
6287
6288 static inline void compute_voice_mms_switch(int v, int32 count, DATA_T *is_buf, IS_RS_DATA_T *rs_buf)
6289 {
6290         Voice *vp = voice + v;
6291         InfoIS_MMS *info = (InfoIS_MMS*)&vp->mms;
6292         int32 i;
6293
6294         if(!info->init){
6295                 memset(is_buf, 0, count * sizeof(DATA_T));
6296         }else if(!is_rs_mode){
6297                 pre_compute_mms(info, v, count);
6298                 for (i = 0; i < count; i++)
6299 #if defined(DATA_T_DOUBLE) || defined(DATA_T_FLOAT)
6300                         is_buf[i] = (DATA_T)(info->op_num_ptr(info));
6301 #else
6302                         is_buf[i] = (DATA_T)(info->op_num_ptr(info) * is_output_level);
6303 #endif
6304         }else{
6305                 IS_RS_DATA_T *rs_buf2 = rs_buf + is_rs_buff_offset;
6306                 Info_Resample *rs = &info->rs;
6307
6308                 is_resample_pre(rs, rs_buf, count);
6309                 pre_compute_mms(info, v, rs->rs_count);
6310                 for (i = 0; i < rs->rs_count; i++)
6311                         rs_buf2[i] = (IS_RS_DATA_T)info->op_num_ptr(info);
6312                 is_resample_core(rs, is_buf, rs_buf, count);
6313         }
6314 }
6315
6316
6317
6318 /**************** interface function SCC MMS ****************/
6319
6320 void init_int_synth_scc(int v)
6321 {
6322         Voice *vp = voice + v;
6323         init_scc_preset(v, &vp->scc, (Preset_IS *)vp->sample->data, vp->sample->sf_sample_index);
6324 }
6325
6326 void noteoff_int_synth_scc(int v)
6327 {
6328         noteoff_scc(&voice[v].scc);
6329 }
6330
6331 void damper_int_synth_scc(int v, int8 damper)
6332 {
6333         damper_scc(&voice[v].scc, damper);
6334 }
6335
6336 void compute_voice_scc(int v, DATA_T *ptr, int32 count)
6337 {
6338         compute_voice_scc_switch(v, count, ptr, is_resample_buffer);
6339 }
6340
6341 void init_int_synth_mms(int v)
6342 {
6343         Voice *vp = voice + v;
6344         init_mms_preset(v, &vp->mms, (Preset_IS *)vp->sample->data, vp->sample->sf_sample_index);
6345 }
6346
6347 void noteoff_int_synth_mms(int v)
6348 {
6349         noteoff_mms(&voice[v].mms);
6350 }
6351
6352 void damper_int_synth_mms(int v, int8 damper)
6353 {
6354         damper_mms(&voice[v].mms, damper);
6355 }
6356
6357 void compute_voice_mms(int v, DATA_T *ptr, int32 count)
6358 {
6359         compute_voice_mms_switch(v, count, ptr, is_resample_buffer);
6360 }
6361
6362
6363 ///// free
6364
6365 void free_int_synth_preset(void)
6366 {
6367         int i;
6368         Preset_IS *set = is_preset;
6369
6370         while(set){
6371                 Preset_IS *next = set->next;
6372                 safe_free(set->ini_file);
6373                 set->ini_file = NULL;
6374                 set->scc_data_load = 0;
6375                 for (i = 0; i < SCC_DATA_MAX; i++) {
6376                         safe_free(set->scc_data_name[i]);
6377                         set->scc_data_name[i] = NULL;
6378                 }
6379                 for (i = 0; i < SCC_SETTING_MAX; i++) {
6380                         if(!set->scc_setting[i])
6381                                 continue;
6382                         safe_free(set->scc_setting[i]->inst_name);
6383                         set->scc_setting[i]->inst_name = NULL;
6384                         safe_free(set->scc_setting[i]);
6385                         set->scc_setting[i] = NULL;
6386                 }
6387                 for (i = 0; i < MMS_SETTING_MAX; i++) {
6388                         if(!set->mms_setting[i])
6389                                 continue;
6390                         safe_free(set->mms_setting[i]->inst_name);
6391                         set->mms_setting[i]->inst_name = NULL;
6392                         safe_free(set->mms_setting[i]);
6393                         set->mms_setting[i] = NULL;
6394                 }
6395                 safe_free(set);
6396                 set = next;
6397         }
6398         is_preset = NULL;
6399 }
6400
6401 void free_int_synth(void)
6402 {
6403         free_int_synth_preset();
6404         free_is_editor_preset();
6405         la_pcm_data_load_flg = 0;
6406 }
6407
6408 void init_int_synth(void)
6409 {
6410         set_sample_rate();
6411         init_int_synth_lite();
6412 }
6413
6414
6415
6416
6417 #ifdef MULTI_THREAD_COMPUTE
6418 #include "thread_int_synth.c"
6419 #endif
6420
6421
6422 #undef POW2
6423
6424 #endif // INT_SYNTH