ShootingGame/WaveTableSynth.cpp

   1 #include "pch.h"
   2 //#include "xbyak\xbyak.h"
   3 #include "WaveTableSynth.h"
   4
   5 using namespace std::placeholders;
   6
   7 namespace sf {
   8
   9   std::vector<Synthesizer::WaveTable> Synthesizer::WaveTable::WaveTables;
  10
  11   void makeWaveFormat(WAVEFORMATEXTENSIBLE& format,
  12     int sample_rate = 44100,int channels = 2,int bits_per_sample = 32,int valid_bits_per_sample = 32,
  13     uint32_t type = WAVE_FORMAT_EXTENSIBLE,
  14     const GUID& sub_type = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)
  15   {
  16     ZeroMemory(&format,sizeof(WAVEFORMATEXTENSIBLE));
  17     format.Format.wFormatTag = type;
  18     format.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
  19     format.SubFormat = sub_type;
  20     format.Format.nSamplesPerSec = sample_rate;
  21     format.Format.nChannels = channels;
  22     format.Format.wBitsPerSample = bits_per_sample;
  23     format.Format.nBlockAlign = (format.Format.wBitsPerSample / 8) * format.Format.nChannels;
  24     format.Format.nAvgBytesPerSec = format.Format.nSamplesPerSec  * format.Format.nBlockAlign;
  25     format.Samples.wValidBitsPerSample = valid_bits_per_sample;
  26     format.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
  27   }
  28
  29   void makeWaveFormat(WAVEFORMATEX& format,int sample_rate = 44100,int channels = 2,int bits = 16,uint32_t type = WAVE_FORMAT_PCM)
  30   {
  31     ZeroMemory(&format,sizeof(WAVEFORMATEX));
  32     format.wFormatTag = type;
  33     format.nSamplesPerSec = sample_rate;
  34     format.nChannels = channels;
  35     format.wBitsPerSample = bits;
  36     format.nBlockAlign = (format.wBitsPerSample / 8) * format.nChannels;
  37     format.nAvgBytesPerSec = format.nSamplesPerSec  * format.nBlockAlign;
  38   };
  39
  40   void Synthesizer::WaveTableOscillator::WaveTable(Synthesizer::WaveTable *p)
  41   {
  42     waveTable_ = p;
  43     if(waveTable_->stereo)
  44     {
  45       processor_ = std::bind(&sf::Synthesizer::WaveTableOscillator::ProcessStereo,this,_1,_2,_3);
  46     } else {
  47       processor_ = std::bind(&sf::Synthesizer::WaveTableOscillator::ProcessMono,this,_1,_2,_3);
  48     }
  49
  50   }
  51
  52   struct Synthesizer::impl {
  53
  54     impl(){};
  55     explicit impl(WAVEFORMATEXTENSIBLE& format,int channel) : format_(format) ,isEnable_(false)
  56     {
  57
  58       // Voice\82Ì\83Z\83b\83g\83A\83b\83v
  59       //Voice v((float)format.Format.nSamplesPerSec);
  60       //v.SetProgram(0,programs_[0]);
  61       //Voice v1((float)format.Format.nSamplesPerSec);
  62       //v1.SetProgram(0,programs_[0]);
  63       //Voice v4 = v;
  64       //Voice v5 = v;
  65       //Voice v2 = std::move(v);
  66       //Voice v3(std::move(v1));
  67
  68       for(int i = 0; i < channel;++i)
  69       {
  70         voices_.push_back(Voice((float)format.Format.nSamplesPerSec));
  71       }
  72
  73     };
  74
  75     ~impl(){};
  76
  77     void Restart(){};
  78
  79     void Process(float *buffer)
  80     {
  81       for(int j = 0;j < voices_.size();++j)
  82       {
  83         voices_[j].Process(buffer);
  84         //*buffer +=  buffer[0];
  85         //*(buffer+ 1) += buffer[1];
  86       }
  87     }
  88     //void ProcessBuffer(boost::shared_array<float> arr,int bufferSize)
  89     //{
  90     //  // \8d¡\82Ì\82Æ\82±\82ë\8fo\97Í\82Í\83X\83e\83\8c\83I\91O\92ñ
  91     //  float *ptr = arr.get();
  92     //  float buffer[2];
  93     //  for(int i = 0;i < bufferSize;++i)
  94     //  {
  95     //    for(int j = 0;j < voices_.size();++j)
  96     //    {
  97     //      voices_[j].Process(buffer);
  98     //      *ptr +=  buffer[0];
  99     //      *(ptr + 1) += buffer[1];
 100     //    }
 101     //    ptr += 2;
 102     //  }
 103
 104     //  //static float sampleIncrement = (440.0f /* Hz */ * (M_PI * 2.0f)) / (float)format_.Format.nSamplesPerSec;
 105     //  //static float theta = 0.0f;
 106
 107     //  //for (size_t i = 0 ; i < bufferSize ; ++i)
 108     //  //{
 109     //  //  float sinValue = sinf( theta );
 110     //  //  int offset = i * format_.Format.nChannels;
 111     //  //  for(size_t j = 0 ;j < format_.Format.nChannels; j++)
 112     //  //  {
 113     //  //    arr[offset + j] = sinValue;
 114     //  //  }
 115     //  //  theta += sampleIncrement;
 116     //  //}
 117     //}
 118
 119
 120     enum struct EnvelopeStatus
 121     {
 122       None,Attack,Decay,Sustain,Release,End
 123     };
 124
 125     struct EnvelopeController
 126     {
 127       EnvelopeController() : envelope_(nullptr),stepTime_(1.0f / 44100.0f)
 128       {
 129       }
 130       EnvelopeController(const EnvelopeController& src) :
 131         envelope_(src.envelope_),
 132         status_(src.status_),
 133         delta_(src.delta_),
 134         counter_(src.counter_),
 135         stepTime_(src.stepTime_),
 136         time_(src.time_),
 137         value_(src.value_)
 138       {}
 139
 140       EnvelopeController(EnvelopeController&& src) :
 141         envelope_(std::move( src.envelope_)),
 142         status_(std::move(src.status_)),
 143         delta_(std::move(src.delta_)),
 144         counter_(std::move(src.counter_)),
 145         stepTime_(std::move(src.stepTime_)),
 146         time_(std::move(src.time_)),
 147         value_(std::move(src.value_))
 148       {}
 149
 150       EnvelopeController& operator= (const EnvelopeController& src)
 151       {
 152         if(this != &src)
 153         {
 154           envelope_ = src.envelope_;
 155           status_ = src.status_;
 156           delta_ = src.delta_;
 157           counter_ = src.counter_;
 158           stepTime_ = src.stepTime_;
 159           time_ = src.time_;
 160           value_ = src.value_;
 161         }
 162         return *this;
 163       }
 164
 165       EnvelopeController& operator= (EnvelopeController&& src)
 166       {
 167         if(this != &src)
 168         {
 169           envelope_ = std::move(src.envelope_);
 170           status_ = std::move(src.status_);
 171           delta_ = std::move(src.delta_);
 172           counter_ = std::move(src.counter_);
 173           stepTime_ = std::move(src.stepTime_);
 174           time_ = std::move(src.time_);
 175           value_ = std::move(src.value_);
 176         }
 177         return *this;
 178       }
 179
 180       void Reset()
 181       {
 182         status_ = EnvelopeStatus::None;
 183       }
 184
 185       void Init(Envelope * env,float sampleRate)
 186       {
 187         envelope_ = env;
 188         stepTime_ = 1.0f / sampleRate;
 189       }
 190
 191       void Attack()
 192       {
 193         counter_ = 0.0f;
 194         if(envelope_->attackTime == 0.0f)
 195         {
 196           value_ = 1.0f;
 197           return Decay();
 198         }
 199         status_ = EnvelopeStatus::Attack;
 200         delta_ = stepTime_ /  envelope_->attackTime;
 201         value_ = 0.0f;
 202
 203       }
 204
 205       void Decay()
 206       {
 207         if(envelope_->sustainLevel == 1.0f)
 208         {
 209           Sustain();
 210         }
 211         delta_ = (1.0f - envelope_->sustainLevel) * stepTime_ / (envelope_->decayTime);
 212         status_ = EnvelopeStatus::Decay;
 213       }
 214
 215       void Sustain()
 216       {
 217
 218         if(envelope_->sustainLevel == 0.0f)
 219         {
 220           status_ = EnvelopeStatus::End;
 221         }
 222
 223         status_ = EnvelopeStatus::Sustain;
 224       }
 225
 226       void Release()
 227       {
 228         if(envelope_->releaseNoteOff){
 229           delta_ = value_ * stepTime_ / (envelope_->releaseTime );
 230           status_ = EnvelopeStatus::Release;
 231         }
 232       }
 233
 234       float Process()
 235       {
 236         if(!IsEnable())
 237         {
 238           return 1.0f;
 239         }
 240
 241         if(envelope_->gain == 0.0f)
 242         {
 243           return 0.0f;
 244         }
 245         counter_ += stepTime_;
 246         switch (status_)
 247         {
 248         case EnvelopeStatus::Attack:
 249           value_ += delta_;
 250           if(value_ >= 1.0f)
 251           {
 252             value_ = 1.0f;
 253             Decay();
 254           }
 255           break;
 256         case EnvelopeStatus::Decay:
 257           value_ -= delta_;
 258           if(value_ <= envelope_->sustainLevel)
 259           {
 260             value_ = envelope_->sustainLevel;
 261             Sustain();
 262           }
 263           break;
 264         case EnvelopeStatus::Sustain:
 265           {
 266             value_ =  envelope_->sustainLevel;
 267           }
 268           break;
 269         case EnvelopeStatus::Release:
 270           {
 271             value_ -= delta_;
 272             if(value_ <= 0.0f)
 273             {
 274               value_ = 0.0f;
 275               status_ = EnvelopeStatus::End;
 276             }
 277           }
 278           break;
 279         }
 280         return value_ * envelope_->gain;
 281       }
 282
 283       EnvelopeStatus GetStatus()
 284       {
 285         return status_;
 286       }
 287
 288       bool IsEnable() const {return envelope_ != nullptr && envelope_->enable;}
 289
 290     private:
 291       Envelope* envelope_;
 292       EnvelopeStatus status_;
 293       float delta_;
 294       float counter_;
 295       float stepTime_;
 296       float time_;
 297       float value_;
 298     };
 299
 300     struct LFOController
 301     {
 302       LFOController() : lfo_(nullptr),value_(0.0f),stepTime_(0.0f)
 303       {
 304       };
 305
 306       LFOController(const LFOController& src) :
 307         lfo_(src.lfo_),
 308         osc_(src.osc_),
 309         envelopeController_(src.envelopeController_),
 310         sampleRate_(src.sampleRate_),
 311         value_(src.value_),
 312         stepTime_(src.stepTime_),
 313         pitchDelta_(src.pitchDelta_),
 314         stepDelta_(src.stepDelta_)
 315       {
 316
 317       }
 318
 319       LFOController(LFOController&& src) :
 320         lfo_(std::move(src.lfo_)),
 321         osc_(std::move(src.osc_)),
 322         envelopeController_(std::move(src.envelopeController_)),
 323         sampleRate_(std::move(src.sampleRate_)),
 324         value_(std::move(src.value_)),
 325         stepTime_(std::move(src.stepTime_)),
 326         pitchDelta_(std::move(src.pitchDelta_)),
 327         stepDelta_(std::move(src.stepDelta_))
 328       {
 329
 330       }
 331
 332       LFOController& operator= (const LFOController& src)
 333       {
 334         if(this != & src)
 335         {
 336           lfo_ = src.lfo_;
 337           osc_ = src.osc_;
 338           envelopeController_ = src.envelopeController_;
 339           sampleRate_ = src.sampleRate_;
 340           value_ = src.value_;
 341           stepTime_ = src.stepTime_;
 342           pitchDelta_ = src.pitchDelta_;
 343           stepDelta_ = src.stepDelta_;
 344         }
 345         return *this;
 346       }
 347
 348       LFOController& operator= (LFOController&& src)
 349       {
 350         if(this != & src)
 351         {
 352           lfo_ = std::move(src.lfo_);
 353           osc_ = std::move(src.osc_);
 354           envelopeController_ = std::move(src.envelopeController_);
 355           sampleRate_ = std::move(src.sampleRate_);
 356           value_ = std::move(src.value_);
 357           stepTime_ = std::move(src.stepTime_);
 358           pitchDelta_ = std::move(src.pitchDelta_);
 359           stepDelta_ = std::move(src.stepDelta_);
 360         }
 361         return *this;
 362       }
 363
 364       void LFOController::LFO(sf::Synthesizer::LFO *lfo)
 365       {
 366         lfo_ = lfo;
 367       }
 368
 369       sf::Synthesizer::LFO& LFOController::LFO()
 370       {
 371         return *lfo_;
 372       }
 373
 374       void Init(float sampleRate)
 375       {
 376         // assert(lfo_ != nullptr);
 377         osc_.WaveTable(lfo_->waveForm);
 378         sampleRate_ = sampleRate;
 379         stepDelta_ = 1.0f / sampleRate_;
 380         pitchDelta_ = lfo_->freq  * ((float)osc_.WaveTable().waveData.size()) /  ( sampleRate_ );
 381         envelopeController_.Init(&lfo_->envelope,sampleRate);
 382       };
 383
 384       void Attack()
 385       {
 386         envelopeController_.Attack();
 387       }
 388
 389       void Release()
 390       {
 391         envelopeController_.Release();
 392       }
 393
 394       void Reset()
 395       {
 396         assert(lfo_ != nullptr);
 397       }
 398
 399       float Process()
 400       {
 401         float buffer[2];
 402         osc_.Process(buffer,pitchDelta_,1.0f);
 403         float value = buffer[0];
 404         value = value * envelopeController_.Process() * lfo_->gain;
 405         return value;
 406       };
 407
 408       void PreProcess()
 409       {
 410         float buffer[2];
 411         osc_.Process(buffer,pitchDelta_,0.0f);
 412         envelopeController_.Process();
 413       }
 414
 415       float SampleRate() const {return sampleRate_;}
 416       void SampleRate(float v)
 417       {
 418         sampleRate_ = v;
 419       }
 420
 421       //      Synthesizer::impl::Envelope& Envelope() {return envelope_;}
 422
 423
 424     private:
 425       sf::Synthesizer::LFO * lfo_;
 426       WaveTableOscillator osc_;
 427       //      Synthesizer::impl::Envelope envelope_;
 428       EnvelopeController envelopeController_;
 429       float sampleRate_;
 430       float value_;
 431       float stepTime_;
 432       float pitchDelta_;
 433       float stepDelta_;
 434     };
 435
 436     struct FilterController
 437     {
 438       //sampleRate_,
 439       //  filter_,
 440       //  y1_,
 441       //  y2_,
 442       //  y3_,
 443       //  y4_,
 444       //  oldx_,
 445       //  oldy1_,
 446       //  oldy2_,
 447       //  oldy3_,
 448       //  x_,
 449       //  r_,
 450       //  p_,
 451       //  k_
 452
 453       FilterController() :
 454         cutoff_(0.0f),
 455         sampleRate_(44100.0f),
 456         filter_(nullptr),
 457         y1_(0.0f),
 458         y2_(0.0f),
 459         y3_(0.0f),
 460         y4_(0.0f),
 461         oldx_(0.0f),
 462         oldy1_(0.0f),
 463         oldy2_(0.0f),
 464         oldy3_(0.0f),
 465         x_(0.0f),
 466         r_(0.0f),
 467         p_(0.0f),
 468         k_(0.0f)
 469       {
 470         //        Init();
 471       }
 472
 473       FilterController(const FilterController& src) :
 474         cutoff_(src.cutoff_),
 475         sampleRate_(src.sampleRate_),
 476         filter_(src.filter_),
 477         y1_(src.y1_),
 478         y2_(src.y2_),
 479         y3_(src.y3_),
 480         y4_(src.y4_),
 481         oldx_(src.oldx_),
 482         oldy1_(src.oldy1_),
 483         oldy2_(src.oldy2_),
 484         oldy3_(src.oldy3_),
 485         x_(src.x_),
 486         r_(src.r_),
 487         p_(src.p_),
 488         k_(src.k_)
 489       {
 490
 491       }
 492
 493       FilterController(FilterController&& src) :
 494         cutoff_(std::move(src.cutoff_)),
 495         sampleRate_(std::move(src.sampleRate_)),
 496         filter_(std::move(src.filter_)),
 497         y1_(std::move(src.y1_)),
 498         y2_(std::move(src.y2_)),
 499         y3_(std::move(src.y3_)),
 500         y4_(std::move(src.y4_)),
 501         oldx_(std::move(src.oldx_)),
 502         oldy1_(std::move(src.oldy1_)),
 503         oldy2_(std::move(src.oldy2_)),
 504         oldy3_(std::move(src.oldy3_)),
 505         x_(std::move(src.x_)),
 506         r_(std::move(src.r_)),
 507         p_(std::move(src.p_)),
 508         k_(std::move(src.k_))
 509       {
 510
 511       }
 512
 513       FilterController& operator= (const FilterController& src)
 514       {
 515         if(this != &src)
 516         {
 517           cutoff_ = src.cutoff_;
 518           sampleRate_ = src.sampleRate_;
 519           filter_ = src.filter_;
 520           y1_ = src.y1_;
 521           y2_ = src.y2_;
 522           y3_ = src.y3_;
 523           y4_ = src.y4_;
 524           oldx_ = src.oldx_;
 525           oldy1_ = src.oldy1_;
 526           oldy2_ = src.oldy2_;
 527           oldy3_ = src.oldy3_;
 528           x_ = src.x_;
 529           r_ = src.r_;
 530           p_ = src.p_;
 531           k_ = src.k_;
 532         }
 533         return *this;
 534       }
 535
 536       FilterController& operator= (FilterController&& src)
 537       {
 538         if(this != &src)
 539         {
 540           cutoff_ = std::move(src.cutoff_);
 541           sampleRate_ = std::move(src.sampleRate_);
 542           filter_ = std::move(src.filter_);
 543           y1_ = std::move(src.y1_);
 544           y2_ = std::move(src.y2_);
 545           y3_ = std::move(src.y3_);
 546           y4_ = std::move(src.y4_);
 547           oldx_ = std::move(src.oldx_);
 548           oldy1_ = std::move(src.oldy1_);
 549           oldy2_ = std::move(src.oldy2_);
 550           oldy3_ = std::move(src.oldy3_);
 551           x_ = std::move(src.x_);
 552           r_ = std::move(src.r_);
 553           p_ = std::move(src.p_);
 554           k_ = std::move(src.k_);
 555         }
 556         return *this;
 557       }
 558
 559       ~FilterController(){}
 560
 561       void Init(Synthesizer::Filter* filter,float sampleRate)
 562       {
 563         filter_ = filter;
 564         cutoff_ = filter->cutoff;
 565         sampleRate_ = sampleRate;
 566         assert(filter_ != nullptr);
 567
 568         y1_ = y2_ = y3_ = y4_ = oldx_ = oldy1_ = oldy2_ = oldy3_ = 0.0f;
 569         Calc();
 570       }
 571
 572       void Calc()
 573       {
 574         float f = (cutoff_ + cutoff_) / sampleRate_;
 575         p_ = f * (1.8f - 0.8f * f);
 576         k_ = p_+ p_ - 1.0f;
 577
 578         float t = (1.0f - p_) * 1.386249f;
 579         float t2 = 12.0f + t*t;
 580         r_ = filter_->resonance * (t2 + 6.0f * t) / (t2 - 6.0f * t);
 581       }
 582
 583       float Process(float input)
 584       {
 585         x_ = input - r_ * y4_;
 586
 587         y1_ = x_ * p_ +  oldx_ * p_ -  k_ * y1_;
 588         y2_ = y1_ * p_ + oldy1_ * p_ - k_ * y2_;
 589         y3_ = y2_ * p_ + oldy2_ * p_ - k_ * y3_;
 590         y4_ = y3_ * p_ + oldy3_ * p_ - k_ * y4_;
 591
 592         y4_ -= (y4_ * y4_ * y4_) / 6.0f;
 593
 594         oldx_ = x_; oldy1_ = y1_; oldy2_ = y2_; oldy3_ = y3_;
 595         return y4_;
 596       }
 597
 598       Synthesizer::Filter* FilterController::Filter()
 599       {
 600         return filter_;
 601       }
 602
 603       void FilterController::Filter(Synthesizer::Filter* filter)
 604       {
 605         Init(filter,sampleRate_);
 606       }
 607
 608       void Start()
 609       {
 610         y1_ = y2_ = y3_ = y4_ = oldx_ = oldy1_ = oldy2_ = oldy3_ = 0.0f;
 611         Calc();
 612       }
 613
 614       void CutOff(float v ) {cutoff_ = v;Calc();}
 615       float CutOff() const {return cutoff_;}
 616
 617     private:
 618       float cutoff_;
 619       float sampleRate_;
 620       Synthesizer::Filter *filter_;
 621       float fs_;
 622       float y1_,y2_,y3_,y4_;
 623       float oldx_;
 624       float oldy1_,oldy2_,oldy3_;
 625       float x_;
 626       float r_;
 627       float p_;
 628       float k_;
 629
 630     };
 631
 632
 633
 634     struct Voice
 635     {
 636
 637       explicit Voice(float sampleRate)
 638         :
 639       programNo_(0),
 640         noteOn_(false),
 641         isFree_(true),
 642         pitchOffset_(0.0f),
 643         volumeOffset_(1.0f),
 644         stepTime_(0.0f),
 645         currentTime_(0.0f),
 646         curentIndex_(0),
 647         pan_(0.5f),
 648         sampleRate_(sampleRate),
 649         pitchDelta_(0.0f),
 650         pitchCounter_(0.0f),
 651         waveSize_(0)
 652       {};
 653
 654       Voice(const Voice& src)
 655         :
 656         timber_(src.timber_),
 657         programNo_(src.programNo_),
 658         noteOn_(src.noteOn_),
 659         isFree_(src.isFree_),
 660         pitchOffset_(src.pitchOffset_),
 661         volumeOffset_(src.volumeOffset_),
 662         stepTime_(src.stepTime_),
 663         currentTime_(src.currentTime_),
 664         curentIndex_(src.curentIndex_),
 665         pan_(src.pan_),
 666         sampleRate_(src.sampleRate_),
 667         pitchDelta_(src.pitchDelta_),
 668         pitchCounter_(src.pitchCounter_),
 669         waveSize_(src.waveSize_),
 670         ampEnv_(src.ampEnv_),
 671         ampLFO_(src.ampLFO_),
 672         filterEnv_(src.filterEnv_),
 673         filterLFO_(src.filterLFO_),
 674         filterL_(src.filterL_),
 675         filterR_(src.filterR_),
 676         pitchEnv_(src.pitchEnv_),
 677         pitchLFO_(src.pitchLFO_),
 678         panEnv_(src.panEnv_),
 679         panLFO_(src.panLFO_)
 680       {
 681         //        osc_ = std::move(osc_->Clone());
 682       }
 683
 684       Voice(Voice&& src)
 685         :
 686         timber_(std::move(src.timber_)),
 687         programNo_(std::move(src.programNo_)),
 688         noteOn_(std::move(src.noteOn_)),
 689         isFree_(std::move(src.isFree_)),
 690         pitchOffset_(std::move(src.pitchOffset_)),
 691         volumeOffset_(std::move(src.volumeOffset_)),
 692         stepTime_(std::move(src.stepTime_)),
 693         currentTime_(std::move(src.currentTime_)),
 694         curentIndex_(std::move(src.curentIndex_)),
 695         pan_(std::move(src.pan_)),
 696         sampleRate_(std::move(src.sampleRate_)),
 697         pitchDelta_(std::move(src.pitchDelta_)),
 698         pitchCounter_(std::move(src.pitchCounter_)),
 699         waveSize_(std::move(src.waveSize_)),
 700         //        osc_(std::move(src.osc_)),
 701         ampEnv_(std::move(src.ampEnv_)),
 702         ampLFO_(std::move(src.ampLFO_)),
 703         filterEnv_(std::move(src.filterEnv_)),
 704         filterLFO_(std::move(src.filterLFO_)),
 705         filterL_(std::move(src.filterL_)),
 706         filterR_(std::move(src.filterR_)),
 707         pitchEnv_(std::move(src.pitchEnv_)),
 708         pitchLFO_(std::move(src.pitchLFO_)),
 709         panEnv_(std::move(src.panEnv_)),
 710         panLFO_(std::move(src.panLFO_))
 711       {
 712         //       osc_.reset(src.osc_.release());
 713         //       *this = std::move(src);
 714       }
 715
 716       Voice& operator= (const Voice& src)
 717       {
 718         if(this != &src)
 719         {
 720           timber_ = src.timber_;
 721           programNo_ = src.programNo_;
 722           noteOn_ = src.noteOn_;
 723           isFree_ = src.isFree_;
 724           pitchOffset_ = src.pitchOffset_;
 725           volumeOffset_ = src.volumeOffset_;
 726           stepTime_ = src.stepTime_;
 727           currentTime_ = src.currentTime_;
 728           curentIndex_ = src.curentIndex_;
 729           pan_ = src.pan_;
 730           sampleRate_ = src.sampleRate_;
 731           pitchDelta_ = src.pitchDelta_;
 732           pitchCounter_ = src.pitchCounter_;
 733           waveSize_ = src.waveSize_;
 734           //        osc_ = src.osc_->Clone();
 735           ampEnv_ = src.ampEnv_;
 736           ampLFO_ = src.ampLFO_;
 737           filterEnv_ = src.filterEnv_;
 738           filterLFO_ = src.filterLFO_;
 739           filterL_ = src.filterL_;
 740           filterR_ = src.filterR_;
 741           pitchEnv_ = src.pitchEnv_;
 742           pitchLFO_ = src.pitchLFO_;
 743           panEnv_ = src.panEnv_;
 744           panLFO_ = src.panLFO_;
 745         }
 746         return *this;
 747       }
 748
 749       Voice& operator= (Voice&& src)
 750       {
 751         if(this != &src)
 752         {
 753           timber_ = std::move(src.timber_);
 754           programNo_ = std::move(src.programNo_);
 755           noteOn_ = std::move(src.noteOn_);
 756           isFree_ = std::move(src.isFree_);
 757           pitchOffset_ = std::move(src.pitchOffset_);
 758           volumeOffset_ = std::move(src.volumeOffset_);
 759           stepTime_ = std::move(src.stepTime_);
 760           currentTime_ = std::move(src.currentTime_);
 761           curentIndex_ = std::move(src.curentIndex_);
 762           pan_ = std::move(src.pan_);
 763           sampleRate_ = std::move(src.sampleRate_);
 764           pitchDelta_ = std::move(src.pitchDelta_);
 765           pitchCounter_ = std::move(src.pitchCounter_);
 766           waveSize_ = std::move(src.waveSize_);
 767           //        osc_.reset(src.osc_.release());
 768           ampEnv_ = std::move(src.ampEnv_);
 769           ampLFO_ = std::move(src.ampLFO_);
 770           filterEnv_ = std::move(src.filterEnv_);
 771           filterLFO_ = std::move(src.filterLFO_);
 772           filterL_ = std::move(src.filterL_);
 773           filterR_ = std::move(src.filterR_);
 774           pitchEnv_ = std::move(src.pitchEnv_);
 775           pitchLFO_ = std::move(src.pitchLFO_);
 776           panEnv_ = std::move(src.panEnv_);
 777           panLFO_ = std::move(src.panLFO_);
 778         }
 779         return *this;
 780       }
 781
 782       void SetSampleRate(float sampleRate)
 783       {
 784         sampleRate_ = sampleRate;
 785       }
 786
 787       void SetProgram(int programNo,Program& program)
 788       {
 789         timber_ = program.timber;
 790         programNo_ = programNo;
 791         Init();
 792         //        osc_->Init(timber_);
 793       }
 794
 795       void Init()
 796       {
 797         ampEnv_.Init(&(timber_.amplitude.envelope),sampleRate_);
 798         filterEnv_.Init(&(timber_.filter.envelope),sampleRate_);
 799         pitchEnv_.Init(&(timber_.pitch.envelope),sampleRate_);
 800         panEnv_.Init(&(timber_.pan.envelope),sampleRate_);
 801         filterL_.Init(&(timber_.filter),sampleRate_);
 802         filterR_.Init(&(timber_.filter),sampleRate_);
 803
 804         ampLFO_.LFO(&timber_.amplitude.lfo);
 805         pitchLFO_.LFO(&timber_.pitch.lfo);
 806         panLFO_.LFO(&timber_.pan.lfo);
 807         filterLFO_.LFO(&timber_.filter.lfo);
 808
 809         ampLFO_.Init(sampleRate_);
 810         pitchLFO_.Init(sampleRate_);
 811         panLFO_.Init(sampleRate_);
 812         filterLFO_.Init(sampleRate_);
 813       }
 814
 815       void Process(float* buffer) // 1\83T\83\93\83v\83\8b\95ª\82Ì\8f\88\97\9d\82ð\8ds\82¤
 816       {
 817         if(!isFree_){
 818
 819           //if(pitchCounter_ >= (waveSize_ - 1.0f))
 820           //{
 821           //  pitchCounter_ -= (waveSize_ - 1.0f);
 822           //}
 823
 824           // Wave\82Ì\90¶\90¬
 825
 826           float waveData[2];
 827
 828           timber_.oscillator->Process(
 829             waveData,
 830             pitchDelta_,
 831             pitchOffset_
 832             + pitchLFO_.Process()
 833             + pitchEnv_.Process()
 834             + timber_.pitch.pitch );
 835
 836           // \83t\83B\83\8b\83^\81[\8f\88\97\9d
 837
 838           float cutoff = timber_.filter.cutoff + filterEnv_.Process() + filterLFO_.Process();
 839           filterL_.CutOff(cutoff);
 840           filterR_.CutOff(cutoff);
 841
 842           waveData[0] = filterL_.Process(waveData[0]);
 843           waveData[1] = filterR_.Process(waveData[1]);
 844
 845
 846           float volume = ampEnv_.Process() + ampLFO_.Process();
 847           if(volume > 1.0f)
 848           {
 849             volume = 1.0f;
 850           }
 851
 852
 853
 854
 855           // \83N\83\8a\83b\83s\83\93\83O
 856
 857           //if(waveData > 1.0f) waveData = 1.0f;
 858           //if(waveData < 1.0f) waveData = -1.0f;
 859
 860           float pan =  (pan_ + panLFO_.Process());
 861           if(pan > 1.0f) pan = 1.0f;
 862           if(pan < -1.0f) pan = -1.0f;
 863
 864           float rvolume;
 865           float lvolume;
 866
 867
 868           if(pan > 0.0f)
 869           {
 870             rvolume = volume * volumeOffset_;
 871             lvolume = rvolume * (1.0f - pan);
 872           } else {
 873             lvolume = volume * volumeOffset_;
 874             rvolume = lvolume * (1.0f + pan);
 875           }
 876
 877           waveData[0] = waveData[0] * lvolume;
 878           waveData[1] = waveData[1] * rvolume;
 879
 880           buffer[0] += waveData[0];
 881           buffer[1] += waveData[1];
 882
 883           if(!noteOn_ && ampEnv_.GetStatus() == EnvelopeStatus::End)
 884           {
 885             isFree_ = true;
 886           }
 887         }
 888       }
 889
 890       bool isFree() {return isFree_;}
 891
 892       void NoteOn(float pitch,float volume)
 893       {
 894         if(!noteOn_){
 895           isFree_ = false;
 896           noteOn_ = true;
 897           pitchOffset_ = pitch;
 898           volumeOffset_ = volume;
 899           stepTime_ = 1.0f / sampleRate_;
 900           pitchDelta_ = timber_.oscillator->CalcPitchDelta(sampleRate_);
 901           //          waveSize_ = (float)osc_->waveData.size();
 902           currentTime_ = 0.0f;
 903           curentIndex_ = 0;
 904           pan_ = timber_.pan.pan;
 905           pitchCounter_ = 0.0f;
 906           ampEnv_.Attack();
 907           filterEnv_.Attack();
 908           pitchEnv_.Attack();
 909           panEnv_.Attack();
 910
 911           ampLFO_.Attack();
 912           filterLFO_.Attack();
 913           pitchLFO_.Attack();
 914           panLFO_.Attack();
 915
 916           filterL_.Start();
 917           filterR_.Start();
 918         }
 919       }
 920
 921       void NoteOff()
 922       {
 923         if(noteOn_)
 924         {
 925           noteOn_ = false;
 926           ampEnv_.Release();
 927           filterEnv_.Release();
 928           pitchEnv_.Release();
 929           panEnv_.Release();
 930
 931           ampLFO_.Release();
 932           filterLFO_.Release();
 933           pitchLFO_.Release();
 934           panLFO_.Release();
 935
 936         }
 937       }
 938
 939       int CurrentProgramNo() const {return programNo_;}
 940
 941     private:
 942       Timber timber_;
 943       int programNo_;
 944       bool noteOn_;
 945       bool isFree_;
 946       float pitchOffset_;
 947       float volumeOffset_;
 948       float stepTime_;
 949       float currentTime_;
 950       int curentIndex_;
 951       float pan_;
 952       float sampleRate_;
 953       float pitchDelta_;
 954       float pitchCounter_;
 955       float waveSize_;
 956       // std::unique_ptr<Oscillator> osc_;
 957       EnvelopeController ampEnv_;
 958       LFOController ampLFO_;
 959       EnvelopeController filterEnv_;
 960       LFOController filterLFO_;
 961       FilterController filterL_;
 962       FilterController filterR_;
 963       EnvelopeController pitchEnv_;
 964       LFOController pitchLFO_;
 965       EnvelopeController panEnv_;
 966       LFOController panLFO_;
 967     };
 968
 969     typedef std::vector<Voice> VoicesType;
 970     typedef std::vector<Timber> TimbersType;
 971     typedef std::vector<Program> ProgramsType;
 972
 973     void NoteOn(int index,float pitch,float velocity)
 974     {
 975       voices_[index].NoteOn(pitch,velocity);
 976     };
 977
 978     void NoteOff(int index)
 979     {
 980       voices_[index].NoteOff();
 981     };
 982
 983     void AddProgram(Program&& program)
 984     {
 985       programs_.push_back(program);
 986     }
 987
 988     Program& GetProgram(int index)
 989     {
 990       return programs_.at(index);
 991     }
 992
 993     void UpdateProgram(int index,Program&& program)
 994     {
 995       programs_[index] = std::move(program);
 996     }
 997
 998     size_t ProgramsSize()
 999     {
1000       return programs_.size();
1001     }
1002
1003     void AssignProgramToVoice(int programNo,int voiceChannelNo)
1004     {
1005       assert(programNo < programs_.size() && voiceChannelNo < voices_.size());
1006       voices_.at(voiceChannelNo).SetProgram(programNo,programs_.at(programNo));
1007     }
1008
1009     size_t Voices() const {return voices_.size();};
1010
1011     bool isEnable() const {return isEnable_;}
1012     void isEnable(bool v) {isEnable_ = v;}
1013
1014     void Clear()
1015     {
1016       WaveTable::WaveTables.clear();
1017       programs_.clear();
1018     }
1019
1020   private:
1021     bool isEnable_;
1022     WAVEFORMATEXTENSIBLE format_;
1023     ProgramsType programs_;// \83v\83\8a\83Z\83b\83g
1024     VoicesType voices_; // Max 64 Voices
1025     //    WaveTablesType waveTables_;
1026   };
1027
1028   Synthesizer::Synthesizer() : impl_(new Synthesizer::impl()){};
1029
1030   Synthesizer::Synthesizer(WAVEFORMATEXTENSIBLE& format,int channel ) : impl_(new Synthesizer::impl(format,channel))
1031   {
1032   }
1033
1034   Synthesizer::~Synthesizer()
1035   {
1036
1037   }
1038
1039   //void Synthesizer::ProcessBuffer(boost::shared_array<float> arr,int bufferSize)
1040   //{
1041   //  impl_->ProcessBuffer(arr,bufferSize);
1042   //}
1043
1044   void Synthesizer::Process(float* buffer)
1045   {
1046     impl_->Process(buffer);
1047   }
1048
1049
1050   void Synthesizer::Restart()
1051   {
1052     impl_->Restart();
1053   }
1054
1055   void Synthesizer::NoteOn(int index,float pitch,float velocity)
1056   {
1057     impl_->NoteOn(index,pitch,velocity);
1058   };
1059   void Synthesizer::NoteOff(int index)
1060   {
1061     impl_->NoteOff(index);
1062   };
1063
1064   size_t Synthesizer::Voices() const
1065   {
1066     return impl_->Voices();
1067   }
1068
1069   void Synthesizer::AddProgram(Program&& program)
1070   {
1071     impl_->AddProgram(std::move(program));
1072   }
1073
1074   Synthesizer::Program& Synthesizer::GetProgram(int index)
1075   {
1076     return impl_->GetProgram(index);
1077   };
1078
1079   void Synthesizer::UpdateProgram(int index,Program&& program)
1080   {
1081     impl_->UpdateProgram(index,std::move(program));
1082   }
1083   size_t Synthesizer::ProgramsSize()
1084   {
1085     return impl_->ProgramsSize();
1086   }
1087
1088   void Synthesizer::AssignProgramToVoice(int programNo,int voiceChannelNo)
1089   {
1090     impl_->AssignProgramToVoice(programNo,voiceChannelNo);
1091   }
1092
1093   Synthesizer::WaveTablesType& Synthesizer::WaveTables()
1094   {
1095     return WaveTable::WaveTables;
1096   }
1097
1098   bool Synthesizer::isEnable() const
1099   {
1100     return impl_->isEnable();
1101
1102   }
1103   void Synthesizer::isEnable(bool v)
1104   {
1105     impl_->isEnable(v);
1106   }
1107
1108   void Synthesizer::Clear()
1109   {
1110     impl_->Clear();
1111   }
1112
1113 }