From 0090c8848a6f7b70bfc83b958368b919d00f80f2 Mon Sep 17 00:00:00 2001 From: David Robillard Date: Thu, 2 Oct 2008 22:02:57 +0000 Subject: Remove JACK dependence from RAUL. git-svn-id: http://svn.drobilla.net/lad/trunk/machina@1596 a436a847-0d15-0410-975c-d299462d15a1 --- src/engine/RaulJackDriver.cpp | 248 ++++++++++++++++++++++++++++++++++++++++++ src/engine/RaulJackDriver.hpp | 120 ++++++++++++++++++++ 2 files changed, 368 insertions(+) create mode 100644 src/engine/RaulJackDriver.cpp create mode 100644 src/engine/RaulJackDriver.hpp (limited to 'src/engine') diff --git a/src/engine/RaulJackDriver.cpp b/src/engine/RaulJackDriver.cpp new file mode 100644 index 0000000..b6bbd27 --- /dev/null +++ b/src/engine/RaulJackDriver.cpp @@ -0,0 +1,248 @@ +/* This file is part of Raul. + * Copyright (C) 2007 Dave Robillard + * + * Raul is free software; you can redistribute it and/or modify it under the + * terms of the GNU General Public License as published by the Free Software + * Foundation; either version 2 of the License, or (at your option) any later + * version. + * + * Raul is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +using std::cerr; using std::endl; +using std::string; + +namespace Raul { + + +JackDriver::JackDriver() +: _client(NULL) +, _is_activated(false) +, _xruns(0) +, _xrun_delay(0) +{ + _last_pos.frame = 0; + _last_pos.valid = (jack_position_bits_t)0; +} + + +JackDriver::~JackDriver() +{ + detach(); +} + + +/** Connect to Jack. + */ +void +JackDriver::attach(const string& client_name, string server_name) +{ + // Already connected + if (_client) + return; + + jack_set_error_function(error_cb); + + if (server_name.length() > 0) + _client = jack_client_open(client_name.c_str(), JackServerName, NULL, + server_name.c_str(), NULL); + else + _client = jack_client_open(client_name.c_str(), JackNullOption, NULL, NULL); + + if (_client == NULL) { + //_app->status_message("[JACK] Unable to create client"); + _is_activated = false; + } else { + jack_set_error_function(error_cb); + jack_on_shutdown(_client, jack_shutdown_cb, this); + jack_set_port_registration_callback(_client, jack_port_registration_cb, this); + jack_set_graph_order_callback(_client, jack_graph_order_cb, this); + jack_set_buffer_size_callback(_client, jack_buffer_size_cb, this); + jack_set_xrun_callback(_client, jack_xrun_cb, this); + jack_set_process_callback(_client, jack_process_cb, this); + + //_is_dirty = true; + _buffer_size = jack_get_buffer_size(_client); + } +} + + +void +JackDriver::detach() +{ + if (_client) { + deactivate(); + jack_client_close(_client); + _client = NULL; + _is_activated = false; + //signal_detached.emit(); + } +} + + +void +JackDriver::activate() +{ + if (!jack_activate(_client)) { + _is_activated = true; + //signal_attached.emit(); + //_app->status_message("[JACK] Attached"); + } else { + //_app->status_message("[JACK] ERROR: Failed to attach"); + _is_activated = false; + } +} + + +void +JackDriver::deactivate() +{ + if (_client) + jack_deactivate(_client); + + _is_activated = false; +} + + +void +JackDriver::jack_port_registration_cb(jack_port_id_t /*port_id*/, int /*registered*/, void* /*jack_driver*/) +{ + /* whatever. */ +} + + +int +JackDriver::jack_graph_order_cb(void* jack_driver) +{ + JackDriver* me = reinterpret_cast(jack_driver); + + assert(me); + me->on_graph_order_changed(); + + return 0; +} + + +int +JackDriver::jack_xrun_cb(void* jack_driver) +{ + JackDriver* me = reinterpret_cast(jack_driver); + + assert(me); + + me->_xruns++; + me->_xrun_delay = jack_get_xrun_delayed_usecs(me->_client); + me->reset_delay(); + + me->on_xrun(); + + return 0; +} + + +int +JackDriver::jack_buffer_size_cb(jack_nframes_t buffer_size, void* jack_driver) +{ + JackDriver* me = reinterpret_cast(jack_driver); + + assert(me); + me->reset_xruns(); + me->reset_delay(); + me->on_buffer_size_changed(buffer_size); + me->_buffer_size = buffer_size; + + return 0; +} + + +int +JackDriver::jack_process_cb(jack_nframes_t nframes, void* jack_driver) +{ + JackDriver* me = reinterpret_cast(jack_driver); + + assert(me); + + me->on_process(nframes); + + return 0; +} + + +void +JackDriver::jack_shutdown_cb(void* jack_driver) +{ + JackDriver* me = reinterpret_cast(jack_driver); + assert(me); + + me->reset_delay(); + me->reset_xruns(); + + me->on_shutdown(); + + me->_client = NULL; +} + + +void +JackDriver::error_cb(const char* msg) +{ + cerr << "JACK ERROR: " << msg << endl; +} + + +jack_nframes_t +JackDriver::buffer_size() +{ + if (_is_activated) + return _buffer_size; + else + return jack_get_buffer_size(_client); +} + + +void +JackDriver::reset_xruns() +{ + _xruns = 0; + _xrun_delay = 0; +} + + +bool +JackDriver::set_buffer_size(jack_nframes_t size) +{ + if (buffer_size() == size) { + return true; + } + + if (!_client) { + _buffer_size = size; + return true; + } + + if (jack_set_buffer_size(_client, size)) { + //_app->status_message("[JACK] ERROR: Unable to set buffer size"); + return false; + } else { + return true; + } +} + + +} // namespace Raul + diff --git a/src/engine/RaulJackDriver.hpp b/src/engine/RaulJackDriver.hpp new file mode 100644 index 0000000..f1b92f1 --- /dev/null +++ b/src/engine/RaulJackDriver.hpp @@ -0,0 +1,120 @@ +/* This file is part of Raul. + * Copyright (C) 2007 Dave Robillard + * + * Raul is free software; you can redistribute it and/or modify it under the + * terms of the GNU General Public License as published by the Free Software + * Foundation; either version 2 of the License, or (at your option) any later + * version. + * + * Raul is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef RAUL_JACK_DRIVER_HPP +#define RAUL_JACK_DRIVER_HPP + +#include +#include +#include +#include + +namespace Raul { + + +/** Jack based driver for an audio context. + * + * Apps can override the on_* methods of this class to implement reactions + * to Jack events (e.g. new port, process callback, etc). + */ +class JackDriver +{ +public: + JackDriver(); + virtual ~JackDriver(); + + void attach(const std::string& client_name, std::string server_name=""); + void detach(); + + void activate(); + void deactivate(); + + bool is_activated() const { return _is_activated; } + bool is_attached() const { return (_client != NULL); } + bool is_realtime() const { return _client && jack_is_realtime(_client); } + + void start_transport() { jack_transport_start(_client); } + void stop_transport() { jack_transport_stop(_client); } + + void rewind_transport() { + jack_position_t zero; + zero.frame = 0; + zero.valid = (jack_position_bits_t)0; + jack_transport_reposition(_client, &zero); + } + + jack_nframes_t buffer_size(); + bool set_buffer_size(jack_nframes_t size); + + inline jack_nframes_t sample_rate() { return jack_get_sample_rate(_client); } + + inline size_t xruns() { return _xruns; } + void reset_xruns(); + + inline float max_delay() { return jack_get_max_delayed_usecs(_client); } + inline void reset_delay() { jack_reset_max_delayed_usecs(_client); } + + jack_client_t* jack_client() { return _client; } + + +protected: + /** Process callback. Derived classes should do all audio processing here. */ + virtual void on_process(jack_nframes_t /*nframes*/) {} + + /** Graph order change callback. */ + virtual void on_graph_order_changed() {} + + /** Buffer size changed callback. + * At the time this is called, buffer_size() will still return the old + * size. Immediately afterwards, it will be set to the new value. + */ + virtual void on_buffer_size_changed(jack_nframes_t /*size*/) {} + + virtual void on_xrun() {} + virtual void on_shutdown() {} + virtual void on_error() {} + +protected: + jack_client_t* _client; + +private: + + static void error_cb(const char* msg); + + void destroy_all_ports(); + + void update_time(); + + static void jack_port_registration_cb(jack_port_id_t port_id, int registered, void* me); + static int jack_graph_order_cb(void* me); + static int jack_xrun_cb(void* me); + static int jack_buffer_size_cb(jack_nframes_t buffer_size, void* me); + static int jack_process_cb(jack_nframes_t nframes, void* me); + + static void jack_shutdown_cb(void* me); + + bool _is_activated; + jack_position_t _last_pos; + jack_nframes_t _buffer_size; + size_t _xruns; + float _xrun_delay; +}; + + +} // namespace Raul + +#endif // RAUL_JACK_DRIVER_HPP -- cgit v1.2.1