/[svn]/libgig/trunk/src/SF.cpp
ViewVC logotype

Diff of /libgig/trunk/src/SF.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2205 by persson, Sat Jul 9 16:43:35 2011 UTC revision 2206 by iliev, Fri Jul 15 14:48:40 2011 UTC
# Line 39  namespace sf2 { Line 39  namespace sf2 {
39          return pow(_1200TH_ROOT_OF_2, Timecents);          return pow(_1200TH_ROOT_OF_2, Timecents);
40      }      }
41    
42      double ToPermilles(int Centibels) {      double ToRatio(int Centibels) {
43          if (Centibels == NONE) return NONE;          if (Centibels == NONE) return NONE;
44          if (Centibels == 0) return 1000.0;          if (Centibels == 0) return 1.0;
45          return pow(_200TH_ROOT_OF_10, Centibels) * 1000.0;          return pow(_200TH_ROOT_OF_10, Centibels);
46      }      }
47    
48      double ToHz(int cents) {      double ToHz(int cents) {
# Line 286  namespace sf2 { Line 286  namespace sf2 {
286          delayVibLfo = -12000;          delayVibLfo = -12000;
287    
288          exclusiveClass = 0;          exclusiveClass = 0;
289            
290            initialFilterFc = 13500;
291            initialFilterQ = 0;
292      }      }
293    
294      int Region::GetUnityNote() {      int Region::GetUnityNote() {
295          return overridingRootKey != -1 ? overridingRootKey : pSample->OriginalPitch;          return overridingRootKey != -1 ? overridingRootKey : pSample->OriginalPitch;
296      }      }
297        
298        int CheckRange(std::string genName, int min, int max, int& gen) {
299            if (gen == NONE) return gen;
300    
301            if (gen < min) {
302                std::cerr << "sf2: " << genName;
303                std::cerr << " is below the minimum allowed value (min=" << min << "): " << gen << std::endl;
304                gen = min;
305            }
306            if (gen > max) {
307                std::cerr << "sf2: " << genName;
308                std::cerr << " is above the maximum allowed value (max=" << max << "): " << gen << std::endl;
309                gen = max;
310            }
311            
312            return gen;
313        }
314    
315      void Region::SetGenerator(sf2::File* pFile, GenList& Gen) {      void Region::SetGenerator(sf2::File* pFile, GenList& Gen) {
316          switch(Gen.GenOper) {          switch(Gen.GenOper) {
# Line 317  namespace sf2 { Line 337  namespace sf2 {
337                  break;                  break;
338              case MOD_LFO_TO_PITCH:              case MOD_LFO_TO_PITCH:
339                  modLfoToPitch = Gen.GenAmount.shAmount;                  modLfoToPitch = Gen.GenAmount.shAmount;
340                    CheckRange("modLfoToPitch", -12000, 12000, modLfoToPitch);
341                  break;                  break;
342              case VIB_LFO_TO_PITCH:              case VIB_LFO_TO_PITCH:
343                  vibLfoToPitch = Gen.GenAmount.shAmount;                  vibLfoToPitch = Gen.GenAmount.shAmount;
344                    CheckRange("vibLfoToPitch", -12000, 12000, vibLfoToPitch);
345                  break;                  break;
346              case MOD_ENV_TO_PITCH:              case MOD_ENV_TO_PITCH:
347                  modEnvToPitch = Gen.GenAmount.shAmount;                  modEnvToPitch = Gen.GenAmount.shAmount;
348                    CheckRange("modEnvToPitch", -12000, 12000, modEnvToPitch);
349                  break;                  break;
350              case INITIAL_FILTER_FC:              case INITIAL_FILTER_FC:
351                    initialFilterFc = Gen.GenAmount.wAmount;
352                    CheckRange("initialFilterFc", 1500, 13500, initialFilterFc);
353                  break;                  break;
354              case INITIAL_FILTER_Q:              case INITIAL_FILTER_Q:
355                    initialFilterQ = Gen.GenAmount.wAmount;
356                    CheckRange("initialFilterQ", 0, 960, initialFilterQ);
357                  break;                  break;
358              case MOD_LFO_TO_FILTER_FC:              case MOD_LFO_TO_FILTER_FC:
359                  modLfoToFilterFc = Gen.GenAmount.shAmount;                  modLfoToFilterFc = Gen.GenAmount.shAmount;
360                    CheckRange("modLfoToFilterFc", -12000, 12000, modLfoToFilterFc);
361                  break;                  break;
362              case MOD_ENV_TO_FILTER_FC:              case MOD_ENV_TO_FILTER_FC:
363                  modEnvToFilterFc = Gen.GenAmount.shAmount;                  modEnvToFilterFc = Gen.GenAmount.shAmount;
364                    CheckRange("modEnvToFilterFc", -12000, 12000, modEnvToFilterFc);
365                  break;                  break;
366              case END_ADDRS_COARSE_OFFSET:              case END_ADDRS_COARSE_OFFSET:
367                  endAddrsCoarseOffset = Gen.GenAmount.wAmount;                  endAddrsCoarseOffset = Gen.GenAmount.wAmount;
368                  break;                  break;
369              case MOD_LFO_TO_VOLUME:              case MOD_LFO_TO_VOLUME:
370                  modLfoToVolume = Gen.GenAmount.shAmount;                  modLfoToVolume = Gen.GenAmount.shAmount;
371                    CheckRange("modLfoToVolume", -960, 960, modLfoToVolume);
372                  break;                  break;
373              case CHORUS_EFFECTS_SEND:              case CHORUS_EFFECTS_SEND:
374                  break;                  break;
# Line 346  namespace sf2 { Line 376  namespace sf2 {
376                  break;                  break;
377              case PAN:              case PAN:
378                  pan = Gen.GenAmount.shAmount;                  pan = Gen.GenAmount.shAmount;
379                    CheckRange("pan", -500, 500, pan);
380                  pan * 64; pan /= 500;                  pan * 64; pan /= 500;
381                  if (pan < -64) pan = -64;                  if (pan < -64) pan = -64;
382                  if (pan >  63) pan =  63;                  if (pan >  63) pan =  63;
383                  break;                  break;
384              case DELAY_MOD_LFO:              case DELAY_MOD_LFO:
385                  delayModLfo = Gen.GenAmount.shAmount;                  delayModLfo = Gen.GenAmount.shAmount;
386                    CheckRange("delayModLfo", -12000, 5000, delayModLfo);
387                  break;                  break;
388              case FREQ_MOD_LFO:              case FREQ_MOD_LFO:
389                  freqModLfo = Gen.GenAmount.shAmount;                  freqModLfo = Gen.GenAmount.shAmount;
390                    CheckRange("freqModLfo", -16000, 4500, freqModLfo);
391                  break;                  break;
392              case DELAY_VIB_LFO:              case DELAY_VIB_LFO:
393                  delayVibLfo = Gen.GenAmount.shAmount;                  delayVibLfo = Gen.GenAmount.shAmount;
394                    CheckRange("delayVibLfo", -12000, 5000, delayVibLfo);
395                  break;                  break;
396              case FREQ_VIB_LFO:              case FREQ_VIB_LFO:
397                  freqVibLfo = Gen.GenAmount.shAmount;                  freqVibLfo = Gen.GenAmount.shAmount;
398                    CheckRange("freqModLfo", -16000, 4500, freqModLfo);
399                  break;                  break;
400              case DELAY_MOD_ENV:              case DELAY_MOD_ENV:
401                  EG2PreAttackDelay = Gen.GenAmount.shAmount;                  EG2PreAttackDelay = Gen.GenAmount.shAmount;
402                    CheckRange("delayModEnv", -12000, 5000, EG2PreAttackDelay);
403                  break;                  break;
404              case ATTACK_MOD_ENV:              case ATTACK_MOD_ENV:
405                  EG2Attack = Gen.GenAmount.shAmount;                  EG2Attack = Gen.GenAmount.shAmount;
406                    CheckRange("attackModEnv", -12000, 8000, EG2Attack);
407                  break;                  break;
408              case HOLD_MOD_ENV:              case HOLD_MOD_ENV:
409                  EG2Hold = Gen.GenAmount.shAmount;                  EG2Hold = Gen.GenAmount.shAmount;
410                    CheckRange("holdModEnv", -12000, 5000, EG2Hold);
411                  break;                  break;
412              case DECAY_MOD_ENV:              case DECAY_MOD_ENV:
413                  EG2Decay = Gen.GenAmount.shAmount;                  EG2Decay = Gen.GenAmount.shAmount;
414                    CheckRange("decayModEnv", -12000, 8000, EG2Decay);
415                  break;                  break;
416              case SUSTAIN_MOD_ENV:              case SUSTAIN_MOD_ENV:
417                  EG2Sustain = Gen.GenAmount.shAmount;                  EG2Sustain = Gen.GenAmount.shAmount;
418                    CheckRange("sustainModEnv", 0, 1000, EG2Sustain);
419                  break;                  break;
420              case RELEASEMODENV:              case RELEASE_MOD_ENV:
421                  EG2Release = Gen.GenAmount.shAmount;                  EG2Release = Gen.GenAmount.shAmount;
422                    CheckRange("releaseModEnv", -12000, 8000, EG2Release);
423                  break;                  break;
424              case KEYNUM_TO_MOD_ENV_HOLD:              case KEYNUM_TO_MOD_ENV_HOLD:
425                  break;                  break;
# Line 386  namespace sf2 { Line 427  namespace sf2 {
427                  break;                  break;
428              case DELAY_VOL_ENV:              case DELAY_VOL_ENV:
429                  EG1PreAttackDelay = Gen.GenAmount.shAmount;                  EG1PreAttackDelay = Gen.GenAmount.shAmount;
430                    CheckRange("delayVolEnv", -12000, 5000, EG1PreAttackDelay);
431                  break;                  break;
432              case ATTACK_VOL_ENV:              case ATTACK_VOL_ENV:
433                  EG1Attack = Gen.GenAmount.shAmount;                  EG1Attack = Gen.GenAmount.shAmount;
434                    CheckRange("attackVolEnv", -12000, 8000, EG1Attack);
435                  break;                  break;
436              case HOLD_VOL_ENV:              case HOLD_VOL_ENV:
437                  EG1Hold = Gen.GenAmount.shAmount;                  EG1Hold = Gen.GenAmount.shAmount;
438                    CheckRange("holdVolEnv", -12000, 5000, EG1Hold);
439                  break;                  break;
440              case DECAY_VOL_ENV:              case DECAY_VOL_ENV:
441                  EG1Decay = Gen.GenAmount.shAmount;                  EG1Decay = Gen.GenAmount.shAmount;
442                    CheckRange("decayVolEnv", -12000, 8000, EG1Decay);
443                  break;                  break;
444              case SUSTAIN_VOL_ENV:              case SUSTAIN_VOL_ENV:
445                  EG1Sustain = Gen.GenAmount.shAmount;                  EG1Sustain = Gen.GenAmount.shAmount;
446                    CheckRange("sustainVolEnv", 0, 1440, EG1Sustain);
447                  break;                  break;
448              case RELEASE_VOL_ENV:              case RELEASE_VOL_ENV:
449                  EG1Release = Gen.GenAmount.shAmount;                  EG1Release = Gen.GenAmount.shAmount;
450                    CheckRange("releaseVolEnv", -12000, 8000, EG1Release);
451                  break;                  break;
452              case KEYNUM_TO_VOL_ENV_HOLD:              case KEYNUM_TO_VOL_ENV_HOLD:
453                  break;                  break;
# Line 416  namespace sf2 { Line 463  namespace sf2 {
463              }              }
464              case KEY_RANGE:              case KEY_RANGE:
465                  loKey = Gen.GenAmount.ranges.byLo;                  loKey = Gen.GenAmount.ranges.byLo;
466                    CheckRange("loKey", 0, 127, loKey);
467                  hiKey = Gen.GenAmount.ranges.byHi;                  hiKey = Gen.GenAmount.ranges.byHi;
468                    CheckRange("hiKey", 0, 127, hiKey);
469                  break;                  break;
470              case VEL_RANGE:              case VEL_RANGE:
471                  minVel = Gen.GenAmount.ranges.byLo;                  minVel = Gen.GenAmount.ranges.byLo;
472                    CheckRange("minVel", 0, 127, minVel);
473                  maxVel = Gen.GenAmount.ranges.byHi;                  maxVel = Gen.GenAmount.ranges.byHi;
474                    CheckRange("maxVel", 0, 127, maxVel);
475                  break;                  break;
476              case STARTLOOP_ADDRS_COARSE_OFFSET:              case STARTLOOP_ADDRS_COARSE_OFFSET:
477                  startloopAddrsCoarseOffset = Gen.GenAmount.wAmount;                  startloopAddrsCoarseOffset = Gen.GenAmount.wAmount;
# Line 438  namespace sf2 { Line 489  namespace sf2 {
489                  break;                  break;
490              case COARSE_TUNE:              case COARSE_TUNE:
491                  coarseTune = Gen.GenAmount.shAmount;                  coarseTune = Gen.GenAmount.shAmount;
492                  if (coarseTune < -120) coarseTune = -120;                  CheckRange("coarseTune", -120, 120, coarseTune);
                 if (coarseTune >  120) coarseTune =  120;  
493                  break;                  break;
494              case FINE_TUNE:              case FINE_TUNE:
495                  fineTune = Gen.GenAmount.shAmount;                  fineTune = Gen.GenAmount.shAmount;
496                    CheckRange("fineTune", -99, 99, fineTune);
497                  break;                  break;
498              case SAMPLE_ID: {              case SAMPLE_ID: {
499                  uint16_t sid = Gen.GenAmount.wAmount;                  uint16_t sid = Gen.GenAmount.wAmount;
# Line 475  namespace sf2 { Line 526  namespace sf2 {
526                  break;                  break;
527              case OVERRIDING_ROOT_KEY:              case OVERRIDING_ROOT_KEY:
528                  overridingRootKey = Gen.GenAmount.shAmount;                  overridingRootKey = Gen.GenAmount.shAmount;
529                    CheckRange("overridingRootKey", -1, 127, overridingRootKey);
530                  break;                  break;
531          }          }
532      }      }
# Line 527  namespace sf2 { Line 579  namespace sf2 {
579      }      }
580    
581      double Region::GetEG1PreAttackDelay(Region* pPresetRegion) {      double Region::GetEG1PreAttackDelay(Region* pPresetRegion) {
582          if (pPresetRegion == NULL || pPresetRegion->EG1PreAttackDelay == NONE) return ToSeconds(EG1PreAttackDelay);          int val = (pPresetRegion == NULL || pPresetRegion->EG1PreAttackDelay == NONE) ?
583          return ToSeconds(pPresetRegion->EG1PreAttackDelay + EG1PreAttackDelay);                    EG1PreAttackDelay : pPresetRegion->EG1PreAttackDelay + EG1PreAttackDelay;
584            return ToSeconds(CheckRange("GetEG1PreAttackDelay()", -12000, 5000, val));
585      }      }
586    
587      double Region::GetEG1Attack(Region* pPresetRegion) {      double Region::GetEG1Attack(Region* pPresetRegion) {
588          if (pPresetRegion == NULL || pPresetRegion->EG1Attack == NONE) return ToSeconds(EG1Attack);          int val = (pPresetRegion == NULL || pPresetRegion->EG1Attack == NONE) ?
589          return ToSeconds(pPresetRegion->EG1Attack + EG1Attack);                    EG1Attack : pPresetRegion->EG1Attack + EG1Attack;
590            return ToSeconds(CheckRange("GetEG1Attack()", -12000, 8000, val));
591      }      }
592    
593      double Region::GetEG1Hold(Region* pPresetRegion) {      double Region::GetEG1Hold(Region* pPresetRegion) {
594          if (pPresetRegion == NULL || pPresetRegion->EG1Hold == NONE) return ToSeconds(EG1Hold);          int val = (pPresetRegion == NULL || pPresetRegion->EG1Hold == NONE) ?
595          return ToSeconds(pPresetRegion->EG1Hold + EG1Hold);                    EG1Hold : pPresetRegion->EG1Hold + EG1Hold;
596            return ToSeconds(CheckRange("GetEG1Hold()", -12000, 5000, val));
597      }      }
598    
599      double Region::GetEG1Decay(Region* pPresetRegion) {      double Region::GetEG1Decay(Region* pPresetRegion) {
600          if (pPresetRegion == NULL || pPresetRegion->EG1Decay == NONE) return ToSeconds(EG1Decay);          int val = (pPresetRegion == NULL || pPresetRegion->EG1Decay == NONE) ?
601          return ToSeconds(pPresetRegion->EG1Decay + EG1Decay);                    EG1Decay : pPresetRegion->EG1Decay + EG1Decay;
602            return ToSeconds(CheckRange("GetEG1Decay()", -12000, 8000, val));
603      }      }
604    
605      double Region::GetEG1Sustain(Region* pPresetRegion) {      int Region::GetEG1Sustain(Region* pPresetRegion) {
606          int sustain = EG1Sustain;          int val = (pPresetRegion == NULL || pPresetRegion->EG1Sustain == NONE) ?
607          if (pPresetRegion != NULL && pPresetRegion->EG1Sustain != NONE) sustain += EG1Sustain;                    EG1Sustain : pPresetRegion->EG1Sustain + EG1Sustain;
608          if (sustain == NONE) return NONE;          return CheckRange("GetEG1Sustain()", 0, 1440, val);
         sustain = std::min(0, std::max(sustain, 1000));  
         return ToPermilles(-sustain);  
609      }      }
610    
611      double Region::GetEG1Release(Region* pPresetRegion) {      double Region::GetEG1Release(Region* pPresetRegion) {
612          if (pPresetRegion == NULL || pPresetRegion->EG1Release == NONE) return ToSeconds(EG1Release);          int val = (pPresetRegion == NULL || pPresetRegion->EG1Release == NONE) ?
613          return ToSeconds(pPresetRegion->EG1Release + EG1Release);                    EG1Release : pPresetRegion->EG1Release + EG1Release;
614            return ToSeconds(CheckRange("GetEG1Release()", -12000, 8000, val));
615      }      }
616    
617      double Region::GetEG2PreAttackDelay(Region* pPresetRegion) {      double Region::GetEG2PreAttackDelay(Region* pPresetRegion) {
618          if (pPresetRegion == NULL || pPresetRegion->EG2PreAttackDelay == NONE) return ToSeconds(EG2PreAttackDelay);          int val = (pPresetRegion == NULL || pPresetRegion->EG2PreAttackDelay == NONE) ?
619          return ToSeconds(pPresetRegion->EG2PreAttackDelay + EG2PreAttackDelay);                    EG2PreAttackDelay : pPresetRegion->EG2PreAttackDelay + EG2PreAttackDelay;
620            return ToSeconds(CheckRange("GetEG2PreAttackDelay()", -12000, 5000, val));
621      }      }
622    
623      double Region::GetEG2Attack(Region* pPresetRegion) {      double Region::GetEG2Attack(Region* pPresetRegion) {
624          if (pPresetRegion == NULL || pPresetRegion->EG2Attack == NONE) return ToSeconds(EG2Attack);          int val = (pPresetRegion == NULL || pPresetRegion->EG2Attack == NONE) ?
625          return ToSeconds(pPresetRegion->EG2Attack + EG2Attack);                    EG2Attack : pPresetRegion->EG2Attack + EG2Attack;
626            return ToSeconds(CheckRange("GetEG2Attack()", -12000, 8000, val));
627      }      }
628    
629      double Region::GetEG2Hold(Region* pPresetRegion) {      double Region::GetEG2Hold(Region* pPresetRegion) {
630          if (pPresetRegion == NULL || pPresetRegion->EG2Hold == NONE) return ToSeconds(EG2Hold);          int val = (pPresetRegion == NULL || pPresetRegion->EG2Hold == NONE) ?
631          return ToSeconds(pPresetRegion->EG2Hold + EG2Hold);                    EG2Hold : pPresetRegion->EG2Hold + EG2Hold;
632            return ToSeconds(CheckRange("GetEG2Hold()", -12000, 5000, val));
633      }      }
634    
635      double Region::GetEG2Decay(Region* pPresetRegion) {      double Region::GetEG2Decay(Region* pPresetRegion) {
636          if (pPresetRegion == NULL || pPresetRegion->EG2Decay == NONE) return ToSeconds(EG2Decay);          int val = (pPresetRegion == NULL || pPresetRegion->EG2Decay == NONE) ?
637          return ToSeconds(pPresetRegion->EG2Decay + EG2Decay);                    EG2Decay : pPresetRegion->EG2Decay + EG2Decay;
638            return ToSeconds(CheckRange("GetEG2Decay()", -12000, 8000, val));
639      }      }
640    
641      double Region::GetEG2Sustain(Region* pPresetRegion) {      int Region::GetEG2Sustain(Region* pPresetRegion) {
642          if (pPresetRegion == NULL || pPresetRegion->EG2Sustain == NONE) {          int val = (pPresetRegion == NULL || pPresetRegion->EG2Sustain == NONE) ?
643              return EG2Sustain == NONE ? NONE : 1000 - EG2Sustain;                    EG2Sustain : pPresetRegion->EG2Sustain + EG2Sustain;
644          }          return CheckRange("GetEG2Sustain()", 0, 1000, val);
         return 1000 - (pPresetRegion->EG2Sustain + EG2Sustain);  
645      }      }
646    
647      double Region::GetEG2Release(Region* pPresetRegion) {      double Region::GetEG2Release(Region* pPresetRegion) {
648          if (pPresetRegion == NULL || pPresetRegion->EG2Release == NONE) return ToSeconds(EG2Release);          int val = (pPresetRegion == NULL || pPresetRegion->EG2Release == NONE) ?
649          return ToSeconds(pPresetRegion->EG2Release + EG2Release);                    EG2Release : pPresetRegion->EG2Release + EG2Release;
650            return ToSeconds(CheckRange("GetEG2Release()", -12000, 8000, val));
651      }      }
652    
653      int Region::GetModEnvToPitch(Region* pPresetRegion) {      int Region::GetModEnvToPitch(Region* pPresetRegion) {
654          return modEnvToPitch + (pPresetRegion ? pPresetRegion->modEnvToPitch : 0);          int val = (pPresetRegion == NULL || pPresetRegion->modEnvToPitch == NONE) ?
655                       modEnvToPitch : pPresetRegion->modEnvToPitch + modEnvToPitch;
656            return CheckRange("GetModEnvToPitch()", -12000, 12000, val);
657      }      }
658    
659      int Region::GetModLfoToPitch(Region* pPresetRegion) {      int Region::GetModLfoToPitch(Region* pPresetRegion) {
660          return modLfoToPitch + (pPresetRegion ? pPresetRegion->modLfoToPitch : 0);          int val = (pPresetRegion == NULL || pPresetRegion->modLfoToPitch == NONE) ?
661                       modLfoToPitch : pPresetRegion->modLfoToPitch + modLfoToPitch;
662            return CheckRange("GetModLfoToPitch()", -12000, 12000, val);
663      }      }
664    
665      int Region::GetModEnvToFilterFc(Region* pPresetRegion) {      int Region::GetModEnvToFilterFc(Region* pPresetRegion) {
666          return modEnvToFilterFc + (pPresetRegion ? pPresetRegion->modEnvToFilterFc : 0);          int val = (pPresetRegion == NULL || pPresetRegion->modEnvToFilterFc == NONE) ?
667                       modEnvToFilterFc : pPresetRegion->modEnvToFilterFc + modEnvToFilterFc;
668            return CheckRange("GetModEnvToFilterFc()", -12000, +12000, val);
669      }      }
670    
671      int Region::GetModLfoToFilterFc(Region* pPresetRegion) {      int Region::GetModLfoToFilterFc(Region* pPresetRegion) {
672          return modLfoToFilterFc + (pPresetRegion ? pPresetRegion->modLfoToFilterFc : 0);          int val = (pPresetRegion == NULL || pPresetRegion->modLfoToFilterFc == NONE) ?
673                       modLfoToFilterFc : pPresetRegion->modLfoToFilterFc + modLfoToFilterFc;
674            return CheckRange("GetModLfoToFilterFc()", -12000, +12000, val);
675      }      }
676    
677      double Region::GetModLfoToVolume(Region* pPresetRegion) {      double Region::GetModLfoToVolume(Region* pPresetRegion) {
678          return ToPermilles(modLfoToVolume + (pPresetRegion ? pPresetRegion->modLfoToVolume : 0));          int val = (pPresetRegion == NULL || pPresetRegion->modLfoToVolume == NONE) ?
679                       modLfoToVolume : pPresetRegion->modLfoToVolume + modLfoToVolume;
680            return CheckRange("GetModLfoToVolume()", -960, 960, val);
681      }      }
682    
683      double Region::GetFreqModLfo(Region* pPresetRegion) {      double Region::GetFreqModLfo(Region* pPresetRegion) {
684          if (pPresetRegion == NULL || pPresetRegion->freqModLfo == NONE) return ToHz(freqModLfo);          int val = (pPresetRegion == NULL || pPresetRegion->freqModLfo == NONE) ?
685          return ToHz(pPresetRegion->freqModLfo + freqModLfo);                    freqModLfo : pPresetRegion->freqModLfo + freqModLfo;
686            return ToHz(CheckRange("GetFreqModLfo()", -16000, 4500, val));
687      }      }
688    
689      double Region::GetDelayModLfo(Region* pPresetRegion) {      double Region::GetDelayModLfo(Region* pPresetRegion) {
690          if (pPresetRegion == NULL || pPresetRegion->delayModLfo == NONE) return ToSeconds(delayModLfo);          int val = (pPresetRegion == NULL || pPresetRegion->delayModLfo == NONE) ?
691          return ToSeconds(pPresetRegion->delayModLfo + delayModLfo);                    delayModLfo : pPresetRegion->delayModLfo + delayModLfo;
692            return ToSeconds(CheckRange("GetDelayModLfo()", -12000, 5000, val));
693      }      }
694    
695      int Region::GetVibLfoToPitch(Region* pPresetRegion) {      int Region::GetVibLfoToPitch(Region* pPresetRegion) {
696          return vibLfoToPitch + (pPresetRegion ? pPresetRegion->vibLfoToPitch : 0);          int val = (pPresetRegion == NULL || pPresetRegion->vibLfoToPitch == NONE) ?
697                       vibLfoToPitch : pPresetRegion->vibLfoToPitch + vibLfoToPitch;
698            return CheckRange("GetVibLfoToPitch()", -12000, 12000, val);
699      }      }
700    
701      double Region::GetFreqVibLfo(Region* pPresetRegion) {      double Region::GetFreqVibLfo(Region* pPresetRegion) {
702          if (pPresetRegion == NULL || pPresetRegion->freqVibLfo == NONE) return ToHz(freqVibLfo);          int val = (pPresetRegion == NULL || pPresetRegion->freqVibLfo == NONE) ?
703          return ToHz(pPresetRegion->freqVibLfo + freqVibLfo);                    freqVibLfo : pPresetRegion->freqVibLfo + freqVibLfo;
704            return ToHz(CheckRange("GetFreqVibLfo()", -16000, 4500, val));
705      }      }
706    
707      double Region::GetDelayVibLfo(Region* pPresetRegion) {      double Region::GetDelayVibLfo(Region* pPresetRegion) {
708          if (pPresetRegion == NULL || pPresetRegion->delayVibLfo == NONE) return ToSeconds(delayVibLfo);          int val = (pPresetRegion == NULL || pPresetRegion->delayVibLfo == NONE) ?
709          return ToSeconds(pPresetRegion->delayVibLfo + delayVibLfo);                    delayVibLfo : pPresetRegion->delayVibLfo + delayVibLfo;
710            return ToSeconds(CheckRange("GetDelayVibLfo()", -12000, 5000, val));
711        }
712    
713        int Region::GetInitialFilterFc(Region* pPresetRegion) {
714            if (pPresetRegion == NULL || pPresetRegion->initialFilterFc == NONE) return initialFilterFc;
715            int val = pPresetRegion->initialFilterFc + initialFilterFc;
716            return CheckRange("GetInitialFilterFc()", 1500, 13500, val);
717        }
718    
719        int Region::GetInitialFilterQ(Region* pPresetRegion) {
720            int val = (pPresetRegion == NULL || pPresetRegion->initialFilterQ == NONE) ?
721                       initialFilterQ : pPresetRegion->initialFilterQ + initialFilterQ;
722            return CheckRange("GetInitialFilterQ()", 0, 960, val);
723      }      }
724    
725      InstrumentBase::InstrumentBase(sf2::File* pFile) {      InstrumentBase::InstrumentBase(sf2::File* pFile) {
# Line 729  namespace sf2 { Line 816  namespace sf2 {
816              r->vibLfoToPitch     = pGlobalRegion->vibLfoToPitch;              r->vibLfoToPitch     = pGlobalRegion->vibLfoToPitch;
817              r->freqVibLfo        = pGlobalRegion->freqVibLfo;              r->freqVibLfo        = pGlobalRegion->freqVibLfo;
818              r->delayVibLfo       = pGlobalRegion->delayVibLfo;              r->delayVibLfo       = pGlobalRegion->delayVibLfo;
819                r->initialFilterFc   = pGlobalRegion->initialFilterFc;
820                r->initialFilterQ    = pGlobalRegion->initialFilterQ;
821    
822              r->HasLoop    = pGlobalRegion->HasLoop;              r->HasLoop    = pGlobalRegion->HasLoop;
823              r->LoopStart  = pGlobalRegion->LoopStart;              r->LoopStart  = pGlobalRegion->LoopStart;
# Line 812  namespace sf2 { Line 901  namespace sf2 {
901          r->EG1PreAttackDelay = r->EG1Attack = r->EG1Hold = r->EG1Decay = r->EG1Sustain = r->EG1Release = NONE;          r->EG1PreAttackDelay = r->EG1Attack = r->EG1Hold = r->EG1Decay = r->EG1Sustain = r->EG1Release = NONE;
902          r->EG2PreAttackDelay = r->EG2Attack = r->EG2Hold = r->EG2Decay = r->EG2Sustain = r->EG2Release = NONE;          r->EG2PreAttackDelay = r->EG2Attack = r->EG2Hold = r->EG2Decay = r->EG2Sustain = r->EG2Release = NONE;
903          r->freqModLfo = r->delayModLfo = r->freqVibLfo = r->delayVibLfo = NONE;          r->freqModLfo = r->delayModLfo = r->freqVibLfo = r->delayVibLfo = NONE;
904            r->initialFilterFc = r->initialFilterQ = NONE;
905    
906          if (pGlobalRegion != NULL) {          if (pGlobalRegion != NULL) {
907              r->pan         = pGlobalRegion->pan;              r->pan         = pGlobalRegion->pan;
# Line 842  namespace sf2 { Line 932  namespace sf2 {
932              r->vibLfoToPitch     = pGlobalRegion->vibLfoToPitch;              r->vibLfoToPitch     = pGlobalRegion->vibLfoToPitch;
933              r->freqVibLfo        = pGlobalRegion->freqVibLfo;              r->freqVibLfo        = pGlobalRegion->freqVibLfo;
934              r->delayVibLfo       = pGlobalRegion->delayVibLfo;              r->delayVibLfo       = pGlobalRegion->delayVibLfo;
935                r->initialFilterFc   = pGlobalRegion->initialFilterFc;
936                r->initialFilterQ    = pGlobalRegion->initialFilterQ;
937          }          }
938    
939          return r;          return r;
Legend:
Removed from v.2205  
changed lines
  Added in v.2206
  ViewVC Help
Powered by ViewVC