86 lines
2.9 KiB
C++
86 lines
2.9 KiB
C++
#pragma once
|
|
|
|
#include <mutex>
|
|
#include <deque>
|
|
#include <memory>
|
|
#include <iostream>
|
|
#include <functional>
|
|
#include <misc/spin_lock.h>
|
|
#include "AudioSamples.h"
|
|
#include "driver/AudioDriver.h"
|
|
|
|
class AudioInputSource;
|
|
namespace tc::audio {
|
|
class AudioInput;
|
|
class Reframer;
|
|
class AudioResampler;
|
|
|
|
class AudioConsumer {
|
|
friend class AudioInput;
|
|
public:
|
|
AudioInput* handle;
|
|
|
|
size_t const channel_count = 0;
|
|
size_t const sample_rate = 0;
|
|
|
|
size_t const frame_size = 0;
|
|
|
|
spin_lock on_read_lock; /* locked to access the function */
|
|
std::function<void(const void* /* buffer */, size_t /* samples */)> on_read;
|
|
private:
|
|
AudioConsumer(AudioInput* handle, size_t channel_count, size_t sample_rate, size_t frame_size);
|
|
|
|
std::unique_ptr<Reframer> reframer;
|
|
|
|
void process_data(const void* /* buffer */, size_t /* samples */);
|
|
void handle_framed_data(const void* /* buffer */, size_t /* samples */);
|
|
};
|
|
|
|
class AudioInput : public AudioDeviceRecord::Consumer {
|
|
friend class ::AudioInputSource;
|
|
public:
|
|
AudioInput(size_t /* channels */, size_t /* sample rate */);
|
|
virtual ~AudioInput();
|
|
|
|
void set_device(const std::shared_ptr<AudioDevice>& /* device */);
|
|
[[nodiscard]] std::shared_ptr<AudioDevice> current_device() const { return this->input_device; }
|
|
void close_device();
|
|
|
|
[[nodiscard]] bool record(std::string& /* error */);
|
|
[[nodiscard]] bool recording();
|
|
void stop();
|
|
|
|
std::deque<std::shared_ptr<AudioConsumer>> consumers() {
|
|
std::lock_guard lock(this->consumers_lock);
|
|
return this->_consumers;
|
|
}
|
|
|
|
std::shared_ptr<AudioConsumer> create_consumer(size_t /* frame size */);
|
|
void delete_consumer(const std::shared_ptr<AudioConsumer>& /* source */);
|
|
|
|
[[nodiscard]] inline size_t channel_count() const { return this->_channel_count; }
|
|
[[nodiscard]] inline size_t sample_rate() const { return this->_sample_rate; }
|
|
|
|
[[nodiscard]] inline float volume() const { return this->_volume; }
|
|
inline void set_volume(float value) { this->_volume = value; }
|
|
private:
|
|
void consume(const void *, size_t, size_t) override;
|
|
|
|
size_t const _channel_count;
|
|
size_t const _sample_rate;
|
|
|
|
std::mutex consumers_lock;
|
|
std::deque<std::shared_ptr<AudioConsumer>> _consumers;
|
|
std::recursive_mutex input_source_lock;
|
|
|
|
std::unique_ptr<AudioResampler> _resampler{nullptr};
|
|
std::shared_ptr<AudioDevice> input_device{};
|
|
|
|
void* resample_buffer{nullptr};
|
|
size_t resample_buffer_size{0};
|
|
|
|
float _volume{1.f};
|
|
|
|
std::shared_ptr<AudioDeviceRecord> input_recorder{};
|
|
};
|
|
} |