comparison audioio/AudioJACKTarget.cpp @ 100:22bf057ea151 1.2-stable

* merge from trunk (1.2 ended up being tracked from trunk, but we may want
  this branch for fixes later)

 dynamic1(jack_nframes_t, jack_get_buffer_size, jack_client_t *, 0);
 dynamic1(jack_nframes_t, jack_get_sample_rate, jack_client_t *, 0);
 dynamic1(int, jack_activate, jack_client_t *, 1);
 dynamic1(int, jack_deactivate, jack_client_t *, 1);
 dynamic1(int, jack_client_close, jack_client_t *, 1);
+dynamic1(jack_nframes_t, jack_frame_time, jack_client_t *, 0);
 dynamic1(jack_nframes_t, jack_port_get_latency, jack_port_t *, 0);
 dynamic1(const char *, jack_port_name, const jack_port_t *, 0);
 
 #define jack_client_new dynamic_jack_client_new
 #define jack_client_open dynamic_jack_client_open

 #define jack_set_process_callback dynamic_jack_set_process_callback
 #define jack_set_xrun_callback dynamic_jack_set_xrun_callback
 #define jack_activate dynamic_jack_activate
 #define jack_deactivate dynamic_jack_deactivate
 #define jack_client_close dynamic_jack_client_close
+#define jack_frame_time dynamic_jack_frame_time
 #define jack_get_ports dynamic_jack_get_ports
 #define jack_port_register dynamic_jack_port_register
 #define jack_port_unregister dynamic_jack_port_unregister
 #define jack_port_get_latency dynamic_jack_port_get_latency
 #define jack_port_name dynamic_jack_port_name

     }
 
     if (m_source) {
 	sourceModelReplaced();
     }
+    
+    // Mainstream JACK (though not jackdmp) calls mlockall() to lock
+    // down all memory for real-time operation.  That isn't a terribly
+    // good idea in an application like this that may have very high
+    // dynamic memory usage in other threads, as mlockall() applies
+    // across all threads.  We're far better off undoing it here and
+    // accepting the possible loss of true RT capability.
+    MUNLOCKALL();
 }
 
 AudioJACKTarget::~AudioJACKTarget()
 {
     std::cerr << "AudioJACKTarget::~AudioJACKTarget()" << std::endl;
+
+    if (m_source) {
+        m_source->setTarget(0, m_bufferSize);
+    }
 
     shutdown();
 
     if (m_client) {
 

 AudioJACKTarget::isOK() const
 {
     return (m_client != 0);
 }
 
+double
+AudioJACKTarget::getCurrentTime() const
+{
+    if (m_client && m_sampleRate) {
+        return double(jack_frame_time(m_client)) / double(m_sampleRate);
+    } else {
+        return 0.0;
+    }
+}
+
 int
 AudioJACKTarget::processStatic(jack_nframes_t nframes, void *arg)
 {
     return ((AudioJACKTarget *)arg)->process(nframes);
 }

 void
 AudioJACKTarget::sourceModelReplaced()
 {
     m_mutex.lock();
 
-    m_source->setTargetBlockSize(m_bufferSize);
+    m_source->setTarget(this, m_bufferSize);
     m_source->setTargetSampleRate(m_sampleRate);
 
     size_t channels = m_source->getSourceChannelCount();
 
     // Because we offer pan, we always want at least 2 channels