22 #include "JackNetInterface.h"
23 #include "JackError.h"
24 #include "JackException.h"
25 #include "JackAudioAdapterInterface.h"
34 #define MASTER_NAME_SIZE 256
64 jack_nframes_t buffer_size;
65 jack_nframes_t sample_rate;
66 char master_name[MASTER_NAME_SIZE];
72 typedef struct _jack_net_slave jack_net_slave_t;
74 typedef int (* JackNetSlaveProcessCallback) (jack_nframes_t buffer_size,
76 float** audio_input_buffer,
78 void** midi_input_buffer,
80 float** audio_output_buffer,
82 void** midi_output_buffer,
85 typedef int (*JackNetSlaveBufferSizeCallback) (jack_nframes_t nframes,
void *arg);
86 typedef int (*JackNetSlaveSampleRateCallback) (jack_nframes_t nframes,
void *arg);
87 typedef void (*JackNetSlaveShutdownCallback) (
void* data);
89 SERVER_EXPORT jack_net_slave_t* jack_net_slave_open(
const char* ip,
int port,
const char* name,
jack_slave_t* request,
jack_master_t* result);
90 SERVER_EXPORT
int jack_net_slave_close(jack_net_slave_t* net);
92 SERVER_EXPORT
int jack_net_slave_activate(jack_net_slave_t* net);
93 SERVER_EXPORT
int jack_net_slave_deactivate(jack_net_slave_t* net);
95 SERVER_EXPORT
int jack_set_net_slave_process_callback(jack_net_slave_t* net, JackNetSlaveProcessCallback net_callback,
void *arg);
96 SERVER_EXPORT
int jack_set_net_slave_buffer_size_callback(jack_net_slave_t* net, JackNetSlaveBufferSizeCallback bufsize_callback,
void *arg);
97 SERVER_EXPORT
int jack_set_net_slave_sample_rate_callback(jack_net_slave_t* net, JackNetSlaveSampleRateCallback samplerate_callback,
void *arg);
98 SERVER_EXPORT
int jack_set_net_slave_shutdown_callback(jack_net_slave_t* net, JackNetSlaveShutdownCallback shutdown_callback,
void *arg);
102 typedef struct _jack_net_master jack_net_master_t;
104 SERVER_EXPORT jack_net_master_t* jack_net_master_open(
const char* ip,
int port,
const char* name,
jack_master_t* request,
jack_slave_t* result);
105 SERVER_EXPORT
int jack_net_master_close(jack_net_master_t* net);
107 SERVER_EXPORT
int jack_net_master_recv(jack_net_master_t* net,
int audio_input,
float** audio_input_buffer,
int midi_input,
void** midi_input_buffer);
108 SERVER_EXPORT
int jack_net_master_send(jack_net_master_t* net,
int audio_output,
float** audio_output_buffer,
int midi_output,
void** midi_output_buffer);
112 typedef struct _jack_adapter jack_adapter_t;
114 SERVER_EXPORT jack_adapter_t* jack_create_adapter(
int input,
int output,
115 jack_nframes_t host_buffer_size,
116 jack_nframes_t host_sample_rate,
117 jack_nframes_t adapted_buffer_size,
118 jack_nframes_t adapted_sample_rate);
119 SERVER_EXPORT
int jack_destroy_adapter(jack_adapter_t* adapter);
120 SERVER_EXPORT
void jack_flush_adapter(jack_adapter_t* adapter);
122 SERVER_EXPORT
int jack_adapter_push_and_pull(jack_adapter_t* adapter,
float** input,
float** output,
unsigned int frames);
123 SERVER_EXPORT
int jack_adapter_pull_and_push(jack_adapter_t* adapter,
float** input,
float** output,
unsigned int frames);
135 float** fAudioCaptureBuffer;
136 float** fAudioPlaybackBuffer;
149 assert(strlen(ip) < 32);
150 strcpy(fMulticastIP, ip);
151 fSocket.SetPort(port);
152 fRequest.buffer_size = request->buffer_size;
153 fRequest.sample_rate = request->sample_rate;
154 fAudioCaptureBuffer = NULL;
155 fAudioPlaybackBuffer = NULL;
156 fMidiCaptureBuffer = NULL;
157 fMidiPlaybackBuffer = NULL;
166 if (SocketAPIInit() < 0) {
167 jack_error(
"Can't init Socket API, exiting...");
172 if (fSocket.NewSocket() == SOCKET_ERROR) {
173 jack_error(
"Can't create the network management input socket : %s", StrError(NET_ERROR_CODE));
178 if (fSocket.Bind() == SOCKET_ERROR) {
179 jack_error(
"Can't bind the network manager socket : %s", StrError(NET_ERROR_CODE));
185 if (fSocket.JoinMCastGroup(fMulticastIP) == SOCKET_ERROR) {
186 jack_error(
"Can't join multicast group : %s", StrError(NET_ERROR_CODE));
190 if (fSocket.SetLocalLoop() == SOCKET_ERROR) {
191 jack_error(
"Can't set local loop : %s", StrError(NET_ERROR_CODE));
195 if (fSocket.SetTimeOut(MANAGER_INIT_TIMEOUT) == SOCKET_ERROR) {
196 jack_error(
"Can't set timeout : %s", StrError(NET_ERROR_CODE));
207 SessionParamsNToH(&net_params, &fParams);
209 if ((rx_bytes == SOCKET_ERROR) && (fSocket.GetError() != NET_NO_DATA)) {
210 jack_error(
"Error in receive : %s", StrError(NET_ERROR_CODE));
211 if (++attempt == 10) {
212 jack_error(
"Can't receive on the socket, exiting net manager" );
219 switch (GetPacketType(&fParams)) {
221 case SLAVE_AVAILABLE:
222 if (MasterInit() == 0) {
223 SessionParamsDisplay(&fParams);
243 result->audio_input = fParams.fSendAudioChannels;
244 result->audio_output = fParams.fReturnAudioChannels;
245 result->midi_input = fParams.fSendMidiChannels;
246 result->midi_output = fParams.fReturnMidiChannels;
247 result->mtu = fParams.fMtu;
248 result->latency = fParams.fNetworkLatency;
259 if (fParams.fProtocolVersion != MASTER_PROTOCOL) {
260 jack_error(
"Error : slave is running with a different protocol %s", fParams.fName);
265 fSocket.GetName(fParams.fMasterNetName);
267 fParams.fSampleEncoder = JackFloatEncoder;
268 fParams.fPeriodSize = fRequest.buffer_size;
269 fParams.fSampleRate = fRequest.sample_rate;
275 if (!JackNetMasterInterface::Init()) {
298 if (fParams.fSendAudioChannels > 0) {
299 fAudioCaptureBuffer =
new float*[fParams.fSendAudioChannels];
300 for (
int audio_port_index = 0; audio_port_index < fParams.fSendAudioChannels; audio_port_index++) {
301 fAudioCaptureBuffer[audio_port_index] =
new float[fParams.fPeriodSize];
302 fNetAudioCaptureBuffer->SetBuffer(audio_port_index, fAudioCaptureBuffer[audio_port_index]);
306 if (fParams.fSendMidiChannels > 0) {
307 fMidiCaptureBuffer =
new JackMidiBuffer*[fParams.fSendMidiChannels];
308 for (
int midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++) {
309 fMidiCaptureBuffer[midi_port_index] = (
JackMidiBuffer*)
new float[fParams.fPeriodSize];
310 fNetMidiCaptureBuffer->SetBuffer(midi_port_index, fMidiCaptureBuffer[midi_port_index]);
314 if (fParams.fReturnAudioChannels > 0) {
315 fAudioPlaybackBuffer =
new float*[fParams.fReturnAudioChannels];
316 for (
int audio_port_index = 0; audio_port_index < fParams.fReturnAudioChannels; audio_port_index++) {
317 fAudioPlaybackBuffer[audio_port_index] =
new float[fParams.fPeriodSize];
318 fNetAudioPlaybackBuffer->SetBuffer(audio_port_index, fAudioPlaybackBuffer[audio_port_index]);
322 if (fParams.fReturnMidiChannels > 0) {
323 fMidiPlaybackBuffer =
new JackMidiBuffer*[fParams.fReturnMidiChannels];
324 for (
int midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++) {
325 fMidiPlaybackBuffer[midi_port_index] = (
JackMidiBuffer*)
new float[fParams.fPeriodSize];
326 fNetMidiPlaybackBuffer->SetBuffer(midi_port_index, fMidiPlaybackBuffer[midi_port_index]);
333 if (fAudioPlaybackBuffer) {
334 for (
int audio_port_index = 0; audio_port_index < fParams.fSendAudioChannels; audio_port_index++)
335 delete[] fAudioPlaybackBuffer[audio_port_index];
336 delete[] fAudioPlaybackBuffer;
337 fAudioPlaybackBuffer = NULL;
340 if (fMidiPlaybackBuffer) {
341 for (
int midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++)
342 delete[] (fMidiPlaybackBuffer[midi_port_index]);
343 delete[] fMidiPlaybackBuffer;
344 fMidiPlaybackBuffer = NULL;
347 if (fAudioCaptureBuffer) {
348 for (
int audio_port_index = 0; audio_port_index < fParams.fReturnAudioChannels; audio_port_index++)
349 delete[] fAudioCaptureBuffer[audio_port_index];
350 delete[] fAudioCaptureBuffer;
351 fAudioCaptureBuffer = NULL;
354 if (fMidiCaptureBuffer) {
355 for (
int midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++)
356 delete[] fMidiCaptureBuffer[midi_port_index];
357 delete[] fMidiCaptureBuffer;
358 fMidiCaptureBuffer = NULL;
362 int Read(
int audio_input,
float** audio_input_buffer,
int midi_input,
void** midi_input_buffer)
365 assert(audio_input == fParams.fReturnAudioChannels);
367 for (
int audio_port_index = 0; audio_port_index < audio_input; audio_port_index++) {
368 fNetAudioPlaybackBuffer->SetBuffer(audio_port_index, audio_input_buffer[audio_port_index]);
371 for (
int midi_port_index = 0; midi_port_index < midi_input; midi_port_index++) {
372 fNetMidiPlaybackBuffer->SetBuffer(midi_port_index, ((
JackMidiBuffer**)midi_input_buffer)[midi_port_index]);
375 if (SyncRecv() == SOCKET_ERROR) {
388 int Write(
int audio_output,
float** audio_output_buffer,
int midi_output,
void** midi_output_buffer)
391 assert(audio_output == fParams.fSendAudioChannels);
393 for (
int audio_port_index = 0; audio_port_index < audio_output; audio_port_index++) {
394 fNetAudioCaptureBuffer->SetBuffer(audio_port_index, audio_output_buffer[audio_port_index]);
397 for (
int midi_port_index = 0; midi_port_index < midi_output; midi_port_index++) {
398 fNetMidiCaptureBuffer->SetBuffer(midi_port_index, ((
JackMidiBuffer**)midi_output_buffer)[midi_port_index]);
403 if (SyncSend() == SOCKET_ERROR) {
416 void EncodeTransportData()
419 void DecodeTransportData()
428 JackNetSlaveProcessCallback fProcessCallback;
431 JackNetSlaveShutdownCallback fShutdownCallback;
434 JackNetSlaveBufferSizeCallback fBufferSizeCallback;
435 void* fBufferSizeArg;
437 JackNetSlaveSampleRateCallback fSampleRateCallback;
438 void* fSampleRateArg;
441 float** fAudioCaptureBuffer;
442 float** fAudioPlaybackBuffer;
454 fProcessCallback(NULL),fProcessArg(NULL),
455 fShutdownCallback(NULL), fShutdownArg(NULL),
456 fBufferSizeCallback(NULL), fBufferSizeArg(NULL),
457 fSampleRateCallback(NULL), fSampleRateArg(NULL),
458 fAudioCaptureBuffer(NULL), fAudioPlaybackBuffer(NULL),
459 fMidiCaptureBuffer(NULL), fMidiPlaybackBuffer(NULL)
461 char host_name[JACK_CLIENT_NAME_SIZE];
464 assert(strlen(ip) < 32);
465 strcpy(fMulticastIP, ip);
466 fParams.fMtu = request->mtu;
467 fParams.fTransportSync = 0;
468 fParams.fSendAudioChannels = request->audio_input;
469 fParams.fReturnAudioChannels = request->audio_output;
470 fParams.fSendMidiChannels = request->midi_input;
471 fParams.fReturnMidiChannels = request->midi_output;
472 fParams.fNetworkLatency = request->latency;
473 fParams.fSampleEncoder = request->encoder;
474 fParams.fKBps = request->kbps;
475 fParams.fSlaveSyncMode = 1;
476 fConnectTimeOut = request->time_out;
479 GetHostName(host_name, JACK_CLIENT_NAME_SIZE);
480 snprintf(fParams.fName, JACK_CLIENT_NAME_SIZE,
"%s_%s", host_name, name);
481 fSocket.GetName(fParams.fSlaveNetName);
484 fSocket.SetPort(port);
485 fSocket.SetAddress(fMulticastIP, port);
493 if (fParams.fNetworkLatency > NETWORK_MAX_LATENCY) {
494 jack_error(
"Error : network latency is limited to %d", NETWORK_MAX_LATENCY);
499 if (!JackNetSlaveInterface::InitConnection(fConnectTimeOut)) {
505 if (!JackNetSlaveInterface::InitRendering()) {
517 if (result != NULL) {
518 result->buffer_size = fParams.fPeriodSize;
519 result->sample_rate = fParams.fSampleRate;
520 result->audio_input = fParams.fSendAudioChannels;
521 result->audio_output = fParams.fReturnAudioChannels;
522 result->midi_input = fParams.fSendMidiChannels;
523 result->midi_output = fParams.fReturnMidiChannels;
524 strcpy(result->master_name, fParams.fMasterNetName);
534 if (fShutdownCallback) {
535 fShutdownCallback(fShutdownArg);
539 if (!JackNetSlaveInterface::InitConnection(fConnectTimeOut)) {
545 if (!JackNetSlaveInterface::InitRendering()) {
557 if (fBufferSizeCallback) {
558 fBufferSizeCallback(fParams.fPeriodSize, fBufferSizeArg);
561 if (fSampleRateCallback) {
562 fSampleRateCallback(fParams.fSampleRate, fSampleRateArg);
579 fAudioCaptureBuffer =
new float*[fParams.fSendAudioChannels];
580 for (
int audio_port_index = 0; audio_port_index < fParams.fSendAudioChannels; audio_port_index++) {
581 fAudioCaptureBuffer[audio_port_index] =
new float[fParams.fPeriodSize];
582 fNetAudioCaptureBuffer->SetBuffer(audio_port_index, fAudioCaptureBuffer[audio_port_index]);
585 fMidiCaptureBuffer =
new JackMidiBuffer*[fParams.fSendMidiChannels];
586 for (
int midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++) {
587 fMidiCaptureBuffer[midi_port_index] = (
JackMidiBuffer*)
new float[fParams.fPeriodSize];
588 fNetMidiCaptureBuffer->SetBuffer(midi_port_index, fMidiCaptureBuffer[midi_port_index]);
591 fAudioPlaybackBuffer =
new float*[fParams.fReturnAudioChannels];
592 for (
int audio_port_index = 0; audio_port_index < fParams.fReturnAudioChannels; audio_port_index++) {
593 fAudioPlaybackBuffer[audio_port_index] =
new float[fParams.fPeriodSize];
594 fNetAudioPlaybackBuffer->SetBuffer(audio_port_index, fAudioPlaybackBuffer[audio_port_index]);
597 fMidiPlaybackBuffer =
new JackMidiBuffer*[fParams.fReturnMidiChannels];
598 for (
int midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++) {
599 fMidiPlaybackBuffer[midi_port_index] = (
JackMidiBuffer*)
new float[fParams.fPeriodSize];
600 fNetMidiPlaybackBuffer->SetBuffer(midi_port_index, fMidiPlaybackBuffer[midi_port_index]);
606 if (fAudioCaptureBuffer) {
607 for (
int audio_port_index = 0; audio_port_index < fParams.fSendAudioChannels; audio_port_index++)
608 delete[] fAudioCaptureBuffer[audio_port_index];
609 delete[] fAudioCaptureBuffer;
610 fAudioCaptureBuffer = NULL;
613 if (fMidiCaptureBuffer) {
614 for (
int midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++)
615 delete[] (fMidiCaptureBuffer[midi_port_index]);
616 delete[] fMidiCaptureBuffer;
617 fMidiCaptureBuffer = NULL;
620 if (fAudioPlaybackBuffer) {
621 for (
int audio_port_index = 0; audio_port_index < fParams.fReturnAudioChannels; audio_port_index++)
622 delete[] fAudioPlaybackBuffer[audio_port_index];
623 delete[] fAudioPlaybackBuffer;
624 fAudioPlaybackBuffer = NULL;
627 if (fMidiPlaybackBuffer) {
628 for (
int midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++)
629 delete[] fMidiPlaybackBuffer[midi_port_index];
630 delete[] fMidiPlaybackBuffer;
631 fMidiPlaybackBuffer = NULL;
636 void EncodeTransportData()
639 void DecodeTransportData()
645 UInt64 period, constraint;
646 period = constraint = UInt64(1000000000.f * (
float(fParams.fPeriodSize) /
float(fParams.fSampleRate)));
647 UInt64 computation = JackTools::ComputationMicroSec(fParams.fPeriodSize) * 1000;
648 fThread.SetParams(period, computation, constraint);
650 return (fThread.AcquireSelfRealTime(80) == 0);
657 while (fThread.GetStatus() == JackThread::kRunning) {
658 if (Process() == SOCKET_ERROR) {
667 fThread.DropRealTime();
668 fThread.SetStatus(JackThread::kIniting);
670 if (Restart() == 0 &&
Init()) {
671 fThread.SetStatus(JackThread::kRunning);
682 if (SyncRecv() == SOCKET_ERROR) {
694 if (SyncSend() == SOCKET_ERROR) {
704 if (Read() == SOCKET_ERROR) {
708 fProcessCallback(fParams.fPeriodSize,
709 fParams.fSendAudioChannels,
711 fParams.fSendMidiChannels,
712 (
void**)fMidiCaptureBuffer,
713 fParams.fReturnAudioChannels,
714 fAudioPlaybackBuffer,
715 fParams.fReturnMidiChannels,
716 (
void**)fMidiPlaybackBuffer,
720 if (Write() == SOCKET_ERROR) {
729 return (fProcessCallback == 0) ? -1 : fThread.StartSync();
734 return (fProcessCallback == 0) ? -1 : fThread.Kill();
738 int SetProcessCallback(JackNetSlaveProcessCallback net_callback,
void *arg)
740 if (fThread.GetStatus() == JackThread::kRunning) {
743 fProcessCallback = net_callback;
749 int SetShutdownCallback(JackNetSlaveShutdownCallback shutdown_callback,
void *arg)
751 if (fThread.GetStatus() == JackThread::kRunning) {
754 fShutdownCallback = shutdown_callback;
760 int SetBufferSizeCallback(JackNetSlaveBufferSizeCallback bufsize_callback,
void *arg)
762 if (fThread.GetStatus() == JackThread::kRunning) {
765 fBufferSizeCallback = bufsize_callback;
766 fBufferSizeArg = arg;
771 int SetSampleRateCallback(JackNetSlaveSampleRateCallback samplerate_callback,
void *arg)
773 if (fThread.GetStatus() == JackThread::kRunning) {
776 fSampleRateCallback = samplerate_callback;
777 fSampleRateArg = arg;
787 jack_nframes_t host_buffer_size,
788 jack_nframes_t host_sample_rate,
789 jack_nframes_t adapted_buffer_size,
790 jack_nframes_t adapted_sample_rate)
793 fCaptureChannels = input;
794 fPlaybackChannels = output;
802 if (fCaptureChannels > 0) {
805 if (fPlaybackChannels > 0) {
810 AdaptRingBufferSize();
811 jack_info(
"Ringbuffer automatic adaptative mode size = %d frames", fRingbufferCurSize);
813 if (fRingbufferCurSize > DEFAULT_RB_SIZE) {
814 fRingbufferCurSize = DEFAULT_RB_SIZE;
816 jack_info(
"Fixed ringbuffer size = %d frames", fRingbufferCurSize);
819 for (
int i = 0; i < fCaptureChannels; i++ ) {
821 fCaptureRingBuffer[i]->Reset(fRingbufferCurSize);
823 for (
int i = 0; i < fPlaybackChannels; i++ ) {
825 fPlaybackRingBuffer[i]->Reset(fRingbufferCurSize);
828 if (fCaptureChannels > 0) {
829 jack_log(
"ReadSpace = %ld", fCaptureRingBuffer[0]->ReadSpace());
831 if (fPlaybackChannels > 0) {
832 jack_log(
"WriteSpace = %ld", fPlaybackRingBuffer[0]->WriteSpace());
843 for (
int i = 0; i < fCaptureChannels; i++ ) {
844 fCaptureRingBuffer[i]->Reset(fRingbufferCurSize);
846 for (
int i = 0; i < fPlaybackChannels; i++ ) {
847 fPlaybackRingBuffer[i]->Reset(fRingbufferCurSize);
856 using namespace Jack;
858 SERVER_EXPORT jack_net_slave_t* jack_net_slave_open(
const char* ip,
int port,
const char* name,
jack_slave_t* request,
jack_master_t* result)
861 if (slave->Open(result) == 0) {
862 return (jack_net_slave_t*)slave;
869 SERVER_EXPORT
int jack_net_slave_close(jack_net_slave_t* net)
877 SERVER_EXPORT
int jack_set_net_slave_process_callback(jack_net_slave_t* net, JackNetSlaveProcessCallback net_callback,
void *arg)
880 return slave->SetProcessCallback(net_callback, arg);
883 SERVER_EXPORT
int jack_net_slave_activate(jack_net_slave_t* net)
886 return slave->Start();
889 SERVER_EXPORT
int jack_net_slave_deactivate(jack_net_slave_t* net)
892 return slave->Stop();
895 SERVER_EXPORT
int jack_set_net_slave_buffer_size_callback(jack_net_slave_t *net, JackNetSlaveBufferSizeCallback bufsize_callback,
void *arg)
898 return slave->SetBufferSizeCallback(bufsize_callback, arg);
901 SERVER_EXPORT
int jack_set_net_slave_sample_rate_callback(jack_net_slave_t *net, JackNetSlaveSampleRateCallback samplerate_callback,
void *arg)
904 return slave->SetSampleRateCallback(samplerate_callback, arg);
907 SERVER_EXPORT
int jack_set_net_slave_shutdown_callback(jack_net_slave_t *net, JackNetSlaveShutdownCallback shutdown_callback,
void *arg)
910 return slave->SetShutdownCallback(shutdown_callback, arg);
915 SERVER_EXPORT jack_net_master_t* jack_net_master_open(
const char* ip,
int port,
const char* name,
jack_master_t* request,
jack_slave_t* result)
918 if (master->Open(result) == 0) {
919 return (jack_net_master_t*)master;
926 SERVER_EXPORT
int jack_net_master_close(jack_net_master_t* net)
933 SERVER_EXPORT
int jack_net_master_recv(jack_net_master_t* net,
int audio_input,
float** audio_input_buffer,
int midi_input,
void** midi_input_buffer)
936 return master->Read(audio_input, audio_input_buffer, midi_input, midi_input_buffer);
939 SERVER_EXPORT
int jack_net_master_send(jack_net_master_t* net,
int audio_output,
float** audio_output_buffer,
int midi_output,
void** midi_output_buffer)
942 return master->Write(audio_output, audio_output_buffer, midi_output, midi_output_buffer);
947 SERVER_EXPORT jack_adapter_t* jack_create_adapter(
int input,
int output,
948 jack_nframes_t host_buffer_size,
949 jack_nframes_t host_sample_rate,
950 jack_nframes_t adapted_buffer_size,
951 jack_nframes_t adapted_sample_rate)
954 return (jack_adapter_t*)
new JackNetAdapter(input, output, host_buffer_size, host_sample_rate, adapted_buffer_size, adapted_sample_rate);
960 SERVER_EXPORT
int jack_destroy_adapter(jack_adapter_t* adapter)
966 SERVER_EXPORT
void jack_flush_adapter(jack_adapter_t* adapter)
972 SERVER_EXPORT
int jack_adapter_push_and_pull(jack_adapter_t* adapter,
float** input,
float** output,
unsigned int frames)
975 return slave->PushAndPull(input, output, frames);
978 SERVER_EXPORT
int jack_adapter_pull_and_push(jack_adapter_t* adapter,
float** input,
float** output,
unsigned int frames)
981 return slave->PullAndPush(input, output, frames);
988 static void jack_format_and_log(
int level,
const char *prefix,
const char *fmt, va_list ap)
993 if (prefix != NULL) {
994 len = strlen(prefix);
995 memcpy(buffer, prefix, len);
1000 vsnprintf(buffer + len,
sizeof(buffer) - len, fmt, ap);
1001 printf(
"%s", buffer);
1009 jack_format_and_log(LOG_LEVEL_INFO,
"Jack: ", fmt, ap);
1017 jack_format_and_log(LOG_LEVEL_INFO,
"Jack: ", fmt, ap);
1025 jack_format_and_log(LOG_LEVEL_INFO,
"Jack: ", fmt, ap);
1033 SERVER_EXPORT
void jack_error(
const char *fmt, ...)
1036 SERVER_EXPORT
void jack_info(
const char *fmt, ...)
1039 SERVER_EXPORT
void jack_log(
const char *fmt, ...)