SoundDevice.hh

Go to the documentation of this file.

#ifndef SOUNDDEVICE_HH
#define SOUNDDEVICE_HH
 
#include "EmuTime.hh"
#include "WavWriter.hh"
#include "static_string_view.hh"
#include <array>
#include <optional>
#include <string>
#include <string_view>
 
namespace openmsx {
 
class DeviceConfig;
class DynamicClock;
class Filename;
class MSXMixer;
 
class SoundDevice
{
public:
        static constexpr unsigned MAX_CHANNELS = 24;
 
        SoundDevice(const SoundDevice&) = delete;
        SoundDevice(SoundDevice&&) = delete;
        SoundDevice& operator=(const SoundDevice&) = delete;
        SoundDevice& operator=(SoundDevice&&) = delete;
 
        [[nodiscard]] const std::string& getName() const { return name; }
 
        [[nodiscard]] std::string_view getDescription() const { return description; }
 
        [[nodiscard]] unsigned getNumChannels() const { return numChannels; }
 
        [[nodiscard]] bool hasStereoChannels() const {
                return stereo == 2;
        }
 
        [[nodiscard]] bool isStereo() const {
                return hasStereoChannels() || !balanceCenter;
        }
 
        struct AmplificationFactors {
                float left;
                float right;
        };
        [[nodiscard]] AmplificationFactors getAmplificationFactor() const {
                auto f = getAmplificationFactorImpl();
                return {f * softwareVolumeLeft, f * softwareVolumeRight};
        }
 
        void setSoftwareVolume(float volume, EmuTime::param time);
        void setSoftwareVolume(float left, float right, EmuTime::param time);
 
        void recordChannel(unsigned channel, const Filename& filename);
        void muteChannel  (unsigned channel, bool muted);
 
        [[nodiscard]] std::span<const float> getLastBuffer(unsigned channel);
 
        [[nodiscard]] float getNativeSampleRate() const { return float(inputSampleRate); }
 
        [[nodiscard]] unsigned getLastMonoBufferSize() const {
                // Tuned so that both the ImGui waveform and spectrum viewer
                // look 'nice' (and aren't too expensive to calculate).
                return inputSampleRate / 7; // ~0.14 seconds
        }
        [[nodiscard]] unsigned getLastBufferSize() const {
                return getLastMonoBufferSize() * stereo;
        }
 
protected:
        SoundDevice(MSXMixer& mixer, std::string_view name, static_string_view description,
                    unsigned numChannels, unsigned inputRate, bool stereo);
        ~SoundDevice();
 
        [[nodiscard]] virtual float getAmplificationFactorImpl() const;
 
        void registerSound(const DeviceConfig& config);
 
        void unregisterSound();
 
        void updateStream(EmuTime::param time);
 
        void setInputRate(unsigned sampleRate) { inputSampleRate = sampleRate; }
        [[nodiscard]] unsigned getInputRate() const { return inputSampleRate; }
 
public: // Will be called by Mixer:
        virtual void setOutputRate(unsigned hostSampleRate, double speed) = 0;
 
        [[nodiscard]] virtual bool updateBuffer(size_t length, float* buffer,
                                                EmuTime::param time) = 0;
 
protected:
        static void addFill(float*& buffer, float value, unsigned num);
 
        virtual void generateChannels(std::span<float*> buffers, unsigned num) = 0;
 
        [[nodiscard]] bool mixChannels(float* dataOut, size_t samples);
 
        [[nodiscard]] const DynamicClock& getHostSampleClock() const;
        [[nodiscard]] double getEffectiveSpeed() const;
 
private:
        MSXMixer& mixer;
        const std::string name;
        const static_string_view description;
 
        std::array<std::optional<Wav16Writer>, MAX_CHANNELS> writer;
 
        float softwareVolumeLeft = 1.0f;
        float softwareVolumeRight = 1.0f;
        unsigned inputSampleRate;
        const unsigned numChannels;
        const unsigned stereo;
        unsigned numRecordChannels = 0;
        std::array<int,  MAX_CHANNELS> channelBalance;
        std::array<bool, MAX_CHANNELS> channelMuted;
        bool balanceCenter = true;
 
        // When channel data needs to be collected separately (e.g. because
        // we're recording the channel, or because we want to present it in the
        // GUI), we store that data in this struct.
        struct PerChannelBuffer {
                std::vector<float> buffer; // dynamically grows when needed
                unsigned stopIdx = 0; // buffer only contains valid data at indices [0, stopIdx)
                unsigned requestCounter = 0; // != 0 means we're interested in collecting this data
                unsigned silent = 999999; // how many 0 samples are at the end of the buffer
        };
        std::array<PerChannelBuffer, MAX_CHANNELS> channelBuffers = {};
};
 
} // namespace openmsx
 
#endif