104 lines
2.9 KiB
C
Raw Normal View History

2019-10-26 01:51:40 +02:00
#pragma once
#include <nan.h>
#include <mutex>
#include <deque>
2019-11-24 18:38:50 +01:00
#include <include/NanEventCallback.h>
2019-10-26 01:51:40 +02:00
namespace tc {
namespace audio {
class AudioInput;
class AudioConsumer;
namespace filter {
class Filter;
}
namespace recorder {
class AudioFilterWrapper;
class AudioRecorderWrapper;
2020-09-24 22:06:52 +02:00
enum FilterMode {
BYPASS,
FILTER,
BLOCK
};
2019-10-26 01:51:40 +02:00
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);
2020-09-24 22:06:52 +02:00
static NAN_METHOD(_get_filter_mode);
static NAN_METHOD(_set_filter_mode);
2019-10-26 01:51:40 +02:00
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() {
2020-09-24 22:06:52 +02:00
std::lock_guard lock(this->filter_mutex_);
return this->filter_;
2019-10-26 01:51:40 +02:00
}
2020-09-24 22:06:52 +02:00
inline FilterMode filter_mode() const { return this->filter_mode_; }
2019-10-26 01:51:40 +02:00
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;
2020-09-24 22:06:52 +02:00
std::mutex filter_mutex_;
std::deque<std::shared_ptr<AudioFilterWrapper>> filter_;
FilterMode filter_mode_{FilterMode::FILTER};
2019-10-26 01:51:40 +02:00
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;
};
}
}
}