166 lines
4.6 KiB
C++
166 lines
4.6 KiB
C++
// Copyright (c) 2026 Ourpad Network
|
|
// See LICENSE file in the project root for full license text.
|
|
|
|
#pragma once
|
|
|
|
#include <string>
|
|
#include <memory>
|
|
#include <functional>
|
|
|
|
namespace pipedal {
|
|
|
|
class MixerEngine;
|
|
|
|
/// Mixer API — bridges WebSocket messages to the MixerEngine.
|
|
///
|
|
/// Follows the existing PiPedalSocket pattern where handlers are registered
|
|
/// via REGISTER_MESSAGE_HANDLER and dispatched by message name.
|
|
///
|
|
/// This class provides the model-level methods that the socket handlers call.
|
|
class MixerApi {
|
|
public:
|
|
MixerApi();
|
|
~MixerApi();
|
|
|
|
/// Set the mixer engine this API talks to.
|
|
void setMixerEngine(MixerEngine* engine) { mixerEngine_ = engine; }
|
|
MixerEngine* mixerEngine() const { return mixerEngine_; }
|
|
|
|
/// --- Channel Control ---
|
|
|
|
/// Set channel volume in dB (-inf to +12)
|
|
void setChannelVolume(int channelIndex, float volumeDb);
|
|
|
|
/// Set channel pan (-1.0 left to +1.0 right)
|
|
void setChannelPan(int channelIndex, float pan);
|
|
|
|
/// Set channel mute state
|
|
void setChannelMute(int channelIndex, bool mute);
|
|
|
|
/// Set channel solo state
|
|
void setChannelSolo(int channelIndex, bool solo);
|
|
|
|
/// Set channel label
|
|
void setChannelLabel(int channelIndex, const std::string& label);
|
|
|
|
/// Set channel type (Instrument, Mic, Line)
|
|
void setChannelType(int channelIndex, const std::string& type);
|
|
|
|
/// Set channel HPF state
|
|
void setChannelHpf(int channelIndex, bool enabled, float frequency);
|
|
|
|
/// --- Channel Lifecycle ---
|
|
|
|
/// Add a new channel for the given physical input
|
|
int addChannel(int physicalInputIndex);
|
|
|
|
/// Remove a channel
|
|
void removeChannel(int channelIndex);
|
|
|
|
/// --- Bus Control ---
|
|
|
|
/// Set bus volume
|
|
void setBusVolume(int64_t busId, float volumeDb);
|
|
|
|
/// Set bus mute
|
|
void setBusMute(int64_t busId, bool mute);
|
|
|
|
/// Add a new bus
|
|
int64_t addBus(const std::string& type, const std::string& name, int channels);
|
|
|
|
/// Remove a bus
|
|
void removeBus(int64_t busId);
|
|
|
|
/// --- Routing ---
|
|
|
|
/// Route a channel to a bus
|
|
void routeChannelToBus(int channelIndex, int64_t busId, float levelDb);
|
|
|
|
/// Route a bus to another bus
|
|
void routeBusToBus(int64_t sourceBusId, int64_t targetBusId, float levelDb);
|
|
|
|
/// Remove a route
|
|
void removeRoute(int64_t sourceId, int64_t targetBusId);
|
|
|
|
/// --- State Queries ---
|
|
|
|
/// Get the full mixer state as a JSON string
|
|
std::string getStateJson() const;
|
|
|
|
/// --- Output Routing ---
|
|
|
|
/// Get output routes as a JSON array string
|
|
std::string getOutputRoutesJson() const;
|
|
|
|
/// Set output routes from a JSON array string
|
|
void setOutputRoutesFromJson(const std::string& json);
|
|
|
|
/// Apply a full mixer state from a JSON string
|
|
void setFullState(const std::string& stateJson);
|
|
|
|
/// --- Scenes ---
|
|
|
|
/// Save current mixer state as a scene
|
|
std::string saveScene(const std::string& name);
|
|
|
|
/// Load a scene by name
|
|
bool loadScene(const std::string& sceneId);
|
|
|
|
/// List available scenes
|
|
std::string listScenes() const;
|
|
|
|
/// Delete a scene
|
|
bool deleteScene(const std::string& sceneId);
|
|
|
|
/// --- MIDI Control Surface Mapping ---
|
|
|
|
/// Get all MIDI mappings as JSON
|
|
std::string getMidiMappingsJson() const;
|
|
|
|
/// Set all MIDI mappings from JSON
|
|
void setMidiMappingsFromJson(const std::string& json);
|
|
|
|
/// Add a single MIDI mapping
|
|
void addMidiMapping(int midiChannel, int ccNumber,
|
|
const std::string& targetType, int64_t targetId,
|
|
float minValue, float maxValue);
|
|
|
|
/// Remove MIDI mapping by CC and channel
|
|
void removeMidiMapping(int midiChannel, int ccNumber);
|
|
|
|
/// Remove MIDI mapping by index
|
|
void removeMidiMappingByIndex(size_t index);
|
|
|
|
/// Clear all MIDI mappings
|
|
void clearMidiMappings();
|
|
|
|
/// Toggle MIDI learn mode
|
|
void setMidiLearnMode(bool enabled);
|
|
bool getMidiLearnMode() const;
|
|
|
|
/// Set the pending learn target (which UI control was touched)
|
|
void setMidiLearnTarget(const std::string& targetType, int64_t targetId);
|
|
|
|
/// Commit a learned mapping (captured CC + pending target)
|
|
bool commitMidiLearnMapping();
|
|
|
|
/// Get last learned CC event info (for UI feedback)
|
|
struct LearnedEventInfo {
|
|
bool hasEvent = false;
|
|
int midiChannel = -1;
|
|
int ccNumber = -1;
|
|
};
|
|
LearnedEventInfo getLastLearnedMidiEvent() const;
|
|
|
|
/// Save MIDI mappings to config file
|
|
void saveMidiMappingsToFile() const;
|
|
|
|
/// Load MIDI mappings from config file
|
|
void loadMidiMappingsFromFile();
|
|
|
|
private:
|
|
MixerEngine* mixerEngine_ = nullptr;
|
|
};
|
|
|
|
} // namespace pipedal
|