23 #include "JackNetOneDriver.h"
24 #include "JackEngineControl.h"
25 #include "JackLockedEngine.h"
26 #include "JackGraphManager.h"
27 #include "JackWaitThreadedDriver.h"
28 #include "JackTools.h"
29 #include "driver_interface.h"
32 #include "netjack_packet.h"
35 #include <samplerate.h>
39 #include <celt/celt.h>
43 #include <opus/opus.h>
44 #include <opus/opus_custom.h>
47 #define MIN(x,y) ((x)<(y) ? (x) : (y))
53 JackNetOneDriver::JackNetOneDriver(
const char* name,
const char* alias, JackLockedEngine* engine, JackSynchro* table,
54 int port,
int mtu,
int capture_ports,
int playback_ports,
int midi_input_ports,
int midi_output_ports,
55 int sample_rate,
int period_size,
int resample_factor,
56 const char* net_name, uint transport_sync,
int bitdepth,
int use_autoconfig,
57 int latency,
int redundancy,
int dont_htonl_floats,
int always_deadline,
int jitter_val)
58 : JackWaiterDriver(name, alias, engine, table)
60 jack_log(
"JackNetOneDriver::JackNetOneDriver port %d", port);
64 WSAStartup(MAKEWORD(2, 0), &wsa);
67 netjack_init(& (this->netj),
89 JackNetOneDriver::~JackNetOneDriver()
96 int JackNetOneDriver::Close()
99 int res = JackWaiterDriver::Close();
102 netjack_release(&netj);
106 int JackNetOneDriver::Attach()
111 int JackNetOneDriver::Detach()
116 int JackNetOneDriver::AllocPorts()
118 jack_port_id_t port_index;
125 for (chn = 0; chn < netj.capture_channels_audio; chn++) {
126 snprintf (buf,
sizeof(buf) - 1,
"system:capture_%u", chn + 1);
128 if (fEngine->PortRegister(fClientControl.fRefNum, buf, JACK_DEFAULT_AUDIO_TYPE,
129 CaptureDriverFlags, fEngineControl->fBufferSize, &port_index) < 0) {
130 jack_error(
"driver: cannot register port for %s", buf);
135 netj.capture_ports = jack_slist_append (netj.capture_ports, (
void *)(intptr_t)port_index);
137 if (netj.bitdepth == CELT_MODE) {
139 #if HAVE_CELT_API_0_11
140 celt_int32 lookahead;
141 CELTMode *celt_mode = celt_mode_create(netj.sample_rate, netj.period_size, NULL);
142 netj.capture_srcs = jack_slist_append(netj.capture_srcs, celt_decoder_create_custom(celt_mode, 1, NULL));
143 #elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
144 celt_int32 lookahead;
145 CELTMode *celt_mode = celt_mode_create(netj.sample_rate, netj.period_size, NULL);
146 netj.capture_srcs = jack_slist_append(netj.capture_srcs, celt_decoder_create(celt_mode, 1, NULL));
148 celt_int32_t lookahead;
149 CELTMode *celt_mode = celt_mode_create(netj.sample_rate, 1, netj.period_size, NULL);
150 netj.capture_srcs = jack_slist_append(netj.capture_srcs, celt_decoder_create(celt_mode));
152 celt_mode_info(celt_mode, CELT_GET_LOOKAHEAD, &lookahead);
153 netj.codec_latency = 2 * lookahead;
155 }
else if (netj.bitdepth == OPUS_MODE) {
157 OpusCustomMode *opus_mode = opus_custom_mode_create(netj.sample_rate, netj.period_size, NULL);
158 OpusCustomDecoder *decoder = opus_custom_decoder_create( opus_mode, 1, NULL );
159 netj.capture_srcs = jack_slist_append(netj.capture_srcs, decoder);
163 netj.capture_srcs = jack_slist_append(netj.capture_srcs, (
void *)src_new(SRC_LINEAR, 1, NULL));
168 for (chn = netj.capture_channels_audio; chn < netj.capture_channels; chn++) {
169 snprintf (buf,
sizeof(buf) - 1,
"system:capture_%u", chn + 1);
171 if (fEngine->PortRegister(fClientControl.fRefNum, buf, JACK_DEFAULT_MIDI_TYPE,
172 CaptureDriverFlags, fEngineControl->fBufferSize, &port_index) < 0) {
173 jack_error(
"driver: cannot register port for %s", buf);
179 jack_slist_append (netj.capture_ports, (
void *)(intptr_t)port_index);
182 for (chn = 0; chn < netj.playback_channels_audio; chn++) {
183 snprintf (buf,
sizeof(buf) - 1,
"system:playback_%u", chn + 1);
185 if (fEngine->PortRegister(fClientControl.fRefNum, buf, JACK_DEFAULT_AUDIO_TYPE,
186 PlaybackDriverFlags, fEngineControl->fBufferSize, &port_index) < 0) {
187 jack_error(
"driver: cannot register port for %s", buf);
192 netj.playback_ports = jack_slist_append (netj.playback_ports, (
void *)(intptr_t)port_index);
193 if (netj.bitdepth == CELT_MODE) {
195 #if HAVE_CELT_API_0_11
196 CELTMode *celt_mode = celt_mode_create(netj.sample_rate, netj.period_size, NULL);
197 netj.playback_srcs = jack_slist_append(netj.playback_srcs, celt_encoder_create_custom(celt_mode, 1, NULL));
198 #elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
199 CELTMode *celt_mode = celt_mode_create(netj.sample_rate, netj.period_size, NULL);
200 netj.playback_srcs = jack_slist_append(netj.playback_srcs, celt_encoder_create(celt_mode, 1, NULL));
202 CELTMode *celt_mode = celt_mode_create(netj.sample_rate, 1, netj.period_size, NULL);
203 netj.playback_srcs = jack_slist_append(netj.playback_srcs, celt_encoder_create(celt_mode));
206 }
else if (netj.bitdepth == OPUS_MODE) {
208 const int kbps = netj.resample_factor;
209 jack_error(
"NEW ONE OPUS ENCODER 128 <> %d!!", kbps);
211 OpusCustomMode *opus_mode = opus_custom_mode_create( netj.sample_rate, netj.period_size, &err );
212 if (err != OPUS_OK) {
jack_error(
"opus mode failed"); }
213 OpusCustomEncoder *oe = opus_custom_encoder_create( opus_mode, 1, &err );
214 if (err != OPUS_OK) {
jack_error(
"opus mode failed"); }
215 opus_custom_encoder_ctl(oe, OPUS_SET_BITRATE(kbps*1024));
216 opus_custom_encoder_ctl(oe, OPUS_SET_COMPLEXITY(10));
217 opus_custom_encoder_ctl(oe, OPUS_SET_SIGNAL(OPUS_SIGNAL_MUSIC));
218 opus_custom_encoder_ctl(oe, OPUS_SET_SIGNAL(OPUS_APPLICATION_RESTRICTED_LOWDELAY));
219 netj.playback_srcs = jack_slist_append(netj.playback_srcs, oe);
223 netj.playback_srcs = jack_slist_append(netj.playback_srcs, (
void *)src_new(SRC_LINEAR, 1, NULL));
227 for (chn = netj.playback_channels_audio; chn < netj.playback_channels; chn++) {
228 snprintf (buf,
sizeof(buf) - 1,
"system:playback_%u", chn + 1);
230 if (fEngine->PortRegister(fClientControl.fRefNum, buf, JACK_DEFAULT_MIDI_TYPE,
231 PlaybackDriverFlags, fEngineControl->fBufferSize, &port_index) < 0) {
232 jack_error(
"driver: cannot register port for %s", buf);
237 netj.playback_ports =
238 jack_slist_append (netj.playback_ports, (
void *)(intptr_t)port_index);
244 bool JackNetOneDriver::Initialize()
249 netjack_release(&netj);
253 if (netjack_startup(&netj)) {
258 if (AllocPorts() != 0) {
265 JackTimedDriver::SetBufferSize(netj.period_size);
266 JackTimedDriver::SetSampleRate(netj.sample_rate);
268 JackDriver::NotifyBufferSize(netj.period_size);
269 JackDriver::NotifySampleRate(netj.sample_rate);
272 fEngineControl->fTransport.SetNetworkSync(
true);
281 int JackNetOneDriver::Read()
284 delay = netjack_wait(&netj);
286 NotifyXRun(fBeginDateUst, (
float) delay);
287 jack_error(
"netxruns... duration: %dms", delay / 1000);
290 if ((netj.num_lost_packets * netj.period_size / netj.sample_rate) > 2)
291 JackTools::ThrowJackNetException();
294 JackDriver::CycleTakeBeginTime();
297 jack_transport_state_t local_trans_state;
299 unsigned int *packet_buf, *packet_bufX;
301 if (! netj.packet_data_valid) {
303 render_payload_to_jack_ports (netj.bitdepth, NULL, netj.net_period_down, netj.capture_ports, netj.capture_srcs, netj.period_size, netj.dont_htonl_floats);
306 packet_buf = netj.rx_buf;
312 netj.reply_port = pkthdr->reply_port;
313 netj.latency = pkthdr->latency;
316 if (netj.latency == 0)
317 netj.resync_threshold = 0;
319 netj.resync_threshold = MIN(15, pkthdr->latency - 1);
322 if (netj.handle_transport_sync) {
324 unsigned int compensated_tranport_pos = (pkthdr->transport_frame + (pkthdr->latency * netj.period_size) + netj.codec_latency);
329 local_trans_state = fEngineControl->fTransport.Query(&local_trans_pos);
332 switch (pkthdr->transport_state) {
334 case JackTransportStarting:
336 if (local_trans_state == JackTransportStopped) {
337 fEngineControl->fTransport.SetCommand(TransportCommandStart);
341 jack_info(
"locally stopped... starting...");
344 if (local_trans_pos.
frame != compensated_tranport_pos) {
346 new_pos.
frame = compensated_tranport_pos + 2 * netj.period_size;
347 new_pos.
valid = (jack_position_bits_t) 0;
350 fEngineControl->fTransport.RequestNewPos(&new_pos);
354 jack_info(
"starting locate to %d", compensated_tranport_pos);
358 case JackTransportStopped:
360 if (local_trans_pos.
frame != (pkthdr->transport_frame)) {
362 new_pos.
frame = pkthdr->transport_frame;
363 new_pos.
valid = (jack_position_bits_t)0;
364 fEngineControl->fTransport.RequestNewPos(&new_pos);
366 jack_info(
"transport is stopped locate to %d", pkthdr->transport_frame);
368 if (local_trans_state != JackTransportStopped)
370 fEngineControl->fTransport.SetCommand(TransportCommandStop);
373 case JackTransportRolling:
379 if (local_trans_state != JackTransportRolling)
380 fEngineControl->fTransport.SetState(JackTransportRolling);
383 case JackTransportLooping:
389 render_payload_to_jack_ports (netj.bitdepth, packet_bufX, netj.net_period_down, netj.capture_ports, netj.capture_srcs, netj.period_size, netj.dont_htonl_floats);
390 packet_cache_release_packet(netj.packcache, netj.expected_framecnt);
394 int JackNetOneDriver::Write()
396 int syncstate = netj.sync_state | ((fEngineControl->fTransport.GetState() == JackTransportNetStarting) ? 1 : 0);
397 uint32_t *packet_buf, *packet_bufX;
399 int packet_size = get_sample_size(netj.bitdepth) * netj.playback_channels * netj.net_period_up +
sizeof(
jacknet_packet_header);
402 packet_buf = (uint32_t *) alloca(packet_size);
405 if (netj.running_free) {
412 pkthdr->sync_state = syncstate;;
413 pkthdr->latency = netj.time_to_deadline;
415 pkthdr->framecnt = netj.expected_framecnt;
417 render_jack_ports_to_payload(netj.bitdepth, netj.playback_ports, netj.playback_srcs, netj.period_size, packet_bufX, netj.net_period_up, netj.dont_htonl_floats);
419 packet_header_hton(pkthdr);
420 if (netj.srcaddress_valid) {
422 static const int flag = 0;
425 netj.syncsource_address.sin_port = htons(netj.reply_port);
427 for (r = 0; r < netj.redundancy; r++)
428 netjack_sendto(netj.sockfd, (
char *)packet_buf, packet_size,
429 flag, (
struct sockaddr*) & (netj.syncsource_address),
sizeof(
struct sockaddr_in), netj.mtu);
435 JackNetOneDriver::FreePorts ()
437 JSList *node = netj.capture_ports;
439 while (node != NULL) {
441 jack_port_id_t port_index = (jack_port_id_t)(intptr_t) node->data;
442 node = jack_slist_remove_link(node, this_node);
443 jack_slist_free_1(this_node);
444 fEngine->PortUnRegister(fClientControl.fRefNum, port_index);
446 netj.capture_ports = NULL;
448 node = netj.playback_ports;
449 while (node != NULL) {
451 jack_port_id_t port_index = (jack_port_id_t)(intptr_t) node->data;
452 node = jack_slist_remove_link(node, this_node);
453 jack_slist_free_1(this_node);
454 fEngine->PortUnRegister(fClientControl.fRefNum, port_index);
456 netj.playback_ports = NULL;
458 if (netj.bitdepth == CELT_MODE) {
460 node = netj.playback_srcs;
461 while (node != NULL) {
463 CELTEncoder *enc = (CELTEncoder *) node->data;
464 node = jack_slist_remove_link(node, this_node);
465 jack_slist_free_1(this_node);
466 celt_encoder_destroy(enc);
468 netj.playback_srcs = NULL;
470 node = netj.capture_srcs;
471 while (node != NULL) {
473 CELTDecoder *dec = (CELTDecoder *) node->data;
474 node = jack_slist_remove_link(node, this_node);
475 jack_slist_free_1(this_node);
476 celt_decoder_destroy(dec);
478 netj.capture_srcs = NULL;
480 }
else if (netj.bitdepth == OPUS_MODE) {
482 node = netj.playback_srcs;
483 while (node != NULL) {
485 OpusCustomEncoder *enc = (OpusCustomEncoder *) node->data;
486 node = jack_slist_remove_link(node, this_node);
487 jack_slist_free_1(this_node);
488 opus_custom_encoder_destroy(enc);
490 netj.playback_srcs = NULL;
492 node = netj.capture_srcs;
493 while (node != NULL) {
495 OpusCustomDecoder *dec = (OpusCustomDecoder *) node->data;
496 node = jack_slist_remove_link(node, this_node);
497 jack_slist_free_1(this_node);
498 opus_custom_decoder_destroy(dec);
500 netj.capture_srcs = NULL;
504 node = netj.playback_srcs;
505 while (node != NULL) {
507 SRC_STATE *state = (SRC_STATE *) node->data;
508 node = jack_slist_remove_link(node, this_node);
509 jack_slist_free_1(this_node);
512 netj.playback_srcs = NULL;
514 node = netj.capture_srcs;
515 while (node != NULL) {
517 SRC_STATE *state = (SRC_STATE *) node->data;
518 node = jack_slist_remove_link(node, this_node);
519 jack_slist_free_1(this_node);
522 netj.capture_srcs = NULL;
531 JackNetOneDriver::render_payload_to_jack_ports_float(
void *packet_payload, jack_nframes_t net_period_down,
JSList *capture_ports,
JSList *capture_srcs, jack_nframes_t nframes,
int dont_htonl_floats)
534 JSList *node = capture_ports;
536 JSList *src_node = capture_srcs;
539 uint32_t *packet_bufX = (uint32_t *)packet_payload;
544 while (node != NULL) {
550 jack_port_id_t port_index = (jack_port_id_t)(intptr_t) node->data;
551 JackPort *port = fGraphManager->GetPort(port_index);
553 jack_default_audio_sample_t* buf =
554 (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_index, fEngineControl->fBufferSize);
556 const char *porttype = port->GetType();
561 if (net_period_down != nframes) {
562 SRC_STATE *src_state = (SRC_STATE *)src_node->data;
563 for (i = 0; i < net_period_down; i++) {
564 packet_bufX[i] = ntohl (packet_bufX[i]);
567 src.data_in = (
float *) packet_bufX;
568 src.input_frames = net_period_down;
571 src.output_frames = nframes;
573 src.src_ratio = (float) nframes / (
float) net_period_down;
574 src.end_of_input = 0;
576 src_set_ratio (src_state, src.src_ratio);
577 src_process (src_state, &src);
578 src_node = jack_slist_next (src_node);
582 if (dont_htonl_floats) {
583 memcpy(buf, packet_bufX, net_period_down *
sizeof(jack_default_audio_sample_t));
585 for (i = 0; i < net_period_down; i++) {
586 val.i = packet_bufX[i];
587 val.i = ntohl (val.i);
595 unsigned int buffer_size_uint32 = net_period_down;
596 uint32_t * buffer_uint32 = (uint32_t*)packet_bufX;
597 decode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
599 packet_bufX = (packet_bufX + net_period_down);
600 node = jack_slist_next (node);
606 JackNetOneDriver::render_jack_ports_to_payload_float (
JSList *playback_ports,
JSList *playback_srcs, jack_nframes_t nframes,
void *packet_payload, jack_nframes_t net_period_up,
int dont_htonl_floats)
609 JSList *node = playback_ports;
611 JSList *src_node = playback_srcs;
614 uint32_t *packet_bufX = (uint32_t *) packet_payload;
616 while (node != NULL) {
622 jack_port_id_t port_index = (jack_port_id_t)(intptr_t) node->data;
623 JackPort *port = fGraphManager->GetPort(port_index);
625 jack_default_audio_sample_t* buf =
626 (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_index, fEngineControl->fBufferSize);
628 const char *porttype = port->GetType();
634 if (net_period_up != nframes) {
635 SRC_STATE *src_state = (SRC_STATE *) src_node->data;
637 src.input_frames = nframes;
639 src.data_out = (
float *) packet_bufX;
640 src.output_frames = net_period_up;
642 src.src_ratio = (float) net_period_up / (
float) nframes;
643 src.end_of_input = 0;
645 src_set_ratio (src_state, src.src_ratio);
646 src_process (src_state, &src);
648 for (i = 0; i < net_period_up; i++) {
649 packet_bufX[i] = htonl (packet_bufX[i]);
651 src_node = jack_slist_next (src_node);
655 if (dont_htonl_floats) {
656 memcpy(packet_bufX, buf, net_period_up *
sizeof(jack_default_audio_sample_t));
658 for (i = 0; i < net_period_up; i++) {
660 val.i = htonl (val.i);
661 packet_bufX[i] = val.i;
668 unsigned int buffer_size_uint32 = net_period_up;
669 uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;
670 encode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
672 packet_bufX = (packet_bufX + net_period_up);
673 node = jack_slist_next (node);
681 JackNetOneDriver::render_payload_to_jack_ports_celt (
void *packet_payload, jack_nframes_t net_period_down,
JSList *capture_ports,
JSList *capture_srcs, jack_nframes_t nframes)
684 JSList *node = capture_ports;
685 JSList *src_node = capture_srcs;
686 unsigned char *packet_bufX = (
unsigned char *)packet_payload;
688 while (node != NULL) {
689 jack_port_id_t port_index = (jack_port_id_t) (intptr_t)node->data;
690 JackPort *port = fGraphManager->GetPort(port_index);
692 jack_default_audio_sample_t* buf =
693 (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_index, fEngineControl->fBufferSize);
695 const char *portname = port->GetType();
699 CELTDecoder *decoder = (CELTDecoder *)src_node->data;
701 #
if HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11
703 celt_decode_float(decoder, NULL, net_period_down, buf, nframes);
705 celt_decode_float(decoder, packet_bufX, net_period_down, buf, nframes);
708 celt_decode_float(decoder, NULL, net_period_down, buf);
710 celt_decode_float(decoder, packet_bufX, net_period_down, buf);
713 src_node = jack_slist_next (src_node);
717 unsigned int buffer_size_uint32 = net_period_down / 2;
718 uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;
720 decode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
722 packet_bufX = (packet_bufX + net_period_down);
723 node = jack_slist_next (node);
729 JackNetOneDriver::render_jack_ports_to_payload_celt (
JSList *playback_ports,
JSList *playback_srcs, jack_nframes_t nframes,
void *packet_payload, jack_nframes_t net_period_up)
732 JSList *node = playback_ports;
733 JSList *src_node = playback_srcs;
735 unsigned char *packet_bufX = (
unsigned char *)packet_payload;
737 while (node != NULL) {
738 jack_port_id_t port_index = (jack_port_id_t) (intptr_t) node->data;
739 JackPort *port = fGraphManager->GetPort(port_index);
741 jack_default_audio_sample_t* buf =
742 (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_index, fEngineControl->fBufferSize);
744 const char *portname = port->GetType();
750 jack_default_audio_sample_t *floatbuf = (jack_default_audio_sample_t *)alloca (
sizeof(jack_default_audio_sample_t) * nframes);
751 memcpy(floatbuf, buf, nframes *
sizeof(jack_default_audio_sample_t));
752 CELTEncoder *encoder = (CELTEncoder *)src_node->data;
753 #
if HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11
754 encoded_bytes = celt_encode_float(encoder, floatbuf, nframes, packet_bufX, net_period_up);
756 encoded_bytes = celt_encode_float(encoder, floatbuf, NULL, packet_bufX, net_period_up);
758 if (encoded_bytes != (
int)net_period_up)
759 jack_error(
"something in celt changed. netjack needs to be changed to handle this.");
760 src_node = jack_slist_next(src_node);
764 unsigned int buffer_size_uint32 = net_period_up / 2;
765 uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;
766 encode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
768 packet_bufX = (packet_bufX + net_period_up);
769 node = jack_slist_next (node);
777 #define CDO (sizeof(short))
778 // render functions for Opus.
780 JackNetOneDriver::render_payload_to_jack_ports_opus (
void *packet_payload, jack_nframes_t net_period_down,
JSList *capture_ports,
JSList *capture_srcs, jack_nframes_t nframes)
783 JSList *node = capture_ports;
784 JSList *src_node = capture_srcs;
786 unsigned char *packet_bufX = (
unsigned char *)packet_payload;
788 while (node != NULL) {
789 jack_port_id_t port_index = (jack_port_id_t) (intptr_t)node->data;
790 JackPort *port = fGraphManager->GetPort(port_index);
792 jack_default_audio_sample_t* buf =
793 (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_index, fEngineControl->fBufferSize);
795 const char *portname = port->GetType();
799 OpusCustomDecoder *decoder = (OpusCustomDecoder*) src_node->data;
800 if( !packet_payload )
801 memset(buf, 0, nframes *
sizeof(
float));
804 memcpy(&len, packet_bufX, CDO);
806 opus_custom_decode_float( decoder, packet_bufX + CDO, len, buf, nframes );
809 src_node = jack_slist_next (src_node);
813 unsigned int buffer_size_uint32 = net_period_down / 2;
814 uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;
816 decode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
818 packet_bufX = (packet_bufX + net_period_down);
819 node = jack_slist_next (node);
825 JackNetOneDriver::render_jack_ports_to_payload_opus (
JSList *playback_ports,
JSList *playback_srcs, jack_nframes_t nframes,
void *packet_payload, jack_nframes_t net_period_up)
828 JSList *node = playback_ports;
829 JSList *src_node = playback_srcs;
831 unsigned char *packet_bufX = (
unsigned char *)packet_payload;
833 while (node != NULL) {
834 jack_port_id_t port_index = (jack_port_id_t) (intptr_t) node->data;
835 JackPort *port = fGraphManager->GetPort(port_index);
837 jack_default_audio_sample_t* buf =
838 (jack_default_audio_sample_t*)fGraphManager->GetBuffer(port_index, fEngineControl->fBufferSize);
840 const char *portname = port->GetType();
846 jack_default_audio_sample_t *floatbuf = (jack_default_audio_sample_t *)alloca (
sizeof(jack_default_audio_sample_t) * nframes);
847 memcpy(floatbuf, buf, nframes *
sizeof(jack_default_audio_sample_t));
848 OpusCustomEncoder *encoder = (OpusCustomEncoder*) src_node->data;
849 encoded_bytes = opus_custom_encode_float( encoder, floatbuf, nframes, packet_bufX + CDO, net_period_up - CDO );
850 unsigned short len = htons(encoded_bytes);
851 memcpy(packet_bufX, &len, CDO);
852 src_node = jack_slist_next( src_node );
856 unsigned int buffer_size_uint32 = net_period_up / 2;
857 uint32_t * buffer_uint32 = (uint32_t*) packet_bufX;
858 encode_midi_buffer (buffer_uint32, buffer_size_uint32, buf);
860 packet_bufX = (packet_bufX + net_period_up);
861 node = jack_slist_next (node);
869 JackNetOneDriver::render_payload_to_jack_ports (
int bitdepth,
void *packet_payload, jack_nframes_t net_period_down,
JSList *capture_ports,
JSList *capture_srcs, jack_nframes_t nframes,
int dont_htonl_floats)
872 if (bitdepth == CELT_MODE)
873 render_payload_to_jack_ports_celt (packet_payload, net_period_down, capture_ports, capture_srcs, nframes);
877 if (bitdepth == OPUS_MODE)
878 render_payload_to_jack_ports_opus (packet_payload, net_period_down, capture_ports, capture_srcs, nframes);
881 render_payload_to_jack_ports_float (packet_payload, net_period_down, capture_ports, capture_srcs, nframes, dont_htonl_floats);
885 JackNetOneDriver::render_jack_ports_to_payload (
int bitdepth,
JSList *playback_ports,
JSList *playback_srcs, jack_nframes_t nframes,
void *packet_payload, jack_nframes_t net_period_up,
int dont_htonl_floats)
888 if (bitdepth == CELT_MODE)
889 render_jack_ports_to_payload_celt (playback_ports, playback_srcs, nframes, packet_payload, net_period_up);
893 if (bitdepth == OPUS_MODE)
894 render_jack_ports_to_payload_opus (playback_ports, playback_srcs, nframes, packet_payload, net_period_up);
897 render_jack_ports_to_payload_float (playback_ports, playback_srcs, nframes, packet_payload, net_period_up, dont_htonl_floats);
913 desc = jack_driver_descriptor_construct(
"netone", JackDriverMaster,
"netjack one slave backend component", &filler);
916 jack_driver_descriptor_add_parameter(desc, &filler,
"audio-ins",
'i', JackDriverParamUInt, &value, NULL,
"Number of capture channels (defaults to 2)", NULL);
917 jack_driver_descriptor_add_parameter(desc, &filler,
"audio-outs",
'o', JackDriverParamUInt, &value, NULL,
"Number of playback channels (defaults to 2)", NULL);
920 jack_driver_descriptor_add_parameter(desc, &filler,
"midi-ins",
'I', JackDriverParamUInt, &value, NULL,
"Number of midi capture channels (defaults to 1)", NULL);
921 jack_driver_descriptor_add_parameter(desc, &filler,
"midi-outs",
'O', JackDriverParamUInt, &value, NULL,
"Number of midi playback channels (defaults to 1)", NULL);
924 jack_driver_descriptor_add_parameter(desc, &filler,
"rate",
'r', JackDriverParamUInt, &value, NULL,
"Sample rate", NULL);
927 jack_driver_descriptor_add_parameter(desc, &filler,
"period",
'p', JackDriverParamUInt, &value, NULL,
"Frames per period", NULL);
930 jack_driver_descriptor_add_parameter(desc, &filler,
"num-periods",
'n', JackDriverParamUInt, &value, NULL,
"Network latency setting in no. of periods", NULL);
933 jack_driver_descriptor_add_parameter(desc, &filler,
"listen-port",
'l', JackDriverParamUInt, &value, NULL,
"The socket port we are listening on for sync packets", NULL);
936 jack_driver_descriptor_add_parameter(desc, &filler,
"factor",
'f', JackDriverParamUInt, &value, NULL,
"Factor for sample rate reduction", NULL);
939 jack_driver_descriptor_add_parameter(desc, &filler,
"upstream-factor",
'u', JackDriverParamUInt, &value, NULL,
"Factor for sample rate reduction on the upstream", NULL);
943 jack_driver_descriptor_add_parameter(desc, &filler,
"celt",
'c', JackDriverParamUInt, &value, NULL,
"Set CELT encoding and number of kbits per channel", NULL);
947 jack_driver_descriptor_add_parameter(desc, &filler,
"opus",
'P', JackDriverParamUInt, &value, NULL,
"Set Opus encoding and number of kbits per channel", NULL);
950 jack_driver_descriptor_add_parameter(desc, &filler,
"bit-depth",
'b', JackDriverParamUInt, &value, NULL,
"Sample bit-depth (0 for float, 8 for 8bit and 16 for 16bit)", NULL);
953 jack_driver_descriptor_add_parameter(desc, &filler,
"transport-sync",
't', JackDriverParamBool, &value, NULL,
"Whether to slave the transport to the master transport", NULL);
956 jack_driver_descriptor_add_parameter(desc, &filler,
"autoconf",
'a', JackDriverParamBool, &value, NULL,
"Whether to use Autoconfig, or just start", NULL);
959 jack_driver_descriptor_add_parameter(desc, &filler,
"redundancy",
'R', JackDriverParamUInt, &value, NULL,
"Send packets N times", NULL);
962 jack_driver_descriptor_add_parameter(desc, &filler,
"native-endian",
'e', JackDriverParamBool, &value, NULL,
"Dont convert samples to network byte order", NULL);
965 jack_driver_descriptor_add_parameter(desc, &filler,
"jitterval",
'J', JackDriverParamInt, &value, NULL,
"Attempted jitterbuffer microseconds on master", NULL);
968 jack_driver_descriptor_add_parameter(desc, &filler,
"always-deadline",
'D', JackDriverParamBool, &value, NULL,
"Always use deadline", NULL);
975 jack_nframes_t sample_rate = 48000;
976 jack_nframes_t resample_factor = 1;
977 jack_nframes_t period_size = 1024;
978 unsigned int capture_ports = 2;
979 unsigned int playback_ports = 2;
980 unsigned int capture_ports_midi = 1;
981 unsigned int playback_ports_midi = 1;
982 unsigned int listen_port = 3000;
983 unsigned int bitdepth = 0;
984 unsigned int handle_transport_sync = 1;
985 unsigned int use_autoconfig = 1;
986 unsigned int latency = 5;
987 unsigned int redundancy = 1;
988 unsigned int mtu = 1400;
990 unsigned int resample_factor_up = 1;
992 int dont_htonl_floats = 0;
993 int always_deadline = 0;
998 for (node = params; node; node = jack_slist_next(node)) {
1000 switch (param->character) {
1002 capture_ports = param->value.ui;
1006 playback_ports = param->value.ui;
1010 capture_ports_midi = param->value.ui;
1014 playback_ports_midi = param->value.ui;
1018 sample_rate = param->value.ui;
1022 period_size = param->value.ui;
1026 listen_port = param->value.ui;
1031 resample_factor = param->value.ui;
1033 jack_error(
"not built with libsamplerate support");
1040 resample_factor_up = param->value.ui;
1042 jack_error(
"not built with libsamplerate support");
1048 bitdepth = param->value.ui;
1053 bitdepth = CELT_MODE;
1054 resample_factor = param->value.ui;
1063 bitdepth = OPUS_MODE;
1064 resample_factor = param->value.ui;
1073 handle_transport_sync = param->value.ui;
1077 use_autoconfig = param->value.ui;
1081 latency = param->value.ui;
1085 redundancy = param->value.ui;
1089 dont_htonl_floats = param->value.ui;
1093 jitter_val = param->value.i;
1097 always_deadline = param->value.ui;
1105 capture_ports_midi, playback_ports_midi, capture_ports, playback_ports,
1106 sample_rate, period_size, resample_factor,
1107 "net_pcm", handle_transport_sync, bitdepth, use_autoconfig, latency, redundancy,
1108 dont_htonl_floats, always_deadline, jitter_val));
1110 if (driver->Open(period_size, sample_rate, 1, 1, capture_ports, playback_ports,
1111 0,
"from_master_",
"to_master_", 0, 0) == 0) {
To be used as a wrapper of JackNetDriver.
Inter process synchronization using using Mach semaphore.
Locked Engine, access to methods is serialized using a mutex.
SERVER_EXPORT void jack_error(const char *fmt,...)
jack_position_bits_t valid
SERVER_EXPORT void jack_info(const char *fmt,...)
LIB_EXPORT int jack_port_type_size(void)
The base interface for drivers clients.
SERVER_EXPORT void jack_log(const char *fmt,...)