X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fbackends%2Fportaudio%2Fportaudio_backend.h;h=b028dc212bd5265fa8cfd782eff2fa7ad9502292;hb=b2cf028fcba055110a9b1bf36af0fb6bd443c1af;hp=498a3d99442353435e692c57b82d4e65ce378609;hpb=684701427e24ff3ecc9fca9a15c12434a19856b6;p=ardour.git

diff --git a/libs/backends/portaudio/portaudio_backend.h b/libs/backends/portaudio/portaudio_backend.h
index 498a3d9944..b028dc212b 100644
--- a/libs/backends/portaudio/portaudio_backend.h
+++ b/libs/backends/portaudio/portaudio_backend.h
@@ -30,6 +30,7 @@
 #include <boost/shared_ptr.hpp>
 
 #include "ardour/audio_backend.h"
+#include "ardour/dsp_load_calculator.h"
 #include "ardour/types.h"
 
 #include "portaudio_io.h"
@@ -196,8 +197,8 @@ class PortAudioBackend : public AudioBackend {
 		int set_output_channels (uint32_t);
 		int set_systemic_input_latency (uint32_t);
 		int set_systemic_output_latency (uint32_t);
-		int set_systemic_midi_input_latency (std::string const, uint32_t) { return 0; }
-		int set_systemic_midi_output_latency (std::string const, uint32_t) { return 0; }
+		int set_systemic_midi_input_latency (std::string const, uint32_t);
+		int set_systemic_midi_output_latency (std::string const, uint32_t);
 
 		int reset_device () { return 0; };
 
@@ -212,10 +213,10 @@ class PortAudioBackend : public AudioBackend {
 		uint32_t     output_channels () const;
 		uint32_t     systemic_input_latency () const;
 		uint32_t     systemic_output_latency () const;
-		uint32_t     systemic_midi_input_latency (std::string const) const { return 0; }
-		uint32_t     systemic_midi_output_latency (std::string const) const { return 0; }
+		uint32_t     systemic_midi_input_latency (std::string const) const;
+		uint32_t     systemic_midi_output_latency (std::string const) const;
 
-		bool can_set_systemic_midi_latencies () const { return false; }
+		bool can_set_systemic_midi_latencies () const { return true; }
 
 		/* External control app */
 		std::string control_app_name () const;
@@ -226,15 +227,9 @@ class PortAudioBackend : public AudioBackend {
 		int set_midi_option (const std::string&);
 		std::string midi_option () const;
 
-		std::vector<DeviceStatus> enumerate_midi_devices () const {
-			return std::vector<AudioBackend::DeviceStatus> ();
-		}
-		int set_midi_device_enabled (std::string const, bool) {
-			return 0;
-		}
-		bool midi_device_enabled (std::string const) const {
-			return true;
-		}
+		std::vector<DeviceStatus> enumerate_midi_devices () const;
+		int set_midi_device_enabled (std::string const, bool);
+		bool midi_device_enabled (std::string const) const;
 
 	protected:
 		/* State Control */
@@ -317,11 +312,42 @@ class PortAudioBackend : public AudioBackend {
 
 		void* get_buffer (PortHandle, pframes_t);
 
-		void* main_blocking_process_thread ();
+		void* blocking_process_thread ();
+
+		void* freewheel_process_thread ();
 
 	private: // Methods
 		bool start_blocking_process_thread ();
 		bool stop_blocking_process_thread ();
+		bool blocking_process_freewheel ();
+		bool blocking_process_main (const float* interleaved_input_data,
+		                            float* interleaved_output_data);
+
+		void process_port_connection_changes ();
+		void process_incoming_midi ();
+		void process_outgoing_midi ();
+
+		bool engine_halted ();
+		bool running ();
+
+		static int portaudio_callback(const void* input,
+	                                  void* output,
+	                                  unsigned long frameCount,
+	                                  const PaStreamCallbackTimeInfo* timeInfo,
+	                                  PaStreamCallbackFlags statusFlags,
+	                                  void* userData);
+
+		bool process_callback(const float* input,
+	                          float* output,
+	                          uint32_t frame_count,
+	                          const PaStreamCallbackTimeInfo* timeInfo,
+	                          PaStreamCallbackFlags statusFlags);
+
+		bool start_freewheel_process_thread ();
+		bool stop_freewheel_process_thread ();
+
+		static bool set_mmcss_pro_audio (HANDLE* task_handle);
+		static bool reset_mmcss (HANDLE task_handle);
 
 	private:
 		std::string _instance_name;
@@ -332,14 +358,23 @@ class PortAudioBackend : public AudioBackend {
 		bool  _active; /* is running, process thread */
 		bool  _freewheel;
 		bool  _freewheeling;
+		bool  _freewheel_ack;
+		bool  _reinit_thread_callback;
 		bool  _measure_latency;
 
-		uint64_t m_cycle_count;
-		uint64_t m_total_deviation_us;
-		uint64_t m_max_deviation_us;
+		ARDOUR::DSPLoadCalculator _dsp_calc;
+
+		bool _freewheel_thread_active;
+
+		pthread_mutex_t _freewheel_mutex;
+		pthread_cond_t _freewheel_signal;
 
-		CycleTimer m_cycle_timer;
-		uint64_t m_last_cycle_start;
+		uint64_t _cycle_count;
+		uint64_t _total_deviation_us;
+		uint64_t _max_deviation_us;
+
+		CycleTimer _cycle_timer;
+		uint64_t _last_cycle_start;
 
 		static std::vector<std::string> _midi_options;
 		static std::vector<AudioBackend::DeviceStatus> _input_audio_device_status;
@@ -361,6 +396,8 @@ class PortAudioBackend : public AudioBackend {
 		uint32_t _systemic_audio_input_latency;
 		uint32_t _systemic_audio_output_latency;
 
+		MidiDeviceInfo* midi_device_info(const std::string&) const;
+
 		/* portaudio specific  */
 		int name_to_id(std::string) const;
 
@@ -371,6 +408,12 @@ class PortAudioBackend : public AudioBackend {
 		/* blocking thread */
 		pthread_t _main_blocking_thread;
 
+		/* main thread in callback mode(or fw thread when running) */
+		pthread_t _main_thread;
+
+		/* freewheel thread in callback mode */
+		pthread_t _pthread_freewheel;
+
 		/* process threads */
 		static void* portaudio_process_thread (void *);
 		std::vector<pthread_t> _threads;