Robin E.R. Davies
535 lines
24 KiB
C++
535 lines
24 KiB
C++
// Copyright (c) 2022 Robin Davies
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
// this software and associated documentation files (the "Software"), to deal in
|
|
// the Software without restriction, including without limitation the rights to
|
|
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
|
// the Software, and to permit persons to whom the Software is furnished to do so,
|
|
// subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in all
|
|
// copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
|
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
#pragma once
|
|
#include <mutex>
|
|
#include "UpdaterStatus.hpp"
|
|
#include "PluginHost.hpp"
|
|
#include "GovernorSettings.hpp"
|
|
#include "Pedalboard.hpp"
|
|
#include "Storage.hpp"
|
|
#include "Banks.hpp"
|
|
#include "JackConfiguration.hpp"
|
|
#include "AudioHost.hpp"
|
|
#include "VuUpdate.hpp"
|
|
#include <functional>
|
|
#include <filesystem>
|
|
#include "Banks.hpp"
|
|
#include "PiPedalConfiguration.hpp"
|
|
#include "JackServerSettings.hpp"
|
|
#include "WifiConfigSettings.hpp"
|
|
#include "WifiDirectConfigSettings.hpp"
|
|
#include "AdminClient.hpp"
|
|
#include <thread>
|
|
#include "Promise.hpp"
|
|
#include "AtomConverter.hpp"
|
|
#include "FileEntry.hpp"
|
|
#include "ChannelRouterSettings.hpp"
|
|
#include <unordered_map>
|
|
#include "Tone3000Downloader.hpp"
|
|
#include "Uri.hpp"
|
|
#include "Tone3000Tone.hpp"
|
|
|
|
namespace pipedal
|
|
{
|
|
|
|
struct RealtimeMidiProgramRequest;
|
|
struct RealtimeNextMidiProgramRequest;
|
|
class Lv2PluginChangeMonitor;
|
|
class Updater;
|
|
class AvahiService;
|
|
class Lv2PluginState;
|
|
|
|
class IPiPedalModelSubscriber
|
|
{
|
|
public:
|
|
using ptr = std::shared_ptr<IPiPedalModelSubscriber>;
|
|
|
|
virtual int64_t GetClientId() = 0;
|
|
virtual void OnItemEnabledChanged(int64_t clientId, int64_t pedalItemId, bool enabled) = 0;
|
|
virtual void OnItemUseModUiChanged(int64_t clientId, int64_t pedalItemId, bool enabled) = 0;
|
|
virtual void OnControlChanged(int64_t clientId, int64_t pedalItemId, const std::string &symbol, float value) = 0;
|
|
virtual void OnInputVolumeChanged(float value) = 0;
|
|
virtual void OnOutputVolumeChanged(float value) = 0;
|
|
virtual void OnUpdateStatusChanged(const UpdateStatus &updateStatus) = 0;
|
|
virtual void OnLv2StateChanged(int64_t pedalItemId, const Lv2PluginState &newState) = 0;
|
|
virtual void OnVst3ControlChanged(int64_t clientId, int64_t pedalItemId, const std::string &symbol, float value, const std::string &state) = 0;
|
|
virtual void OnPedalboardChanged(int64_t clientId, const Pedalboard &pedalboard) = 0;
|
|
virtual void OnPresetsChanged(int64_t clientId, const PresetIndex &presets) = 0;
|
|
virtual void OnPresetChanged(bool changed) = 0;
|
|
virtual void OnSnapshotModified(int64_t selectedSnapshot, bool modified) = 0;
|
|
virtual void OnSelectedSnapshotChanged(int64_t selectedSnapshot) = 0;
|
|
virtual void OnPluginPresetsChanged(const std::string &pluginUri) = 0;
|
|
virtual void OnChannelRouterSettingsChanged(int64_t clientId, const ChannelRouterSettings &channelRouterSettings) = 0;
|
|
virtual void OnVuMeterUpdate(const std::vector<VuUpdateX> &updates) = 0;
|
|
virtual void OnBankIndexChanged(const BankIndex &bankIndex) = 0;
|
|
virtual void OnJackServerSettingsChanged(const JackServerSettings &jackServerSettings) = 0;
|
|
virtual void OnJackConfigurationChanged(const JackConfiguration &jackServerConfiguration) = 0;
|
|
virtual void OnLoadPluginPreset(int64_t instanceId, const std::vector<ControlValue> &controlValues) = 0;
|
|
virtual void OnMidiValueChanged(int64_t instanceId, const std::string &symbol, float value) = 0;
|
|
virtual void OnNotifyMidiListener(int64_t clientHandle, uint8_t cc0, uint8_t cc1, uint8_t cc2) = 0;
|
|
virtual void OnNotifyPatchProperty(int64_t clientModel, uint64_t instanceId, const std::string &propertyUri, const std::string &atomJson) = 0;
|
|
virtual void OnWifiConfigSettingsChanged(const WifiConfigSettings &wifiConfigSettings) = 0;
|
|
virtual void OnWifiDirectConfigSettingsChanged(const WifiDirectConfigSettings &wifiDirectConfigSettings) = 0;
|
|
virtual void OnGovernorSettingsChanged(const std::string &governor) = 0;
|
|
virtual void OnFavoritesChanged(const std::map<std::string, bool> &favorites) = 0;
|
|
virtual void OnShowStatusMonitorChanged(bool show) = 0;
|
|
virtual void OnSystemMidiBindingsChanged(const std::vector<MidiBinding> &bindings) = 0;
|
|
virtual void OnNotifyPathPatchPropertyChanged(int64_t instanceId, const std::string &pathPatchPropertyString, const std::string &atomString) = 0;
|
|
|
|
// virtual void OnPatchPropertyChanged(int64_t clientId, int64_t instanceId,const std::string& propertyUri,const json_variant& value) = 0;
|
|
virtual void OnErrorMessage(const std::string &message) = 0;
|
|
|
|
virtual void OnTone3000DownloadStarted(int64_t handle, const std::string &title) = 0;
|
|
virtual void OnTone3000DownloadProgress(const Tone3000DownloadProgress &progress) = 0;
|
|
virtual void OnTone3000DownloadComplete(int64_t handle, const std::string &resultPath) = 0;
|
|
virtual void OnTone3000DownloadError(int64_t handle, const std::string &errorMessage) = 0;
|
|
virtual void OnLv2PluginsChanging() = 0;
|
|
|
|
virtual void OnNetworkChanging(bool hotspotConnected) = 0;
|
|
virtual void OnHasWifiChanged(bool hasWifi) = 0;
|
|
virtual void OnAlsaSequencerConfigurationChanged(const AlsaSequencerConfiguration &alsaSequencerConfiguration) = 0;
|
|
virtual void Close() = 0;
|
|
};
|
|
|
|
class HotspotManager;
|
|
|
|
class PiPedalModel : private IAudioHostCallbacks, private Tone3000Downloader::Listener
|
|
{
|
|
public:
|
|
using clock = std::chrono::steady_clock;
|
|
|
|
using PostHandle = uint64_t;
|
|
using PostCallback = std::function<void()>;
|
|
using NetworkChangedListener = std::function<void(void)>;
|
|
|
|
private:
|
|
bool updaterEnabled = true;
|
|
PedalboardItem *GetPedalboardItemForFileProperty(const UiFileProperty &fileProperty);
|
|
|
|
// Tone3000Downloader::Listener implementation
|
|
virtual void OnStartTone3000Download(int64_t handle, const std::string &title) override;
|
|
virtual void OnTone3000Progress(const Tone3000DownloadProgress &progress) override;
|
|
virtual void OnTone3000DownloadComplete(int64_t handle, const std::string &resultPath) override;
|
|
virtual void OnTone3000DownloadError(int64_t handle, const std::string &errorMessage) override;
|
|
|
|
std::shared_ptr<Tone3000Downloader> tone3000Downloader;
|
|
void CancelAudioRetry();
|
|
clock::time_point lastRestartTime = clock::time_point::min();
|
|
int audioRestartRetries = 0;
|
|
PostHandle audioRetryPostHandle = 0;
|
|
|
|
bool hasWifi = false;
|
|
|
|
void SetHasWifi(bool hasWifi);
|
|
std::unique_ptr<HotspotManager> hotspotManager;
|
|
|
|
std::unique_ptr<Updater> updater;
|
|
UpdateStatus currentUpdateStatus;
|
|
void OnUpdateStatusChanged(const UpdateStatus &updateStatus);
|
|
std::function<void(void)> restartListener;
|
|
|
|
std::unique_ptr<Lv2PluginChangeMonitor> pluginChangeMonitor;
|
|
|
|
std::unique_ptr<std::jthread> pingThread;
|
|
|
|
std::vector<MidiBinding> systemMidiBindings;
|
|
|
|
std::unique_ptr<AvahiService> avahiService;
|
|
uint16_t webPort;
|
|
|
|
PiPedalAlsaDevices &alsaDevices = PiPedalAlsaDevices::instance();
|
|
std::recursive_mutex mutex;
|
|
|
|
AdminClient adminClient;
|
|
|
|
class MidiListener
|
|
{
|
|
public:
|
|
int64_t clientId;
|
|
int64_t clientHandle;
|
|
};
|
|
class AtomOutputListener
|
|
{
|
|
public:
|
|
bool WantsProperty(uint64_t instanceId, LV2_URID patchProperty) const
|
|
{
|
|
if (instanceId != this->instanceId)
|
|
return false;
|
|
return this->propertyUrid == 0 || patchProperty == this->propertyUrid;
|
|
}
|
|
int64_t clientId;
|
|
int64_t clientHandle;
|
|
uint64_t instanceId;
|
|
LV2_URID propertyUrid;
|
|
};
|
|
void DeleteMidiListeners(int64_t clientId);
|
|
void DeleteAtomOutputListeners(int64_t clientId);
|
|
|
|
std::vector<MidiListener> midiEventListeners;
|
|
std::vector<AtomOutputListener> atomOutputListeners;
|
|
|
|
JackServerSettings jackServerSettings;
|
|
|
|
PluginHost pluginHost;
|
|
AtomConverter atomConverter; // must be AFTER pluginHost!
|
|
|
|
Pedalboard pedalboard;
|
|
ChannelRouterSettings::ptr channelRouterSettings;
|
|
|
|
bool previousPedalboardLoaded = false;
|
|
Pedalboard previousPedalboard;
|
|
Storage storage;
|
|
bool hasPresetChanged = false;
|
|
|
|
NetworkChangedListener networkChangedListener;
|
|
void FireNetworkChanged()
|
|
{
|
|
if (networkChangedListener)
|
|
{
|
|
networkChangedListener();
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<AudioHost> audioHost;
|
|
JackConfiguration jackConfiguration;
|
|
std::shared_ptr<Lv2Pedalboard> lv2Pedalboard;
|
|
std::filesystem::path webRoot;
|
|
|
|
using SubscriberList = std::vector<std::shared_ptr<IPiPedalModelSubscriber>>;
|
|
SubscriberList subscribers;
|
|
void SetPresetChanged(int64_t clientId, bool value, bool changeSnapshotSelect = true);
|
|
void FireSnapshotModified(int64_t snapshotIndex, bool modified);
|
|
void FireSelectedSnapshotChanged(int64_t selectedSnapshot);
|
|
void FirePresetsChanged(int64_t clientId);
|
|
void FirePresetChanged(bool changed);
|
|
void FirePluginPresetsChanged(const std::string &pluginUri);
|
|
void FirePedalboardChanged(int64_t clientId, bool reloadAudioThread = true);
|
|
void FireChannelRouterSettingsChanged(int64_t clientId);
|
|
void FireBanksChanged(int64_t clientId);
|
|
void FireJackConfigurationChanged(const JackConfiguration &jackConfiguration);
|
|
void FireLv2StateChanged(int64_t instanceId, const Lv2PluginState &lv2State);
|
|
void UpdateDefaults(SnapshotValue &snapshotValue, const PedalboardItem *pedalboardItem);
|
|
void UpdateDefaults(Snapshot *snapshot, std::unordered_map<int64_t, PedalboardItem *> &itemMap);
|
|
void UpdateDefaults(PedalboardItem *pedalboardItem, std::unordered_map<int64_t, PedalboardItem *> &itemMap);
|
|
void UpdateDefaults(Pedalboard *pedalboard);
|
|
class VuSubscription
|
|
{
|
|
public:
|
|
int64_t subscriptionHandle;
|
|
int64_t instanceid;
|
|
};
|
|
int64_t nextSubscriptionId = 1;
|
|
std::vector<VuSubscription> activeVuSubscriptions;
|
|
|
|
std::vector<MonitorPortSubscription> activeMonitorPortSubscriptions;
|
|
|
|
void UpdateRealtimeVuSubscriptions();
|
|
void UpdateRealtimeMonitorPortSubscriptions();
|
|
|
|
void RestartAudio(bool useDummyAudioDriver = false);
|
|
|
|
std::vector<RealtimePatchPropertyRequest *> outstandingParameterRequests;
|
|
|
|
IPiPedalModelSubscriber *GetNotificationSubscriber(int64_t clientId);
|
|
std::atomic<bool> closed = false;
|
|
bool SyncLv2State();
|
|
|
|
private: // IAudioHostCallbacks
|
|
virtual void OnNotifyLv2StateChanged(uint64_t instanceId) override;
|
|
virtual bool OnNotifyMaybeLv2StateChanged(uint64_t instanceId) override;
|
|
virtual void OnNotifyVusSubscription(const std::vector<VuUpdateX> &updates) override;
|
|
virtual void OnNotifyMonitorPort(const MonitorPortUpdate &update) override;
|
|
virtual void OnNotifyMidiValueChanged(int64_t instanceId, int portIndex, float value) override;
|
|
virtual void OnNotifyMidiListen(uint8_t cc0, uint8_t cc1, uint8_t cc2) override;
|
|
virtual void OnPatchSetReply(uint64_t instanceId, LV2_URID patchSetProperty, const LV2_Atom *atomValue) override;
|
|
virtual void OnNotifyMidiRealtimeEvent(RealtimeMidiEventType eventType) override;
|
|
virtual void OnNotifyMidiRealtimeSnapshotRequest(int32_t snapshotIndex, int64_t snapshotRequestId) override;
|
|
virtual void OnAlsaDriverTerminatedAbnormally() override;
|
|
virtual void OnAlsaSequencerDeviceAdded(int client, const std::string &clientName) override;
|
|
virtual void OnAlsaSequencerDeviceRemoved(int client) override;
|
|
|
|
void OnNotifyPathPatchPropertyReceived(
|
|
int64_t instanceId,
|
|
LV2_URID pathPatchProperty,
|
|
LV2_Atom *pathProperty) override;
|
|
|
|
virtual void OnNotifyMidiProgramChange(RealtimeMidiProgramRequest &midiProgramRequest) override;
|
|
virtual void OnNotifyNextMidiProgram(const RealtimeNextMidiProgramRequest &request) override;
|
|
virtual void OnNotifyNextMidiBank(const RealtimeNextMidiProgramRequest &request) override;
|
|
virtual void OnNotifyLv2RealtimeError(int64_t instanceId, const std::string &error) override;
|
|
|
|
PostHandle networkChangingDelayHandle = 0;
|
|
void CancelNetworkChangingTimer();
|
|
|
|
void OnNetworkChanging(bool ethernetConnected, bool hotspotConnected);
|
|
void OnNetworkChanged(bool ethernetConnected, bool hotspotConnected);
|
|
|
|
void UpdateVst3Settings(Pedalboard &pedalboard);
|
|
|
|
PiPedalConfiguration configuration;
|
|
|
|
void CheckForResourceInitialization(Pedalboard &pedalboard);
|
|
UiFileProperty::ptr FindLoadedPatchProperty(int64_t instanceId, const std::string &patchPropertyUri);
|
|
|
|
public:
|
|
PiPedalModel();
|
|
virtual ~PiPedalModel();
|
|
|
|
enum class Direction
|
|
{
|
|
Increase,
|
|
Decrease
|
|
};
|
|
|
|
void EnableUpdater(bool enable);
|
|
|
|
Storage &GetStorage() { return storage; }
|
|
|
|
virtual std::string Tone3000ThumbnailDirectory() override;
|
|
|
|
bool GetHasWifi();
|
|
|
|
void NextBank(Direction direction = Direction::Increase);
|
|
void PreviousBank() { NextBank(Direction::Decrease); }
|
|
void NextPreset(Direction direction = Direction::Increase);
|
|
void PreviousPreset() { NextPreset(Direction::Decrease); }
|
|
|
|
int64_t DownloadModelsFromTone3000(
|
|
const std::string &responseuri,
|
|
const Tone3000PkceParams &pkce,
|
|
const std::string &downloadPath,
|
|
Tone3000DownloadType downloadType);
|
|
|
|
void CancelTone3000Download(
|
|
int64_t clientId,
|
|
int64_t downloadHandle);
|
|
void RequestShutdown(bool restart);
|
|
|
|
virtual PostHandle Post(PostCallback &&fn);
|
|
virtual PostHandle PostDelayed(const clock::duration &delay, PostCallback &&fn);
|
|
virtual bool CancelPost(PostHandle handle);
|
|
|
|
template <class REP, class PERIOD>
|
|
PostHandle PostDelayed(const std::chrono::duration<REP, PERIOD> &delay, PostCallback &&fn)
|
|
{
|
|
return PostDelayed(
|
|
std::chrono::duration_cast<clock::duration, REP, PERIOD>(delay),
|
|
std::move(fn));
|
|
}
|
|
|
|
std::shared_ptr<Lv2PluginInfo> GetPluginInfo(const std::string &uri);
|
|
|
|
void SetNetworkChangedListener(NetworkChangedListener listener)
|
|
{
|
|
networkChangedListener = listener;
|
|
}
|
|
|
|
void StartHotspotMonitoring();
|
|
|
|
void WaitForAudioDeviceToComeOnline();
|
|
|
|
UpdateStatus GetUpdateStatus();
|
|
void UpdateNow(const std::string &updateUrl);
|
|
void FireUpdateStatusChanged(const UpdateStatus &updateStatus);
|
|
uint16_t GetWebPort() const { return webPort; }
|
|
std::filesystem::path GetPluginUploadDirectory() const;
|
|
void Close();
|
|
|
|
void SetRestartListener(std::function<void(void)> &&listener);
|
|
void OnLv2PluginsChanged();
|
|
void SetOnboarding(bool value);
|
|
std::map<std::string, std::string> GetWifiRegulatoryDomains();
|
|
|
|
void UpdateDnsSd();
|
|
|
|
AdminClient &GetAdminClient() { return adminClient; }
|
|
|
|
void Init(const PiPedalConfiguration &configuration);
|
|
|
|
const PiPedalConfiguration &Configuration() const { return configuration; }
|
|
|
|
void LoadLv2PluginInfo();
|
|
void Load();
|
|
|
|
const PluginHost &GetPluginHost() const { return pluginHost; }
|
|
PluginHost &GetPluginHost() { return pluginHost; }
|
|
|
|
Pedalboard GetCurrentPedalboardCopy()
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(mutex);
|
|
return pedalboard; // can return a referece because we'd lose mutex protection
|
|
}
|
|
PluginUiPresets GetPluginUiPresets(const std::string &pluginUri);
|
|
PluginPresets GetPluginPresets(const std::string &pluginUri);
|
|
|
|
void LoadPluginPreset(int64_t pluginInstanceId, uint64_t presetInstanceId);
|
|
|
|
void AddNotificationSubscription(std::shared_ptr<IPiPedalModelSubscriber> pSubscriber);
|
|
void RemoveNotificationSubsription(std::shared_ptr<IPiPedalModelSubscriber> pSubscriber);
|
|
|
|
void SetPedalboardItemEnable(int64_t clientId, int64_t instanceId, bool enabled);
|
|
void SetPedalboardItemUseModUi(int64_t clientId, int64_t instanceId, bool enabled);
|
|
void SetControl(int64_t clientId, int64_t pedalItemId, const std::string &symbol, float value);
|
|
void PreviewControl(int64_t clientId, int64_t pedalItemId, const std::string &symbol, float value);
|
|
|
|
void SetInputVolume(float value);
|
|
void SetOutputVolume(float value);
|
|
void PreviewInputVolume(float value);
|
|
void PreviewOutputVolume(float value);
|
|
|
|
void SetPedalboard(int64_t clientId, Pedalboard &pedalboard);
|
|
Pedalboard &GetPedalboard();
|
|
std::shared_ptr<Lv2Pedalboard> GetLv2Pedalboard();
|
|
|
|
void UpdateCurrentPedalboard(int64_t clientId, Pedalboard &pedalboard);
|
|
|
|
void SetSnapshots(std::vector<std::shared_ptr<Snapshot>> &snapshots, int64_t selectedSnapshot);
|
|
void SetSnapshot(int64_t selectedSnapshot);
|
|
|
|
void GetPresets(PresetIndex *pResult);
|
|
|
|
Pedalboard GetPreset(int64_t instanceId);
|
|
void GetBank(int64_t instanceId, BankFile *pBank);
|
|
|
|
int64_t UploadBank(BankFile &bankFile, int64_t uploadAfter = -1);
|
|
int64_t UploadPreset(const BankFile &bankFile, int64_t uploadAfter = -1);
|
|
void UploadPluginPresets(const PluginPresets &pluginPresets);
|
|
void SaveCurrentPreset(int64_t clientId);
|
|
int64_t SaveCurrentPresetAs(int64_t clientId, int64_t bankInstanceId, const std::string &name, int64_t saveAfterInstanceId = -1);
|
|
int64_t SavePluginPresetAs(int64_t instanceId, const std::string &name);
|
|
|
|
void LoadPreset(int64_t clientId, int64_t instanceId);
|
|
bool UpdatePresets(int64_t clientId, const PresetIndex &presets);
|
|
void UpdatePluginPresets(const PluginUiPresets &pluginPresets);
|
|
int64_t DeletePresets(int64_t clientId, const std::vector<int64_t> &presetInstanceIds);
|
|
bool RenamePreset(int64_t clientId, int64_t instanceId, const std::string &name);
|
|
int64_t CopyPreset(int64_t clientId, int64_t fromIndex, int64_t toIndex);
|
|
uint64_t CopyPluginPreset(const std::string &pluginUri, uint64_t presetId);
|
|
|
|
void MoveBank(int64_t clientId, int from, int to);
|
|
int64_t DeleteBank(int64_t clientId, int64_t instanceId);
|
|
|
|
int64_t DuplicatePreset(int64_t clientId, int64_t instanceId) { return CopyPreset(clientId, instanceId, -1); }
|
|
|
|
JackConfiguration GetJackConfiguration();
|
|
|
|
JackChannelSelection GetJackChannelSelection();
|
|
|
|
void SetAlsaSequencerConfiguration(const AlsaSequencerConfiguration &alsaSequencerConfiguration);
|
|
AlsaSequencerConfiguration GetAlsaSequencerConfiguration();
|
|
|
|
std::vector<AlsaSequencerPortSelection> GetAlsaSequencerPorts();
|
|
|
|
void SetShowStatusMonitor(bool show);
|
|
bool GetShowStatusMonitor();
|
|
|
|
void SetWifiConfigSettings(const WifiConfigSettings &wifiConfigSettings);
|
|
WifiConfigSettings GetWifiConfigSettings();
|
|
std::vector<std::string> GetKnownWifiNetworks();
|
|
|
|
void SetWifiDirectConfigSettings(const WifiDirectConfigSettings &wifiConfigSettings);
|
|
WifiDirectConfigSettings GetWifiDirectConfigSettings();
|
|
|
|
void SetGovernorSettings(const std::string &governor);
|
|
GovernorSettings GetGovernorSettings();
|
|
|
|
int64_t AddVuSubscription(int64_t instanceId);
|
|
void RemoveVuSubscription(int64_t subscriptionHandle);
|
|
|
|
void SetSystemMidiBindings(std::vector<MidiBinding> &bindings);
|
|
std::vector<MidiBinding> GetSystemMidiBidings();
|
|
|
|
int64_t MonitorPort(int64_t instanceId, const std::string &key, float updateInterval, PortMonitorCallback onUpdate);
|
|
void UnmonitorPort(int64_t subscriptionHandle);
|
|
|
|
void SendGetPatchProperty(
|
|
int64_t clientId,
|
|
int64_t instanceId,
|
|
const std::string uri,
|
|
std::function<void(const std::string &jsonResjult)> onSuccess,
|
|
std::function<void(const std::string &error)> onError);
|
|
|
|
void SendSetPatchProperty(
|
|
int64_t clientId,
|
|
int64_t instanceId,
|
|
const std::string uri,
|
|
const json_variant &value,
|
|
std::function<void()> onSuccess,
|
|
std::function<void(const std::string &error)> onError);
|
|
|
|
BankIndex GetBankIndex() const;
|
|
void RenameBank(int64_t clientId, int64_t bankId, const std::string &newName);
|
|
int64_t SaveBankAs(int64_t clientId, int64_t bankId, const std::string &newName);
|
|
void OpenBank(int64_t clientId, int64_t bankId);
|
|
|
|
JackHostStatus GetJackStatus()
|
|
{
|
|
return this->audioHost->getJackStatus();
|
|
}
|
|
JackServerSettings GetJackServerSettings();
|
|
void SetJackServerSettings(const JackServerSettings &jackServerSettings);
|
|
|
|
void ListenForMidiEvent(int64_t clientId, int64_t clientHandle);
|
|
void CancelListenForMidiEvent(int64_t clientId, int64_t clientHandle);
|
|
|
|
void MonitorPatchProperty(int64_t clientId, int64_t clientHandle, uint64_t instanceId, const std::string &propertyUri);
|
|
void CancelMonitorPatchProperty(int64_t clientId, int64_t clientHandle);
|
|
|
|
std::vector<AlsaDeviceInfo> GetAlsaDevices();
|
|
const std::filesystem::path &GetWebRoot() const;
|
|
|
|
std::map<std::string, bool> GetFavorites() const;
|
|
void SetFavorites(const std::map<std::string, bool> &favorites);
|
|
void SetUpdatePolicy(UpdatePolicyT updatePolicy);
|
|
void ForceUpdateCheck();
|
|
FileRequestResult GetFileList2(const std::string &relativePath, const UiFileProperty &fileProperty);
|
|
|
|
void DeleteSampleFile(const std::filesystem::path &fileName);
|
|
std::string CreateNewSampleDirectory(const std::string &relativePath, const UiFileProperty &uiFileProperty);
|
|
std::string RenameFilePropertyFile(const std::string &oldRelativePath, const std::string &newRelativePath, const UiFileProperty &uiFileProperty);
|
|
std::string CopyFilePropertyFile(const std::string &oldRelativePath, const std::string &newRelativePath, const UiFileProperty &uiFileProperty, bool overwrite);
|
|
FilePropertyDirectoryTree::ptr GetFilePropertydirectoryTree(const UiFileProperty &uiFileProperty, const std::string &selectedPath);
|
|
|
|
bool IsInUploadsDirectory(const std::string &path);
|
|
|
|
std::string UploadUserFile(const std::string &directory, int64_t instanceId, const std::string &patchProperty, const std::string &filename, std::istream &inputStream, size_t streamLength);
|
|
uint64_t CreateNewPreset();
|
|
|
|
bool LoadCurrentPedalboard();
|
|
|
|
void MoveAudioFile(
|
|
const std::string &path,
|
|
int32_t from,
|
|
int32_t to);
|
|
|
|
void SetPedalboardItemTitle(int64_t instanceId, const std::string &title, const std::string &iconColor);
|
|
|
|
void SetSelectedPedalboardPlugin(uint64_t clientId, uint64_t pedalboardId);
|
|
|
|
std::vector<PresetIndexEntry> RequestBankPresets(int64_t bankInstanceId);
|
|
int64_t ImportPresetsFromBank(int64_t bankInstanceId, const std::vector<int64_t> &presets);
|
|
int64_t CopyPresetsToBank(int64_t bankInstanceId, const std::vector<int64_t> &presets);
|
|
|
|
void SetChannelRouterSettings(int64_t clientId, ChannelRouterSettings::ptr &settings);
|
|
ChannelRouterSettings::ptr GetChannelRouterSettings();
|
|
void WriteTone3000Readme(const std::filesystem::path &filePath, const tone3000::Tone &tone, const std::string &thumbnailUrl);
|
|
};
|
|
|
|
} // namespace pipedal.
|