19 #include "JackNetInterface.h"
20 #include "JackException.h"
35 JackNetInterface::JackNetInterface() : fSocket()
40 JackNetInterface::JackNetInterface(
const char* multicast_ip,
int port) : fSocket(multicast_ip, port)
42 strcpy(fMulticastIP, multicast_ip);
46 JackNetInterface::JackNetInterface(session_params_t& params, JackNetSocket& socket,
const char* multicast_ip) : fSocket(socket)
49 strcpy(fMulticastIP, multicast_ip);
53 void JackNetInterface::Initialize()
57 fNetAudioCaptureBuffer = NULL;
58 fNetAudioPlaybackBuffer = NULL;
59 fNetMidiCaptureBuffer = NULL;
60 fNetMidiPlaybackBuffer = NULL;
61 memset(&fSendTransportData, 0,
sizeof(net_transport_data_t));
62 memset(&fReturnTransportData, 0,
sizeof(net_transport_data_t));
65 void JackNetInterface::FreeNetworkBuffers()
67 delete fNetMidiCaptureBuffer;
68 delete fNetMidiPlaybackBuffer;
69 delete fNetAudioCaptureBuffer;
70 delete fNetAudioPlaybackBuffer;
71 fNetMidiCaptureBuffer = NULL;
72 fNetMidiPlaybackBuffer = NULL;
73 fNetAudioCaptureBuffer = NULL;
74 fNetAudioPlaybackBuffer = NULL;
77 JackNetInterface::~JackNetInterface()
79 jack_log(
"JackNetInterface::~JackNetInterface");
84 delete fNetAudioCaptureBuffer;
85 delete fNetAudioPlaybackBuffer;
86 delete fNetMidiCaptureBuffer;
87 delete fNetMidiPlaybackBuffer;
90 int JackNetInterface::SetNetBufferSize()
93 float audio_size = (fNetAudioCaptureBuffer)
94 ? fNetAudioCaptureBuffer->GetCycleSize()
95 : (fNetAudioPlaybackBuffer) ? fNetAudioPlaybackBuffer->GetCycleSize() : 0;
96 jack_log(
"audio_size %f", audio_size);
99 float midi_size = (fNetMidiCaptureBuffer)
100 ? fNetMidiCaptureBuffer->GetCycleSize()
101 : (fNetMidiPlaybackBuffer) ? fNetMidiPlaybackBuffer->GetCycleSize() : 0;
102 jack_log(
"midi_size %f", midi_size);
105 int bufsize = NETWORK_MAX_LATENCY * (fParams.fMtu + (int)audio_size + (
int)midi_size);
106 jack_log(
"SetNetBufferSize bufsize = %d", bufsize);
109 if (fSocket.SetOption(SOL_SOCKET, SO_SNDBUF, &bufsize,
sizeof(bufsize)) == SOCKET_ERROR) {
114 if (fSocket.SetOption(SOL_SOCKET, SO_RCVBUF, &bufsize,
sizeof(bufsize)) == SOCKET_ERROR) {
121 bool JackNetInterface::SetParams()
124 strcpy(fTxHeader.fPacketType,
"header");
125 fTxHeader.fID = fParams.fID;
126 fTxHeader.fCycle = 0;
127 fTxHeader.fSubCycle = 0;
128 fTxHeader.fIsLastPckt = 0;
131 strcpy(fRxHeader.fPacketType,
"header");
132 fRxHeader.fID = fParams.fID;
133 fRxHeader.fCycle = 0;
134 fRxHeader.fSubCycle = 0;
135 fRxHeader.fIsLastPckt = 0;
138 fTxBuffer =
new char[fParams.fMtu];
139 fRxBuffer =
new char[fParams.fMtu];
144 fTxData = fTxBuffer + HEADER_SIZE;
145 fRxData = fRxBuffer + HEADER_SIZE;
150 int JackNetInterface::MidiSend(NetMidiBuffer* buffer,
int midi_channnels,
int audio_channels)
152 if (midi_channnels > 0) {
154 fTxHeader.fDataType =
'm';
155 uint data_size = buffer->RenderFromJackPorts();
156 fTxHeader.fNumPacket = buffer->GetNumPackets(data_size, PACKET_AVAILABLE_SIZE(&fParams));
158 for (uint subproc = 0; subproc < fTxHeader.fNumPacket; subproc++) {
159 fTxHeader.fSubCycle = subproc;
160 fTxHeader.fIsLastPckt = ((subproc == (fTxHeader.fNumPacket - 1)) && audio_channels == 0) ? 1 : 0;
161 fTxHeader.fPacketSize = HEADER_SIZE + buffer->RenderToNetwork(subproc, data_size);
162 memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE);
163 if (Send(fTxHeader.fPacketSize, 0) == SOCKET_ERROR) {
171 int JackNetInterface::AudioSend(NetAudioBuffer* buffer,
int audio_channels)
174 if (audio_channels > 0) {
175 fTxHeader.fDataType =
'a';
176 fTxHeader.fActivePorts = buffer->RenderFromJackPorts();
177 fTxHeader.fNumPacket = buffer->GetNumPackets(fTxHeader.fActivePorts);
179 for (uint subproc = 0; subproc < fTxHeader.fNumPacket; subproc++) {
180 fTxHeader.fSubCycle = subproc;
181 fTxHeader.fIsLastPckt = (subproc == (fTxHeader.fNumPacket - 1)) ? 1 : 0;
182 fTxHeader.fPacketSize = HEADER_SIZE + buffer->RenderToNetwork(subproc, fTxHeader.fActivePorts);
183 memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE);
185 if (Send(fTxHeader.fPacketSize, 0) == SOCKET_ERROR) {
193 int JackNetInterface::MidiRecv(packet_header_t* rx_head, NetMidiBuffer* buffer, uint& recvd_midi_pckt)
195 int rx_bytes = Recv(rx_head->fPacketSize, 0);
196 fRxHeader.fCycle = rx_head->fCycle;
197 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
198 buffer->RenderFromNetwork(rx_head->fSubCycle, rx_bytes - HEADER_SIZE);
200 if (++recvd_midi_pckt == rx_head->fNumPacket) {
201 buffer->RenderToJackPorts();
206 int JackNetInterface::AudioRecv(packet_header_t* rx_head, NetAudioBuffer* buffer)
208 int rx_bytes = Recv(rx_head->fPacketSize, 0);
209 fRxHeader.fCycle = rx_head->fCycle;
210 fRxHeader.fSubCycle = rx_head->fSubCycle;
211 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
212 fRxHeader.fActivePorts = rx_head->fActivePorts;
213 rx_bytes = buffer->RenderFromNetwork(rx_head->fCycle, rx_head->fSubCycle, fRxHeader.fActivePorts);
215 if (fRxHeader.fIsLastPckt) {
216 buffer->RenderToJackPorts();
221 int JackNetInterface::FinishRecv(NetAudioBuffer* buffer)
224 buffer->RenderToJackPorts();
225 return NET_PACKET_ERROR;
228 NetAudioBuffer* JackNetInterface::AudioBufferFactory(
int nports,
char* buffer)
230 switch (fParams.fSampleEncoder) {
232 case JackFloatEncoder:
233 return new NetFloatAudioBuffer(&fParams, nports, buffer);
236 return new NetIntAudioBuffer(&fParams, nports, buffer);
239 case JackCeltEncoder:
240 return new NetCeltAudioBuffer(&fParams, nports, buffer, fParams.fKBps);
248 bool JackNetMasterInterface::Init()
250 jack_log(
"JackNetMasterInterface::Init, ID %u", fParams.fID);
252 session_params_t host_params;
257 if (fSocket.NewSocket() == SOCKET_ERROR) {
258 jack_error(
"Can't create socket : %s", StrError(NET_ERROR_CODE));
263 if (fSocket.SetTimeOut(MASTER_INIT_TIMEOUT) < 0)
264 jack_error(
"Can't set timeout : %s", StrError(NET_ERROR_CODE));
267 if (fSocket.Connect() == SOCKET_ERROR) {
268 jack_error(
"Can't connect : %s", StrError(NET_ERROR_CODE));
273 jack_info(
"Sending parameters to %s...", fParams.fSlaveNetName);
276 session_params_t net_params;
277 memset(&net_params, 0,
sizeof(session_params_t));
278 SetPacketType(&fParams, SLAVE_SETUP);
279 SessionParamsHToN(&fParams, &net_params);
281 if (fSocket.Send(&net_params,
sizeof(session_params_t), 0) == SOCKET_ERROR) {
282 jack_error(
"Error in send : %s", StrError(NET_ERROR_CODE));
285 memset(&net_params, 0,
sizeof(session_params_t));
286 if (((rx_bytes = fSocket.Recv(&net_params,
sizeof(session_params_t), 0)) == SOCKET_ERROR) && (fSocket.GetError() != NET_NO_DATA)) {
291 SessionParamsNToH(&net_params, &host_params);
293 while ((GetPacketType(&host_params) != START_MASTER) && (++attempt < SLAVE_SETUP_RETRY));
294 if (attempt == SLAVE_SETUP_RETRY) {
302 int JackNetMasterInterface::SetRxTimeout()
304 jack_log(
"JackNetMasterInterface::SetRxTimeout");
305 float time = 3 * 1000000.f * (
static_cast<float>(fParams.fPeriodSize) / static_cast<float>(fParams.fSampleRate));
306 return fSocket.SetTimeOut(static_cast<int>(time));
309 bool JackNetMasterInterface::SetParams()
311 jack_log(
"JackNetMasterInterface::SetParams audio in = %d audio out = %d MIDI in = %d MIDI out = %d",
312 fParams.fSendAudioChannels, fParams.fReturnAudioChannels,
313 fParams.fSendMidiChannels, fParams.fReturnMidiChannels);
315 JackNetInterface::SetParams();
317 fTxHeader.fDataStream =
's';
318 fRxHeader.fDataStream =
'r';
320 fMaxCycleOffset = fParams.fNetworkLatency;
323 if (fParams.fSendMidiChannels > 0) {
324 fNetMidiCaptureBuffer =
new NetMidiBuffer(&fParams, fParams.fSendMidiChannels, fTxData);
327 if (fParams.fReturnMidiChannels > 0) {
328 fNetMidiPlaybackBuffer =
new NetMidiBuffer(&fParams, fParams.fReturnMidiChannels, fRxData);
334 if (fParams.fSendAudioChannels > 0) {
335 fNetAudioCaptureBuffer = AudioBufferFactory(fParams.fSendAudioChannels, fTxData);
336 assert(fNetAudioCaptureBuffer);
339 if (fParams.fReturnAudioChannels > 0) {
340 fNetAudioPlaybackBuffer = AudioBufferFactory(fParams.fReturnAudioChannels, fRxData);
341 assert(fNetAudioPlaybackBuffer);
344 }
catch (exception&) {
345 jack_error(
"NetAudioBuffer allocation error...");
358 if (SetNetBufferSize() == SOCKET_ERROR) {
359 jack_error(
"Can't set net buffer sizes : %s", StrError(NET_ERROR_CODE));
366 FreeNetworkBuffers();
370 void JackNetMasterInterface::Exit()
372 jack_log(
"JackNetMasterInterface::Exit, ID %u", fParams.fID);
378 jack_info(
"Exiting '%s'", fParams.fName);
379 SetPacketType(&fParams, KILL_MASTER);
380 JackNetSocket mcast_socket(fMulticastIP, fSocket.GetPort());
382 session_params_t net_params;
383 memset(&net_params, 0,
sizeof(session_params_t));
384 SessionParamsHToN(&fParams, &net_params);
386 if (mcast_socket.NewSocket() == SOCKET_ERROR) {
387 jack_error(
"Can't create socket : %s", StrError(NET_ERROR_CODE));
389 if (mcast_socket.SendTo(&net_params,
sizeof(session_params_t), 0, fMulticastIP) == SOCKET_ERROR) {
390 jack_error(
"Can't send suicide request : %s", StrError(NET_ERROR_CODE));
393 mcast_socket.Close();
396 void JackNetMasterInterface::FatalRecvError()
399 jack_error(
"Recv connection lost error = %s, '%s' exiting", StrError(NET_ERROR_CODE), fParams.fName);
406 void JackNetMasterInterface::FatalSendError()
409 jack_error(
"Send connection lost error = %s, '%s' exiting", StrError(NET_ERROR_CODE), fParams.fName);
416 int JackNetMasterInterface::Recv(
size_t size,
int flags)
420 if (((rx_bytes = fSocket.Recv(fRxBuffer, size, flags)) == SOCKET_ERROR) && fRunning) {
437 packet_header_t* header =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
438 PacketHeaderNToH(header, header);
442 int JackNetMasterInterface::Send(
size_t size,
int flags)
445 packet_header_t* header =
reinterpret_cast<packet_header_t*
>(fTxBuffer);
446 PacketHeaderHToN(header, header);
448 if (((tx_bytes = fSocket.Send(fTxBuffer, size, flags)) == SOCKET_ERROR) && fRunning) {
462 bool JackNetMasterInterface::IsSynched()
464 return (fCurrentCycleOffset <= fMaxCycleOffset);
467 int JackNetMasterInterface::SyncSend()
470 fTxHeader.fSubCycle = 0;
471 fTxHeader.fDataType =
's';
472 fTxHeader.fIsLastPckt = (fParams.fSendMidiChannels == 0 && fParams.fSendAudioChannels == 0) ? 1 : 0;
473 fTxHeader.fPacketSize = fParams.fMtu;
475 memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE);
477 return Send(fTxHeader.fPacketSize, 0);
480 int JackNetMasterInterface::DataSend()
482 if (MidiSend(fNetMidiCaptureBuffer, fParams.fSendMidiChannels, fParams.fSendAudioChannels) == SOCKET_ERROR) {
485 return AudioSend(fNetAudioCaptureBuffer, fParams.fSendAudioChannels);
488 int JackNetMasterInterface::SyncRecv()
491 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
506 rx_bytes = Recv(fParams.fMtu, MSG_PEEK);
508 if (rx_bytes == SOCKET_ERROR) {
512 while ((strcmp(rx_head->fPacketType,
"header") != 0) && (rx_head->fDataType !=
's'));
514 fCurrentCycleOffset = fTxHeader.fCycle - rx_head->fCycle;
516 if (fCurrentCycleOffset < fMaxCycleOffset) {
517 jack_info(
"Synching with latency = %d", fCurrentCycleOffset);
520 rx_bytes = Recv(rx_head->fPacketSize, 0);
521 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
526 int JackNetMasterInterface::DataRecv()
529 uint recvd_midi_pckt = 0;
530 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
532 while (!fRxHeader.fIsLastPckt) {
534 rx_bytes = Recv(fParams.fMtu, MSG_PEEK);
537 if (rx_bytes == SOCKET_ERROR) {
541 if (rx_bytes && (rx_head->fDataStream ==
'r') && (rx_head->fID == fParams.fID)) {
543 switch (rx_head->fDataType) {
546 rx_bytes = MidiRecv(rx_head, fNetMidiPlaybackBuffer, recvd_midi_pckt);
550 rx_bytes = AudioRecv(rx_head, fNetAudioPlaybackBuffer);
554 jack_info(
"NetMaster : overloaded, skipping receive from '%s'", fParams.fName);
555 return FinishRecv(fNetAudioPlaybackBuffer);
563 void JackNetMasterInterface::EncodeSyncPacket()
567 memset(fTxData, 0, PACKET_AVAILABLE_SIZE(&fParams));
570 if (fParams.fTransportSync) {
571 EncodeTransportData();
572 TransportDataHToN(&fSendTransportData, &fSendTransportData);
574 memcpy(fTxData, &fSendTransportData,
sizeof(net_transport_data_t));
582 fTxHeader.fActivePorts = (fNetAudioPlaybackBuffer) ? fNetAudioPlaybackBuffer->ActivePortsToNetwork(fTxData) : 0;
585 void JackNetMasterInterface::DecodeSyncPacket()
589 if (fParams.fTransportSync) {
591 memcpy(&fReturnTransportData, fRxData,
sizeof(net_transport_data_t));
592 TransportDataNToH(&fReturnTransportData, &fReturnTransportData);
593 DecodeTransportData();
599 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
602 if (fNetAudioCaptureBuffer) {
603 fNetAudioCaptureBuffer->ActivePortsFromNetwork(fRxData, rx_head->fActivePorts);
609 uint JackNetSlaveInterface::fSlaveCounter = 0;
611 bool JackNetSlaveInterface::Init()
613 jack_log(
"JackNetSlaveInterface::Init()");
616 strcpy(fParams.fPacketType,
"params");
617 fParams.fProtocolVersion = SLAVE_PROTOCOL;
618 SetPacketType(&fParams, SLAVE_AVAILABLE);
625 status = SendAvailableToMaster();
626 if (status == NET_SOCKET_ERROR) {
630 while (status != NET_CONNECTED);
633 jack_info(
"Initializing connection with %s...", fParams.fMasterNetName);
634 status = SendStartToMaster();
635 if (status == NET_ERROR) {
639 while (status != NET_ROLLING);
645 bool JackNetSlaveInterface::InitConnection(
int time_out_sec)
647 jack_log(
"JackNetSlaveInterface::InitConnection()");
648 uint try_count = (time_out_sec > 0) ? ((1000000 * time_out_sec) / SLAVE_INIT_TIMEOUT) : LONG_MAX;
651 strcpy(fParams.fPacketType,
"params");
652 fParams.fProtocolVersion = SLAVE_PROTOCOL;
653 SetPacketType(&fParams, SLAVE_AVAILABLE);
658 status = SendAvailableToMaster(try_count);
659 if (status == NET_SOCKET_ERROR) {
663 while (status != NET_CONNECTED && --try_count > 0);
665 return (try_count != 0);
668 bool JackNetSlaveInterface::InitRendering()
670 jack_log(
"JackNetSlaveInterface::InitRendering()");
675 jack_info(
"Initializing connection with %s...", fParams.fMasterNetName);
676 status = SendStartToMaster();
677 if (status == NET_ERROR)
680 while (status != NET_ROLLING);
685 net_status_t JackNetSlaveInterface::SendAvailableToMaster(
long try_count)
687 jack_log(
"JackNetSlaveInterface::SendAvailableToMaster()");
689 session_params_t host_params;
693 if (fSocket.NewSocket() == SOCKET_ERROR) {
694 jack_error(
"Fatal error : network unreachable - %s", StrError(NET_ERROR_CODE));
695 return NET_SOCKET_ERROR;
698 if (fSocket.IsLocal(fMulticastIP)) {
702 if (fSocket.Bind() == SOCKET_ERROR) {
703 jack_error(
"Can't bind the socket : %s", StrError(NET_ERROR_CODE));
704 return NET_SOCKET_ERROR;
709 if (fSocket.SetTimeOut(SLAVE_INIT_TIMEOUT) == SOCKET_ERROR)
710 jack_error(
"Can't set timeout : %s", StrError(NET_ERROR_CODE));
713 if (fSocket.SetLocalLoop() == SOCKET_ERROR)
714 jack_error(
"Can't disable multicast loop : %s", StrError(NET_ERROR_CODE));
720 session_params_t net_params;
721 memset(&net_params, 0,
sizeof(session_params_t));
722 SessionParamsHToN(&fParams, &net_params);
723 if (fSocket.SendTo(&net_params,
sizeof(session_params_t), 0, fMulticastIP) == SOCKET_ERROR)
724 jack_error(
"Error in data send : %s", StrError(NET_ERROR_CODE));
727 memset(&net_params, 0,
sizeof(session_params_t));
728 rx_bytes = fSocket.CatchHost(&net_params,
sizeof(session_params_t), 0);
729 SessionParamsNToH(&net_params, &host_params);
730 if ((rx_bytes == SOCKET_ERROR) && (fSocket.GetError() != NET_NO_DATA)) {
731 jack_error(
"Can't receive : %s", StrError(NET_ERROR_CODE));
732 return NET_RECV_ERROR;
735 while (strcmp(host_params.fPacketType, fParams.fPacketType) && (GetPacketType(&host_params) != SLAVE_SETUP) && (--try_count > 0));
738 if (try_count == 0) {
740 return NET_CONNECT_ERROR;
744 fParams = host_params;
747 if (fSocket.Connect() == SOCKET_ERROR) {
748 jack_error(
"Error in connect : %s", StrError(NET_ERROR_CODE));
749 return NET_CONNECT_ERROR;
751 return NET_CONNECTED;
754 net_status_t JackNetSlaveInterface::SendStartToMaster()
756 jack_log(
"JackNetSlaveInterface::SendStartToMaster");
759 session_params_t net_params;
760 memset(&net_params, 0,
sizeof(session_params_t));
761 SetPacketType(&fParams, START_MASTER);
762 SessionParamsHToN(&fParams, &net_params);
763 if (fSocket.Send(&net_params,
sizeof(session_params_t), 0) == SOCKET_ERROR) {
764 jack_error(
"Error in send : %s", StrError(NET_ERROR_CODE));
765 return (fSocket.GetError() == NET_CONN_ERROR) ? NET_ERROR : NET_SEND_ERROR;
770 bool JackNetSlaveInterface::SetParams()
772 jack_log(
"JackNetSlaveInterface::SetParams audio in = %d audio out = %d MIDI in = %d MIDI out = %d",
773 fParams.fSendAudioChannels, fParams.fReturnAudioChannels,
774 fParams.fSendMidiChannels, fParams.fReturnMidiChannels);
776 JackNetInterface::SetParams();
778 fTxHeader.fDataStream =
'r';
779 fRxHeader.fDataStream =
's';
782 if (fParams.fSendMidiChannels > 0) {
783 fNetMidiCaptureBuffer =
new NetMidiBuffer(&fParams, fParams.fSendMidiChannels, fRxData);
786 if (fParams.fReturnMidiChannels > 0) {
787 fNetMidiPlaybackBuffer =
new NetMidiBuffer(&fParams, fParams.fReturnMidiChannels, fTxData);
793 if (fParams.fSendAudioChannels > 0) {
794 fNetAudioCaptureBuffer = AudioBufferFactory(fParams.fSendAudioChannels, fRxData);
795 assert(fNetAudioCaptureBuffer);
798 if (fParams.fReturnAudioChannels > 0) {
799 fNetAudioPlaybackBuffer = AudioBufferFactory(fParams.fReturnAudioChannels, fTxData);
800 assert(fNetAudioPlaybackBuffer);
803 }
catch (exception&) {
804 jack_error(
"NetAudioBuffer allocation error...");
809 if (SetNetBufferSize() == SOCKET_ERROR) {
810 jack_error(
"Can't set net buffer sizes : %s", StrError(NET_ERROR_CODE));
817 FreeNetworkBuffers();
821 void JackNetSlaveInterface::FatalRecvError()
823 jack_error(
"Recv connection lost error = %s", StrError(NET_ERROR_CODE));
824 throw JackNetException();
827 void JackNetSlaveInterface::FatalSendError()
829 jack_error(
"Send connection lost error = %s", StrError(NET_ERROR_CODE));
830 throw JackNetException();
833 int JackNetSlaveInterface::Recv(
size_t size,
int flags)
835 int rx_bytes = fSocket.Recv(fRxBuffer, size, flags);
837 if (rx_bytes == SOCKET_ERROR) {
853 packet_header_t* header =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
854 PacketHeaderNToH(header, header);
858 int JackNetSlaveInterface::Send(
size_t size,
int flags)
860 packet_header_t* header =
reinterpret_cast<packet_header_t*
>(fTxBuffer);
861 PacketHeaderHToN(header, header);
862 int tx_bytes = fSocket.Send(fTxBuffer, size, flags);
865 if (tx_bytes == SOCKET_ERROR) {
880 int JackNetSlaveInterface::SyncRecv()
883 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
887 rx_bytes = Recv(fParams.fMtu, 0);
889 if (rx_bytes == SOCKET_ERROR) {
893 while ((strcmp(rx_head->fPacketType,
"header") != 0) && (rx_head->fDataType !=
's'));
895 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
899 int JackNetSlaveInterface::DataRecv()
902 uint recvd_midi_pckt = 0;
903 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
905 while (!fRxHeader.fIsLastPckt) {
907 rx_bytes = Recv(fParams.fMtu, MSG_PEEK);
910 if (rx_bytes == SOCKET_ERROR) {
914 if (rx_bytes && (rx_head->fDataStream ==
's') && (rx_head->fID == fParams.fID)) {
916 switch (rx_head->fDataType) {
919 rx_bytes = MidiRecv(rx_head, fNetMidiCaptureBuffer, recvd_midi_pckt);
923 rx_bytes = AudioRecv(rx_head, fNetAudioCaptureBuffer);
927 jack_info(
"NetSlave : overloaded, skipping receive");
928 return FinishRecv(fNetAudioCaptureBuffer);
933 fRxHeader.fCycle = rx_head->fCycle;
937 int JackNetSlaveInterface::SyncSend()
940 if (fParams.fSlaveSyncMode) {
941 fTxHeader.fCycle = fRxHeader.fCycle;
945 fTxHeader.fSubCycle = 0;
946 fTxHeader.fDataType =
's';
947 fTxHeader.fIsLastPckt = (fParams.fReturnMidiChannels == 0 && fParams.fReturnAudioChannels == 0) ? 1 : 0;
948 fTxHeader.fPacketSize = fParams.fMtu;
950 memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE);
952 return Send(fTxHeader.fPacketSize, 0);
955 int JackNetSlaveInterface::DataSend()
957 if (MidiSend(fNetMidiPlaybackBuffer, fParams.fReturnMidiChannels, fParams.fReturnAudioChannels) == SOCKET_ERROR) {
960 return AudioSend(fNetAudioPlaybackBuffer, fParams.fReturnAudioChannels);
964 void JackNetSlaveInterface::EncodeSyncPacket()
968 memset(fTxData, 0, PACKET_AVAILABLE_SIZE(&fParams));
971 if (fParams.fTransportSync) {
972 EncodeTransportData();
973 TransportDataHToN(&fReturnTransportData, &fReturnTransportData);
975 memcpy(fTxData, &fReturnTransportData,
sizeof(net_transport_data_t));
983 fTxHeader.fActivePorts = (fNetAudioCaptureBuffer) ? fNetAudioCaptureBuffer->ActivePortsToNetwork(fTxData) : 0;
986 void JackNetSlaveInterface::DecodeSyncPacket()
990 if (fParams.fTransportSync) {
992 memcpy(&fSendTransportData, fRxData,
sizeof(net_transport_data_t));
993 TransportDataNToH(&fSendTransportData, &fSendTransportData);
994 DecodeTransportData();
1000 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
1003 if (fNetAudioPlaybackBuffer) {
1004 fNetAudioPlaybackBuffer->ActivePortsFromNetwork(fRxData, rx_head->fActivePorts);