23 #include "JackNetInterface.h"
24 #include "JackAudioAdapterInterface.h"
33 #define MASTER_NAME_SIZE 256
63 jack_nframes_t buffer_size;
64 jack_nframes_t sample_rate;
65 char master_name[MASTER_NAME_SIZE];
73 typedef struct _jack_net_slave jack_net_slave_t;
75 typedef int (* JackNetSlaveProcessCallback) (jack_nframes_t buffer_size,
77 float** audio_input_buffer,
79 void** midi_input_buffer,
81 float** audio_output_buffer,
83 void** midi_output_buffer,
86 typedef int (*JackNetSlaveBufferSizeCallback) (jack_nframes_t nframes,
void *arg);
87 typedef int (*JackNetSlaveSampleRateCallback) (jack_nframes_t nframes,
void *arg);
88 typedef void (*JackNetSlaveShutdownCallback) (
void* arg);
89 typedef int (*JackNetSlaveRestartCallback) (
void* arg);
90 typedef void (*JackNetSlaveErrorCallback) (
int error_code,
void* arg);
92 LIB_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);
93 LIB_EXPORT
int jack_net_slave_close(jack_net_slave_t* net);
95 LIB_EXPORT
int jack_net_slave_activate(jack_net_slave_t* net);
96 LIB_EXPORT
int jack_net_slave_deactivate(jack_net_slave_t* net);
97 LIB_EXPORT
int jack_net_slave_is_active(jack_net_slave_t* net);
99 LIB_EXPORT
int jack_set_net_slave_process_callback(jack_net_slave_t* net, JackNetSlaveProcessCallback net_callback,
void *arg);
100 LIB_EXPORT
int jack_set_net_slave_buffer_size_callback(jack_net_slave_t* net, JackNetSlaveBufferSizeCallback bufsize_callback,
void *arg);
101 LIB_EXPORT
int jack_set_net_slave_sample_rate_callback(jack_net_slave_t* net, JackNetSlaveSampleRateCallback samplerate_callback,
void *arg);
102 LIB_EXPORT
int jack_set_net_slave_shutdown_callback(jack_net_slave_t* net, JackNetSlaveShutdownCallback shutdown_callback,
void *arg);
103 LIB_EXPORT
int jack_set_net_slave_restart_callback(jack_net_slave_t* net, JackNetSlaveRestartCallback restart_callback,
void *arg);
104 LIB_EXPORT
int jack_set_net_slave_error_callback(jack_net_slave_t* net, JackNetSlaveErrorCallback error_callback,
void *arg);
108 typedef struct _jack_net_master jack_net_master_t;
110 LIB_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);
111 LIB_EXPORT
int jack_net_master_close(jack_net_master_t* net);
113 LIB_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);
114 LIB_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);
116 LIB_EXPORT
int jack_net_master_recv_slice(jack_net_master_t* net,
int audio_input,
float** audio_input_buffer,
int midi_input,
void** midi_input_buffer,
int frames);
117 LIB_EXPORT
int jack_net_master_send_slice(jack_net_master_t* net,
int audio_output,
float** audio_output_buffer,
int midi_output,
void** midi_output_buffer,
int frames);
121 typedef struct _jack_adapter jack_adapter_t;
123 LIB_EXPORT jack_adapter_t* jack_create_adapter(
int input,
int output,
124 jack_nframes_t host_buffer_size,
125 jack_nframes_t host_sample_rate,
126 jack_nframes_t adapted_buffer_size,
127 jack_nframes_t adapted_sample_rate);
128 LIB_EXPORT
int jack_destroy_adapter(jack_adapter_t* adapter);
129 LIB_EXPORT
void jack_flush_adapter(jack_adapter_t* adapter);
131 LIB_EXPORT
int jack_adapter_push_and_pull(jack_adapter_t* adapter,
float** input,
float** output,
unsigned int frames);
132 LIB_EXPORT
int jack_adapter_pull_and_push(jack_adapter_t* adapter,
float** input,
float** output,
unsigned int frames);
134 #define LOG_LEVEL_INFO 1
135 #define LOG_LEVEL_ERROR 2
137 LIB_EXPORT
void jack_error(
const char *fmt, ...);
138 LIB_EXPORT
void jack_info(
const char *fmt, ...);
139 LIB_EXPORT
void jack_log(
const char *fmt, ...);
160 assert(strlen(ip) < 32);
161 strcpy(fMulticastIP, ip);
162 fSocket.SetPort(port);
163 fRequest.buffer_size = request->buffer_size;
164 fRequest.sample_rate = request->sample_rate;
165 fRequest.audio_input = request->audio_input;
166 fRequest.audio_output = request->audio_output;
167 fRequest.time_out = request->time_out;
168 fRequest.partial_cycle = request->partial_cycle;
175 for (
int i = 0; i < fParams.fReturnAudioChannels; i++) {
176 delete fRingBuffer[i];
178 delete [] fRingBuffer;
185 if (fRequest.buffer_size == 0) {
190 if (fRequest.sample_rate == 0) {
196 if (SocketAPIInit() < 0) {
197 jack_error(
"Can't init Socket API, exiting...");
202 if (fSocket.NewSocket() == SOCKET_ERROR) {
203 jack_error(
"Can't create the network management input socket : %s", StrError(NET_ERROR_CODE));
208 if (fSocket.Bind() == SOCKET_ERROR) {
209 jack_error(
"Can't bind the network manager socket : %s", StrError(NET_ERROR_CODE));
215 if (fSocket.JoinMCastGroup(fMulticastIP) == SOCKET_ERROR) {
216 jack_error(
"Can't join multicast group : %s", StrError(NET_ERROR_CODE));
220 if (fSocket.SetLocalLoop() == SOCKET_ERROR) {
221 jack_error(
"Can't set local loop : %s", StrError(NET_ERROR_CODE));
225 if (fSocket.SetTimeOut(MANAGER_INIT_TIMEOUT) == SOCKET_ERROR) {
226 jack_error(
"Can't set timeout : %s", StrError(NET_ERROR_CODE));
232 int try_count = (fRequest.time_out > 0) ?
int((1000000.f *
float(fRequest.time_out)) / float(MANAGER_INIT_TIMEOUT)) : INT_MAX;
238 SessionParamsNToH(&net_params, &fParams);
240 if ((rx_bytes == SOCKET_ERROR) && (fSocket.GetError() != NET_NO_DATA)) {
241 jack_error(
"Error in receive : %s", StrError(NET_ERROR_CODE));
242 if (++attempt == 10) {
243 jack_error(
"Can't receive on the socket, exiting net manager" );
249 switch (GetPacketType(&fParams)) {
251 case SLAVE_AVAILABLE:
253 SessionParamsDisplay(&fParams);
270 while (fRunning && (--try_count > 0));
272 if (try_count == 0) {
278 result->audio_input = fParams.fSendAudioChannels;
279 result->audio_output = fParams.fReturnAudioChannels;
280 result->midi_input = fParams.fSendMidiChannels;
281 result->midi_output = fParams.fReturnMidiChannels;
282 result->mtu = fParams.fMtu;
283 result->latency = fParams.fNetworkLatency;
286 if (fRequest.partial_cycle && result->latency > 0) {
288 for (
int i = 0; i < fParams.fReturnAudioChannels; i++) {
289 fRingBuffer[i] =
new JackRingBuffer(fRequest.buffer_size * result->latency * 2);
302 if (fParams.fProtocolVersion != NETWORK_PROTOCOL) {
303 jack_error(
"Error : slave '%s' is running with a different protocol %d != %d", fParams.fName, fParams.fProtocolVersion, NETWORK_PROTOCOL);
308 fSocket.GetName(fParams.fMasterNetName);
310 fParams.fPeriodSize = fRequest.buffer_size;
311 fParams.fSampleRate = fRequest.sample_rate;
313 if (fRequest.audio_input == -1) {
314 if (fParams.fSendAudioChannels == -1) {
315 jack_error(
"Error : master and slave use -1 for wanted inputs...");
318 result->audio_input = fParams.fSendAudioChannels;
319 jack_info(
"Takes slave %d inputs", fParams.fSendAudioChannels);
321 }
else if (fParams.fSendAudioChannels == -1) {
322 fParams.fSendAudioChannels = fRequest.audio_input;
323 jack_info(
"Takes master %d inputs", fRequest.audio_input);
324 }
else if (fParams.fSendAudioChannels != fRequest.audio_input) {
325 jack_error(
"Error : master wants %d inputs and slave wants %d inputs...", fRequest.audio_input, fParams.fSendAudioChannels);
329 if (fRequest.audio_output == -1) {
330 if (fParams.fReturnAudioChannels == -1) {
331 jack_error(
"Error : master and slave use -1 for wanted outputs...");
334 result->audio_output = fParams.fReturnAudioChannels;
335 jack_info(
"Takes slave %d outputs", fParams.fReturnAudioChannels);
337 }
else if (fParams.fReturnAudioChannels == -1) {
338 fParams.fReturnAudioChannels = fRequest.audio_output;
339 jack_info(
"Takes master %d outputs", fRequest.audio_output);
340 }
else if (fParams.fReturnAudioChannels != fRequest.audio_output) {
341 jack_error(
"Error : master wants %d outputs and slave wants %d outputs...", fRequest.audio_output, fParams.fReturnAudioChannels);
349 if (!JackNetMasterInterface::Init()) {
367 void UseRingBuffer(
int audio_input,
float** audio_input_buffer,
int write,
int read)
371 for (
int i = 0; i < audio_input; i++) {
372 fRingBuffer[i]->Write(audio_input_buffer[i], write);
373 fRingBuffer[i]->Read(audio_input_buffer[i], read);
378 int Read(
int audio_input,
float** audio_input_buffer,
int midi_input,
void** midi_input_buffer,
int frames)
383 if (frames < 0) frames = fParams.fPeriodSize;
386 assert(audio_input == fParams.fReturnAudioChannels);
388 for (
int audio_port_index = 0; audio_port_index < audio_input; audio_port_index++) {
389 fNetAudioPlaybackBuffer->SetBuffer(audio_port_index, audio_input_buffer[audio_port_index]);
392 for (
int midi_port_index = 0; midi_port_index < midi_input; midi_port_index++) {
393 fNetMidiPlaybackBuffer->SetBuffer(midi_port_index, ((
JackMidiBuffer**)midi_input_buffer)[midi_port_index]);
396 int res1 = SyncRecv();
401 for (
int audio_port_index = 0; audio_port_index < audio_input; audio_port_index++) {
402 memset(audio_input_buffer[audio_port_index], 0,
sizeof(
float) * fParams.fPeriodSize);
404 UseRingBuffer(audio_input, audio_input_buffer, fParams.fPeriodSize, frames);
410 case SYNC_PACKET_ERROR:
416 DecodeSyncPacket(read_frames);
420 int res2 = DataRecv();
421 UseRingBuffer(audio_input, audio_input_buffer, read_frames, frames);
430 int Write(
int audio_output,
float** audio_output_buffer,
int midi_output,
void** midi_output_buffer,
int frames)
435 if (frames < 0) frames = fParams.fPeriodSize;
437 assert(audio_output == fParams.fSendAudioChannels);
439 for (
int audio_port_index = 0; audio_port_index < audio_output; audio_port_index++) {
440 fNetAudioCaptureBuffer->SetBuffer(audio_port_index, audio_output_buffer[audio_port_index]);
443 for (
int midi_port_index = 0; midi_port_index < midi_output; midi_port_index++) {
444 fNetMidiCaptureBuffer->SetBuffer(midi_port_index, ((
JackMidiBuffer**)midi_output_buffer)[midi_port_index]);
447 EncodeSyncPacket(frames);
450 if (SyncSend() == SOCKET_ERROR) {
455 if (DataSend() == SOCKET_ERROR) {
467 void EncodeTransportData()
470 void DecodeTransportData()
478 float** fAudioCaptureBuffer;
479 float** fAudioPlaybackBuffer;
486 JackNetSlaveProcessCallback fProcessCallback;
489 JackNetSlaveShutdownCallback fShutdownCallback;
492 JackNetSlaveRestartCallback fRestartCallback;
495 JackNetSlaveErrorCallback fErrorCallback;
498 JackNetSlaveBufferSizeCallback fBufferSizeCallback;
499 void* fBufferSizeArg;
501 JackNetSlaveSampleRateCallback fSampleRateCallback;
502 void* fSampleRateArg;
512 fProcessCallback(NULL),fProcessArg(NULL),
513 fShutdownCallback(NULL), fShutdownArg(NULL),
514 fRestartCallback(NULL), fRestartArg(NULL),
515 fErrorCallback(NULL), fErrorArg(NULL),
516 fBufferSizeCallback(NULL), fBufferSizeArg(NULL),
517 fSampleRateCallback(NULL), fSampleRateArg(NULL)
519 char host_name[JACK_CLIENT_NAME_SIZE];
522 assert(strlen(ip) < 32);
523 strcpy(fMulticastIP, ip);
524 fParams.fMtu = request->mtu;
525 fParams.fTransportSync = 0;
526 fParams.fSendAudioChannels = request->audio_input;
527 fParams.fReturnAudioChannels = request->audio_output;
528 fParams.fSendMidiChannels = request->midi_input;
529 fParams.fReturnMidiChannels = request->midi_output;
530 fParams.fNetworkLatency = request->latency;
531 fParams.fSampleEncoder = request->encoder;
532 fParams.fKBps = request->kbps;
533 fParams.fSlaveSyncMode = 1;
534 fConnectTimeOut = request->time_out;
537 GetHostName(host_name, JACK_CLIENT_NAME_SIZE);
538 snprintf(fParams.fName, JACK_CLIENT_NAME_SIZE,
"%s_%s", host_name, name);
539 fSocket.GetName(fParams.fSlaveNetName);
542 fSocket.SetPort(port);
543 fSocket.SetAddress(fMulticastIP, port);
545 fAudioCaptureBuffer = NULL;
546 fAudioPlaybackBuffer = NULL;
547 fMidiCaptureBuffer = NULL;
548 fMidiPlaybackBuffer = NULL;
557 if (fParams.fSendAudioChannels > 0) {
558 fAudioCaptureBuffer =
new float*[fParams.fSendAudioChannels];
559 for (
int audio_port_index = 0; audio_port_index < fParams.fSendAudioChannels; audio_port_index++) {
560 fAudioCaptureBuffer[audio_port_index] =
new float[fParams.fPeriodSize];
561 memset(fAudioCaptureBuffer[audio_port_index], 0,
sizeof(
float) * fParams.fPeriodSize);
562 fNetAudioCaptureBuffer->SetBuffer(audio_port_index, fAudioCaptureBuffer[audio_port_index]);
566 if (fParams.fSendMidiChannels > 0) {
567 fMidiCaptureBuffer =
new JackMidiBuffer*[fParams.fSendMidiChannels];
568 for (
int midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++) {
569 fMidiCaptureBuffer[midi_port_index] = (
JackMidiBuffer*)
new float[fParams.fPeriodSize];
570 memset(fMidiCaptureBuffer[midi_port_index], 0,
sizeof(
float) * fParams.fPeriodSize);
571 fNetMidiCaptureBuffer->SetBuffer(midi_port_index, fMidiCaptureBuffer[midi_port_index]);
575 if (fParams.fReturnAudioChannels > 0) {
576 fAudioPlaybackBuffer =
new float*[fParams.fReturnAudioChannels];
577 for (
int audio_port_index = 0; audio_port_index < fParams.fReturnAudioChannels; audio_port_index++) {
578 fAudioPlaybackBuffer[audio_port_index] =
new float[fParams.fPeriodSize];
579 memset(fAudioPlaybackBuffer[audio_port_index], 0,
sizeof(
float) * fParams.fPeriodSize);
580 fNetAudioPlaybackBuffer->SetBuffer(audio_port_index, fAudioPlaybackBuffer[audio_port_index]);
584 if (fParams.fReturnMidiChannels > 0) {
585 fMidiPlaybackBuffer =
new JackMidiBuffer*[fParams.fReturnMidiChannels];
586 for (
int midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++) {
587 fMidiPlaybackBuffer[midi_port_index] = (
JackMidiBuffer*)
new float[fParams.fPeriodSize];
588 memset(fMidiPlaybackBuffer[midi_port_index], 0,
sizeof(
float) * fParams.fPeriodSize);
589 fNetMidiPlaybackBuffer->SetBuffer(midi_port_index, fMidiPlaybackBuffer[midi_port_index]);
596 if (fAudioCaptureBuffer) {
597 for (
int audio_port_index = 0; audio_port_index < fParams.fSendAudioChannels; audio_port_index++) {
598 delete[] fAudioCaptureBuffer[audio_port_index];
600 delete[] fAudioCaptureBuffer;
601 fAudioCaptureBuffer = NULL;
604 if (fMidiCaptureBuffer) {
605 for (
int midi_port_index = 0; midi_port_index < fParams.fSendMidiChannels; midi_port_index++) {
606 delete[] fMidiCaptureBuffer[midi_port_index];
608 delete[] fMidiCaptureBuffer;
609 fMidiCaptureBuffer = NULL;
612 if (fAudioPlaybackBuffer) {
613 for (
int audio_port_index = 0; audio_port_index < fParams.fReturnAudioChannels; audio_port_index++) {
614 delete[] fAudioPlaybackBuffer[audio_port_index];
616 delete[] fAudioPlaybackBuffer;
617 fAudioPlaybackBuffer = NULL;
620 if (fMidiPlaybackBuffer) {
621 for (
int midi_port_index = 0; midi_port_index < fParams.fReturnMidiChannels; midi_port_index++) {
622 delete[] (fMidiPlaybackBuffer[midi_port_index]);
624 delete[] fMidiPlaybackBuffer;
625 fMidiPlaybackBuffer = NULL;
632 if (fParams.fSendAudioChannels == 0
633 && fParams.fReturnAudioChannels == 0
634 && fParams.fSendMidiChannels == 0
635 && fParams.fReturnMidiChannels == 0) {
636 jack_error(
"Incorrect audio/midi channels number...");
641 if ((fParams.fMtu < DEFAULT_MTU) && (fParams.fMtu > MAX_MTU)) {
642 jack_error(
"MTU is not in the expected range [%d ... %d]", DEFAULT_MTU, MAX_MTU);
647 if ((fParams.fSampleEncoder == JackCeltEncoder) && (fParams.fKBps == 0)) {
652 if ((fParams.fSampleEncoder == JackOpusEncoder) && (fParams.fKBps == 0)) {
658 if (fParams.fNetworkLatency > NETWORK_MAX_LATENCY) {
659 jack_error(
"Network latency is limited to %d", NETWORK_MAX_LATENCY);
664 if (!JackNetSlaveInterface::InitConnection(fConnectTimeOut)) {
670 if (!JackNetSlaveInterface::InitRendering()) {
682 if (result != NULL) {
683 result->buffer_size = fParams.fPeriodSize;
684 result->sample_rate = fParams.fSampleRate;
685 result->audio_input = fParams.fSendAudioChannels;
686 result->audio_output = fParams.fReturnAudioChannels;
687 result->midi_input = fParams.fSendMidiChannels;
688 result->midi_output = fParams.fReturnMidiChannels;
689 strcpy(result->master_name, fParams.fMasterNetName);
693 fFrames = fParams.fPeriodSize;
695 SessionParamsDisplay(&fParams);
707 if (fRestartCallback) {
708 if (fRestartCallback(fRestartArg) != 0) {
712 }
else if (fShutdownCallback) {
713 fShutdownCallback(fShutdownArg);
717 if (!JackNetSlaveInterface::InitConnection(fConnectTimeOut)) {
718 jack_error(
"Initing network fails after time_out, retry...");
725 if (!JackNetSlaveInterface::InitRendering()) {
737 if (fBufferSizeCallback) {
738 if (fBufferSizeCallback(fParams.fPeriodSize, fBufferSizeArg) != 0) {
739 jack_error(
"New buffer size = %d cannot be used...", fParams.fPeriodSize);
744 if (fSampleRateCallback) {
745 if (fSampleRateCallback(fParams.fSampleRate, fSampleRateArg) != 0) {
746 jack_error(
"New sample rate = %d cannot be used...", fParams.fSampleRate);
763 void EncodeTransportData()
766 void DecodeTransportData()
772 UInt64 period, constraint;
773 period = constraint = UInt64(1000000000.f * (
float(fParams.fPeriodSize) /
float(fParams.fSampleRate)));
774 UInt64 computation = JackTools::ComputationMicroSec(fParams.fPeriodSize) * 1000;
775 fThread.SetParams(period, computation, constraint);
777 return (fThread.AcquireSelfRealTime(80) == 0);
782 return (fThread.GetStatus() == JackThread::kRunning);
795 while (fThread.GetStatus() == JackThread::kRunning) {
796 if (Process() == SOCKET_ERROR) {
805 fThread.DropRealTime();
806 fThread.SetStatus(JackThread::kIniting);
808 if (Restart() == 0 &&
Init()) {
809 fThread.SetStatus(JackThread::kRunning);
820 switch (SyncRecv()) {
825 case SYNC_PACKET_ERROR:
827 if (fErrorCallback) {
828 fErrorCallback(SYNC_PACKET_ERROR, fErrorArg);
834 DecodeSyncPacket(fFrames);
838 int res = DataRecv();
839 if (res == DATA_PACKET_ERROR && fErrorCallback) {
840 fErrorCallback(DATA_PACKET_ERROR, fErrorArg);
847 EncodeSyncPacket(fFrames);
849 if (SyncSend() == SOCKET_ERROR) {
859 SetPacketTimeOut(INT_MAX);
865 SetPacketTimeOut(PACKET_TIMEOUT * fParams.fNetworkLatency);
871 if (Read() == SOCKET_ERROR) {
875 if (fFrames < 0) fFrames = fParams.fPeriodSize;
877 fProcessCallback(fFrames,
878 fParams.fSendAudioChannels,
880 fParams.fSendMidiChannels,
881 (
void**)fMidiCaptureBuffer,
882 fParams.fReturnAudioChannels,
883 fAudioPlaybackBuffer,
884 fParams.fReturnMidiChannels,
885 (
void**)fMidiPlaybackBuffer,
889 if (Write() == SOCKET_ERROR) {
898 return (fProcessCallback == 0) ? -1 : fThread.StartSync();
903 return (fProcessCallback == 0) ? -1 : fThread.Kill();
907 int SetProcessCallback(JackNetSlaveProcessCallback net_callback,
void *arg)
909 if (fThread.GetStatus() == JackThread::kRunning) {
912 fProcessCallback = net_callback;
918 int SetShutdownCallback(JackNetSlaveShutdownCallback shutdown_callback,
void *arg)
920 if (fThread.GetStatus() == JackThread::kRunning) {
923 fShutdownCallback = shutdown_callback;
929 int SetRestartCallback(JackNetSlaveRestartCallback restart_callback,
void *arg)
931 if (fThread.GetStatus() == JackThread::kRunning) {
934 fRestartCallback = restart_callback;
940 int SetErrorCallback(JackNetSlaveErrorCallback error_callback,
void *arg)
942 if (fThread.GetStatus() == JackThread::kRunning) {
945 fErrorCallback = error_callback;
951 int SetBufferSizeCallback(JackNetSlaveBufferSizeCallback bufsize_callback,
void *arg)
953 if (fThread.GetStatus() == JackThread::kRunning) {
956 fBufferSizeCallback = bufsize_callback;
957 fBufferSizeArg = arg;
962 int SetSampleRateCallback(JackNetSlaveSampleRateCallback samplerate_callback,
void *arg)
964 if (fThread.GetStatus() == JackThread::kRunning) {
967 fSampleRateCallback = samplerate_callback;
968 fSampleRateArg = arg;
978 jack_nframes_t host_buffer_size,
979 jack_nframes_t host_sample_rate,
980 jack_nframes_t adapted_buffer_size,
981 jack_nframes_t adapted_sample_rate)
984 fCaptureChannels = input;
985 fPlaybackChannels = output;
993 if (fCaptureChannels > 0) {
996 if (fPlaybackChannels > 0) {
1001 AdaptRingBufferSize();
1002 jack_info(
"Ringbuffer automatic adaptative mode size = %d frames", fRingbufferCurSize);
1004 if (fRingbufferCurSize > DEFAULT_RB_SIZE) {
1005 fRingbufferCurSize = DEFAULT_RB_SIZE;
1007 jack_info(
"Fixed ringbuffer size = %d frames", fRingbufferCurSize);
1010 for (
int i = 0; i < fCaptureChannels; i++ ) {
1012 fCaptureRingBuffer[i]->Reset(fRingbufferCurSize);
1014 for (
int i = 0; i < fPlaybackChannels; i++ ) {
1016 fPlaybackRingBuffer[i]->Reset(fRingbufferCurSize);
1019 if (fCaptureChannels > 0) {
1020 jack_log(
"ReadSpace = %ld", fCaptureRingBuffer[0]->ReadSpace());
1022 if (fPlaybackChannels > 0) {
1023 jack_log(
"WriteSpace = %ld", fPlaybackRingBuffer[0]->WriteSpace());
1034 for (
int i = 0; i < fCaptureChannels; i++ ) {
1035 fCaptureRingBuffer[i]->Reset(fRingbufferCurSize);
1037 for (
int i = 0; i < fPlaybackChannels; i++ ) {
1038 fPlaybackRingBuffer[i]->Reset(fRingbufferCurSize);
1047 using namespace Jack;
1049 LIB_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)
1052 if (slave->Open(result) == 0) {
1053 return (jack_net_slave_t*)slave;
1060 LIB_EXPORT
int jack_net_slave_close(jack_net_slave_t* net)
1068 LIB_EXPORT
int jack_set_net_slave_process_callback(jack_net_slave_t* net, JackNetSlaveProcessCallback net_callback,
void *arg)
1071 return slave->SetProcessCallback(net_callback, arg);
1074 LIB_EXPORT
int jack_net_slave_activate(jack_net_slave_t* net)
1077 return slave->Start();
1080 LIB_EXPORT
int jack_net_slave_deactivate(jack_net_slave_t* net)
1083 return slave->Stop();
1086 LIB_EXPORT
int jack_net_slave_is_active(jack_net_slave_t* net)
1089 return slave->IsRunning();
1092 LIB_EXPORT
int jack_set_net_slave_buffer_size_callback(jack_net_slave_t *net, JackNetSlaveBufferSizeCallback bufsize_callback,
void *arg)
1095 return slave->SetBufferSizeCallback(bufsize_callback, arg);
1098 LIB_EXPORT
int jack_set_net_slave_sample_rate_callback(jack_net_slave_t *net, JackNetSlaveSampleRateCallback samplerate_callback,
void *arg)
1101 return slave->SetSampleRateCallback(samplerate_callback, arg);
1104 LIB_EXPORT
int jack_set_net_slave_shutdown_callback(jack_net_slave_t *net, JackNetSlaveShutdownCallback shutdown_callback,
void *arg)
1107 return slave->SetShutdownCallback(shutdown_callback, arg);
1110 LIB_EXPORT
int jack_set_net_slave_restart_callback(jack_net_slave_t *net, JackNetSlaveRestartCallback restart_callback,
void *arg)
1113 return slave->SetRestartCallback(restart_callback, arg);
1116 LIB_EXPORT
int jack_set_net_slave_error_callback(jack_net_slave_t *net, JackNetSlaveErrorCallback error_callback,
void *arg)
1119 return slave->SetErrorCallback(error_callback, arg);
1124 LIB_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)
1127 if (master->Open(result) == 0) {
1128 return (jack_net_master_t*)master;
1135 LIB_EXPORT
int jack_net_master_close(jack_net_master_t* net)
1143 LIB_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)
1146 return master->Read(audio_input, audio_input_buffer, midi_input, midi_input_buffer, -1);
1149 LIB_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)
1152 return master->Write(audio_output, audio_output_buffer, midi_output, midi_output_buffer, -1);
1155 LIB_EXPORT
int jack_net_master_recv_slice(jack_net_master_t* net,
int audio_input,
float** audio_input_buffer,
int midi_input,
void** midi_input_buffer,
int frames)
1158 return master->Read(audio_input, audio_input_buffer, midi_input, midi_input_buffer, frames);
1161 LIB_EXPORT
int jack_net_master_send_slice(jack_net_master_t* net,
int audio_output,
float** audio_output_buffer,
int midi_output,
void** midi_output_buffer,
int frames)
1164 return master->Write(audio_output, audio_output_buffer, midi_output, midi_output_buffer, frames);
1169 LIB_EXPORT jack_adapter_t* jack_create_adapter(
int input,
int output,
1170 jack_nframes_t host_buffer_size,
1171 jack_nframes_t host_sample_rate,
1172 jack_nframes_t adapted_buffer_size,
1173 jack_nframes_t adapted_sample_rate)
1176 return (jack_adapter_t*)
new JackNetAdapter(input, output, host_buffer_size, host_sample_rate, adapted_buffer_size, adapted_sample_rate);
1182 LIB_EXPORT
int jack_destroy_adapter(jack_adapter_t* adapter)
1188 LIB_EXPORT
void jack_flush_adapter(jack_adapter_t* adapter)
1194 LIB_EXPORT
int jack_adapter_push_and_pull(jack_adapter_t* adapter,
float** input,
float** output,
unsigned int frames)
1197 return slave->PushAndPull(input, output, frames);
1200 LIB_EXPORT
int jack_adapter_pull_and_push(jack_adapter_t* adapter,
float** input,
float** output,
unsigned int frames)
1203 return slave->PullAndPush(input, output, frames);
1206 static void jack_format_and_log(
int level,
const char *prefix,
const char *fmt, va_list ap)
1208 static const char* netjack_log = getenv(
"JACK_NETJACK_LOG");
1209 static bool is_netjack_log = (netjack_log) ? atoi(netjack_log) : 0;
1211 if (is_netjack_log) {
1215 if (prefix != NULL) {
1216 len = strlen(prefix);
1217 memcpy(buffer, prefix, len);
1222 vsnprintf(buffer + len,
sizeof(buffer) - len, fmt, ap);
1223 printf(
"%s", buffer);
1228 LIB_EXPORT
void jack_error(
const char *fmt, ...)
1232 jack_format_and_log(LOG_LEVEL_INFO,
"Jack: ", fmt, ap);
1236 LIB_EXPORT
void jack_info(
const char *fmt, ...)
1240 jack_format_and_log(LOG_LEVEL_INFO,
"Jack: ", fmt, ap);
1244 LIB_EXPORT
void jack_log(
const char *fmt, ...)
1248 jack_format_and_log(LOG_LEVEL_INFO,
"Jack: ", fmt, ap);