105 lines
3.0 KiB
C++
105 lines
3.0 KiB
C++
#pragma once
|
|
|
|
#include <nan.h>
|
|
#include <mutex>
|
|
#include <deque>
|
|
#include <include/NanEventCallback.h>
|
|
|
|
namespace tc {
|
|
namespace audio {
|
|
class AudioInput;
|
|
class AudioConsumer;
|
|
|
|
namespace filter {
|
|
class Filter;
|
|
}
|
|
|
|
namespace recorder {
|
|
class AudioFilterWrapper;
|
|
class AudioRecorderWrapper;
|
|
/*
|
|
get_filters() : ConsumeFilter[];
|
|
|
|
register_filter(filter: ConsumeFilter);
|
|
unregister_filter(filter: ConsumeFilter);
|
|
|
|
create_filter_vad() : VADConsumeFilter;
|
|
create_filter_threshold() : ThresholdConsumeFilter;
|
|
*/
|
|
|
|
class AudioConsumerWrapper : public Nan::ObjectWrap {
|
|
friend class AudioRecorderWrapper;
|
|
public:
|
|
static NAN_MODULE_INIT(Init);
|
|
static NAN_METHOD(NewInstance);
|
|
static inline Nan::Persistent<v8::Function> & constructor() {
|
|
static Nan::Persistent<v8::Function> my_constructor;
|
|
return my_constructor;
|
|
}
|
|
|
|
static inline Nan::Persistent<v8::FunctionTemplate> & constructor_template() {
|
|
static Nan::Persistent<v8::FunctionTemplate> my_constructor_template;
|
|
return my_constructor_template;
|
|
}
|
|
|
|
AudioConsumerWrapper(AudioRecorderWrapper*, const std::shared_ptr<AudioConsumer>& /* handle */);
|
|
~AudioConsumerWrapper() override;
|
|
|
|
static NAN_METHOD(_get_filters);
|
|
static NAN_METHOD(_unregister_filter);
|
|
|
|
static NAN_METHOD(_create_filter_vad);
|
|
static NAN_METHOD(_create_filter_threshold);
|
|
static NAN_METHOD(_create_filter_state);
|
|
|
|
std::shared_ptr<AudioFilterWrapper> create_filter(const std::string& /* name */, const std::shared_ptr<filter::Filter>& /* filter impl */);
|
|
void delete_filter(const AudioFilterWrapper*);
|
|
|
|
inline std::deque<std::shared_ptr<AudioFilterWrapper>> filters() {
|
|
std::lock_guard lock(this->_filters_lock);
|
|
return this->_filters;
|
|
}
|
|
|
|
inline std::shared_ptr<AudioConsumer> native_consumer() { return this->_handle; }
|
|
|
|
std::mutex native_read_callback_lock;
|
|
std::function<void(const void * /* buffer */, size_t /* samples */)> native_read_callback;
|
|
private:
|
|
AudioRecorderWrapper* _recorder;
|
|
|
|
std::mutex execute_lock;
|
|
std::shared_ptr<AudioConsumer> _handle;
|
|
|
|
std::mutex _filters_lock;
|
|
std::deque<std::shared_ptr<AudioFilterWrapper>> _filters;
|
|
bool last_consumed = false;
|
|
|
|
void do_wrap(const v8::Local<v8::Object>& /* object */);
|
|
|
|
void unbind(); /* called with execute_lock locked */
|
|
void process_data(const void* /* buffer */, size_t /* samples */);
|
|
|
|
struct DataEntry {
|
|
void* buffer = nullptr;
|
|
size_t sample_count = 0;
|
|
|
|
~DataEntry() {
|
|
if(buffer)
|
|
free(buffer);
|
|
}
|
|
};
|
|
|
|
std::mutex _data_lock;
|
|
std::deque<std::unique_ptr<DataEntry>> _data_entries;
|
|
|
|
Nan::callback_t<> _call_data;
|
|
Nan::callback_t<> _call_ended;
|
|
Nan::callback_t<> _call_started;
|
|
/*
|
|
callback_data: (buffer: Float32Array) => any;
|
|
callback_ended: () => any;
|
|
*/
|
|
};
|
|
}
|
|
}
|
|
} |