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