IPlugAPP_host.h

/*
 ==============================================================================
 
 This file is part of the iPlug 2 library. Copyright (C) the iPlug 2 developers. 
 
 See LICENSE.txt for  more info.
 
 ==============================================================================
*/
 
#pragma once
 
#include <cstdlib>
#include <string>
#include <vector>
#include <limits>
#include <memory>
#include <optional>
 
#include "wdltypes.h"
#include "wdlstring.h"
 
#include "IPlugPlatform.h"
#include "IPlugConstants.h"
 
#include "IPlugAPP.h"
 
#include "config.h"
 
#ifdef OS_WIN
  #include <WindowsX.h>
  #include <commctrl.h>
  #include <shlobj.h>
  #define DEFAULT_INPUT_DEV "Default Device"
  #define DEFAULT_OUTPUT_DEV "Default Device"
#elif defined(OS_MAC)
  #include "IPlugSWELL.h"
  #define SLEEP( milliseconds ) usleep( (unsigned long) (milliseconds * 1000.0) )
  #define DEFAULT_INPUT_DEV "Built-in Input"
  #define DEFAULT_OUTPUT_DEV "Built-in Output"
#elif defined(OS_LINUX)
  #include "IPlugSWELL.h"
#endif
 
#include "RtAudio.h"
#include "RtMidi.h"
 
#define OFF_TEXT "off"
 
extern HWND gHWND;
extern HINSTANCE gHINSTANCE;
 
BEGIN_IPLUG_NAMESPACE
 
const int kNumBufferSizeOptions = 11;
const std::string kBufferSizeOptions[kNumBufferSizeOptions] = {"32", "64", "96", "128", "192", "256", "512", "1024", "2048", "4096", "8192" };
const int kDeviceDS = 0; const int kDeviceCoreAudio = 0; const int kDeviceAlsa = 0;
const int kDeviceASIO = 1; const int kDeviceJack = 1;
extern UINT gSCROLLMSG;
 
class IPlugAPP;
 
class IPlugAPPHost
{
public:
  
  struct AppState
  {
    WDL_String mAudioInDev;
    WDL_String mAudioOutDev;
    WDL_String mMidiInDev;
    WDL_String mMidiOutDev;
    uint32_t mAudioDriverType;
    uint32_t mAudioSR;
    uint32_t mBufferSize;
    uint32_t mMidiInChan;
    uint32_t mMidiOutChan;
    
    uint32_t mAudioInChanL;
    uint32_t mAudioInChanR;
    uint32_t mAudioOutChanL;
    uint32_t mAudioOutChanR;
    
    AppState()
    : mAudioInDev(DEFAULT_INPUT_DEV)
    , mAudioOutDev(DEFAULT_OUTPUT_DEV)
    , mMidiInDev(OFF_TEXT)
    , mMidiOutDev(OFF_TEXT)
    , mAudioDriverType(0) // DirectSound / CoreAudio by default
    , mBufferSize(512)
    , mAudioSR(44100)
    , mMidiInChan(0)
    , mMidiOutChan(0)
    
    , mAudioInChanL(1)
    , mAudioInChanR(2)
    , mAudioOutChanL(1)
    , mAudioOutChanR(2)
    {
    }
    
    AppState (const AppState& obj)
    : mAudioInDev(obj.mAudioInDev.Get())
    , mAudioOutDev(obj.mAudioOutDev.Get())
    , mMidiInDev(obj.mMidiInDev.Get())
    , mMidiOutDev(obj.mMidiOutDev.Get())
    , mAudioDriverType(obj.mAudioDriverType)
    , mBufferSize(obj.mBufferSize)
    , mAudioSR(obj.mAudioSR)
    , mMidiInChan(obj.mMidiInChan)
    , mMidiOutChan(obj.mMidiOutChan)
    
    , mAudioInChanL(obj.mAudioInChanL)
    , mAudioInChanR(obj.mAudioInChanR)
    , mAudioOutChanL(obj.mAudioOutChanL)
    , mAudioOutChanR(obj.mAudioOutChanR)
    {
    }
    
    bool operator==(const AppState& rhs) const {
      return (rhs.mAudioDriverType == mAudioDriverType &&
              rhs.mBufferSize == mBufferSize &&
              rhs.mAudioSR == mAudioSR &&
              rhs.mMidiInChan == mMidiInChan &&
              rhs.mMidiOutChan == mMidiOutChan &&
              (std::string_view(rhs.mAudioInDev.Get()) == mAudioInDev.Get()) &&
              (std::string_view(rhs.mAudioOutDev.Get()) == mAudioOutDev.Get()) &&
              (std::string_view(rhs.mMidiInDev.Get()) == mMidiInDev.Get()) &&
              (std::string_view(rhs.mMidiOutDev.Get()) == mMidiOutDev.Get()) &&
              rhs.mAudioInChanL == mAudioInChanL &&
              rhs.mAudioInChanR == mAudioInChanR &&
              rhs.mAudioOutChanL == mAudioOutChanL &&
              rhs.mAudioOutChanR == mAudioOutChanR
      );
    }
    bool operator!=(const AppState& rhs) const { return !operator==(rhs); }
  };
  
  static IPlugAPPHost* Create();
  static std::unique_ptr<IPlugAPPHost> sInstance;
 
  void SetScreenshotPath(const char* path) { mScreenshotPath.Set(path); }
 
  const char* GetScreenshotPath() const { return mScreenshotPath.Get(); }
 
  bool IsScreenshotMode() const { return mScreenshotPath.GetLength() > 0; }
 
  void SetNoIO(bool noIO) { mNoIO = noIO; }
 
  bool IsNoIO() const { return mNoIO; }
 
  void PopulateSampleRateList(HWND hwndDlg, RtAudio::DeviceInfo* pInputDevInfo, RtAudio::DeviceInfo* pOutputDevInfo);
  void PopulateAudioInputList(HWND hwndDlg, RtAudio::DeviceInfo* pInfo);
  void PopulateAudioOutputList(HWND hwndDlg, RtAudio::DeviceInfo* pInfo);
  void PopulateDriverSpecificControls(HWND hwndDlg);
  void PopulateAudioDialogs(HWND hwndDlg);
  bool PopulateMidiDialogs(HWND hwndDlg);
  void PopulatePreferencesDialog(HWND hwndDlg);
  
  IPlugAPPHost();
  ~IPlugAPPHost();
  
  bool OpenWindow(HWND pParent);
  void CloseWindow();
 
  bool Init();
  bool InitState();
  void UpdateINI();
  
  std::string GetAudioDeviceName(uint32_t deviceID) const;
  
  std::optional<uint32_t> GetAudioDeviceID(const char* name) const;
  
  int GetMIDIPortNumber(ERoute direction, const char* name) const;
  
  void ProbeAudioIO();
  void ProbeMidiIO();
  bool InitMidi();
  void CloseAudio();
  bool InitAudio(uint32_t inId, uint32_t outId, uint32_t sr, uint32_t iovs);
  bool AudioSettingsInStateAreEqual(AppState& os, AppState& ns);
  bool MIDISettingsInStateAreEqual(AppState& os, AppState& ns);
 
  bool TryToChangeAudioDriverType();
  bool TryToChangeAudio();
  bool SelectMIDIDevice(ERoute direction, const char* portName);
  
  static int AudioCallback(void* pOutputBuffer, void* pInputBuffer, uint32_t nFrames, double streamTime, RtAudioStreamStatus status, void* pUserData);
  static void MIDICallback(double deltatime, std::vector<uint8_t>* pMsg, void* pUserData);
  static void ErrorCallback(RtAudioErrorType type, const std::string& errorText);
 
  static WDL_DLGRET PreferencesDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
  static WDL_DLGRET MainDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
 
  IPlugAPP* GetPlug() { return mIPlug.get(); }
private:
  std::unique_ptr<IPlugAPP> mIPlug = nullptr;
  std::unique_ptr<RtAudio> mDAC = nullptr;
  std::unique_ptr<RtMidiIn> mMidiIn = nullptr;
  std::unique_ptr<RtMidiOut> mMidiOut = nullptr;
  int mMidiOutChannel = -1;
  int mMidiInChannel = -1;
 
  AppState mState;
  AppState mTempState;
  AppState mActiveState;
  
  double mSampleRate = 44100.;
  uint32_t mSamplesElapsed = 0;
  uint32_t mVecWait = 0;
  uint32_t mBufferSize = 512;
  uint32_t mBufIndex = 0; // index for signal vector, loops from 0 to mSigVS
  bool mExiting = false;
  bool mAudioEnding = false;
  bool mAudioDone = false;
  bool mNoIO = false;
 
  std::optional<uint32_t> mDefaultInputDev;
  std::optional<uint32_t> mDefaultOutputDev;
    
  WDL_String mINIPath;
  WDL_String mScreenshotPath;
 
  std::vector<uint32_t> mAudioInputDevIDs;
  std::vector<uint32_t> mAudioOutputDevIDs;
  std::vector<std::string> mMidiInputDevNames;
  std::vector<std::string> mMidiOutputDevNames;
  
  WDL_PtrList<double> mInputBufPtrs;
  WDL_PtrList<double> mOutputBufPtrs;
  
  friend class IPlugAPP;
};
 
END_IPLUG_NAMESPACE