RADMedia.h

Go to the documentation of this file.

#ifndef RADMEDIA_H
#define RADMEDIA_H
 
#pragma once
 
#include <RADCore/RADCore.h>
 
#include <atomic>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace RADMedia {
 
    enum class AudioSampleFormat {
        Unknown,
        UInt8,
        Int16,
        Int24,
        Int32,
        Float32
    };
 
    enum class AudioDeviceDirection {
        Input,
        Output
    };
 
    struct WavFormat {
        uint16_t channels = 0;
        uint32_t sampleRate = 0;
        uint16_t bitsPerSample = 0;
        uint16_t blockAlign = 0;
        uint32_t byteRate = 0;
        AudioSampleFormat sampleFormat = AudioSampleFormat::Unknown;
    };
 
    class WavFile {
    public:
        static std::optional<WavFile> load(const std::string& path, std::string* error = nullptr);
        static bool savePcm16(const std::string& path, uint16_t channels, uint32_t sampleRate,
            const std::vector<int16_t>& interleavedSamples, std::string* error = nullptr);
 
        const WavFormat& format() const;
        const std::vector<uint8_t>& audioData() const;
        size_t frameCount() const;
        double durationSeconds() const;
 
    private:
        WavFormat format_;
        std::vector<uint8_t> audioData_;
    };
 
    class WavStreamReader {
    public:
        WavStreamReader();
        ~WavStreamReader();
 
        WavStreamReader(const WavStreamReader&) = delete;
        WavStreamReader& operator=(const WavStreamReader&) = delete;
 
        bool open(const std::string& path, std::string* error = nullptr);
        void close();
        bool isOpen() const;
 
        const WavFormat& format() const;
        size_t totalFrames() const;
        size_t framesRemaining() const;
        double durationSeconds() const;
        bool eof() const;
 
        ssize_t readFrames(void* buffer, size_t maxFrames);
 
    private:
        struct Impl;
        std::unique_ptr<Impl> pImpl_;
    };
 
    struct AudioSinkDevice {
        std::string id;
        std::string name;
        std::string description;
    };
 
    struct AudioSourceDevice {
        std::string id;
        std::string name;
        std::string description;
    };
 
    class AudioDevice {
    public:
        static std::vector<AudioSinkDevice> outputDevices();
        static std::vector<AudioSourceDevice> inputDevices();
    };
 
    struct MidiInputDeviceInfo {
        std::string id;
        std::string name;
        std::string description;
    };
 
    enum class MidiMessageType {
        NoteOff,
        NoteOn,
        ControlChange,
        ProgramChange,
        PitchBend,
        Other
    };
 
    struct MidiMessage {
        MidiMessageType type = MidiMessageType::Other;
        uint8_t channel = 0;
        uint8_t data1 = 0;
        uint8_t data2 = 0;
        uint8_t status = 0;
    };
 
    class MidiInputDevice {
    public:
        MidiInputDevice();
        ~MidiInputDevice();
 
        MidiInputDevice(const MidiInputDevice&) = delete;
        MidiInputDevice& operator=(const MidiInputDevice&) = delete;
        MidiInputDevice(MidiInputDevice&&) noexcept;
        MidiInputDevice& operator=(MidiInputDevice&&) noexcept;
 
        static std::vector<MidiInputDeviceInfo> inputDevices();
 
        bool open(const std::string& deviceId, std::string* error = nullptr);
        void close();
        bool isOpen() const;
        const std::string& deviceId() const;
        std::vector<MidiMessage> readMessages(size_t maxBytes = 256);
 
    private:
        struct Impl;
        std::unique_ptr<Impl> pImpl_;
    };
 
    struct AudioBuffer {
        WavFormat format;
        std::vector<float> interleaved;
 
        size_t frameCount() const;
        double durationSeconds() const;
    };
 
    struct MidiNoteEvent {
        double startSeconds = 0.0;
        double durationSeconds = 0.0;
        uint8_t channel = 0;
        uint8_t note = 60;
        uint8_t velocity = 96;
    };
 
    struct MidiProgramChange {
        double timeSeconds = 0.0;
        uint8_t channel = 0;
        uint8_t bank = 0;
        uint8_t program = 0;
    };
 
    struct MidiPitchBend {
        double timeSeconds = 0.0;
        uint8_t channel = 0;
        uint16_t value = 8192;
    };
 
    struct MidiClip {
        uint32_t sampleRate = 48000;
        uint16_t channels = 2;
        double durationSeconds = 0.0;
        double tailSeconds = 0.25;
        std::vector<MidiNoteEvent> notes;
        std::vector<MidiProgramChange> programs;
        std::vector<MidiPitchBend> pitchBends;
 
        double resolvedDurationSeconds() const;
    };
 
    enum class MusicXmlStaffMode {
        Treble,
        Bass,
        GrandStaff
    };
 
    struct MusicXmlNoteEvent {
        int startTicks = 0;
        int durationTicks = 0;
        int midiNote = 60;
        int writtenDurationTicks = 0;
        int writtenDots = 0;
        int tupletActualNotes = 0;
        int tupletNormalNotes = 0;
        std::string color;
    };
 
    struct MusicXmlHairpinEvent {
        int startTicks = 0;
        int endTicks = 0;
        int kind = 1;
    };
 
    struct MusicXmlRepeatEvent {
        int startMeasure = 0;
        int measureCount = 1;
        int repeatCount = 1;
    };
 
    struct MusicXmlRehearsalEvent {
        int measure = 0;
        std::string text;
    };
 
    struct MusicXmlScoreOptions {
        std::string partName = "Part";
        int divisions = 960;
        int beats = 4;
        int beatType = 4;
        int measureCount = 1;
        int measuresPerSystem = 4;
        int systemsPerPage = 5;
        MusicXmlStaffMode staffMode = MusicXmlStaffMode::Treble;
        int grandStaffSplitNote = 60;
        int keyFifths = 0;
        std::vector<int> measureKeyFifths;
        std::vector<MusicXmlHairpinEvent> hairpins;
        std::vector<MusicXmlRepeatEvent> repeats;
        std::vector<MusicXmlRehearsalEvent> rehearsals;
    };
 
    class MusicXml {
    public:
        static std::string escape(const std::string& value);
        static std::vector<int> durationChunks(int ticks, int divisions = 960);
        static std::string partwiseScore(const std::vector<MusicXmlNoteEvent>& notes,
            const MusicXmlScoreOptions& options, std::string* error = nullptr);
    };
 
    enum class SoundFontType {
        Unknown,
        SF2,
        SF3
    };
 
    struct SoundFontInfo {
        std::string path;
        std::string name;
        SoundFontType type = SoundFontType::Unknown;
    };
 
    struct SoundFontPreset {
        std::string name;
        uint16_t bank = 0;
        uint16_t program = 0;
    };
 
    class SoundFontCatalog {
    public:
        static std::vector<std::string> defaultSearchPaths();
        static bool supportsExtension(const std::string& path);
        static SoundFontType typeForPath(const std::string& path);
        static std::vector<SoundFontInfo> scan(const std::vector<std::string>& paths = {});
        static std::vector<SoundFontPreset> presets(const std::string& path, std::string* error = nullptr);
        static std::vector<SoundFontPreset> generalMidiPresets();
        static std::string generalMidiPresetName(uint16_t program);
    };
 
    class MidiSynthesizer {
    public:
        MidiSynthesizer();
        ~MidiSynthesizer();
 
        MidiSynthesizer(const MidiSynthesizer&) = delete;
        MidiSynthesizer& operator=(const MidiSynthesizer&) = delete;
        MidiSynthesizer(MidiSynthesizer&&) noexcept;
        MidiSynthesizer& operator=(MidiSynthesizer&&) noexcept;
 
        static bool isAvailable();
        static std::vector<std::string> defaultSoundFontPaths();
 
        bool open(uint32_t sampleRate = 48000, float gain = 0.2f, std::string* error = nullptr);
        void close();
        bool isOpen() const;
        uint32_t sampleRate() const;
 
        bool loadSoundFont(const std::string& path, bool resetPresets = true, std::string* error = nullptr);
        std::optional<AudioBuffer> render(const MidiClip& clip, std::string* error = nullptr);
        bool beginStream(const MidiClip& clip, std::string* error = nullptr);
        std::optional<AudioBuffer> renderNext(size_t maxFrames, std::string* error = nullptr);
        bool streamFinished() const;
        static std::optional<AudioBuffer> renderClip(const MidiClip& clip, const std::string& soundFontPath,
            std::string* error = nullptr);
 
    private:
        struct Impl;
        bool ensureFluidSynthLoaded(uint32_t sampleRate, float gain, std::string* error);
        std::unique_ptr<Impl> pImpl_;
    };
 
    class AudioDecoder {
    public:
        static bool supportsExtension(const std::string& path);
        static std::optional<AudioBuffer> decodeFile(const std::string& path, std::string* error = nullptr);
        static std::vector<std::string> supportedExtensions();
    };
 
    class AudioDecoderStream {
    public:
        AudioDecoderStream();
        ~AudioDecoderStream();
 
        AudioDecoderStream(const AudioDecoderStream&) = delete;
        AudioDecoderStream& operator=(const AudioDecoderStream&) = delete;
 
        bool open(const std::string& path, std::string* error = nullptr);
        void close();
        bool isOpen() const;
        bool eof() const;
        const WavFormat& format() const;
        size_t readFrames(float* interleaved, size_t maxFrames);
 
    private:
        struct Impl;
        std::unique_ptr<Impl> pImpl_;
    };
 
    class RADAudioDevice : public RADCore::RADIODevice {
    public:
        RADEvents:
            RAD_EVENT(started, ());
            RAD_EVENT(stopped, ());
            RAD_EVENT(underrun, ());
 
        RADAudioDevice(RADCore::EventLoop& loop, AudioDeviceDirection direction);
        ~RADAudioDevice() override;
 
        static bool isFormatSupported(const std::string& deviceId, AudioDeviceDirection direction, const WavFormat& format);
 
        AudioDeviceDirection direction() const;
 
        void setDeviceId(std::string deviceId);
        const std::string& deviceId() const;
 
        void setFormat(WavFormat format);
        const WavFormat& format() const;
 
        void setFramesPerChunk(size_t frames);
        size_t framesPerChunk() const;
        void setTargetLatencyUsec(unsigned int usec);
        unsigned int targetLatencyUsec() const;
        void setPeriodFrames(size_t frames);
        size_t periodFrames() const;
        void setBufferFrames(size_t frames);
        size_t bufferFrames() const;
 
        void setMaxBufferedBytes(size_t bytes);
        size_t maxBufferedBytes() const;
        size_t bytesAvailable() const;
 
        bool open(RADCore::OpenMode mode) override;
        void close() override;
        bool isOpen() const override;
        ssize_t readData(void* buffer, size_t maxBytes) override;
        ssize_t writeData(const void* data, size_t size) override;
        ssize_t writeFrames(const void* data, size_t frames);
        size_t delayFrames() const;
        void drain();
        void drop();
 
    private:
        struct Impl;
        std::shared_ptr<Impl> pImpl_;
    };
 
    class AudioInputDevice : public RADAudioDevice {
    public:
        explicit AudioInputDevice(RADCore::EventLoop& loop);
    };
 
    class AudioPlayer : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(started, ());
            RAD_EVENT(finished, ());
            RAD_EVENT(stopped, ());
            RAD_EVENT(errorOccurred, (std::string));
 
        bool play(const WavFile& wav, const std::string& deviceId = "default", std::string* error = nullptr);
        bool playBuffer(const AudioBuffer& buffer, const std::string& deviceId = "default", std::string* error = nullptr);
        bool playBufferLowLatency(const AudioBuffer& buffer, const std::string& deviceId = "default",
            size_t framesPerChunk = 256, unsigned int targetLatencyUsec = 5000, std::string* error = nullptr);
        bool playFile(const std::string& path, const std::string& deviceId = "default", std::string* error = nullptr);
        void stop();
        void playAsync(RADCore::EventLoop& loop, WavFile wav, const std::string& deviceId = "default");
        void playFileAsync(RADCore::EventLoop& loop, const std::string& path, const std::string& deviceId = "default");
 
    private:
        bool playInternal(const WavFile& wav, const std::string& deviceId, std::string* error, bool resetStopRequest);
        bool playBufferInternal(const AudioBuffer& buffer, const std::string& deviceId, size_t framesPerChunk,
            unsigned int targetLatencyUsec, std::string* error, bool resetStopRequest);
        bool playFileInternal(const std::string& path, const std::string& deviceId, std::string* error, bool resetStopRequest);
        std::atomic<bool> stopRequested_{false};
    };
 
} // namespace RADMedia
 
#endif