jack_audiobackend.cc finally compiles
This commit is contained in:
parent
a9691abf3b
commit
5e0c6af406
@ -396,7 +396,7 @@ ARDOUR_UI::create_engine ()
|
||||
loading_message (_("Starting audio engine"));
|
||||
|
||||
try {
|
||||
engine = new ARDOUR::AudioEngine (ARDOUR_COMMAND_LINE::backend_client_name, ARDOUR_COMMAND_LINE::backend_session_uuid);
|
||||
engine = ARDOUR::AudioEngine::create (ARDOUR_COMMAND_LINE::backend_client_name, ARDOUR_COMMAND_LINE::backend_session_uuid);
|
||||
|
||||
} catch (...) {
|
||||
|
||||
@ -487,7 +487,7 @@ ARDOUR_UI::post_engine ()
|
||||
|
||||
update_disk_space ();
|
||||
update_cpu_load ();
|
||||
update_sample_rate (engine->frame_rate());
|
||||
update_sample_rate (engine->sample_rate());
|
||||
update_timecode_format ();
|
||||
|
||||
Config->ParameterChanged.connect (forever_connections, MISSING_INVALIDATOR, boost::bind (&ARDOUR_UI::parameter_changed, this, _1), gui_context());
|
||||
@ -923,7 +923,7 @@ If you still wish to quit, please use the\n\n\
|
||||
_session = 0;
|
||||
}
|
||||
|
||||
engine->stop (true);
|
||||
engine->stop ();
|
||||
quit ();
|
||||
}
|
||||
|
||||
|
@ -28,6 +28,8 @@
|
||||
|
||||
#include <boost/function.hpp>
|
||||
|
||||
#include "ardour/types.h"
|
||||
|
||||
namespace ARDOUR {
|
||||
|
||||
class AudioEngine;
|
||||
@ -45,6 +47,8 @@ class AudioBackend {
|
||||
*/
|
||||
virtual std::string name() const = 0;
|
||||
|
||||
virtual void* private_handle() const = 0;
|
||||
|
||||
/** return true if the underlying mechanism/API is still available
|
||||
* for us to utilize. return false if some or all of the AudioBackend
|
||||
* API can no longer be effectively used.
|
||||
@ -98,13 +102,6 @@ class AudioBackend {
|
||||
*/
|
||||
virtual uint32_t available_output_channel_count (const std::string& device) const = 0;
|
||||
|
||||
enum SampleFormat {
|
||||
Signed16bitInteger,
|
||||
Signed24bitInteger,
|
||||
Signed32bitInteger,
|
||||
FloatingPoint
|
||||
};
|
||||
|
||||
/* Set the hardware parameters.
|
||||
*
|
||||
* If called when the current state is stopped or paused,
|
||||
@ -163,15 +160,15 @@ class AudioBackend {
|
||||
*/
|
||||
virtual int set_systemic_output_latency (uint32_t) = 0;
|
||||
|
||||
virtual std::string get_device_name () const = 0;
|
||||
virtual float get_sample_rate () const = 0;
|
||||
virtual uint32_t get_buffer_size () const = 0;
|
||||
virtual SampleFormat get_sample_format () const = 0;
|
||||
virtual bool get_interleaved () const = 0;
|
||||
virtual uint32_t get_input_channels () const = 0;
|
||||
virtual uint32_t get_output_channels () const = 0;
|
||||
virtual uint32_t get_systemic_input_latency () const = 0;
|
||||
virtual uint32_t get_systemic_output_latency () const = 0;
|
||||
virtual std::string device_name () const = 0;
|
||||
virtual float sample_rate () const = 0;
|
||||
virtual uint32_t buffer_size () const = 0;
|
||||
virtual SampleFormat sample_format () const = 0;
|
||||
virtual bool interleaved () const = 0;
|
||||
virtual uint32_t input_channels () const = 0;
|
||||
virtual uint32_t output_channels () const = 0;
|
||||
virtual uint32_t systemic_input_latency () const = 0;
|
||||
virtual uint32_t systemic_output_latency () const = 0;
|
||||
|
||||
/* Basic state control */
|
||||
|
||||
@ -246,7 +243,7 @@ class AudioBackend {
|
||||
* Implementations can feel free to smooth the values returned over
|
||||
* time (e.g. high pass filtering, or its equivalent).
|
||||
*/
|
||||
virtual float get_cpu_load() const = 0;
|
||||
virtual float cpu_load() const = 0;
|
||||
|
||||
/* Transport Control (JACK is the only audio API that currently offers
|
||||
the concept of shared transport control)
|
||||
@ -260,14 +257,14 @@ class AudioBackend {
|
||||
virtual void transport_stop () {}
|
||||
/** return the current transport state
|
||||
*/
|
||||
virtual TransportState transport_state () { return TransportStopped; }
|
||||
virtual TransportState transport_state () const { return TransportStopped; }
|
||||
/** Attempt to locate the transport to @param pos
|
||||
*/
|
||||
virtual void transport_locate (framepos_t /*pos*/) {}
|
||||
/** Return the current transport location, in samples measured
|
||||
* from the origin (defined by the transport time master)
|
||||
*/
|
||||
virtual framepos_t transport_frame() { return 0; }
|
||||
virtual framepos_t transport_frame() const { return 0; }
|
||||
|
||||
/** If @param yn is true, become the time master for any inter-application transport
|
||||
* timebase, otherwise cease to be the time master for the same.
|
||||
@ -279,9 +276,7 @@ class AudioBackend {
|
||||
*/
|
||||
virtual int set_time_master (bool /*yn*/) { return 0; }
|
||||
|
||||
virtual framecnt_t sample_rate () const;
|
||||
virtual pframes_t samples_per_cycle () const;
|
||||
virtual int usecs_per_cycle () const { return 1000000 * (samples_per_cycle() / sample_rate()); }
|
||||
virtual int usecs_per_cycle () const { return 1000000 * (buffer_size() / sample_rate()); }
|
||||
virtual size_t raw_buffer_size (DataType t);
|
||||
|
||||
/* Process time */
|
||||
@ -338,7 +333,7 @@ class AudioBackend {
|
||||
*/
|
||||
virtual int create_process_thread (boost::function<void()> func, pthread_t*, size_t stacksize) = 0;
|
||||
|
||||
private:
|
||||
protected:
|
||||
AudioEngine& engine;
|
||||
};
|
||||
|
||||
|
@ -104,7 +104,8 @@ public:
|
||||
pframes_t samples_since_cycle_start ();
|
||||
bool get_sync_offset (pframes_t& offset) const;
|
||||
int create_process_thread (boost::function<void()> func, pthread_t*, size_t stacksize);
|
||||
|
||||
bool is_realtime() const;
|
||||
|
||||
/* END BACKEND PROXY API */
|
||||
|
||||
bool freewheeling() const { return _freewheeling; }
|
||||
@ -180,13 +181,21 @@ public:
|
||||
static void destroy();
|
||||
void died ();
|
||||
|
||||
/* The backend will cause this at the appropriate time(s)
|
||||
/* The backend will cause these at the appropriate time(s)
|
||||
*/
|
||||
int process_callback (pframes_t nframes);
|
||||
int process_callback (pframes_t nframes);
|
||||
int buffer_size_change (pframes_t nframes);
|
||||
int sample_rate_change (pframes_t nframes);
|
||||
void freewheel_callback (bool);
|
||||
void timebase_callback (TransportState state, pframes_t nframes, framepos_t pos, int new_position);
|
||||
int sync_callback (TransportState state, framepos_t position);
|
||||
int port_registration_callback ();
|
||||
void latency_callback (bool for_playback);
|
||||
void halted_callback (const char* reason);
|
||||
|
||||
/* sets up the process callback thread */
|
||||
static void thread_init_callback (void *);
|
||||
|
||||
int buffer_size_change (pframes_t nframes);
|
||||
int sample_rate_change (pframes_t nframes);
|
||||
|
||||
private:
|
||||
AudioEngine (const std::string& client_name, const std::string& session_uuid);
|
||||
|
||||
|
@ -22,6 +22,7 @@
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
@ -38,10 +39,11 @@ class JackConnection;
|
||||
|
||||
class JACKAudioBackend : public AudioBackend {
|
||||
public:
|
||||
JACKAudioBackend (AudioEngine& e);
|
||||
JACKAudioBackend (AudioEngine& e, void*);
|
||||
~JACKAudioBackend ();
|
||||
|
||||
std::string name() const;
|
||||
void* private_handle() const;
|
||||
bool connected() const;
|
||||
bool is_realtime () const;
|
||||
|
||||
@ -61,34 +63,53 @@ class JACKAudioBackend : public AudioBackend {
|
||||
int set_systemic_input_latency (uint32_t);
|
||||
int set_systemic_output_latency (uint32_t);
|
||||
|
||||
std::string get_device_name () const;
|
||||
float get_sample_rate () const;
|
||||
uint32_t get_buffer_size () const;
|
||||
SampleFormat get_sample_format () const;
|
||||
bool get_interleaved () const;
|
||||
uint32_t get_input_channels () const;
|
||||
uint32_t get_output_channels () const;
|
||||
uint32_t get_systemic_input_latency () const;
|
||||
uint32_t get_systemic_output_latency () const;
|
||||
std::string device_name () const;
|
||||
float sample_rate () const;
|
||||
uint32_t buffer_size () const;
|
||||
SampleFormat sample_format () const;
|
||||
bool interleaved () const;
|
||||
uint32_t input_channels () const;
|
||||
uint32_t output_channels () const;
|
||||
uint32_t systemic_input_latency () const;
|
||||
uint32_t systemic_output_latency () const;
|
||||
|
||||
int start ();
|
||||
int stop ();
|
||||
int pause ();
|
||||
int freewheel (bool);
|
||||
|
||||
float cpu_load() const;
|
||||
|
||||
pframes_t sample_time ();
|
||||
pframes_t sample_time_at_cycle_start ();
|
||||
pframes_t samples_since_cycle_start ();
|
||||
|
||||
size_t raw_buffer_size (DataType t);
|
||||
|
||||
int create_process_thread (boost::function<void()> func, pthread_t*, size_t stacksize);
|
||||
|
||||
void transport_start ();
|
||||
void transport_stop ();
|
||||
void transport_locate (framepos_t /*pos*/);
|
||||
TransportState transport_state () const;
|
||||
framepos_t transport_frame() const;
|
||||
|
||||
int set_time_master (bool /*yn*/);
|
||||
bool get_sync_offset (pframes_t& /*offset*/) const;
|
||||
|
||||
private:
|
||||
JackConnection* _jack_connection;
|
||||
JackConnection* _jack_connection; //< shared with JACKPortEngine
|
||||
bool _running;
|
||||
bool _freewheeling;
|
||||
std::map<DataType,size_t> _raw_buffer_sizes;
|
||||
|
||||
static int _xrun_callback (void *arg);
|
||||
static int _graph_order_callback (void *arg);
|
||||
static void* _process_thread (void *arg);
|
||||
static int _sample_rate_callback (pframes_t nframes, void *arg);
|
||||
static int _bufsize_callback (pframes_t nframes, void *arg);
|
||||
static void _jack_timebase_callback (jack_transport_state_t, pframes_t, jack_position_t*, int, void*);
|
||||
static int _jack_sync_callback (jack_transport_state_t, jack_position_t*, void *arg);
|
||||
static void _freewheel_callback (int , void *arg);
|
||||
static void _registration_callback (jack_port_id_t, int, void *);
|
||||
static void _connect_callback (jack_port_id_t, jack_port_id_t, int, void *);
|
||||
static void _latency_callback (jack_latency_callback_mode_t, void*);
|
||||
#ifdef HAVE_JACK_SESSION
|
||||
static void _session_callback (jack_session_event_t *event, void *arg);
|
||||
@ -99,12 +120,12 @@ class JACKAudioBackend : public AudioBackend {
|
||||
int jack_bufsize_callback (pframes_t);
|
||||
int jack_sample_rate_callback (pframes_t);
|
||||
void freewheel_callback (int);
|
||||
void connect_callback (jack_port_id_t, jack_port_id_t, int);
|
||||
int process_callback (pframes_t nframes);
|
||||
void jack_latency_callback (jack_latency_callback_mode_t);
|
||||
|
||||
void disconnected (const char*);
|
||||
|
||||
void set_jack_callbacks ();
|
||||
int connect_to_jack (std::string client_name, std::string session_uuid);
|
||||
int reconnect_to_jack ();
|
||||
|
||||
struct ThreadData {
|
||||
JACKAudioBackend* engine;
|
||||
@ -136,6 +157,8 @@ class JACKAudioBackend : public AudioBackend {
|
||||
uint32_t _current_sample_rate;
|
||||
uint32_t _current_buffer_size;
|
||||
uint32_t _current_usecs_per_cycle;
|
||||
uint32_t _current_systemic_input_latency;
|
||||
uint32_t _current_systemic_output_latency;
|
||||
|
||||
};
|
||||
|
||||
|
@ -20,13 +20,84 @@
|
||||
#ifndef __libardour_jack_portengine_h__
|
||||
#define __libardour_jack_portengine_h__
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include "ardour/port_engine.h"
|
||||
#include "ardour/types.h"
|
||||
|
||||
namespace ARDOUR {
|
||||
|
||||
class JackConnection;
|
||||
|
||||
class JACKPortEngine : public PortEngine
|
||||
{
|
||||
public:
|
||||
JACKPortEngine (const std::string& client_name,
|
||||
const std::string& session_uuid);
|
||||
JACKPortEngine (void* arg); // argument is a JackConnection
|
||||
|
||||
bool connected() const;
|
||||
void* private_handle() const;
|
||||
|
||||
int set_port_name (PortHandle, const std::string&);
|
||||
std::string get_port_name (PortHandle) const;
|
||||
PortHandle* get_port_by_name (const std::string&) const;
|
||||
|
||||
std::string make_port_name_relative (const std::string& name) const;
|
||||
std::string make_port_name_non_relative (const std::string& name) const;
|
||||
bool port_is_mine (const std::string& fullname) const;
|
||||
|
||||
PortHandle register_port (const std::string& shortname, ARDOUR::DataType, ARDOUR::PortFlags);
|
||||
void unregister_port (PortHandle);
|
||||
|
||||
bool connected (PortHandle);
|
||||
bool connected_to (PortHandle, const std::string&);
|
||||
bool physically_connected (PortHandle);
|
||||
|
||||
int get_connections (PortHandle, std::vector<std::string>&);
|
||||
|
||||
int connect (PortHandle, const std::string&);
|
||||
int disconnect (PortHandle, const std::string&);
|
||||
int disconnect_all (PortHandle);
|
||||
|
||||
int connect (const std::string& src, const std::string& dst);
|
||||
int disconnect (const std::string& src, const std::string& dst);
|
||||
|
||||
/* MIDI */
|
||||
|
||||
void midi_event_get (pframes_t& timestamp, size_t& size, uint8_t** buf, void* port_buffer, uint32_t event_index);
|
||||
int midi_event_put (void* port_buffer, pframes_t timestamp, const uint8_t* buffer, size_t size);
|
||||
uint32_t get_midi_event_count (void* port_buffer);
|
||||
void midi_clear (void* port_buffer);
|
||||
|
||||
/* Monitoring */
|
||||
|
||||
bool can_monitor_input() const;
|
||||
int request_input_monitoring (PortHandle, bool);
|
||||
int ensure_input_monitoring (PortHandle, bool);
|
||||
bool monitoring_input (PortHandle);
|
||||
|
||||
/* Latency management
|
||||
*/
|
||||
|
||||
void set_latency_range (PortHandle, bool for_playback, LatencyRange);
|
||||
LatencyRange get_latency_range (PortHandle, bool for_playback);
|
||||
LatencyRange get_connected_latency_range (PortHandle, int dir);
|
||||
|
||||
void* get_buffer (PortHandle, pframes_t);
|
||||
|
||||
pframes_t last_frame_time () const;
|
||||
|
||||
private:
|
||||
JackConnection* _jack_connection;
|
||||
|
||||
static int _graph_order_callback (void *arg);
|
||||
static void _registration_callback (jack_port_id_t, int, void *);
|
||||
static void _connect_callback (jack_port_id_t, jack_port_id_t, int, void *);
|
||||
|
||||
void connect_callback (jack_port_id_t, jack_port_id_t, int);
|
||||
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
@ -55,10 +55,12 @@ class PortManager
|
||||
|
||||
/* Port connectivity */
|
||||
|
||||
int connect (const std::string& source, const std::string& destination);
|
||||
int disconnect (const std::string& source, const std::string& destination);
|
||||
int disconnect (boost::shared_ptr<Port>);
|
||||
int connect (const std::string& source, const std::string& destination);
|
||||
int disconnect (const std::string& source, const std::string& destination);
|
||||
int disconnect (boost::shared_ptr<Port>);
|
||||
bool connected (const std::string&);
|
||||
int reestablish_ports ();
|
||||
int reconnect_ports ();
|
||||
|
||||
/* other Port management */
|
||||
|
||||
|
@ -1426,8 +1426,8 @@ class Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionLi
|
||||
*/
|
||||
std::list<GQuark> _current_trans_quarks;
|
||||
|
||||
void jack_timebase_callback (jack_transport_state_t, pframes_t, jack_position_t*, int);
|
||||
int jack_sync_callback (jack_transport_state_t, jack_position_t*);
|
||||
// void timebase_callback (TransportState, pframes_t, jack_position_t*, int);
|
||||
int jack_sync_callback (TransportState, framepos_t);
|
||||
void reset_jack_connection (jack_client_t* jack);
|
||||
void process_rtop (SessionEvent*);
|
||||
|
||||
|
@ -165,6 +165,33 @@ AudioEngine::split_cycle (pframes_t offset)
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
AudioEngine::sample_rate_change (pframes_t nframes)
|
||||
{
|
||||
/* check for monitor input change every 1/10th of second */
|
||||
|
||||
monitor_check_interval = nframes / 10;
|
||||
last_monitor_check = 0;
|
||||
|
||||
if (_session) {
|
||||
_session->set_frame_rate (nframes);
|
||||
}
|
||||
|
||||
SampleRateChanged (nframes); /* EMIT SIGNAL */
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
AudioEngine::buffer_size_change (pframes_t bufsiz)
|
||||
{
|
||||
if (_session) {
|
||||
_session->set_block_size (bufsiz);
|
||||
last_monitor_check = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/** Method called by our ::process_thread when there is work to be done.
|
||||
* @param nframes Number of frames to process.
|
||||
@ -399,7 +426,7 @@ AudioEngine::set_session (Session *s)
|
||||
|
||||
start_metering_thread ();
|
||||
|
||||
pframes_t blocksize = _backend->get_buffer_size ();
|
||||
pframes_t blocksize = _backend->buffer_size ();
|
||||
|
||||
/* page in as much of the session process code as we
|
||||
can before we really start running.
|
||||
@ -558,6 +585,12 @@ AudioEngine::start ()
|
||||
if (_backend->start() == 0) {
|
||||
_running = true;
|
||||
_has_run = true;
|
||||
last_monitor_check = 0;
|
||||
|
||||
if (_session && _session->config.get_jack_time_master()) {
|
||||
_backend->set_time_master (true);
|
||||
}
|
||||
|
||||
Running(); /* EMIT SIGNAL */
|
||||
} else {
|
||||
/* should report error? */
|
||||
@ -573,8 +606,19 @@ AudioEngine::stop ()
|
||||
if (!_backend) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return _backend->stop ();
|
||||
|
||||
Glib::Threads::Mutex::Lock lm (_process_lock);
|
||||
|
||||
if (_backend->stop () == 0) {
|
||||
_running = false;
|
||||
stop_metering_thread ();
|
||||
|
||||
Stopped (); /* EMIT SIGNAL */
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
int
|
||||
@ -584,7 +628,13 @@ AudioEngine::pause ()
|
||||
return 0;
|
||||
}
|
||||
|
||||
return _backend->pause ();
|
||||
if (_backend->pause () == 0) {
|
||||
_running = false;
|
||||
Stopped(); /* EMIT SIGNAL */
|
||||
return 0;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
int
|
||||
@ -605,7 +655,17 @@ AudioEngine::get_cpu_load() const
|
||||
if (!_backend) {
|
||||
return 0.0;
|
||||
}
|
||||
return _backend->get_cpu_load ();
|
||||
return _backend->cpu_load ();
|
||||
}
|
||||
|
||||
bool
|
||||
AudioEngine::is_realtime() const
|
||||
{
|
||||
if (!_backend) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return _backend->is_realtime();
|
||||
}
|
||||
|
||||
void
|
||||
@ -668,7 +728,7 @@ AudioEngine::samples_per_cycle () const
|
||||
if (!_backend) {
|
||||
return 0;
|
||||
}
|
||||
return _backend->samples_per_cycle ();
|
||||
return _backend->buffer_size ();
|
||||
}
|
||||
|
||||
int
|
||||
@ -677,7 +737,7 @@ AudioEngine::usecs_per_cycle () const
|
||||
if (!_backend) {
|
||||
return -1;
|
||||
}
|
||||
return _backend->start ();
|
||||
return _backend->usecs_per_cycle ();
|
||||
}
|
||||
|
||||
size_t
|
||||
@ -734,3 +794,73 @@ AudioEngine::create_process_thread (boost::function<void()> func, pthread_t* thr
|
||||
return _backend->create_process_thread (func, thr, stacksize);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
AudioEngine::thread_init_callback (void* arg)
|
||||
{
|
||||
/* make sure that anybody who needs to know about this thread
|
||||
knows about it.
|
||||
*/
|
||||
|
||||
pthread_set_name (X_("audioengine"));
|
||||
|
||||
PBD::notify_gui_about_thread_creation ("gui", pthread_self(), X_("AudioEngine"), 4096);
|
||||
PBD::notify_gui_about_thread_creation ("midiui", pthread_self(), X_("AudioEngine"), 128);
|
||||
|
||||
SessionEvent::create_per_thread_pool (X_("AudioEngine"), 512);
|
||||
|
||||
MIDI::JackMIDIPort::set_process_thread (pthread_self());
|
||||
|
||||
if (arg) {
|
||||
AudioEngine* ae = static_cast<AudioEngine*> (arg);
|
||||
/* the special thread created/managed by the backend */
|
||||
ae->_main_thread = new ProcessThread;
|
||||
}
|
||||
}
|
||||
|
||||
/* XXXX
|
||||
void
|
||||
AudioEngine::timebase_callback (TransportState state, pframes_t nframes, jack_position_t pos, int new_position)
|
||||
{
|
||||
if (_session && _session->synced_to_jack()) {
|
||||
// _session->timebase_callback (state, nframes, pos, new_position);
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
int
|
||||
AudioEngine::sync_callback (TransportState state, framepos_t position)
|
||||
{
|
||||
if (_session) {
|
||||
return _session->jack_sync_callback (state, position);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
AudioEngine::freewheel_callback (bool onoff)
|
||||
{
|
||||
if (onoff) {
|
||||
_pre_freewheel_mmc_enabled = MIDI::Manager::instance()->mmc()->send_enabled ();
|
||||
MIDI::Manager::instance()->mmc()->enable_send (false);
|
||||
} else {
|
||||
MIDI::Manager::instance()->mmc()->enable_send (_pre_freewheel_mmc_enabled);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
AudioEngine::latency_callback (bool for_playback)
|
||||
{
|
||||
if (_session) {
|
||||
_session->update_latency (for_playback);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
AudioEngine::halted_callback (const char* why)
|
||||
{
|
||||
stop_metering_thread ();
|
||||
|
||||
MIDI::JackMIDIPort::EngineHalted (); /* EMIT SIGNAL */
|
||||
Halted (why); /* EMIT SIGNAL */
|
||||
}
|
||||
|
@ -20,6 +20,11 @@
|
||||
#include <math.h>
|
||||
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <glibmm/timer.h>
|
||||
|
||||
#include "pbd/error.h"
|
||||
|
||||
#include "midi++/manager.h"
|
||||
|
||||
#include "ardour/audioengine.h"
|
||||
#include "ardour/types.h"
|
||||
@ -27,59 +32,24 @@
|
||||
#include "ardour/jack_connection.h"
|
||||
#include "ardour/jack_portengine.h"
|
||||
|
||||
#include "i18n.h"
|
||||
|
||||
using namespace ARDOUR;
|
||||
using namespace PBD;
|
||||
using std::string;
|
||||
using std::vector;
|
||||
|
||||
#define GET_PRIVATE_JACK_POINTER(localvar) jack_client_t* localvar = _jack_connection->jack(); if (!(v)) { return; }
|
||||
#define GET_PRIVATE_JACK_POINTER_RET(localvar,r) jack_client_t* localvar = _jack_connection->jack(); if (!(v)) { return r; }
|
||||
|
||||
extern "C" {
|
||||
|
||||
|
||||
/* functions looked up using dlopen-and-cousins, and so naming scope
|
||||
* must be non-mangled.
|
||||
*/
|
||||
|
||||
AudioBackend* backend_factory (AudioEngine& ae, void* backend_data)
|
||||
{
|
||||
JACKAudioBackend* ab = new JACKAudioBackend (ae, backend_data);
|
||||
return ab;
|
||||
}
|
||||
|
||||
PortEngine* portengine_factory (PortEngine& ae, void* backend_data)
|
||||
{
|
||||
JACKPortEngine* pe = new JACKPortEngine (ae, backend_data);
|
||||
return pe;
|
||||
}
|
||||
|
||||
int
|
||||
instantiate (const std::string& arg1, const std::string& arg2, void** backend_data)
|
||||
{
|
||||
JackConnection *jc;
|
||||
try {
|
||||
jc = new JackConnection (arg1, arg2);
|
||||
} catch {
|
||||
return -1;
|
||||
}
|
||||
|
||||
*backend_data = (void*) jc;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
deinstantiate (void* backend_data)
|
||||
{
|
||||
JackConnection* jc = static_cast<JackConnection*> (backend_data);
|
||||
delete jc;
|
||||
}
|
||||
}
|
||||
#define GET_PRIVATE_JACK_POINTER(localvar) jack_client_t* localvar = _jack_connection->jack(); if (!(localvar)) { return; }
|
||||
#define GET_PRIVATE_JACK_POINTER_RET(localvar,r) jack_client_t* localvar = _jack_connection->jack(); if (!(localvar)) { return r; }
|
||||
|
||||
JACKAudioBackend::JACKAudioBackend (AudioEngine& e, void* jc)
|
||||
: AudioBackend (e)
|
||||
, _jack_connection (jc)
|
||||
, _jack_connection (static_cast<JackConnection*>(jc))
|
||||
, _running (false)
|
||||
, _freewheeling (false)
|
||||
, _target_sample_rate (48000)
|
||||
, _target_buffer_size (1024)
|
||||
, _target_sample_format (FloatingPoint)
|
||||
, _target_sample_format (FormatFloat)
|
||||
, _target_interleaved (false)
|
||||
, _target_input_channels (-1)
|
||||
, _target_output_channels (-1)
|
||||
@ -95,9 +65,9 @@ JACKAudioBackend::name() const
|
||||
}
|
||||
|
||||
void*
|
||||
JACKAudioBackend::private_handle()
|
||||
JACKAudioBackend::private_handle() const
|
||||
{
|
||||
return _jack_connection->jack()
|
||||
return _jack_connection->jack();
|
||||
}
|
||||
|
||||
bool
|
||||
@ -107,7 +77,7 @@ JACKAudioBackend::connected() const
|
||||
}
|
||||
|
||||
bool
|
||||
JACKAudioBackend::is_realtime ()
|
||||
JACKAudioBackend::is_realtime () const
|
||||
{
|
||||
GET_PRIVATE_JACK_POINTER_RET (_priv_jack,false);
|
||||
return jack_is_realtime (_priv_jack);
|
||||
@ -125,8 +95,8 @@ JACKAudioBackend::available_sample_rates (const string& /*device*/) const
|
||||
{
|
||||
vector<float> f;
|
||||
|
||||
if (_jack) {
|
||||
f.push_back (get_sample_rate());
|
||||
if (connected()) {
|
||||
f.push_back (sample_rate());
|
||||
return f;
|
||||
}
|
||||
|
||||
@ -153,8 +123,8 @@ JACKAudioBackend::available_buffer_sizes (const string& /*device*/) const
|
||||
{
|
||||
vector<uint32_t> s;
|
||||
|
||||
if (_jack) {
|
||||
s.push_back (get_buffer_size());
|
||||
if (connected()) {
|
||||
s.push_back (buffer_size());
|
||||
return s;
|
||||
}
|
||||
|
||||
@ -174,13 +144,13 @@ JACKAudioBackend::available_buffer_sizes (const string& /*device*/) const
|
||||
}
|
||||
|
||||
uint32_t
|
||||
JACKAudioBackend::available_input_channel_count (const string& /*device*/)
|
||||
JACKAudioBackend::available_input_channel_count (const string& /*device*/) const
|
||||
{
|
||||
return 128;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
JACKAudioBackend::available_output_channel_count (const string& /*device*/)
|
||||
JACKAudioBackend::available_output_channel_count (const string& /*device*/) const
|
||||
{
|
||||
return 128;
|
||||
}
|
||||
@ -190,7 +160,7 @@ JACKAudioBackend::available_output_channel_count (const string& /*device*/)
|
||||
int
|
||||
JACKAudioBackend::set_device_name (const string& dev)
|
||||
{
|
||||
if (_jack) {
|
||||
if (connected()) {
|
||||
/* need to stop and restart JACK for this to work, at present */
|
||||
return -1;
|
||||
}
|
||||
@ -203,12 +173,17 @@ int
|
||||
JACKAudioBackend::set_sample_rate (float sr)
|
||||
{
|
||||
GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
|
||||
|
||||
if (!connected()) {
|
||||
_target_sample_rate = sr;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (sr == jack_get_sample_rate (_priv_jack)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return jack_set_sample_rate (_priv_jack, lrintf (sr));
|
||||
return -1;
|
||||
}
|
||||
|
||||
int
|
||||
@ -216,6 +191,11 @@ JACKAudioBackend::set_buffer_size (uint32_t nframes)
|
||||
{
|
||||
GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
|
||||
|
||||
if (!connected()) {
|
||||
_target_buffer_size = nframes;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (nframes == jack_get_buffer_size (_priv_jack)) {
|
||||
return 0;
|
||||
}
|
||||
@ -229,7 +209,7 @@ JACKAudioBackend::set_sample_format (SampleFormat sf)
|
||||
/* as far as JACK clients are concerned, the hardware is always
|
||||
* floating point format.
|
||||
*/
|
||||
if (sf == FloatingPoint) {
|
||||
if (sf == FormatFloat) {
|
||||
return 0;
|
||||
}
|
||||
return -1;
|
||||
@ -250,167 +230,179 @@ JACKAudioBackend::set_interleaved (bool yn)
|
||||
int
|
||||
JACKAudioBackend::set_input_channels (uint32_t cnt)
|
||||
{
|
||||
if (_jack) {
|
||||
if (connected()) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
_target_input_channels = cnt;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
JACKAudioBackend::set_output_channels (uint32_t cnt)
|
||||
{
|
||||
if (_jack) {
|
||||
if (connected()) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
_target_output_channels = cnt;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
JACKAudioBackend::set_systemic_input_latency (uint32_t l)
|
||||
{
|
||||
if (_jack) {
|
||||
if (connected()) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
_target_systemic_input_latency = l;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
JACKAudioBackend::set_systemic_output_latency (uint32_t l)
|
||||
{
|
||||
if (_jack) {
|
||||
if (connected()) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
_target_systemic_output_latency = l;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* --- Parameter retrieval --- */
|
||||
|
||||
std::string
|
||||
JACKAudioBackend::get_device_name () const
|
||||
JACKAudioBackend::device_name () const
|
||||
{
|
||||
return string();
|
||||
}
|
||||
|
||||
float
|
||||
JACKAudioBackend::get_sample_rate () const
|
||||
JACKAudioBackend::sample_rate () const
|
||||
{
|
||||
if (_jack) {
|
||||
if (connected()) {
|
||||
return _current_sample_rate;
|
||||
}
|
||||
return _target_sample_rate;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
JACKAudioBackend::get_buffer_size () const
|
||||
JACKAudioBackend::buffer_size () const
|
||||
{
|
||||
if (_jack) {
|
||||
if (connected()) {
|
||||
return _current_buffer_size;
|
||||
}
|
||||
return _target_buffer_size;
|
||||
}
|
||||
|
||||
SampleFormat
|
||||
JACKAudioBackend::get_sample_format () const
|
||||
JACKAudioBackend::sample_format () const
|
||||
{
|
||||
return FloatingPoint;
|
||||
return FormatFloat;
|
||||
}
|
||||
|
||||
bool
|
||||
JACKAudioBackend::get_interleaved () const
|
||||
JACKAudioBackend::interleaved () const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
JACKAudioBackend::get_input_channels () const
|
||||
JACKAudioBackend::input_channels () const
|
||||
{
|
||||
if (_jack) {
|
||||
return n_physical (JackPortIsInput);
|
||||
if (connected()) {
|
||||
return n_physical (JackPortIsInput).n_audio();
|
||||
}
|
||||
return _target_input_channels;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
JACKAudioBackend::get_output_channels () const
|
||||
JACKAudioBackend::output_channels () const
|
||||
{
|
||||
if (_jack) {
|
||||
return n_physical (JackPortIsOutput);
|
||||
if (connected()) {
|
||||
return n_physical (JackPortIsOutput).n_audio();
|
||||
}
|
||||
return _target_output_channels;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
JACKAudioBackend::get_systemic_input_latency () const
|
||||
JACKAudioBackend::systemic_input_latency () const
|
||||
{
|
||||
return _current_systemic_output_latency;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
JACKAudioBackend::get_systemic_output_latency () const
|
||||
JACKAudioBackend::systemic_output_latency () const
|
||||
{
|
||||
return _current_systemic_output_latency;
|
||||
}
|
||||
|
||||
size_t
|
||||
JACKAudioBackend::raw_buffer_size(DataType t)
|
||||
{
|
||||
std::map<DataType,size_t>::const_iterator s = _raw_buffer_sizes.find(t);
|
||||
return (s != _raw_buffer_sizes.end()) ? s->second : 0;
|
||||
}
|
||||
|
||||
/* ---- BASIC STATE CONTROL API: start/stop/pause/freewheel --- */
|
||||
|
||||
int
|
||||
JACKAudioBackend::start ()
|
||||
{
|
||||
if (!connected()) {
|
||||
_jack_connection->open ();
|
||||
}
|
||||
|
||||
engine.reestablish_ports ();
|
||||
|
||||
if (!jack_port_type_get_buffer_size) {
|
||||
warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg;
|
||||
}
|
||||
|
||||
GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
|
||||
|
||||
if (!_running) {
|
||||
|
||||
if (!jack_port_type_get_buffer_size) {
|
||||
warning << _("This version of JACK is old - you should upgrade to a newer version that supports jack_port_type_get_buffer_size()") << endmsg;
|
||||
}
|
||||
|
||||
if (_session) {
|
||||
BootMessage (_("Connect session to engine"));
|
||||
_session->set_frame_rate (jack_get_sample_rate (_priv_jack));
|
||||
}
|
||||
|
||||
/* a proxy for whether jack_activate() will definitely call the buffer size
|
||||
* callback. with older versions of JACK, this function symbol will be null.
|
||||
* this is reliable, but not clean.
|
||||
*/
|
||||
|
||||
if (!jack_port_type_get_buffer_size) {
|
||||
jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
|
||||
}
|
||||
|
||||
_processed_frames = 0;
|
||||
last_monitor_check = 0;
|
||||
|
||||
set_jack_callbacks ();
|
||||
|
||||
if (jack_activate (_priv_jack) == 0) {
|
||||
_running = true;
|
||||
_has_run = true;
|
||||
Running(); /* EMIT SIGNAL */
|
||||
} else {
|
||||
// error << _("cannot activate JACK client") << endmsg;
|
||||
}
|
||||
engine.sample_rate_change (jack_get_sample_rate (_priv_jack));
|
||||
|
||||
/* testing the nullity of this function name is a proxy for
|
||||
* whether jack_activate() will definitely call the buffer size
|
||||
* callback. with older versions of JACK, this function symbol
|
||||
* will be null. this is sort of reliable, but not clean since
|
||||
* weak symbol support is highly platform and compiler
|
||||
* specific.
|
||||
*/
|
||||
if (!jack_port_type_get_buffer_size) {
|
||||
jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
|
||||
}
|
||||
|
||||
return _running ? 0 : -1;
|
||||
|
||||
set_jack_callbacks ();
|
||||
|
||||
if (jack_activate (_priv_jack) == 0) {
|
||||
_running = true;
|
||||
} else {
|
||||
// error << _("cannot activate JACK client") << endmsg;
|
||||
}
|
||||
|
||||
engine.reconnect_ports ();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
JACKAudioBackend::stop ()
|
||||
{
|
||||
GET_PRIVATE_JACK_POINTER_RET (_priv_jack, -1);
|
||||
|
||||
_jack_connection->close ();
|
||||
|
||||
{
|
||||
Glib::Threads::Mutex::Lock lm (_process_lock);
|
||||
jack_client_close (_priv_jack);
|
||||
_jack = 0;
|
||||
}
|
||||
_current_buffer_size = 0;
|
||||
_current_sample_rate = 0;
|
||||
|
||||
_buffer_size = 0;
|
||||
_frame_rate = 0;
|
||||
_raw_buffer_sizes.clear();
|
||||
|
||||
return 0;
|
||||
@ -439,121 +431,12 @@ JACKAudioBackend::freewheel (bool onoff)
|
||||
return 0;
|
||||
}
|
||||
|
||||
return jack_set_freewheel (_priv_jack, onoff);
|
||||
}
|
||||
|
||||
int
|
||||
JACKAudioBackend::set_parameters (const Parameters& params)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
JACKAudioBackend::get_parameters (Parameters& params) const
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* parameters */
|
||||
|
||||
ARDOUR::pframes_t
|
||||
AudioEngine::frames_per_cycle () const
|
||||
{
|
||||
GET_PRIVATE_JACK_POINTER_RET (_priv_jack,0);
|
||||
|
||||
if (_buffer_size == 0) {
|
||||
return jack_get_buffer_size (_priv_jack);
|
||||
} else {
|
||||
return _buffer_size;
|
||||
}
|
||||
}
|
||||
|
||||
ARDOUR::framecnt_t
|
||||
AudioEngine::frame_rate () const
|
||||
{
|
||||
GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
|
||||
if (_frame_rate == 0) {
|
||||
return (_frame_rate = jack_get_sample_rate (_priv_jack));
|
||||
} else {
|
||||
return _frame_rate;
|
||||
}
|
||||
}
|
||||
|
||||
size_t
|
||||
AudioEngine::raw_buffer_size (DataType t)
|
||||
{
|
||||
std::map<DataType,size_t>::const_iterator s = _raw_buffer_sizes.find(t);
|
||||
return (s != _raw_buffer_sizes.end()) ? s->second : 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*--- private support methods ---*/
|
||||
|
||||
int
|
||||
JACKAudioBackend::reconnect_to_jack ()
|
||||
{
|
||||
if (_jack_connection->connected()) {
|
||||
_jack_connection->close ();
|
||||
/* XXX give jackd a chance */
|
||||
Glib::usleep (250000);
|
||||
if (jack_set_freewheel (_priv_jack, onoff) == 0) {
|
||||
_freewheeling = true;
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (_jack_connection->open()) {
|
||||
error << _("failed to connect to JACK") << endmsg;
|
||||
return -1;
|
||||
}
|
||||
|
||||
Ports::iterator i;
|
||||
|
||||
boost::shared_ptr<Ports> p = ports.reader ();
|
||||
|
||||
for (i = p->begin(); i != p->end(); ++i) {
|
||||
if (i->second->reestablish ()) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (i != p->end()) {
|
||||
/* failed */
|
||||
remove_all_ports ();
|
||||
return -1;
|
||||
}
|
||||
|
||||
GET_PRIVATE_JACK_POINTER_RET (_priv_jack,-1);
|
||||
|
||||
MIDI::Manager::instance()->reestablish (_priv_jack);
|
||||
|
||||
if (_session) {
|
||||
_session->reset_jack_connection (_priv_jack);
|
||||
jack_bufsize_callback (jack_get_buffer_size (_priv_jack));
|
||||
_session->set_frame_rate (jack_get_sample_rate (_priv_jack));
|
||||
}
|
||||
|
||||
last_monitor_check = 0;
|
||||
|
||||
set_jack_callbacks ();
|
||||
|
||||
if (jack_activate (_priv_jack) == 0) {
|
||||
_running = true;
|
||||
_has_run = true;
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* re-establish connections */
|
||||
|
||||
for (i = p->begin(); i != p->end(); ++i) {
|
||||
i->second->reconnect ();
|
||||
}
|
||||
|
||||
MIDI::Manager::instance()->reconnect ();
|
||||
|
||||
Running (); /* EMIT SIGNAL*/
|
||||
|
||||
start_metering_thread ();
|
||||
|
||||
return 0;
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* --- TRANSPORT STATE MANAGEMENT --- */
|
||||
@ -586,8 +469,8 @@ JACKAudioBackend::transport_frame () const
|
||||
return jack_get_current_transport_frame (_priv_jack);
|
||||
}
|
||||
|
||||
JACKAudioBackend::TransportState
|
||||
JACKAudioBackend::transport_state ()
|
||||
TransportState
|
||||
JACKAudioBackend::transport_state () const
|
||||
{
|
||||
GET_PRIVATE_JACK_POINTER_RET (_priv_jack, ((TransportState) JackTransportStopped));
|
||||
jack_position_t pos;
|
||||
@ -601,29 +484,12 @@ JACKAudioBackend::set_time_master (bool yn)
|
||||
if (yn) {
|
||||
return jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
|
||||
} else {
|
||||
return jack_release_timebase (_jack);
|
||||
return jack_release_timebase (_priv_jack);
|
||||
}
|
||||
}
|
||||
|
||||
/* process-time */
|
||||
|
||||
framecnt_t
|
||||
JACKAudioBackend::sample_rate () const
|
||||
{
|
||||
|
||||
}
|
||||
pframes_t
|
||||
JACKAudioBackend::samples_per_cycle () const
|
||||
{
|
||||
}
|
||||
|
||||
size_t
|
||||
JACKAudioBackend::raw_buffer_size(DataType t)
|
||||
{
|
||||
std::map<DataType,size_t>::const_iterator s = _raw_buffer_sizes.find(t);
|
||||
return (s != _raw_buffer_sizes.end()) ? s->second : 0;
|
||||
}
|
||||
|
||||
bool
|
||||
JACKAudioBackend::get_sync_offset (pframes_t& offset) const
|
||||
{
|
||||
@ -651,35 +517,26 @@ JACKAudioBackend::get_sync_offset (pframes_t& offset) const
|
||||
}
|
||||
|
||||
pframes_t
|
||||
JACKAudioBackend::frames_since_cycle_start ()
|
||||
JACKAudioBackend::sample_time ()
|
||||
{
|
||||
jack_client_t* _priv_jack = _jack;
|
||||
if (!_running || !_priv_jack) {
|
||||
return 0;
|
||||
}
|
||||
return jack_frames_since_cycle_start (_priv_jack);
|
||||
}
|
||||
|
||||
pframes_t
|
||||
JACKAudioBackend::frame_time ()
|
||||
{
|
||||
jack_client_t* _priv_jack = _jack;
|
||||
if (!_running || !_priv_jack) {
|
||||
return 0;
|
||||
}
|
||||
GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
|
||||
return jack_frame_time (_priv_jack);
|
||||
}
|
||||
|
||||
pframes_t
|
||||
JACKAudioBackend::frame_time_at_cycle_start ()
|
||||
JACKAudioBackend::sample_time_at_cycle_start ()
|
||||
{
|
||||
jack_client_t* _priv_jack = _jack;
|
||||
if (!_running || !_priv_jack) {
|
||||
return 0;
|
||||
}
|
||||
GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
|
||||
return jack_last_frame_time (_priv_jack);
|
||||
}
|
||||
|
||||
pframes_t
|
||||
JACKAudioBackend::samples_since_cycle_start ()
|
||||
{
|
||||
GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 0);
|
||||
return jack_frames_since_cycle_start (_priv_jack);
|
||||
}
|
||||
|
||||
/* JACK Callbacks */
|
||||
|
||||
static void
|
||||
@ -693,21 +550,15 @@ JACKAudioBackend::set_jack_callbacks ()
|
||||
{
|
||||
GET_PRIVATE_JACK_POINTER (_priv_jack);
|
||||
|
||||
jack_set_thread_init_callback (_priv_jack, _thread_init_callback, this);
|
||||
jack_set_thread_init_callback (_priv_jack, AudioEngine::thread_init_callback, 0);
|
||||
|
||||
jack_set_process_thread (_priv_jack, _process_thread, this);
|
||||
jack_set_sample_rate_callback (_priv_jack, _sample_rate_callback, this);
|
||||
jack_set_buffer_size_callback (_priv_jack, _bufsize_callback, this);
|
||||
jack_set_graph_order_callback (_priv_jack, _graph_order_callback, this);
|
||||
jack_set_port_registration_callback (_priv_jack, _registration_callback, this);
|
||||
jack_set_port_connect_callback (_priv_jack, _connect_callback, this);
|
||||
jack_set_xrun_callback (_priv_jack, _xrun_callback, this);
|
||||
jack_set_sync_callback (_priv_jack, _jack_sync_callback, this);
|
||||
jack_set_freewheel_callback (_priv_jack, _freewheel_callback, this);
|
||||
|
||||
if (_session && _session->config.get_jack_time_master()) {
|
||||
jack_set_timebase_callback (_priv_jack, 0, _jack_timebase_callback, this);
|
||||
}
|
||||
|
||||
#ifdef HAVE_JACK_SESSION
|
||||
if( jack_set_session_callback)
|
||||
jack_set_session_callback (_priv_jack, _session_callback, this);
|
||||
@ -724,40 +575,75 @@ void
|
||||
JACKAudioBackend::_jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
|
||||
jack_position_t* pos, int new_position, void *arg)
|
||||
{
|
||||
static_cast<AudioEngine*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
|
||||
static_cast<JACKAudioBackend*> (arg)->jack_timebase_callback (state, nframes, pos, new_position);
|
||||
}
|
||||
|
||||
void
|
||||
JACKAudioBackend::jack_timebase_callback (jack_transport_state_t state, pframes_t nframes,
|
||||
jack_position_t* pos, int new_position)
|
||||
JACKAudioBackend::jack_timebase_callback (jack_transport_state_t state, pframes_t /*nframes*/,
|
||||
jack_position_t* pos, int /*new_position*/)
|
||||
{
|
||||
if (_jack && _session && _session->synced_to_jack()) {
|
||||
_session->jack_timebase_callback (state, nframes, pos, new_position);
|
||||
TransportState tstate;
|
||||
framepos_t position;
|
||||
|
||||
switch (state) {
|
||||
case JackTransportStopped:
|
||||
tstate = TransportStopped;
|
||||
break;
|
||||
case JackTransportRolling:
|
||||
tstate = TransportRolling;
|
||||
break;
|
||||
case JackTransportLooping:
|
||||
tstate = TransportLooping;
|
||||
break;
|
||||
case JackTransportStarting:
|
||||
tstate = TransportStarting;
|
||||
break;
|
||||
}
|
||||
|
||||
if (pos) {
|
||||
position = pos->frame;
|
||||
}
|
||||
|
||||
// engine.timebase_callback (tstate, nframes, position, new_position);
|
||||
}
|
||||
|
||||
int
|
||||
JACKAudioBackend::_jack_sync_callback (jack_transport_state_t state, jack_position_t* pos, void* arg)
|
||||
{
|
||||
return static_cast<AudioEngine*> (arg)->jack_sync_callback (state, pos);
|
||||
return static_cast<JACKAudioBackend*> (arg)->jack_sync_callback (state, pos);
|
||||
}
|
||||
|
||||
int
|
||||
JACKAudioBackend::jack_sync_callback (jack_transport_state_t state, jack_position_t* pos)
|
||||
{
|
||||
if (_jack && _session) {
|
||||
return _session->jack_sync_callback (state, pos);
|
||||
TransportState tstate;
|
||||
|
||||
switch (state) {
|
||||
case JackTransportStopped:
|
||||
tstate = TransportStopped;
|
||||
break;
|
||||
case JackTransportRolling:
|
||||
tstate = TransportRolling;
|
||||
break;
|
||||
case JackTransportLooping:
|
||||
tstate = TransportLooping;
|
||||
break;
|
||||
case JackTransportStarting:
|
||||
tstate = TransportStarting;
|
||||
break;
|
||||
}
|
||||
|
||||
return engine.sync_callback (tstate, pos->frame);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
int
|
||||
JACKAudioBackend::_xrun_callback (void *arg)
|
||||
{
|
||||
AudioEngine* ae = static_cast<AudioEngine*> (arg);
|
||||
JACKAudioBackend* ae = static_cast<JACKAudioBackend*> (arg);
|
||||
if (ae->connected()) {
|
||||
ae->Xrun (); /* EMIT SIGNAL */
|
||||
ae->engine.Xrun (); /* EMIT SIGNAL */
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -766,99 +652,30 @@ JACKAudioBackend::_xrun_callback (void *arg)
|
||||
void
|
||||
JACKAudioBackend::_session_callback (jack_session_event_t *event, void *arg)
|
||||
{
|
||||
AudioEngine* ae = static_cast<AudioEngine*> (arg);
|
||||
JACKAudioBackend* ae = static_cast<JACKAudioBackend*> (arg);
|
||||
if (ae->connected()) {
|
||||
ae->JackSessionEvent ( event ); /* EMIT SIGNAL */
|
||||
ae->engine.JackSessionEvent (event); /* EMIT SIGNAL */
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
int
|
||||
JACKAudioBackend::_graph_order_callback (void *arg)
|
||||
{
|
||||
AudioEngine* ae = static_cast<AudioEngine*> (arg);
|
||||
|
||||
if (ae->connected() && !ae->port_remove_in_progress) {
|
||||
ae->GraphReordered (); /* EMIT SIGNAL */
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
JACKAudioBackend::_freewheel_callback (int onoff, void *arg)
|
||||
{
|
||||
static_cast<AudioEngine*>(arg)->freewheel_callback (onoff);
|
||||
static_cast<JACKAudioBackend*>(arg)->freewheel_callback (onoff);
|
||||
}
|
||||
|
||||
void
|
||||
JACKAudioBackend::freewheel_callback (int onoff)
|
||||
{
|
||||
_freewheeling = onoff;
|
||||
|
||||
if (onoff) {
|
||||
_pre_freewheel_mmc_enabled = MIDI::Manager::instance()->mmc()->send_enabled ();
|
||||
MIDI::Manager::instance()->mmc()->enable_send (false);
|
||||
} else {
|
||||
MIDI::Manager::instance()->mmc()->enable_send (_pre_freewheel_mmc_enabled);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
JACKAudioBackend::_registration_callback (jack_port_id_t /*id*/, int /*reg*/, void* arg)
|
||||
{
|
||||
AudioEngine* ae = static_cast<AudioEngine*> (arg);
|
||||
|
||||
if (!ae->port_remove_in_progress) {
|
||||
ae->PortRegisteredOrUnregistered (); /* EMIT SIGNAL */
|
||||
}
|
||||
engine.freewheel_callback (onoff);
|
||||
}
|
||||
|
||||
void
|
||||
JACKAudioBackend::_latency_callback (jack_latency_callback_mode_t mode, void* arg)
|
||||
{
|
||||
return static_cast<AudioEngine *> (arg)->jack_latency_callback (mode);
|
||||
}
|
||||
|
||||
void
|
||||
JACKAudioBackend::_connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn, void* arg)
|
||||
{
|
||||
AudioEngine* ae = static_cast<AudioEngine*> (arg);
|
||||
ae->connect_callback (id_a, id_b, conn);
|
||||
}
|
||||
|
||||
void
|
||||
JACKAudioBackend::connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn)
|
||||
{
|
||||
if (port_remove_in_progress) {
|
||||
return;
|
||||
}
|
||||
|
||||
GET_PRIVATE_JACK_POINTER (_priv_jack);
|
||||
|
||||
jack_port_t* jack_port_a = jack_port_by_id (_priv_jack, id_a);
|
||||
jack_port_t* jack_port_b = jack_port_by_id (_priv_jack, id_b);
|
||||
|
||||
boost::shared_ptr<Port> port_a;
|
||||
boost::shared_ptr<Port> port_b;
|
||||
Ports::iterator x;
|
||||
boost::shared_ptr<Ports> pr = ports.reader ();
|
||||
|
||||
x = pr->find (make_port_name_relative (jack_port_name (jack_port_a)));
|
||||
if (x != pr->end()) {
|
||||
port_a = x->second;
|
||||
}
|
||||
|
||||
x = pr->find (make_port_name_relative (jack_port_name (jack_port_b)));
|
||||
if (x != pr->end()) {
|
||||
port_b = x->second;
|
||||
}
|
||||
|
||||
PortConnectedOrDisconnected (
|
||||
port_a, jack_port_name (jack_port_a),
|
||||
port_b, jack_port_name (jack_port_b),
|
||||
conn == 0 ? false : true
|
||||
); /* EMIT SIGNAL */
|
||||
return static_cast<JACKAudioBackend*> (arg)->jack_latency_callback (mode);
|
||||
}
|
||||
|
||||
int
|
||||
@ -890,7 +707,7 @@ JACKAudioBackend::_start_process_thread (void* arg)
|
||||
void*
|
||||
JACKAudioBackend::_process_thread (void *arg)
|
||||
{
|
||||
return static_cast<AudioEngine *> (arg)->process_thread ();
|
||||
return static_cast<JACKAudioBackend*> (arg)->process_thread ();
|
||||
}
|
||||
|
||||
void*
|
||||
@ -899,9 +716,7 @@ JACKAudioBackend::process_thread ()
|
||||
/* JACK doesn't do this for us when we use the wait API
|
||||
*/
|
||||
|
||||
_thread_init_callback (0);
|
||||
|
||||
_main_thread = new ProcessThread;
|
||||
AudioEngine::thread_init_callback (this);
|
||||
|
||||
while (1) {
|
||||
GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
|
||||
@ -921,41 +736,26 @@ JACKAudioBackend::process_thread ()
|
||||
int
|
||||
JACKAudioBackend::_sample_rate_callback (pframes_t nframes, void *arg)
|
||||
{
|
||||
return static_cast<AudioEngine *> (arg)->jack_sample_rate_callback (nframes);
|
||||
return static_cast<JACKAudioBackend*> (arg)->jack_sample_rate_callback (nframes);
|
||||
}
|
||||
|
||||
int
|
||||
JACKAudioBackend::jack_sample_rate_callback (pframes_t nframes)
|
||||
{
|
||||
_frame_rate = nframes;
|
||||
_usecs_per_cycle = (int) floor ((((double) frames_per_cycle() / nframes)) * 1000000.0);
|
||||
|
||||
/* check for monitor input change every 1/10th of second */
|
||||
|
||||
monitor_check_interval = nframes / 10;
|
||||
last_monitor_check = 0;
|
||||
|
||||
if (_session) {
|
||||
_session->set_frame_rate (nframes);
|
||||
}
|
||||
|
||||
SampleRateChanged (nframes); /* EMIT SIGNAL */
|
||||
|
||||
return 0;
|
||||
_current_sample_rate = nframes;
|
||||
return engine.sample_rate_change (nframes);
|
||||
}
|
||||
|
||||
void
|
||||
JACKAudioBackend::jack_latency_callback (jack_latency_callback_mode_t mode)
|
||||
{
|
||||
if (_session) {
|
||||
_session->update_latency (mode == JackPlaybackLatency);
|
||||
}
|
||||
engine.latency_callback (mode == JackPlaybackLatency);
|
||||
}
|
||||
|
||||
int
|
||||
JACKAudioBackend::_bufsize_callback (pframes_t nframes, void *arg)
|
||||
{
|
||||
return static_cast<AudioEngine *> (arg)->jack_bufsize_callback (nframes);
|
||||
return static_cast<JACKAudioBackend*> (arg)->jack_bufsize_callback (nframes);
|
||||
}
|
||||
|
||||
int
|
||||
@ -970,8 +770,7 @@ JACKAudioBackend::jack_bufsize_callback (pframes_t nframes)
|
||||
GET_PRIVATE_JACK_POINTER_RET (_priv_jack, 1);
|
||||
|
||||
_current_buffer_size = nframes;
|
||||
_current_usecs_per_cycle = (int) floor ((((double) nframes / frame_rate())) * 1000000.0);
|
||||
last_monitor_check = 0;
|
||||
_current_usecs_per_cycle = (int) floor ((((double) nframes / sample_rate())) * 1000000.0);
|
||||
|
||||
if (jack_port_type_get_buffer_size) {
|
||||
_raw_buffer_sizes[DataType::AUDIO] = jack_port_type_get_buffer_size (_priv_jack, JACK_DEFAULT_AUDIO_TYPE);
|
||||
@ -993,66 +792,29 @@ JACKAudioBackend::jack_bufsize_callback (pframes_t nframes)
|
||||
_raw_buffer_sizes[DataType::MIDI] = nframes * 4 - (nframes/2);
|
||||
}
|
||||
|
||||
BufferSizeChange (nframes);
|
||||
|
||||
if (_session) {
|
||||
_session->set_block_size (_buffer_size);
|
||||
}
|
||||
engine.buffer_size_change (nframes);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
JACKAudioBackend::halted_info (jack_status_t code, const char* reason, void *arg)
|
||||
JACKAudioBackend::disconnected (const char* why)
|
||||
{
|
||||
/* called from jack shutdown handler */
|
||||
|
||||
AudioEngine* ae = static_cast<AudioEngine *> (arg);
|
||||
bool was_running = ae->_running;
|
||||
bool was_running = _running;
|
||||
|
||||
ae->stop_metering_thread ();
|
||||
|
||||
ae->_running = false;
|
||||
ae->_buffer_size = 0;
|
||||
ae->_frame_rate = 0;
|
||||
ae->_jack = 0;
|
||||
_running = false;
|
||||
_current_buffer_size = 0;
|
||||
_current_sample_rate = 0;
|
||||
|
||||
if (was_running) {
|
||||
MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
|
||||
#ifdef HAVE_JACK_ON_INFO_SHUTDOWN
|
||||
switch (code) {
|
||||
case JackBackendError:
|
||||
ae->Halted(reason); /* EMIT SIGNAL */
|
||||
break;
|
||||
default:
|
||||
ae->Halted(""); /* EMIT SIGNAL */
|
||||
}
|
||||
#else
|
||||
ae->Halted(""); /* EMIT SIGNAL */
|
||||
#endif
|
||||
engine.halted_callback (why); /* EMIT SIGNAL */
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
JACKAudioBackend::halted (void *arg)
|
||||
float
|
||||
JACKAudioBackend::cpu_load() const
|
||||
{
|
||||
cerr << "HALTED by JACK\n";
|
||||
|
||||
/* called from jack shutdown handler */
|
||||
|
||||
AudioEngine* ae = static_cast<AudioEngine *> (arg);
|
||||
bool was_running = ae->_running;
|
||||
|
||||
ae->stop_metering_thread ();
|
||||
|
||||
ae->_running = false;
|
||||
ae->_buffer_size = 0;
|
||||
ae->_frame_rate = 0;
|
||||
ae->_jack = 0;
|
||||
|
||||
if (was_running) {
|
||||
MIDI::JackMIDIPort::JackHalted (); /* EMIT SIGNAL */
|
||||
ae->Halted(""); /* EMIT SIGNAL */
|
||||
}
|
||||
GET_PRIVATE_JACK_POINTER_RET(_priv_jack,0);
|
||||
return jack_cpu_load (_priv_jack);
|
||||
}
|
||||
|
||||
|
@ -62,6 +62,8 @@ JackConnection::open ()
|
||||
boost::scoped_ptr<EnvironmentalProtectionAgency> current_epa;
|
||||
jack_status_t status;
|
||||
|
||||
close ();
|
||||
|
||||
/* revert all environment settings back to whatever they were when ardour started
|
||||
*/
|
||||
|
||||
|
@ -1,3 +1,74 @@
|
||||
JACKPortEngine::init ()
|
||||
{
|
||||
jack_set_port_registration_callback (_priv_jack, _registration_callback, this);
|
||||
jack_set_port_connect_callback (_priv_jack, _connect_callback, this);
|
||||
jack_set_graph_order_callback (_priv_jack, _graph_order_callback, this);
|
||||
}
|
||||
|
||||
void
|
||||
JACKPortEngine::_registration_callback (jack_port_id_t /*id*/, int /*reg*/, void* arg)
|
||||
{
|
||||
JACKPortEngine* pm = static_cast<JACKAudioBackend*> (arg);
|
||||
|
||||
if (!pm->port_remove_in_progress) {
|
||||
pm->engine.PortRegisteredOrUnregistered (); /* EMIT SIGNAL */
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
JACKPortEngine::_connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn, void* arg)
|
||||
{
|
||||
JACKPortEngine* pm = static_cast<JACKAudioBackend*> (arg);
|
||||
pm->connect_callback (id_a, id_b, conn);
|
||||
}
|
||||
|
||||
void
|
||||
JACKPortEngine::connect_callback (jack_port_id_t id_a, jack_port_id_t id_b, int conn)
|
||||
{
|
||||
if (port_remove_in_progress) {
|
||||
return;
|
||||
}
|
||||
|
||||
GET_PRIVATE_JACK_POINTER (_priv_jack);
|
||||
|
||||
jack_port_t* jack_port_a = jack_port_by_id (_priv_jack, id_a);
|
||||
jack_port_t* jack_port_b = jack_port_by_id (_priv_jack, id_b);
|
||||
|
||||
boost::shared_ptr<Port> port_a;
|
||||
boost::shared_ptr<Port> port_b;
|
||||
Ports::iterator x;
|
||||
boost::shared_ptr<Ports> pr = ports.reader ();
|
||||
|
||||
x = pr->find (make_port_name_relative (jack_port_name (jack_port_a)));
|
||||
if (x != pr->end()) {
|
||||
port_a = x->second;
|
||||
}
|
||||
|
||||
x = pr->find (make_port_name_relative (jack_port_name (jack_port_b)));
|
||||
if (x != pr->end()) {
|
||||
port_b = x->second;
|
||||
}
|
||||
|
||||
PortConnectedOrDisconnected (
|
||||
port_a, jack_port_name (jack_port_a),
|
||||
port_b, jack_port_name (jack_port_b),
|
||||
conn == 0 ? false : true
|
||||
); /* EMIT SIGNAL */
|
||||
}
|
||||
|
||||
int
|
||||
JACKPortEngine::_graph_order_callback (void *arg)
|
||||
{
|
||||
JACKPortEngine* pm = static_cast<JACKAudioBackend*> (arg);
|
||||
|
||||
if (pm->connected() && !pm->port_remove_in_progress) {
|
||||
pm->engine.GraphReordered (); /* EMIT SIGNAL */
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
JACKPortEngine::physically_connected (PortHandle p)
|
||||
{
|
||||
jack_port_t* _jack_port = (jack_port_t*) p;
|
||||
|
@ -289,7 +289,7 @@ LV2Plugin::init(const void* c_plugin, framecnt_t rate)
|
||||
_latency_control_port = 0;
|
||||
_next_cycle_start = std::numeric_limits<framepos_t>::max();
|
||||
_next_cycle_speed = 1.0;
|
||||
_block_length = _engine.frames_per_cycle();
|
||||
_block_length = _engine.samples_per_cycle();
|
||||
_seq_size = _engine.raw_buffer_size(DataType::MIDI);
|
||||
_state_version = 0;
|
||||
_was_activated = false;
|
||||
@ -1901,7 +1901,7 @@ LV2Plugin::Impl::designated_input (const char* uri, void** bufptrs[], void** buf
|
||||
return port;
|
||||
}
|
||||
|
||||
static bool lv2_filter (const string& str, void *arg)
|
||||
static bool lv2_filter (const string& str, void* /*arg*/)
|
||||
{
|
||||
/* Not a dotfile, has a prefix before a period, suffix is "lv2" */
|
||||
|
||||
|
@ -473,3 +473,42 @@ AudioEngine::disconnect (boost::shared_ptr<Port> port)
|
||||
return port->disconnect_all ();
|
||||
}
|
||||
|
||||
int
|
||||
PortManager::reestablish_ports ()
|
||||
{
|
||||
Ports::iterator i;
|
||||
|
||||
boost::shared_ptr<Ports> p = ports.reader ();
|
||||
|
||||
for (i = p->begin(); i != p->end(); ++i) {
|
||||
if (i->second->reestablish ()) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (i != p->end()) {
|
||||
/* failed */
|
||||
remove_all_ports ();
|
||||
return -1;
|
||||
}
|
||||
|
||||
MIDI::Manager::instance()->reestablish ();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
PortManager::reconnect_ports ()
|
||||
{
|
||||
boost::shared_ptr<Ports> p = ports.reader ();
|
||||
|
||||
/* re-establish connections */
|
||||
|
||||
for (i = p->begin(); i != p->end(); ++i) {
|
||||
i->second->reconnect ();
|
||||
}
|
||||
|
||||
MIDI::Manager::instance()->reconnect ();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -180,31 +180,30 @@ Session::timecode_time (Timecode::Time &t)
|
||||
}
|
||||
|
||||
int
|
||||
Session::jack_sync_callback (jack_transport_state_t state,
|
||||
jack_position_t* pos)
|
||||
Session::jack_sync_callback (TransportState state, framepos_t pos)
|
||||
{
|
||||
bool slave = synced_to_jack();
|
||||
|
||||
switch (state) {
|
||||
case JackTransportStopped:
|
||||
if (slave && _transport_frame != pos->frame && post_transport_work() == 0) {
|
||||
request_locate (pos->frame, false);
|
||||
case TransportStopped:
|
||||
if (slave && _transport_frame != pos && post_transport_work() == 0) {
|
||||
request_locate (pos, false);
|
||||
// cerr << "SYNC: stopped, locate to " << pos->frame << " from " << _transport_frame << endl;
|
||||
return false;
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
|
||||
case JackTransportStarting:
|
||||
case TransportStarting:
|
||||
// cerr << "SYNC: starting @ " << pos->frame << " a@ " << _transport_frame << " our work = " << post_transport_work() << " pos matches ? " << (_transport_frame == pos->frame) << endl;
|
||||
if (slave) {
|
||||
return _transport_frame == pos->frame && post_transport_work() == 0;
|
||||
return _transport_frame == pos && post_transport_work() == 0;
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
|
||||
case JackTransportRolling:
|
||||
case TransportRolling:
|
||||
// cerr << "SYNC: rolling slave = " << slave << endl;
|
||||
if (slave) {
|
||||
start_transport ();
|
||||
@ -212,17 +211,21 @@ Session::jack_sync_callback (jack_transport_state_t state,
|
||||
break;
|
||||
|
||||
default:
|
||||
error << string_compose (_("Unknown JACK transport state %1 in sync callback"), state)
|
||||
error << string_compose (_("Unknown transport state %1 in sync callback"), state)
|
||||
<< endmsg;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/* XXX REQUIRES SOMEWAY TO EFFICIENTLY ACCESS jack_position_t WITHOUT BRIDGING
|
||||
* THE ENTIRE DATA STRUCTURE
|
||||
*/
|
||||
#if 0
|
||||
void
|
||||
Session::jack_timebase_callback (jack_transport_state_t /*state*/,
|
||||
Session::jack_timebase_callback (TransportState /*state*/,
|
||||
pframes_t /*nframes*/,
|
||||
jack_position_t* pos,
|
||||
framepos_t pos,
|
||||
int /*new_position*/)
|
||||
{
|
||||
Timecode::BBT_Time bbt;
|
||||
@ -299,6 +302,7 @@ Session::jack_timebase_callback (jack_transport_state_t /*state*/,
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif /* jack data structure issues */
|
||||
|
||||
ARDOUR::framecnt_t
|
||||
Session::convert_to_frames (AnyTime const & position)
|
||||
|
@ -435,9 +435,11 @@ def build(bld):
|
||||
# the JACK audio backend
|
||||
|
||||
obj = bld.shlib (features = 'c cxx cshlib cxxshlib',
|
||||
source = [ 'jack_connection.cc',
|
||||
'jack_audiobackend.cc'
|
||||
])
|
||||
source = [
|
||||
'jack_api.cc',
|
||||
'jack_connection.cc',
|
||||
'jack_audiobackend.cc'
|
||||
])
|
||||
obj.cxxflags = [ '-fPIC' ]
|
||||
obj.name = 'jack_audiobackend'
|
||||
obj.target = 'jack_audiobackend'
|
||||
|
Loading…
Reference in New Issue
Block a user