JackProxyDriver.cpp
/*
Copyright (C) 2014 Cédric Schieli
This program 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.
This program 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 more 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 Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "JackCompilerDeps.h"
#include "driver_interface.h"
#include "JackEngineControl.h"
#include "JackLockedEngine.h"
#include "JackWaitCallbackDriver.h"
#include "JackProxyDriver.h"
using namespace std;
namespace Jack
{
JackProxyDriver::JackProxyDriver(const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table,
const char* upstream, const char* promiscuous,
char* client_name, bool auto_connect, bool auto_save)
: JackRestarterDriver(name, alias, engine, table)
{
jack_log("JackProxyDriver::JackProxyDriver upstream %s", upstream);
assert(strlen(upstream) < JACK_CLIENT_NAME_SIZE);
strcpy(fUpstream, upstream);
assert(strlen(client_name) < JACK_CLIENT_NAME_SIZE);
strcpy(fClientName, client_name);
if (promiscuous) {
fPromiscuous = strdup(promiscuous);
}
fAutoConnect = auto_connect;
fAutoSave = auto_save;
}
JackProxyDriver::~JackProxyDriver()
{
if (fHandle) {
UnloadJackModule(fHandle);
}
}
int JackProxyDriver::LoadClientLib()
{
// Already loaded
if (fHandle) {
return 0;
}
fHandle = LoadJackModule(JACK_PROXY_CLIENT_LIB);
if (!fHandle) {
return -1;
}
LoadSymbols();
return 0;
}
//open, close, attach and detach------------------------------------------------------
int JackProxyDriver::Open(jack_nframes_t buffer_size,
jack_nframes_t samplerate,
bool capturing,
bool playing,
int inchannels,
int outchannels,
bool monitor,
const char* capture_driver_name,
const char* playback_driver_name,
jack_nframes_t capture_latency,
jack_nframes_t playback_latency)
{
fDetectPlaybackChannels = (outchannels == -1);
fDetectCaptureChannels = (inchannels == -1);
if (LoadClientLib() != 0) {
jack_error("Cannot dynamically load client library !");
return -1;
}
return JackWaiterDriver::Open(buffer_size, samplerate,
capturing, playing,
inchannels, outchannels,
monitor,
capture_driver_name, playback_driver_name,
capture_latency, playback_latency);
}
int JackProxyDriver::Close()
{
FreePorts();
return JackWaiterDriver::Close();
}
// Attach and Detach are defined as empty methods: port allocation is done when driver actually start (that is in Init)
int JackProxyDriver::Attach()
{
return 0;
}
int JackProxyDriver::Detach()
{
return 0;
}
//init and restart--------------------------------------------------------------------
/*
JackProxyDriver is wrapped in a JackWaitCallbackDriver decorator that behaves
as a "dummy driver, until Initialize method returns.
*/
bool JackProxyDriver::Initialize()
{
jack_log("JackProxyDriver::Initialize");
// save existing local connections if needed
if (fAutoSave) {
SaveConnections(0);
}
// new loading, but existing client, restart the driver
if (fClient) {
jack_info("JackProxyDriver restarting...");
jack_client_close(fClient);
}
FreePorts();
// display some additional infos
jack_info("JackProxyDriver started in %s mode.",
(fEngineControl->fSyncMode) ? "sync" : "async");
do {
jack_status_t status;
char *old = NULL;
if (fPromiscuous) {
// as we are fiddling with the environment variable content, save it
const char* tmp = getenv("JACK_PROMISCUOUS_SERVER");
if (tmp) {
old = strdup(tmp);
}
// temporary enable promiscuous mode
if (setenv("JACK_PROMISCUOUS_SERVER", fPromiscuous, 1) < 0) {
free(old);
jack_error("Error allocating memory.");
return false;
}
}
jack_info("JackProxyDriver connecting to %s", fUpstream);
fClient = jack_client_open(fClientName, static_cast<jack_options_t>(JackNoStartServer|JackServerName), &status, fUpstream);
if (fPromiscuous) {
// restore previous environment variable content
if (old) {
if (setenv("JACK_PROMISCUOUS_SERVER", old, 1) < 0) {
free(old);
jack_error("Error allocating memory.");
return false;
}
free(old);
} else {
unsetenv("JACK_PROMISCUOUS_SERVER");
}
}
// the connection failed, try again later
if (!fClient) {
JackSleep(1000000);
}
} while (!fClient);
jack_info("JackProxyDriver connected to %s", fUpstream);
// we are connected, let's register some callbacks
jack_on_shutdown(fClient, shutdown_callback, this);
if (jack_set_process_callback(fClient, process_callback, this) != 0) {
jack_error("Cannot set process callback.");
return false;
}
if (jack_set_buffer_size_callback(fClient, bufsize_callback, this) != 0) {
jack_error("Cannot set buffer size callback.");
return false;
}
if (jack_set_sample_rate_callback(fClient, srate_callback, this) != 0) {
jack_error("Cannot set sample rate callback.");
return false;
}
if (jack_set_port_connect_callback(fClient, connect_callback, this) != 0) {
jack_error("Cannot set port connect callback.");
return false;
}
// detect upstream physical playback ports if needed
if (fDetectPlaybackChannels) {
fPlaybackChannels = CountIO(JACK_DEFAULT_AUDIO_TYPE, JackPortIsPhysical | JackPortIsOutput);
}
// detect upstream physical capture ports if needed
if (fDetectCaptureChannels) {
fCaptureChannels = CountIO(JACK_DEFAULT_AUDIO_TYPE, JackPortIsPhysical | JackPortIsInput);
}
if (AllocPorts() != 0) {
jack_error("Can't allocate ports.");
return false;
}
bufsize_callback(jack_get_buffer_size(fClient));
srate_callback(jack_get_sample_rate(fClient));
// restore local connections if needed
if (fAutoSave) {
LoadConnections(0);
}
// everything is ready, start upstream processing
if (jack_activate(fClient) != 0) {
jack_error("Cannot activate jack client.");
return false;
}
// connect upstream ports if needed
if (fAutoConnect) {
ConnectPorts();
}
return true;
}
int JackProxyDriver::Stop()
{
if (fClient && (jack_deactivate(fClient) != 0)) {
jack_error("Cannot deactivate jack client.");
return -1;
}
return 0;
}
//client callbacks---------------------------------------------------------------------------
int JackProxyDriver::process_callback(jack_nframes_t nframes, void* arg)
{
assert(static_cast<JackProxyDriver*>(arg));
return static_cast<JackProxyDriver*>(arg)->Process();
}
int JackProxyDriver::bufsize_callback(jack_nframes_t nframes, void* arg)
{
assert(static_cast<JackProxyDriver*>(arg));
return static_cast<JackProxyDriver*>(arg)->bufsize_callback(nframes);
}
int JackProxyDriver::bufsize_callback(jack_nframes_t nframes)
{
if (JackTimedDriver::SetBufferSize(nframes) == 0) {
return -1;
}
JackDriver::NotifyBufferSize(nframes);
return 0;
}
int JackProxyDriver::srate_callback(jack_nframes_t nframes, void* arg)
{
assert(static_cast<JackProxyDriver*>(arg));
return static_cast<JackProxyDriver*>(arg)->srate_callback(nframes);
}
int JackProxyDriver::srate_callback(jack_nframes_t nframes)
{
if (JackTimedDriver::SetSampleRate(nframes) == 0) {
return -1;
}
JackDriver::NotifySampleRate(nframes);
return 0;
}
void JackProxyDriver::connect_callback(jack_port_id_t a, jack_port_id_t b, int connect, void* arg)
{
assert(static_cast<JackProxyDriver*>(arg));
static_cast<JackProxyDriver*>(arg)->connect_callback(a, b, connect);
}
void JackProxyDriver::connect_callback(jack_port_id_t a, jack_port_id_t b, int connect)
{
jack_port_t* port;
int i;
// skip port if not our own
port = jack_port_by_id(fClient, a);
if (!jack_port_is_mine(fClient, port)) {
port = jack_port_by_id(fClient, b);
if (!jack_port_is_mine(fClient, port)) {
return;
}
}
for (i = 0; i < fCaptureChannels; i++) {
if (fUpstreamPlaybackPorts[i] == port) {
fUpstreamPlaybackPortConnected[i] = connect;
}
}
for (i = 0; i < fPlaybackChannels; i++) {
if (fUpstreamCapturePorts[i] == port) {
fUpstreamCapturePortConnected[i] = connect;
}
}
}
void JackProxyDriver::shutdown_callback(void* arg)
{
assert(static_cast<JackProxyDriver*>(arg));
static_cast<JackProxyDriver*>(arg)->RestartWait();
}
//jack ports and buffers--------------------------------------------------------------
int JackProxyDriver::CountIO(const char* type, int flags)
{
int count = 0;
const char** ports = jack_get_ports(fClient, NULL, type, flags);
if (ports != NULL) {
while (ports[count]) { count++; }
jack_free(ports);
}
return count;
}
int JackProxyDriver::AllocPorts()
{
jack_log("JackProxyDriver::AllocPorts fBufferSize = %ld fSampleRate = %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate);
char proxy[REAL_JACK_PORT_NAME_SIZE];
int i;
fUpstreamPlaybackPorts = new jack_port_t* [fCaptureChannels];
fUpstreamPlaybackPortConnected = new int [fCaptureChannels];
for (i = 0; i < fCaptureChannels; i++) {
snprintf(proxy, sizeof(proxy), "%s:to_client_%d", fClientName, i + 1);
fUpstreamPlaybackPorts[i] = jack_port_register(fClient, proxy, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput | JackPortIsTerminal, 0);
if (fUpstreamPlaybackPorts[i] == NULL) {
jack_error("driver: cannot register upstream port %s", proxy);
return -1;
}
fUpstreamPlaybackPortConnected[i] = 0;
}
fUpstreamCapturePorts = new jack_port_t* [fPlaybackChannels];
fUpstreamCapturePortConnected = new int [fPlaybackChannels];
for (i = 0; i < fPlaybackChannels; i++) {
snprintf(proxy, sizeof(proxy), "%s:from_client_%d", fClientName, i + 1);
fUpstreamCapturePorts[i] = jack_port_register(fClient, proxy, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput | JackPortIsTerminal, 0);
if (fUpstreamCapturePorts[i] == NULL) {
jack_error("driver: cannot register upstream port %s", proxy);
return -1;
}
fUpstreamCapturePortConnected[i] = 0;
}
// local ports are registered here
return JackAudioDriver::Attach();
}
int JackProxyDriver::FreePorts()
{
jack_log("JackProxyDriver::FreePorts");
int i;
for (i = 0; i < fCaptureChannels; i++) {
if (fCapturePortList[i] > 0) {
fEngine->PortUnRegister(fClientControl.fRefNum, fCapturePortList[i]);
fCapturePortList[i] = 0;
}
if (fUpstreamPlaybackPorts && fUpstreamPlaybackPorts[i]) {
fUpstreamPlaybackPorts[i] = NULL;
}
}
for (i = 0; i < fPlaybackChannels; i++) {
if (fPlaybackPortList[i] > 0) {
fEngine->PortUnRegister(fClientControl.fRefNum, fPlaybackPortList[i]);
fPlaybackPortList[i] = 0;
}
if (fUpstreamCapturePorts && fUpstreamCapturePorts[i]) {
fUpstreamCapturePorts[i] = NULL;
}
}
delete[] fUpstreamPlaybackPorts;
delete[] fUpstreamPlaybackPortConnected;
delete[] fUpstreamCapturePorts;
delete[] fUpstreamCapturePortConnected;
fUpstreamPlaybackPorts = NULL;
fUpstreamPlaybackPortConnected = NULL;
fUpstreamCapturePorts = NULL;
fUpstreamCapturePortConnected = NULL;
return 0;
}
void JackProxyDriver::ConnectPorts()
{
jack_log("JackProxyDriver::ConnectPorts");
const char** ports = jack_get_ports(fClient, NULL, JACK_DEFAULT_AUDIO_TYPE, JackPortIsPhysical | JackPortIsOutput);
if (ports != NULL) {
for (int i = 0; i < fCaptureChannels && ports[i]; i++) {
jack_connect(fClient, ports[i], jack_port_name(fUpstreamPlaybackPorts[i]));
}
jack_free(ports);
}
ports = jack_get_ports(fClient, NULL, JACK_DEFAULT_AUDIO_TYPE, JackPortIsPhysical | JackPortIsInput);
if (ports != NULL) {
for (int i = 0; i < fPlaybackChannels && ports[i]; i++) {
jack_connect(fClient, jack_port_name(fUpstreamCapturePorts[i]), ports[i]);
}
jack_free(ports);
}
}
//driver processes--------------------------------------------------------------------
int JackProxyDriver::Read()
{
// take the time at the beginning of the cycle
JackDriver::CycleTakeBeginTime();
int i;
void *from, *to;
size_t buflen = sizeof(jack_default_audio_sample_t) * fEngineControl->fBufferSize;
for (i = 0; i < fCaptureChannels; i++) {
if (fUpstreamPlaybackPortConnected[i]) {
from = jack_port_get_buffer(fUpstreamPlaybackPorts[i], fEngineControl->fBufferSize);
to = GetInputBuffer(i);
memcpy(to, from, buflen);
}
}
return 0;
}
int JackProxyDriver::Write()
{
int i;
void *from, *to;
size_t buflen = sizeof(jack_default_audio_sample_t) * fEngineControl->fBufferSize;
for (i = 0; i < fPlaybackChannels; i++) {
if (fUpstreamCapturePortConnected[i]) {
to = jack_port_get_buffer(fUpstreamCapturePorts[i], fEngineControl->fBufferSize);
from = GetOutputBuffer(i);
memcpy(to, from, buflen);
}
}
return 0;
}
//driver loader-----------------------------------------------------------------------
#ifdef __cplusplus
extern "C"
{
#endif
SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor()
{
jack_driver_desc_t * desc;
jack_driver_desc_filler_t filler;
jack_driver_param_value_t value;
desc = jack_driver_descriptor_construct("proxy", JackDriverMaster, "proxy backend", &filler);
strcpy(value.str, DEFAULT_UPSTREAM);
jack_driver_descriptor_add_parameter(desc, &filler, "upstream", 'u', JackDriverParamString, &value, NULL, "Name of the upstream jack server", NULL);
strcpy(value.str, "");
jack_driver_descriptor_add_parameter(desc, &filler, "promiscuous", 'p', JackDriverParamString, &value, NULL, "Promiscuous group", NULL);
value.i = -1;
jack_driver_descriptor_add_parameter(desc, &filler, "input-ports", 'C', JackDriverParamInt, &value, NULL, "Number of audio input ports", "Number of audio input ports. If -1, audio physical input from the master");
jack_driver_descriptor_add_parameter(desc, &filler, "output-ports", 'P', JackDriverParamInt, &value, NULL, "Number of audio output ports", "Number of audio output ports. If -1, audio physical output from the master");
strcpy(value.str, "proxy");
jack_driver_descriptor_add_parameter(desc, &filler, "client-name", 'n', JackDriverParamString, &value, NULL, "Name of the jack client", NULL);
value.i = false;
jack_driver_descriptor_add_parameter(desc, &filler, "use-username", 'U', JackDriverParamBool, &value, NULL, "Use current username as client name", NULL);
value.i = false;
jack_driver_descriptor_add_parameter(desc, &filler, "auto-connect", 'c', JackDriverParamBool, &value, NULL, "Auto connect proxy to upstream system ports", NULL);
value.i = false;
jack_driver_descriptor_add_parameter(desc, &filler, "auto-save", 's', JackDriverParamBool, &value, NULL, "Save/restore connection state when restarting", NULL);
return desc;
}
SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize(Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params)
{
char upstream[JACK_CLIENT_NAME_SIZE + 1];
char promiscuous[JACK_CLIENT_NAME_SIZE + 1] = {0};
char client_name[JACK_CLIENT_NAME_SIZE + 1];
jack_nframes_t period_size = 1024; // to be used while waiting for master period_size
jack_nframes_t sample_rate = 48000; // to be used while waiting for master sample_rate
int capture_ports = -1;
int playback_ports = -1;
const JSList* node;
const jack_driver_param_t* param;
bool auto_connect = false;
bool auto_save = false;
bool use_promiscuous = false;
// Possibly use env variable for upstream name
const char* default_upstream = getenv("JACK_PROXY_UPSTREAM");
strcpy(upstream, (default_upstream) ? default_upstream : DEFAULT_UPSTREAM);
// Possibly use env variable for upstream promiscuous
const char* default_promiscuous = getenv("JACK_PROXY_PROMISCUOUS");
strcpy(promiscuous, (default_promiscuous) ? default_promiscuous : "");
// Possibly use env variable for client name
const char* default_client_name = getenv("JACK_PROXY_CLIENT_NAME");
strcpy(client_name, (default_client_name) ? default_client_name : DEFAULT_CLIENT_NAME);
#ifdef WIN32
const char* username = getenv("USERNAME");
#else
const char* username = getenv("LOGNAME");
#endif
for (node = params; node; node = jack_slist_next(node)) {
param = (const jack_driver_param_t*) node->data;
switch (param->character)
{
case 'u' :
assert(strlen(param->value.str) < JACK_CLIENT_NAME_SIZE);
strcpy(upstream, param->value.str);
break;
case 'p':
assert(strlen(param->value.str) < JACK_CLIENT_NAME_SIZE);
use_promiscuous = true;
strcpy(promiscuous, param->value.str);
break;
case 'C':
capture_ports = param->value.i;
break;
case 'P':
playback_ports = param->value.i;
break;
case 'n' :
assert(strlen(param->value.str) < JACK_CLIENT_NAME_SIZE);
strncpy(client_name, param->value.str, JACK_CLIENT_NAME_SIZE);
break;
case 'U' :
if (username && *username) {
assert(strlen(username) < JACK_CLIENT_NAME_SIZE);
strncpy(client_name, username, JACK_CLIENT_NAME_SIZE);
}
case 'c':
auto_connect = true;
break;
case 's':
auto_save = true;
break;
}
}
try {
Jack::JackDriverClientInterface* driver = new Jack::JackWaitCallbackDriver(
new Jack::JackProxyDriver("system", "proxy_pcm", engine, table, upstream, use_promiscuous ? promiscuous : NULL, client_name, auto_connect, auto_save));
if (driver->Open(period_size, sample_rate, 1, 1, capture_ports, playback_ports, false, "capture_", "playback_", 0, 0) == 0) {
return driver;
} else {
delete driver;
return NULL;
}
} catch (...) {
return NULL;
}
}
#ifdef __cplusplus
}
#endif
}
Jack
Definition: JackAC3Encoder.cpp:30
Jack::JackLockedEngine
Locked Engine, access to methods is serialized using a mutex.
Definition: JackLockedEngine.h:78
jack_port_by_id
LIB_EXPORT jack_port_t * jack_port_by_id(jack_client_t *client, jack_port_id_t port_id)
Definition: JackAPI.cpp:1326
jack_driver_param_value_t
Definition: driver_interface.h:64
Jack::JackPosixSemaphore
Inter process synchronization using POSIX semaphore.
Definition: JackPosixSemaphore.h:36
jack_set_process_callback
LIB_EXPORT int jack_set_process_callback(jack_client_t *client, JackProcessCallback process_callback, void *arg)
Definition: JackAPI.cpp:829
jack_activate
LIB_EXPORT int jack_activate(jack_client_t *client)
Definition: JackAPI.cpp:1067
Jack::JackProxyDriver
Definition: JackProxyDriver.h:60
std
jack_error
SERVER_EXPORT void jack_error(const char *fmt,...)
Definition: JackError.cpp:92
jack_connect
LIB_EXPORT int jack_connect(jack_client_t *, const char *source_port, const char *destination_port)
Definition: JackAPI.cpp:1211
jack_port_register
LIB_EXPORT jack_port_t * jack_port_register(jack_client_t *client, const char *port_name, const char *port_type, unsigned long flags, unsigned long buffer_size)
Definition: JackAPI.cpp:1093
jack_info
SERVER_EXPORT void jack_info(const char *fmt,...)
Definition: JackError.cpp:100
jack_on_shutdown
LIB_EXPORT void jack_on_shutdown(jack_client_t *client, JackShutdownCallback shutdown_callback, void *arg)
Definition: JackAPI.cpp:805
jack_set_port_connect_callback
LIB_EXPORT int jack_set_port_connect_callback(jack_client_t *, JackPortConnectCallback connect_callback, void *arg)
Definition: JackAPI.cpp:987
jack_client_open
LIB_EXPORT jack_client_t * jack_client_open(const char *client_name, jack_options_t options, jack_status_t *status,...)
Definition: JackLibAPI.cpp:167
Jack::JackWaitCallbackDriver
Wrapper for a restartable non-threaded driver (e.g. JackProxyDriver).
Definition: JackWaitCallbackDriver.h:35
jack_get_buffer_size
LIB_EXPORT jack_nframes_t jack_get_buffer_size(jack_client_t *)
Definition: JackAPI.cpp:1275
jack_set_sample_rate_callback
LIB_EXPORT int jack_set_sample_rate_callback(jack_client_t *client, JackSampleRateCallback srate_callback, void *arg)
Definition: JackAPI.cpp:948
jack_port_get_buffer
LIB_EXPORT void * jack_port_get_buffer(jack_port_t *, jack_nframes_t)
Definition: JackAPI.cpp:363
jack_port_is_mine
LIB_EXPORT int jack_port_is_mine(const jack_client_t *, const jack_port_t *port)
Definition: JackAPI.cpp:1127
jack_get_sample_rate
LIB_EXPORT jack_nframes_t jack_get_sample_rate(jack_client_t *)
Definition: JackAPI.cpp:1261
jack_driver_desc_filler_t
Definition: driver_interface.h:142
jack_set_buffer_size_callback
LIB_EXPORT int jack_set_buffer_size_callback(jack_client_t *client, JackBufferSizeCallback bufsize_callback, void *arg)
Definition: JackAPI.cpp:935
Jack::JackDriverClientInterface
The base interface for drivers clients.
Definition: JackDriver.h:114
Jack::JackRestarterDriver::RestartWait
int RestartWait()
Definition: JackTimedDriver.cpp:94
jack_port_name
LIB_EXPORT const char * jack_port_name(const jack_port_t *port)
Definition: JackAPI.cpp:383
jack_driver_param_t
Definition: driver_interface.h:125
jack_get_ports
LIB_EXPORT const char ** jack_get_ports(jack_client_t *, const char *port_name_pattern, const char *type_name_pattern, unsigned long flags)
Definition: JackAPI.cpp:1289
jack_deactivate
LIB_EXPORT int jack_deactivate(jack_client_t *client)
Definition: JackAPI.cpp:1080
_JSList
Definition: linux/alsa/jslist.h:35
jack_log
SERVER_EXPORT void jack_log(const char *fmt,...)
Definition: JackError.cpp:108
jack_driver_desc_t
Definition: driver_interface.h:132
jack_client_close
LIB_EXPORT int jack_client_close(jack_client_t *client)
Definition: JackLibAPI.cpp:189