SynthApp/WaveTableSynth.h

   1 #pragma once
   2
   3 namespace sf {
   4   struct Synthesizer
   5   {
   6     // \83G\83\93\83x\83\8d\81[\83v\83p\83\89\83\81\81[\83^
   7     struct Envelope
   8     {
   9       Envelope() :
  10         enable(true),
  11         releaseNoteOff(true),
  12         attackTime(0.0f),
  13         decayTime(0.5f),
  14         sustainLevel(0.5f),
  15         releaseTime(3.0f),
  16         gain(1.0f)
  17       {}
  18
  19       Envelope(const Envelope& src) :
  20         enable(src.enable),
  21         releaseNoteOff(src.releaseNoteOff),
  22         attackTime(src.attackTime),
  23         decayTime(src.decayTime),
  24         sustainLevel(src.sustainLevel),
  25         releaseTime(src.releaseTime),
  26         gain(src.gain)
  27       {}
  28
  29       Envelope(Envelope&& src) :
  30         enable(std::move(src.enable)),
  31         releaseNoteOff(std::move(src.releaseNoteOff)),
  32         attackTime(std::move(src.attackTime)),
  33         decayTime(std::move(src.decayTime)),
  34         sustainLevel(std::move(src.sustainLevel)),
  35         releaseTime(std::move(src.releaseTime)),
  36         gain(std::move(src.gain))
  37       {}
  38
  39       Envelope& operator=(const Envelope& src)
  40       {
  41         if(this != &src)
  42         {
  43           enable = src.enable;
  44           releaseNoteOff = src.releaseNoteOff;
  45           attackTime = src.attackTime;
  46           decayTime = src.decayTime;
  47           sustainLevel = src.sustainLevel;
  48           releaseTime = src.releaseTime;
  49           gain = src.gain;
  50         }
  51         return *this;
  52       }
  53
  54       Envelope& operator=(Envelope&& src)
  55       {
  56         if(this != &src)
  57         {
  58           enable = std::move(src.enable);
  59           releaseNoteOff = std::move(src.releaseNoteOff);
  60           attackTime = std::move(src.attackTime);
  61           decayTime = std::move(src.decayTime);
  62           sustainLevel = std::move(src.sustainLevel);
  63           releaseTime = std::move(src.releaseTime);
  64           gain = std::move(src.gain);
  65         }
  66         return *this;
  67       }
  68
  69       bool enable;
  70       bool releaseNoteOff;
  71       float attackTime;
  72       float decayTime;
  73       float sustainLevel;
  74       float releaseTime;
  75       float gain;
  76     };
  77
  78     struct Timber;
  79     enum struct OscillatorCategory
  80     {
  81       WaveTable,SquwareWave,SinWave
  82     };
  83     // \83I\83V\83\8c\81[\83^\83C\83\93\83^\81[\83t\83F\81[\83X
  84     struct Oscillator
  85     {
  86       typedef  std::unique_ptr<Oscillator> PtrType;
  87       virtual ~Oscillator(){}
  88       virtual void Process(float * data,float delta,float offset) = 0;
  89       virtual float SampleRate() const = 0;
  90       virtual float CalcPitchDelta(float sampleRate) = 0;
  91 //      virtual void Init(Timber& timber) = 0;
  92       virtual OscillatorCategory Category() = 0;
  93       virtual PtrType Clone() = 0;
  94     };
  95
  96     // \83E\83F\81[\83u\83f\81[\83^
  97     typedef std::vector<float> WaveData;
  98
  99     // \83E\83F\81[\83u\83e\81[\83u\83\8b
 100     struct WaveTable
 101     {
 102       WaveTable() :
 103         stereo(false),
 104         sampleRate(44100.0f),//
 105         basePitch(0.0f)
 106       {};
 107
 108       WaveTable(const WaveTable& src) :
 109         stereo(src.stereo),
 110         sampleRate(src.sampleRate),//
 111         basePitch(src.basePitch)
 112       {waveData = src.waveData;};
 113
 114       WaveTable(WaveTable&& src) :
 115         stereo(std::move(src.stereo)),
 116         sampleRate(std::move(src.sampleRate)),//
 117         basePitch(std::move(src.basePitch))
 118       {waveData = std::move(src.waveData);};
 119
 120       WaveTable& operator=(const WaveTable& src)
 121       {
 122         if(this != &src)
 123         {
 124           stereo = src.stereo;
 125           sampleRate = src.sampleRate;//
 126           basePitch = src.basePitch;
 127           waveData = src.waveData;
 128         }
 129         return *this;
 130       }
 131
 132       WaveTable& operator=(WaveTable&& src)
 133       {
 134         if(this != &src)
 135         {
 136           stereo = std::move(src.stereo);
 137           sampleRate = std::move(src.sampleRate);//
 138           basePitch = std::move(src.basePitch);
 139           waveData = std::move(src.waveData);
 140         }
 141         return *this;
 142       }
 143
 144       bool stereo;
 145       float sampleRate;//
 146       float basePitch;
 147       WaveData waveData;
 148       static std::vector<WaveTable> WaveTables;
 149     };
 150
 151     // LFO
 152     struct LFO
 153     {
 154       LFO() :
 155         waveForm(nullptr),
 156         startNoteOn(true),
 157         freq(20.0f),
 158         gain(1.0f)
 159       {}
 160       LFO(const LFO &src)
 161         :
 162         waveForm(src.waveForm),
 163         envelope(src.envelope),
 164         startNoteOn(src.startNoteOn),
 165         freq(src.freq),
 166         gain(src.gain)
 167       {}
 168
 169       LFO(LFO &&src) :
 170         waveForm(std::move(src.waveForm)),
 171         envelope(std::move(src.envelope)),
 172         startNoteOn(std::move(src.startNoteOn)),
 173         freq(std::move(src.freq)),
 174         gain(std::move(src.gain))
 175       {}
 176
 177       LFO& operator=(const LFO &src)
 178       {
 179         if(this !=  &src)
 180         {
 181           waveForm = src.waveForm;
 182           envelope = src.envelope;
 183           startNoteOn = src.startNoteOn;
 184           freq = src.freq;
 185           gain = src.gain;
 186
 187         }
 188         return *this;
 189       }
 190       LFO& operator=(LFO &&src)
 191       {
 192         if(this !=  &src)
 193         {
 194           waveForm = std::move(src.waveForm);
 195           envelope = std::move(src.envelope);
 196           startNoteOn = std::move(src.startNoteOn);
 197           freq = std::move(src.freq);
 198           gain = std::move(src.gain);
 199
 200         }
 201         return *this;
 202       }
 203
 204       bool startNoteOn;
 205       WaveTable* waveForm;
 206       Envelope envelope;
 207       float freq;
 208       float gain;
 209     };
 210
 211     // \83t\83B\83\8b\83^\81[\83J\83e\83S\83\8a\81[
 212     enum struct FilterCategory
 213     {
 214       LPF,HPF,BPF
 215     };
 216
 217     // \83t\83B\83\8b\83^\81[
 218     struct Filter
 219     {
 220       Filter() : category(FilterCategory::LPF),level(0.0f),resonance(0.0f),cutoff(0.0f){};
 221       Filter(const Filter& src) :
 222         category(src.category),
 223         level(src.level),
 224         cutoff(src.cutoff),
 225         resonance(src.resonance),
 226         envelope(src.envelope),
 227         lfo(src.lfo)
 228       {
 229       }
 230
 231       Filter( Filter&& src) :
 232         category(std::move(src.category)),
 233         level(std::move(src.level)),
 234         cutoff(std::move(src.cutoff)),
 235         resonance(std::move(src.resonance)),
 236         envelope(std::move(src.envelope)),
 237         lfo(std::move(src.lfo))
 238       {
 239       }
 240
 241       Filter& operator= (const Filter& src)
 242       {
 243         if(this != &src)
 244         {
 245           category = src.category;
 246           level = src.level;
 247           cutoff = src.cutoff;
 248           resonance = src.resonance;
 249           envelope = src.envelope;
 250           lfo = src.lfo;
 251         }
 252         return *this;
 253       }
 254
 255       Filter& operator= (Filter&& src)
 256       {
 257         if(this != &src)
 258         {
 259           category = std::move(src.category);
 260           level = std::move(src.level);
 261           cutoff = std::move(src.cutoff);
 262           resonance = std::move(src.resonance);
 263           envelope = std::move(src.envelope);
 264           lfo = std::move(src.lfo);
 265         }
 266         return *this;
 267       }
 268
 269       FilterCategory category;
 270       float level;
 271       float cutoff;
 272       float resonance;
 273       Envelope envelope;
 274       LFO  lfo;
 275     };
 276
 277     // \89¹\97Ê\83p\83\89\83\81\81[\83^
 278     struct Amplitude
 279     {
 280       Amplitude() : gain(1.0f) {}
 281       Amplitude(const Amplitude& src) :
 282         gain(src.gain),
 283         envelope(src.envelope),
 284         lfo(src.lfo)
 285       {}
 286
 287       Amplitude(Amplitude&& src) :
 288         gain(std::move(src.gain)),
 289         envelope(std::move(src.envelope)),
 290         lfo(std::move(src.lfo))
 291       {}
 292       Amplitude& operator= (const Amplitude& src)
 293       {
 294         if(this != &src)
 295         {
 296           gain = src.gain;
 297           envelope = src.envelope;
 298           lfo = src.lfo;
 299         }
 300         return *this;
 301       }
 302
 303       Amplitude& operator= (Amplitude&& src)
 304       {
 305         if(this != &src)
 306         {
 307           gain = std::move(src.gain);
 308           envelope = std::move(src.envelope);
 309           lfo = std::move(src.lfo);
 310         }
 311         return *this;
 312       }
 313
 314       float gain;
 315       Envelope envelope;
 316       LFO lfo;
 317     };
 318
 319     // \8eü\94g\90\94\83p\83\89\83\81\81[\83^
 320     struct Pitch {
 321       Pitch() : pitch(1.0f){}
 322       Pitch(const Pitch& src) :
 323         pitch(src.pitch),
 324         envelope(src.envelope),
 325         lfo(src.lfo)
 326       {}
 327
 328       Pitch(Pitch&& src) :
 329         pitch(std::move(src.pitch)),
 330         envelope(std::move(src.envelope)),
 331         lfo(std::move(src.lfo))
 332       {}
 333       Pitch& operator= (const Pitch& src)
 334       {
 335         if(this != &src)
 336         {
 337           pitch = src.pitch;
 338           envelope = src.envelope;
 339           lfo = src.lfo;
 340         }
 341         return *this;
 342       }
 343
 344       Pitch& operator= (Pitch&& src)
 345       {
 346         if(this != &src)
 347         {
 348           pitch = std::move(src.pitch);
 349           envelope = std::move(src.envelope);
 350           lfo = std::move(src.lfo);
 351         }
 352         return *this;
 353       }
 354
 355       float pitch;
 356       Envelope envelope;
 357       LFO lfo;
 358     };
 359
 360     // \92è\88Ê\83p\83\89\83\81\81[\83^
 361     struct Pan {
 362       Pan() : pan(0.5f) {};
 363       Pan(const Pan& src) :
 364         pan(src.pan),
 365         envelope(src.envelope),
 366         lfo(src.lfo)
 367       {}
 368
 369       Pan(Pan&& src) :
 370         pan(std::move(src.pan)),
 371         envelope(std::move(src.envelope)),
 372         lfo(std::move(src.lfo))
 373       {}
 374
 375       Pan& operator= (const Pan& src)
 376       {
 377         if(this != &src)
 378         {
 379           pan = src.pan;
 380           envelope = src.envelope;
 381           lfo = src.lfo;
 382
 383         }
 384         return *this;
 385       }
 386
 387       Pan& operator= (Pan&& src)
 388       {
 389         if(this != &src)
 390         {
 391           pan = std::move(src.pan);
 392           envelope = std::move(src.envelope);
 393           lfo = std::move(src.lfo);
 394         }
 395         return *this;
 396       }
 397
 398       float pan;
 399       Envelope envelope;
 400       LFO lfo;
 401     };
 402
 403     typedef std::vector<WaveTable> WaveTablesType;
 404
 405     struct WaveTableOscillator : public Oscillator
 406     {
 407       typedef std::function<void (float * ,float,float)> ProcessorType;
 408
 409       WaveTableOscillator() : waveTable_(nullptr),waveCounter_(0.0f)
 410       {
 411
 412       };
 413
 414       explicit WaveTableOscillator(WaveTable* waveTable) : waveTable_(nullptr),waveCounter_(0.0f)
 415       {
 416         WaveTable(waveTable);
 417       }
 418
 419       WaveTableOscillator(const WaveTableOscillator& src) : waveTable_(nullptr),
 420         waveCounter_(src.waveCounter_)
 421       {
 422         if(src.waveTable_ != nullptr)
 423         {
 424           WaveTable(src.waveTable_);
 425         }
 426
 427       }
 428
 429       WaveTableOscillator(WaveTableOscillator&& src) :
 430         waveTable_(std::move(nullptr)),
 431         waveCounter_(std::move(src.waveCounter_))
 432       {
 433         if(src.waveTable_ != nullptr)
 434         {
 435           WaveTable(src.waveTable_);
 436         }
 437
 438       }
 439
 440       WaveTableOscillator& operator= (const WaveTableOscillator& src)
 441       {
 442         if(this != &src)
 443         {
 444           this->waveCounter_ = src.waveCounter_;
 445           WaveTable(src.waveTable_);
 446         }
 447         return *this;
 448       }
 449
 450       WaveTableOscillator& operator= (WaveTableOscillator&& src)
 451       {
 452         if(this != &src)
 453         {
 454           this->waveCounter_ = std::move(src.waveCounter_);
 455           WaveTable(src.waveTable_);
 456         }
 457         return *this;
 458       }
 459
 460       void Process(float * data,float delta,float offset)
 461       {
 462
 463         //if(waveTable_->stereo)
 464         //{
 465         //  ProcessStereo(data,delta);
 466         //} else {
 467         //  ProcessMono(data,delta);
 468         //}
 469         processor_(data,delta,offset);
 470       }
 471
 472       void ProcessStereo(float * data,float delta,float offset)
 473       {
 474         waveCounter_ += delta * (offset + waveTable_->basePitch);
 475
 476         if(waveTable_->waveData.size() <= (int)(waveCounter_ * 2.0f))
 477         {
 478           waveCounter_ -= (float)waveTable_->waveData.size() / 2.0f;
 479         }
 480
 481         int index = (float) waveCounter_;
 482         float *src = &waveTable_->waveData[index * 2];
 483         *data = *src;
 484         ++data;++src;
 485         *data = *src;
 486
 487       }
 488
 489       void ProcessMono(float * data,float delta,float offset)
 490       {
 491         waveCounter_ += delta * (offset + waveTable_->basePitch);
 492
 493         if(waveTable_->waveData.size() <= (int)(waveCounter_))
 494         {
 495           waveCounter_ -= (float)waveTable_->waveData.size();
 496         }
 497         int index = (int) waveCounter_;
 498         float d = waveTable_->waveData[index];
 499         *data++ = d;
 500         *data = d;
 501
 502       }
 503
 504       float SampleRate() const {return waveTable_->sampleRate;}
 505       float CalcPitchDelta(float sampleRate)
 506       {
 507         return SampleRate() * ((float)WaveTable().waveData.size() / sampleRate);
 508       }
 509
 510       //void Init()
 511       //{
 512       //    //WaveTable(&(WaveTable::WaveTables[timber.waveTableNo]));
 513       //}
 514
 515       OscillatorCategory Category() {return OscillatorCategory::WaveTable;};
 516
 517       PtrType Clone() {return PtrType(new WaveTableOscillator(*this));}
 518
 519       Synthesizer::WaveTable& WaveTableOscillator::WaveTable() {return *waveTable_;}
 520       void Synthesizer::WaveTableOscillator::WaveTable(Synthesizer::WaveTable *p);
 521
 522     private:
 523       Synthesizer::WaveTable *waveTable_;
 524       float waveCounter_;
 525       ProcessorType processor_;
 526     };
 527
 528     // \89¹\90F\83p\83\89\83\81\81[\83^
 529     struct Timber
 530     {
 531       Timber() {};
 532       Timber(const Timber& src) :
 533         amplitude(src.amplitude),
 534         filter(src.filter),
 535         pitch(src.pitch),
 536         pan(src.pan)
 537       {
 538         if(src.oscillator.get() != nullptr){
 539           oscillator = src.oscillator->Clone();
 540         }
 541       }
 542
 543       Timber(Timber&& src) :
 544 //        waveTableNo(std::move(src.waveTableNo)),
 545         amplitude(std::move(src.amplitude)),
 546         filter(std::move(src.filter)),
 547         pitch(std::move(src.pitch)),
 548         pan(std::move(src.pan))
 549       {
 550         if(src.oscillator.get() != nullptr){
 551           oscillator.reset(src.oscillator.release());
 552         }
 553       }
 554
 555       Timber& operator= (const Timber& src)
 556       {
 557         if(this != &src)
 558         {
 559    //       waveTableNo = src.waveTableNo;
 560         if(src.oscillator.get() != nullptr){
 561           oscillator  = src.oscillator->Clone();
 562         }
 563           amplitude = src.amplitude;
 564           filter = src.filter;
 565           pitch = src.pitch;
 566           pan = src.pan;
 567
 568         }
 569         return *this;
 570       }
 571
 572       Timber& operator= (Timber&& src)
 573       {
 574         if(this != &src)
 575         {
 576  //         waveTableNo = std::move(src.waveTableNo);
 577         if(src.oscillator.get() != nullptr){
 578           oscillator.reset(src.oscillator.release());
 579         }
 580           amplitude = std::move(src.amplitude);
 581           filter = std::move(src.filter);
 582           pitch = std::move(src.pitch);
 583           pan = std::move(src.pan);
 584         }
 585         return *this;
 586       }
 587
 588       Oscillator::PtrType oscillator;
 589 //      int waveTableNo;
 590       Amplitude amplitude;
 591       Filter filter;
 592       Pitch pitch;
 593       Pan pan;
 594     };
 595
 596     // \89¹\90F\83v\83\8d\83O\83\89\83\80\83p\83\89\83\81\81[\83^
 597     struct Program {
 598       Program(){}
 599       Program(const std::wstring& name,const Timber& timber) :
 600         name(name),timber(timber)
 601       {}
 602
 603       Program(const Program& src)
 604         :
 605         name(src.name),timber(src.timber)
 606       {
 607
 608       }
 609
 610       Program(const Program&& src) :
 611         name(std::move(src.name)),timber(std::move(src.timber))
 612       {
 613
 614       }
 615
 616       Program& operator= (const Program& src)
 617       {
 618         if(this != &src)
 619         {
 620           name = src.name;
 621           timber = src.timber;
 622         }
 623         return *this;
 624       }
 625
 626       Program& operator= (const Program&& src)
 627       {
 628         if(this != &src)
 629         {
 630           name = std::move(src.name);
 631           timber = std::move(src.timber);
 632         }
 633         return *this;
 634       }
 635
 636       std::wstring name;
 637       Timber timber;
 638     };
 639     typedef std::vector<Program> ProgramsType;
 640     // \83R\83\93\83X\83g\83\89\83N\83^
 641     Synthesizer();
 642     // \83R\83\93\83X\83g\83\89\83N\83^
 643     explicit Synthesizer(WAVEFORMATEXTENSIBLE& format,int channel = 4);
 644     // \83f\83X\83g\83\89\83N\83^
 645     ~Synthesizer();
 646     // \83\8a\83X\83^\81[\83g
 647     void Restart();
 648     // \94g\8c`\90¶\90¬\8f\88\97\9d
 649     void Process(float* buffer);
 650     // \83m\81[\83g\83I\83\93\8f\88\97\9d
 651     void NoteOn(int index,float pitch,float velocity);
 652     // \83m\81[\83g\83I\83t\8f\88\97\9d
 653     void NoteOff(int index);
 654
 655     // \89¹\90F\83v\83\8d\83O\83\89\83\80
 656     void AddProgram(Program&& program);
 657     Program& GetProgram(int index);
 658
 659     void UpdateProgram(int index,Program&& Program);
 660     size_t ProgramsSize();
 661
 662     void AssignProgramToVoice(int programNo,int voiceChannelNo);
 663
 664     size_t Voices() const;
 665
 666     // \83E\83F\81[\83u\83e\81[\83u\83\8b
 667     static WaveTablesType& WaveTables();
 668
 669     bool isEnable() const ;
 670     void isEnable(bool v);
 671
 672     void Clear();
 673
 674   private:
 675     struct impl;
 676     std::unique_ptr<impl> impl_;
 677   };
 678 }