JackAudioAdapter.cpp
/*
Copyright (C) 2008 Grame
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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "JackAudioAdapter.h"
#include "JackError.h"
#include "JackCompilerDeps.h"
#include "JackTools.h"
#include "JackTime.h"
#include "jslist.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
using namespace std;
namespace Jack
{
int JackAudioAdapter::Process(jack_nframes_t frames, void* arg)
{
JackAudioAdapter* adapter = static_cast<JackAudioAdapter*>(arg);
return adapter->ProcessAux(frames);
}
int JackAudioAdapter::ProcessAux(jack_nframes_t frames)
{
// Always clear output
for (int i = 0; i < fAudioAdapter->GetInputs(); i++) {
fInputBufferList[i] = (jack_default_audio_sample_t*)jack_port_get_buffer(fCapturePortList[i], frames);
memset(fInputBufferList[i], 0, frames * sizeof(jack_default_audio_sample_t));
}
for (int i = 0; i < fAudioAdapter->GetOutputs(); i++) {
fOutputBufferList[i] = (jack_default_audio_sample_t*)jack_port_get_buffer(fPlaybackPortList[i], frames);
}
fAudioAdapter->PullAndPush(fInputBufferList, fOutputBufferList, frames);
return 0;
}
int JackAudioAdapter::BufferSize(jack_nframes_t buffer_size, void* arg)
{
JackAudioAdapter* adapter = static_cast<JackAudioAdapter*>(arg);
adapter->Reset();
adapter->fAudioAdapter->SetHostBufferSize(buffer_size);
return 0;
}
int JackAudioAdapter::SampleRate(jack_nframes_t sample_rate, void* arg)
{
JackAudioAdapter* adapter = static_cast<JackAudioAdapter*>(arg);
adapter->Reset();
adapter->fAudioAdapter->SetHostSampleRate(sample_rate);
return 0;
}
void JackAudioAdapter::Latency(jack_latency_callback_mode_t mode, void* arg)
{
JackAudioAdapter* adapter = static_cast<JackAudioAdapter*>(arg);
if (mode == JackCaptureLatency) {
for (int i = 0; i < adapter->fAudioAdapter->GetInputs(); i++) {
jack_latency_range_t range;
range.min = range.max = adapter->fAudioAdapter->GetInputLatency(i);
jack_port_set_latency_range(adapter->fCapturePortList[i], JackCaptureLatency, &range);
}
} else {
for (int i = 0; i < adapter->fAudioAdapter->GetOutputs(); i++) {
jack_latency_range_t range;
range.min = range.max = adapter->fAudioAdapter->GetOutputLatency(i);
jack_port_set_latency_range(adapter->fPlaybackPortList[i], JackPlaybackLatency, &range);
}
}
}
JackAudioAdapter::JackAudioAdapter(jack_client_t* client, JackAudioAdapterInterface* audio_io, const JSList* params)
:fClient(client), fAudioAdapter(audio_io)
{
const JSList* node;
const jack_driver_param_t* param;
fAutoConnect = false;
for (node = params; node; node = jack_slist_next(node)) {
param = (const jack_driver_param_t*)node->data;
switch (param->character) {
case 'c':
fAutoConnect = true;
break;
}
}
}
JackAudioAdapter::~JackAudioAdapter()
{
// When called, Close has already been used for the client, thus ports are already unregistered.
delete fAudioAdapter;
}
void JackAudioAdapter::FreePorts()
{
for (int i = 0; i < fAudioAdapter->GetInputs(); i++) {
if (fCapturePortList[i]) {
jack_port_unregister(fClient, fCapturePortList[i]);
}
}
for (int i = 0; i < fAudioAdapter->GetOutputs(); i++) {
if (fPlaybackPortList[i]) {
jack_port_unregister(fClient, fPlaybackPortList[i]);
}
}
delete[] fCapturePortList;
delete[] fPlaybackPortList;
delete[] fInputBufferList;
delete[] fOutputBufferList;
}
void JackAudioAdapter::ConnectPorts()
{
const char** ports;
ports = jack_get_ports(fClient, NULL, NULL, JackPortIsPhysical | JackPortIsInput);
if (ports != NULL) {
for (int i = 0; i < fAudioAdapter->GetInputs() && ports[i]; i++) {
jack_connect(fClient, jack_port_name(fCapturePortList[i]), ports[i]);
}
jack_free(ports);
}
ports = jack_get_ports(fClient, NULL, NULL, JackPortIsPhysical | JackPortIsOutput);
if (ports != NULL) {
for (int i = 0; i < fAudioAdapter->GetOutputs() && ports[i]; i++) {
jack_connect(fClient, ports[i], jack_port_name(fPlaybackPortList[i]));
}
jack_free(ports);
}
}
void JackAudioAdapter::Reset()
{
fAudioAdapter->Reset();
}
int JackAudioAdapter::Open()
{
char name[32];
jack_log("JackAudioAdapter::Open fCaptureChannels %d fPlaybackChannels %d", fAudioAdapter->GetInputs(), fAudioAdapter->GetOutputs());
fAudioAdapter->Create();
//jack ports
fCapturePortList = new jack_port_t*[fAudioAdapter->GetInputs()];
fPlaybackPortList = new jack_port_t*[fAudioAdapter->GetOutputs()];
fInputBufferList = new jack_default_audio_sample_t*[fAudioAdapter->GetInputs()];
fOutputBufferList = new jack_default_audio_sample_t*[fAudioAdapter->GetOutputs()];
for (int i = 0; i < fAudioAdapter->GetInputs(); i++) {
snprintf(name, sizeof(name), "capture_%d", i + 1);
if ((fCapturePortList[i] = jack_port_register(fClient, name, JACK_DEFAULT_AUDIO_TYPE, CaptureDriverFlags, 0)) == NULL) {
goto fail;
}
}
for (int i = 0; i < fAudioAdapter->GetOutputs(); i++) {
snprintf(name, sizeof(name), "playback_%d", i + 1);
if ((fPlaybackPortList[i] = jack_port_register(fClient, name, JACK_DEFAULT_AUDIO_TYPE, PlaybackDriverFlags, 0)) == NULL) {
goto fail;
}
}
//callbacks and activation
if (jack_set_process_callback(fClient, Process, this) < 0) {
goto fail;
}
if (jack_set_buffer_size_callback(fClient, BufferSize, this) < 0) {
goto fail;
}
if (jack_set_sample_rate_callback(fClient, SampleRate, this) < 0) {
goto fail;
}
if (jack_set_latency_callback(fClient, Latency, this) < 0) {
goto fail;
}
if (jack_activate(fClient) < 0) {
goto fail;
}
if (fAutoConnect) {
ConnectPorts();
}
// Ring buffers are now allocated...
return fAudioAdapter->Open();
return 0;
fail:
FreePorts();
fAudioAdapter->Destroy();
return -1;
}
int JackAudioAdapter::Close()
{
fAudioAdapter->Close();
fAudioAdapter->Destroy();
return 0;
}
} //namespace
jack_port_unregister
LIB_EXPORT int jack_port_unregister(jack_client_t *, jack_port_t *)
Definition: JackAPI.cpp:1109
Jack
Definition: JackAC3Encoder.cpp:30
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
std
jack_port_set_latency_range
LIB_EXPORT void jack_port_set_latency_range(jack_port_t *port, jack_latency_callback_mode_t mode, jack_latency_range_t *range)
Definition: JackAPI.cpp:586
jack_connect
LIB_EXPORT int jack_connect(jack_client_t *, const char *source_port, const char *destination_port)
Definition: JackAPI.cpp:1211
_jack_latency_range::min
jack_nframes_t min
Definition: types.h:270
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_latency_range
Definition: types.h:265
_jack_latency_range::max
jack_nframes_t max
Definition: types.h:274
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_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_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
_JSList
Definition: linux/alsa/jslist.h:35
jack_log
SERVER_EXPORT void jack_log(const char *fmt,...)
Definition: JackError.cpp:108