TeaSpeak-Client/native/serverconnection/src/audio/js/AudioConsumer.h

#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;

			enum FilterMode {
			    BYPASS,
			    FILTER,
			    BLOCK
			};

			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);

                    static NAN_METHOD(_get_filter_mode);
                    static NAN_METHOD(_set_filter_mode);

					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->filter_mutex_);
						return this->filter_;
					}

					inline FilterMode filter_mode() const { return this->filter_mode_; }

					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 filter_mutex_;
					std::deque<std::shared_ptr<AudioFilterWrapper>> filter_;
                    FilterMode filter_mode_{FilterMode::FILTER};
					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;
			};
		}
	}
}