//=============================================================================
//  Zerberus
//  Zample player
//
//  Copyright (C) 2013 Werner Schweer
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License version 2
//  as published by the Free Software Foundation and appearing in
//  the file LICENCE.GPL
//=============================================================================
 
#ifndef __ZERBERUS_H__
#define __ZERBERUS_H__
 
#include <math.h>
#include <atomic>
// #include <mutex>
#include <list>
 
#include "synthesizer/synthesizer.h"
#include "synthesizer/event.h"
#include "voice.h"
 
class Channel;
class ZInstrument;
enum class Trigger : char;
 
static const int MAX_VOICES  = 512;
static const int MAX_CHANNEL = 64;
static const int MAX_TRIGGER = 512;
 
//---------------------------------------------------------
//   VoiceFifo
//---------------------------------------------------------
 
class VoiceFifo {
      Voice* buffer[MAX_VOICES];
      std::atomic<int> n;
      int writeIdx = 0;       // index of next slot to write
      int readIdx  = 0;       // index of slot to read
 
   public:
      VoiceFifo() {
            n = 0;
            }
      ~VoiceFifo() {
            for (Voice* v : buffer)
                  delete v;
            }
      void push(Voice* v) {
            buffer[writeIdx++] = v;
            writeIdx %= MAX_VOICES;
            ++n;
            }
      Voice* pop()  {
            Q_ASSERT(n != 0);
            --n;
            Voice* v = buffer[readIdx++];
            readIdx %= MAX_VOICES;
            return v;
            }
      bool empty() const { return n == 0; }
      };
 
//---------------------------------------------------------
//   Zerberus
//---------------------------------------------------------
 
class Zerberus : public Ms::Synthesizer {
      static bool initialized;
      static std::list<ZInstrument*> globalInstruments;
 
      double _masterTuning = 440.0;
      std::atomic<bool> busy;
 
      std::list<ZInstrument*> instruments;
      Channel* _channel[MAX_CHANNEL];
 
      int allocatedVoices = 0;
      VoiceFifo freeVoices;
      Voice* activeVoices = 0;
      int _loadProgress = 0;
      bool _loadWasCanceled = false;
 
      void programChange(int channel, int program);
      void trigger(Channel*, int key, int velo, Trigger, int cc, int ccVal, double durSinceNoteOn);
      void processNoteOff(Channel*, int pitch);
      void processNoteOn(Channel* cp, int key, int velo);
 
   public:
      Zerberus();
      ~Zerberus();
 
      virtual void process(unsigned frames, float*, float*, float*);
      virtual void play(const Ms::PlayEvent& event);
 
      bool loadInstrument(const QString&);
 
      ZInstrument* instrument(int program) const;
      Voice* getActiveVoices()      { return activeVoices; }
      Channel* channel(int n)       { return _channel[n]; }
      int loadProgress()            { return _loadProgress; }
      void setLoadProgress(int val) { _loadProgress = val; }
      bool loadWasCanceled()        { return _loadWasCanceled; }
      void setLoadWasCanceled(bool status)     { _loadWasCanceled = status; }
 
      virtual void setMasterTuning(double val) { _masterTuning = val;  }
      virtual double masterTuning() const      { return _masterTuning; }
 
      double ct2hz(double c) { return pow(2.0, (c-6900.0) / 1200.0) * _masterTuning; }
 
      virtual const char* name() const;
      virtual const QList<Ms::MidiPatch*>& getPatchInfo() const;
 
      virtual Ms::SynthesizerGroup state() const;
      virtual bool setState(const Ms::SynthesizerGroup&);
 
      virtual void allSoundsOff(int channel);
      virtual void allNotesOff(int channel);
 
      virtual bool addSoundFont(const QString&);
      virtual bool removeSoundFont(const QString&);
      virtual bool loadSoundFonts(const QStringList&);
      virtual QStringList soundFonts() const;
 
      virtual Ms::SynthesizerGui* gui();
      static QFileInfoList sfzFiles();
      };
 
#endif
 

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: buffer.