X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=source%2Fsrc%2Fqt%2Fosd_sound_mod_template.h;h=b70e1f73e8e727d8a8fb7bec55598e148f718afa;hb=043fdd49f9a4b26605ff3595c9aad9d0dd95ec16;hp=fb31e069776914a934d41e59c42033bbf5b63390;hpb=15353e02e1b65308eee9ef45b7eb28d3205ebad1;p=csp-qt%2Fcommon_source_project-fm7.git

diff --git a/source/src/qt/osd_sound_mod_template.h b/source/src/qt/osd_sound_mod_template.h
index fb31e0697..b70e1f73e 100644
--- a/source/src/qt/osd_sound_mod_template.h
+++ b/source/src/qt/osd_sound_mod_template.h
@@ -11,253 +11,248 @@
 
 #include <QObject>
 #include <mutex>
+#include <memory>
 
 #include "../common.h"
-#include "../fifo_templates.h"
+#include "./sound_buffer_qt.h"
 
 QT_BEGIN_NAMESPACE
 
 class OSD_BASE;
 class USING_FLAGS;
 class CSP_Logger;
-class DLL_PREFIX SOUND_MODULE_BASE : public QObject
+
+class DLL_PREFIX SOUND_OUTPUT_MODULE_BASE : public QObject
 {
 	Q_OBJECT
 protected:
-	OSD_BASE    *m_OSD;
-	USING_FLAGS *m_using_flags;
-	CSP_Logger  *m_logger;
-	void        *m_extconfig;
-	FIFO_BASE::LOCKED_RINGBUFFER<int16_t> *m_queue;
-	std::recursive_mutex m_locker;
-	std::recursive_mutex m_locker_outqueue;
-public:
-	SOUND_MODULE_BASE(OSD_BASE *parent, USING_FLAGS *pflags, CSP_Logger *logger, int buffer_size = 4096, void *configvalues = nullptr)
-		: m_OSD(parent), m_using_flags(pflags), m_logger(logger),
-		m_extconfig(configvalues), 
-		QObject(qobject_cast<QObject*>parent)
-	{
-		m_queue = new FIFO_BASE::LOCKED_RINGBUFFER<int16_t>(buffer_size);
-	}
-	~SOUND_MODULE_BASE()
+	OSD*								m_OSD;
+	std::shared_ptr<SOUND_BUFFER_QT>	m_fileio;
+	std::shared_ptr<USING_FLAGS>		m_using_flags;
+	
+	std::atomic<bool>					m_config_ok;
+
+	int64_t								m_chunk_bytes;
+	int64_t								m_buffer_bytes;
+	
+	int									m_rate;
+	int									m_latency_ms;
+	int									m_channels;
+	size_t								m_wordsize;
+	std::atomic<void*>					m_extconfig_ptr;
+	std::atomic<int>					m_extconfig_bytes;
+	std::atomic<int>					m_loglevel;
+	std::atomic<int>					m_logdomain;
+
+	virtual void update_driver_fileio()
 	{
-		std::lock_guard<std::recursive_mutex> locker(m_locker);
-		std::lock_guard<std::recursive_mutex> locker(m_locker_outqueue);
-		if(m_queue != nullptr) {
-			delete m_queue;
-		}
+		release_driver_fileio();
+		// Update driver side of fileio by m_fileio;
+		//connect(m_fileio.get(), SIGNAL(bytesWritten(qint64)), real_driver, SLOT, QObject::DirectConnection);
+		//connect(m_fileio.get(), SIGNAL(aboutToClose()), real_driver, SLOT, QObject::DirectConnection);
+		// Optional:
+		// connect(m_fileio.get(), SIGNAL(readyRead()), real_driver, SLOT, QObject::DirectConnection);
 	}
-	virtual int get_sound_rate(bool is_input = false, int dev_channel = 0)
+
+	virtual void release_driver_fileio()
 	{
-		return 44100;
+		// Maybe disconnect some signals via m_fileio.
 	}
 	
-	virtual int64_t enqueueOutputSink(int16_t* p, int64_t size)
+	template <class... Args>
+		bool debug_log(Args... args)
 	{
-		std::lock_guard<std::recursive_mutex> locker(m_locker_outqueue);
-		if(m_queue != nullptr) {
-			bool flag;
-			int64_t wsize = m_queue->write(p, size, flag);
-			if((wsize > size) || (wsize <= 0) || !(flag)) {
-				return 0;
-			}
-			return wsize;
-		}
-		return 0;
+		_TCHAR buf[1024];
+		memset(buf, 0x00, sizeof(buf));
+		my_sprintf_s(buf, sizeof(buf) - 1, args);
+
+		return do_send_log(m_loglevel.load(), m_logdomain.load(),
+						   QString::fromUtf8(buf, sizeof(buf)));
 	}
 	
-	virtual int64_t dequeueOutputSink(int16_t* p, int64_t size)
-	{
-		std::lock_guard<std::recursive_mutex> locker(m_locker_outqueue);
-		if(m_queue != nullptr) {
-			bool flag;
-			int64_t rsize = m_queue->read(p, size, flag);
-			if((rsize > size) || (rsize <= 0) || !(flag)) {
-				return 0;
-			}
-			return rsize;
-		}
-		return 0;
+public:
+	SOUND_OUTPUT_MODULE_BASE(OSD_BASE *parent,
+							 SOUND_BUFFER_QT* deviceIO = nullptr,
+							 int base_rate = 48000,
+							 int base_latency_ms = 100,
+							 int base_channels = 2,
+							 void *extra_config_values = nullptr);
+	~SOUND_OUTPUT_MODULE_BASE();
+
+	std::recursive_timed_mutex				m_locker;
+
+	virtual void initialize_driver()
+	{
+		// AT LEAST:
+		// connect(this, SIGNAL(sig_start_audio()), ..., QObject::QueuedConnection);
+		// connect(this, SIGNAL(sig_pause_audio()), ..., QObject::QueuedConnection);
+		// connect(this, SIGNAL(sig_resume_audio()), ..., QObject::QueuedConnection);
+		// connect(this, SIGNAL(sig_close_audio()), ..., QObject::QueuedConnection);
+		// connect(this, SIGNAL(sig_discard_audio()), ..., QObject::QueuedConnection);
+		// connect(this, SIGNAL(sig_released(bool)), ..., QObject::QueuedConnection);
+		// connect(this, SIGNAL(sig_req_open_sound(int, int, QString)), ..., QObject::QueuedConnection);
+
+		// For Logging
+		// connect(real_driver, SIGNAL(sig_log(QString)), this, SLOT(do_send_log(QString)), QObject::QueuedConnection);
+		// connect(real_driver, SIGNAL(sig_log(int, int, QString)), this, SLOT(do_send_log(int, int, QString)), QObject::QueuedConnection);
 	}
-	virtual int64_t enqueueInputSource(int device_ch, int16_t* p, int64_t size)
+	virtual void release_driver()
 	{
-		return 0;
 	}
-	virtual int64_t dequeueInputSource(int device_ch, int16_t* p, int64_t size)
+	
+	int64_t update_sound(void* datasrc, int samples);
+	
+	std::shared_ptr<QIODevice> set_io_device(QIODevice *p);
+	std::shared_ptr<QIODevice> set_io_device(std::shared_ptr<QIODevice> ps);
+	std::shared_ptr<QIODevice> get_io_device()
 	{
-		return 0;
+		return m_fileio;
 	}
+	bool is_io_device_exists();
 	
-	virtual int64_t outputSinkQueueSize()
+	virtual uint64_t wrote_data_to()
 	{
-		std::lock_guard<std::recursive_mutex> locker(m_locker_outqueue);
-		if(m_queue != nullptr) {
-			return m_queue->size();
-		}
 		return 0;
 	}
-	virtual int64_t outputSinkDataCount()
+	virtual int64_t driver_elapsed_usec()
 	{
-		std::lock_guard<std::recursive_mutex> locker(m_locker_outqueue);
-		if(m_queue != nullptr) {
-			return m_queue->count();
-		}
 		return 0;
 	}
-	virtual bool outputSinkQueueAvailable()
-	{
-		std::lock_guard<std::recursive_mutex> locker(m_locker_outqueue);
-		if(m_queue != nullptr) {
-			return m_queue->available();
-		}
-		return false;
-	}
-	virtual bool outputSinkQueueReadReady()
-	{
-		std::lock_guard<std::recursive_mutex> locker(m_locker_outqueue);
-		if(m_queue != nullptr) {
-			return m_queue->read_ready();
-		}
-		return false;
-	}
-	virtual bool outputSinkQueueWriteReady()
-	{
-		std::lock_guard<std::recursive_mutex> locker(m_locker_outqueue);
-		if(m_queue != nullptr) {
-			return m_queue->write_ready();
-		}
-		return false;
-	}
-
-
-	virtual int64_t inputSourceQueueSize(int input_ch = 0)
+	virtual int64_t driver_processed_usec()
 	{
 		return 0;
 	}
-	virtual int64_t inputSourceDataCount(int input_ch = 0)
+	bool config_ok()
 	{
-		return 0;
+		return m_config_ok.load();
 	}
-	virtual bool inputSourceQueueAvailable(int input_ch = 0)
-	{
-		return false;
-	}
-	virtual bool inputSourceQueueReadReady(int input_ch = 0)
+	
+	int64_t get_buffer_bytes();
+	int64_t get_chunk_bytes();
+	int get_latency_ms();
+	int get_channels();
+	int get_sample_rate();
+	size_t get_word_size();
+	void get_buffer_parameters(int& channels, int& rate, int& latency_ms,
+							   size_t& word_size, int& chunk_bytes, int& buffer_bytes);
+	virtual int64_t get_bytes_available();
+	virtual int64_t get_bytes_left();
+	
+	virtual SOUND_OUTPUT_MODULE_BASE* get_real_driver()
 	{
-		return false;
+		return dynamic_cast<SOUND_OUTPUT_MODULE_BASE>this;
 	}
-	virtual bool inputSourceQueueWriteReady(int input_ch = 0)
+
+	virtual std::list<std::string> get_sound_devices_list()
 	{
-		return false;
+		static std::list<std::string> dummy_list;
+		return dummy_list;
 	}
 	
-	virtual bool initalizeSoundOutputDevice(int channels, int sample_rate, int& samples_per_chunk, int& chunks, std::string device_name)
+	virtual const _TCHAR* get_sound_device_name(int num)
 	{
-		return true;
+		return (const _TCHAR*)nullptr;
 	}
-
-	virtual bool initalizeSoundOutputDevice(int channels, int sample_rate, int& samples_per_chunk, int& chunks, int device_num)
+	virtual const _TCHAR* get_current_device_name()
 	{
-		return true;
+		return (const _TCHAR*)(_T("Empty"));
 	}
-	virtual bool detachSoundOutputDevice()
-	{
-		return true;
-	}
-	virtual bool isSoundOutputDeviceReady()
+	
+	virtual void set_logger(const std::shared_ptr<CSP_Logger> logger);
+	virtual void set_system_flags(const std::shared_ptr<USING_FLAGS> p);
+	void* get_extra_config_ptr()
 	{
-		return false;
+		return m_extconfig_ptr.load();
 	}
-
-	virtual bool initalizeSoundInputDevice(int channels, int sample_rate, int& samples_per_chunk, int& chunks, std::string device_name)
+	int get_extra_config_bytes()
 	{
-		return true;
+		return m_extconfig_bytes.load();
 	}
+	virtual bool set_extra_config(void* p, int bytes);
+	virtual bool modify_extra_config(void* p, int& bytes);
+public slot:
+	virtual void update_config() {}
+	virtual void update_extra_config() {}
+	
+	bool start();
+	bool pause();
+	bool resume();
+	bool stop();
+	bool discard();
 
-	virtual bool initalizeSoundInputDevice(int input_channel, int channels, int sample_rate, int& samples_per_chunk, int& chunks, int device_num)
+	virtual void reset_to_defalut() {} 
+	virtual void set_volume(double level) {}
+	virtual bool is_running_sound()
 	{
 		return true;
 	}
-	virtual void detachSoundInputDevice(int input_channel = 0)
+	bool update_rate(int rate)
 	{
-		return true;
+		return reconfig_sound(rate, m_channels);
 	}
-	virtual bool isSoundInputDeviceReady(int input_channel = 0)
+	bool update_channels(int channels)
 	{
-		return false;
+		return reconfig_sound(m_rate, channels);
 	}
+	bool update_latency(int latency_ms, bool fortce = false);
+	bool reconfig_sound(int rate, int channels);
+	void request_to_release();
 	
-	virtual void soundOutHandler(int64_t& req_size, void* userdata = nullptr)
+	virtual bool do_send_log(int level, int domain, QString _str);
+	virtual bool do_send_log(int level, int domain, const _TCHAR* _str, int maxlen);
+	virtual bool do_send_log(const _TCHAR* str, int maxlen)
 	{
+		do_send_log(m_loglevel.load(), m_logdomain.load(), _str, maxlen);
 	}
-	virtual void soundInHandler(int64_t &req_size, void* userdata = nullptr)
+	virtual bool do_send_log(const QString _str)
 	{
+		do_send_log(m_loglevel.load(), m_logdomain.load(), _str);
 	}
-	// Kick sound out handler
-	virtual bool soundOutReq()
-	{
-		return true;
-	}
-	// Kick sound in handler
-	virtual bool soundInReq(int input_ch)
-	{
-		return true;
-	}
-public slot:
-	virtual void initialize_sound(int rate, int samples, int* presented_rate, int* presented_samples)
+	
+	virtual void do_set_device_by_name(QString name) {};
+	virtual void do_set_device_by_name(const _TCHAR *name)
 	{
-		std::lock_guard<std::recursive_mutex> locker(m_locker_outqueue);
-		// more lock via m_locker etc, if needs.
-		if(presented_rate != nullptr) {
-			*presenyted_rate = rate;
-		}
-		if(presented_samples != nullptr) {
-			*presenyted_samples = samples;
+		if(name != nullptr) {
+			do_set_device_by_name(QString::fromUtf8(name));
 		}
 	}
-	virtual void update_sound(int* extra_frames) {}
-	virtual void mute_sound() {}
-	virtual void stop_sound() {}
-
-	// *PURE* SLOTS
-	virtual void do_start_recording_sound() {}
-	virtual void do_stop_recording_sound() {}
-	virtual void do_restart_recording_sound() {}
-	virtual void do_request_capture_sound(int ch) {}
-	virtual void do_resize_output_buffer(int count, int channels) {}
-	virtual void do_resize_capture_buffer(int ch, int count, int channels) {}
-	virtual void do_receive_external_sound(int count, int channels, int16_t* data) {}
-
-	virtual void set_logger(CSP_Logger* logger)
-	{
-		std::lock_guard<std::recursive_mutex> locker(m_locker);
-		m_logger = logger;
-	}
-	virtual void set_osd(OSD_BASE* p)
+	virtual void do_set_device_by_name(const _TCHAR *name, int maxlen)
 	{
-		std::lock_guard<std::recursive_mutex> locker(m_locker);
-		m_OSD = p;
+		if((name != nullptr) && (maxlen > 0)) {
+			do_set_device_by_name(QString::fromUtf8(name, maxlen));
+		}
 	}
+	virtual void do_set_device_by_number(int) {};
+	
+	// This set device by device-name having QAction (as QObject).
+	virtual void do_set_device_by_name(void);
+	virtual void do_set_device_by_number(void);
 
-	virtual void set_system_flags(USING_FLAGS* p)
-	{
-		std::lock_guard<std::recursive_mutex> locker(m_locker);
-		m_using_flags = p;
-	}
-	virtual void update_extra_config(void* p)
-	{
-		std::lock_guard<std::recursive_mutex> locker(m_locker);
-		m_extconfig = p;
-		// more lock via m_locker_outqueue etc, if needs.
-	}
+	// From real driver: notify to update sound devices list.
+	virtual void do_update_device_list() {}
 	
+	virtual void set_osd(OSD_BASE* p);
+
 signals:
-	void sig_send_log(QString);
-	void sig_send_log_with_class(int, int, QString);
-	void sig_req_input(int64_t);
-	void sig_complete_output(int64_t);
-	void sig_send_captured_sound_data(int, int64_t, int, int16_t[]);
-	void sig_send_output_sound_data(int64_t, int, int16_t[]);
+	// loglevel, logdomain, message
+	void sig_send_log(int, int, QString);
+	// rate, channels, path
+	void sig_req_open_sound(int, int, QString);
+	//
+	void sig_start_audio();
+	void sig_pause_audio();
+	void sig_resume_audio();
+	void sig_close_audio();
+	void sig_discard_audio();
+	// 
+	// notify completed to release sound driver.
+	void sig_released(bool);
+	// To UI: notify reset sound device list.
+	void sig_reset_sound_device_list();
+	// To UI: notify update sound device list #arg1 to #arg2.
+	void sig_set_sound_device(int, QString);
+	// To UI: notify adding sound device list #arg1.
+	void sig_add_sound_device(QString);
 };
 
 QT_END_NAMESPACE