19 #include "JackNetInterface.h"
20 #include "JackException.h"
21 #include "JackError.h"
37 JackNetInterface::JackNetInterface() : fSocket()
42 JackNetInterface::JackNetInterface(
const char* multicast_ip,
int port) : fSocket(multicast_ip, port)
44 strcpy(fMulticastIP, multicast_ip);
48 JackNetInterface::JackNetInterface(session_params_t& params, JackNetSocket& socket,
const char* multicast_ip) : fSocket(socket)
51 strcpy(fMulticastIP, multicast_ip);
55 void JackNetInterface::Initialize()
60 fNetAudioCaptureBuffer = NULL;
61 fNetAudioPlaybackBuffer = NULL;
62 fNetMidiCaptureBuffer = NULL;
63 fNetMidiPlaybackBuffer = NULL;
64 memset(&fSendTransportData, 0,
sizeof(net_transport_data_t));
65 memset(&fReturnTransportData, 0,
sizeof(net_transport_data_t));
68 void JackNetInterface::FreeNetworkBuffers()
70 delete fNetMidiCaptureBuffer;
71 delete fNetMidiPlaybackBuffer;
72 delete fNetAudioCaptureBuffer;
73 delete fNetAudioPlaybackBuffer;
74 fNetMidiCaptureBuffer = NULL;
75 fNetMidiPlaybackBuffer = NULL;
76 fNetAudioCaptureBuffer = NULL;
77 fNetAudioPlaybackBuffer = NULL;
80 JackNetInterface::~JackNetInterface()
82 jack_log(
"JackNetInterface::~JackNetInterface");
87 delete fNetAudioCaptureBuffer;
88 delete fNetAudioPlaybackBuffer;
89 delete fNetMidiCaptureBuffer;
90 delete fNetMidiPlaybackBuffer;
93 int JackNetInterface::SetNetBufferSize()
96 float audio_size = (fNetAudioCaptureBuffer)
97 ? fNetAudioCaptureBuffer->GetCycleSize()
98 : (fNetAudioPlaybackBuffer) ? fNetAudioPlaybackBuffer->GetCycleSize() : 0;
99 jack_log(
"audio_size %f", audio_size);
102 float midi_size = (fNetMidiCaptureBuffer)
103 ? fNetMidiCaptureBuffer->GetCycleSize()
104 : (fNetMidiPlaybackBuffer) ? fNetMidiPlaybackBuffer->GetCycleSize() : 0;
105 jack_log(
"midi_size %f", midi_size);
108 int bufsize = NETWORK_MAX_LATENCY * (fParams.fMtu + (int)audio_size + (
int)midi_size);
109 jack_log(
"SetNetBufferSize bufsize = %d", bufsize);
112 if (fSocket.SetOption(SOL_SOCKET, SO_SNDBUF, &bufsize,
sizeof(bufsize)) == SOCKET_ERROR) {
117 if (fSocket.SetOption(SOL_SOCKET, SO_RCVBUF, &bufsize,
sizeof(bufsize)) == SOCKET_ERROR) {
124 bool JackNetInterface::SetParams()
127 strcpy(fTxHeader.fPacketType,
"header");
128 fTxHeader.fID = fParams.fID;
129 fTxHeader.fCycle = 0;
130 fTxHeader.fSubCycle = 0;
131 fTxHeader.fIsLastPckt = 0;
134 strcpy(fRxHeader.fPacketType,
"header");
135 fRxHeader.fID = fParams.fID;
136 fRxHeader.fCycle = 0;
137 fRxHeader.fSubCycle = 0;
138 fRxHeader.fIsLastPckt = 0;
141 fTxBuffer =
new char[fParams.fMtu];
142 fRxBuffer =
new char[fParams.fMtu];
147 fTxData = fTxBuffer + HEADER_SIZE;
148 fRxData = fRxBuffer + HEADER_SIZE;
153 int JackNetInterface::MidiSend(NetMidiBuffer* buffer,
int midi_channnels,
int audio_channels)
155 if (midi_channnels > 0) {
157 fTxHeader.fDataType =
'm';
158 uint data_size = buffer->RenderFromJackPorts();
159 fTxHeader.fNumPacket = buffer->GetNumPackets(data_size, PACKET_AVAILABLE_SIZE(&fParams));
161 for (uint subproc = 0; subproc < fTxHeader.fNumPacket; subproc++) {
162 fTxHeader.fSubCycle = subproc;
163 fTxHeader.fIsLastPckt = ((subproc == (fTxHeader.fNumPacket - 1)) && audio_channels == 0) ? 1 : 0;
164 fTxHeader.fPacketSize = HEADER_SIZE + buffer->RenderToNetwork(subproc, data_size);
165 memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE);
166 if (Send(fTxHeader.fPacketSize, 0) == SOCKET_ERROR) {
174 int JackNetInterface::AudioSend(NetAudioBuffer* buffer,
int audio_channels)
177 if (audio_channels > 0) {
178 fTxHeader.fDataType =
'a';
179 fTxHeader.fActivePorts = buffer->RenderFromJackPorts();
180 fTxHeader.fNumPacket = buffer->GetNumPackets(fTxHeader.fActivePorts);
182 for (uint subproc = 0; subproc < fTxHeader.fNumPacket; subproc++) {
183 fTxHeader.fSubCycle = subproc;
184 fTxHeader.fIsLastPckt = (subproc == (fTxHeader.fNumPacket - 1)) ? 1 : 0;
185 fTxHeader.fPacketSize = HEADER_SIZE + buffer->RenderToNetwork(subproc, fTxHeader.fActivePorts);
186 memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE);
188 if (Send(fTxHeader.fPacketSize, 0) == SOCKET_ERROR) {
196 int JackNetInterface::MidiRecv(packet_header_t* rx_head, NetMidiBuffer* buffer, uint& recvd_midi_pckt)
198 int rx_bytes = Recv(rx_head->fPacketSize, 0);
199 fRxHeader.fCycle = rx_head->fCycle;
200 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
201 buffer->RenderFromNetwork(rx_head->fSubCycle, rx_bytes - HEADER_SIZE);
204 if (++recvd_midi_pckt == rx_head->fNumPacket) {
205 buffer->RenderToJackPorts();
210 int JackNetInterface::AudioRecv(packet_header_t* rx_head, NetAudioBuffer* buffer)
212 int rx_bytes = Recv(rx_head->fPacketSize, 0);
213 fRxHeader.fCycle = rx_head->fCycle;
214 fRxHeader.fSubCycle = rx_head->fSubCycle;
215 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
216 fRxHeader.fActivePorts = rx_head->fActivePorts;
217 rx_bytes = buffer->RenderFromNetwork(rx_head->fCycle, rx_head->fSubCycle, fRxHeader.fActivePorts);
220 if (fRxHeader.fIsLastPckt) {
221 buffer->RenderToJackPorts();
226 int JackNetInterface::FinishRecv(NetAudioBuffer* buffer)
228 buffer->RenderToJackPorts();
229 return NET_PACKET_ERROR;
232 NetAudioBuffer* JackNetInterface::AudioBufferFactory(
int nports,
char* buffer)
234 switch (fParams.fSampleEncoder) {
236 case JackFloatEncoder:
237 return new NetFloatAudioBuffer(&fParams, nports, buffer);
240 return new NetIntAudioBuffer(&fParams, nports, buffer);
243 case JackCeltEncoder:
244 return new NetCeltAudioBuffer(&fParams, nports, buffer, fParams.fKBps);
247 case JackOpusEncoder:
248 return new NetOpusAudioBuffer(&fParams, nports, buffer, fParams.fKBps);
254 void JackNetInterface::SetRcvTimeOut()
257 if (fSocket.SetTimeOut(PACKET_TIMEOUT) == SOCKET_ERROR) {
258 jack_error(
"Can't set rx timeout : %s", StrError(NET_ERROR_CODE));
267 bool JackNetMasterInterface::Init()
269 jack_log(
"JackNetMasterInterface::Init : ID %u", fParams.fID);
271 session_params_t host_params;
276 if (fSocket.NewSocket() == SOCKET_ERROR) {
277 jack_error(
"Can't create socket : %s", StrError(NET_ERROR_CODE));
282 if (fSocket.SetTimeOut(MASTER_INIT_TIMEOUT) < 0) {
283 jack_error(
"Can't set init timeout : %s", StrError(NET_ERROR_CODE));
287 if (fSocket.Connect() == SOCKET_ERROR) {
288 jack_error(
"Can't connect : %s", StrError(NET_ERROR_CODE));
293 jack_info(
"Sending parameters to %s...", fParams.fSlaveNetName);
296 session_params_t net_params;
297 memset(&net_params, 0,
sizeof(session_params_t));
298 SetPacketType(&fParams, SLAVE_SETUP);
299 SessionParamsHToN(&fParams, &net_params);
301 if (fSocket.Send(&net_params,
sizeof(session_params_t), 0) == SOCKET_ERROR) {
302 jack_error(
"Error in send : %s", StrError(NET_ERROR_CODE));
305 memset(&net_params, 0,
sizeof(session_params_t));
306 if (((rx_bytes = fSocket.Recv(&net_params,
sizeof(session_params_t), 0)) == SOCKET_ERROR) && (fSocket.GetError() != NET_NO_DATA)) {
311 SessionParamsNToH(&net_params, &host_params);
313 while ((GetPacketType(&host_params) != START_MASTER) && (++attempt < SLAVE_SETUP_RETRY));
315 if (attempt == SLAVE_SETUP_RETRY) {
323 bool JackNetMasterInterface::SetParams()
325 jack_log(
"JackNetMasterInterface::SetParams audio in = %d audio out = %d MIDI in = %d MIDI out = %d",
326 fParams.fSendAudioChannels, fParams.fReturnAudioChannels,
327 fParams.fSendMidiChannels, fParams.fReturnMidiChannels);
329 JackNetInterface::SetParams();
331 fTxHeader.fDataStream =
's';
332 fRxHeader.fDataStream =
'r';
334 fMaxCycleOffset = fParams.fNetworkLatency;
337 if (fParams.fSendMidiChannels > 0) {
338 fNetMidiCaptureBuffer =
new NetMidiBuffer(&fParams, fParams.fSendMidiChannels, fTxData);
341 if (fParams.fReturnMidiChannels > 0) {
342 fNetMidiPlaybackBuffer =
new NetMidiBuffer(&fParams, fParams.fReturnMidiChannels, fRxData);
348 if (fParams.fSendAudioChannels > 0) {
349 fNetAudioCaptureBuffer = AudioBufferFactory(fParams.fSendAudioChannels, fTxData);
350 assert(fNetAudioCaptureBuffer);
353 if (fParams.fReturnAudioChannels > 0) {
354 fNetAudioPlaybackBuffer = AudioBufferFactory(fParams.fReturnAudioChannels, fRxData);
355 assert(fNetAudioPlaybackBuffer);
358 }
catch (exception&) {
359 jack_error(
"NetAudioBuffer allocation error...");
364 if (SetNetBufferSize() == SOCKET_ERROR) {
365 jack_error(
"Can't set net buffer sizes : %s", StrError(NET_ERROR_CODE));
372 FreeNetworkBuffers();
376 void JackNetMasterInterface::Exit()
378 jack_log(
"JackNetMasterInterface::Exit, ID %u", fParams.fID);
384 jack_info(
"Exiting '%s'", fParams.fName);
385 SetPacketType(&fParams, KILL_MASTER);
386 JackNetSocket mcast_socket(fMulticastIP, fSocket.GetPort());
388 session_params_t net_params;
389 memset(&net_params, 0,
sizeof(session_params_t));
390 SessionParamsHToN(&fParams, &net_params);
392 if (mcast_socket.NewSocket() == SOCKET_ERROR) {
393 jack_error(
"Can't create socket : %s", StrError(NET_ERROR_CODE));
395 if (mcast_socket.SendTo(&net_params,
sizeof(session_params_t), 0, fMulticastIP) == SOCKET_ERROR) {
396 jack_error(
"Can't send suicide request : %s", StrError(NET_ERROR_CODE));
399 mcast_socket.Close();
402 void JackNetMasterInterface::FatalRecvError()
405 jack_error(
"Recv connection lost error = %s, '%s' exiting", StrError(NET_ERROR_CODE), fParams.fName);
412 void JackNetMasterInterface::FatalSendError()
415 jack_error(
"Send connection lost error = %s, '%s' exiting", StrError(NET_ERROR_CODE), fParams.fName);
422 int JackNetMasterInterface::Recv(
size_t size,
int flags)
426 if (((rx_bytes = fSocket.Recv(fRxBuffer, size, flags)) == SOCKET_ERROR) && fRunning) {
430 packet_header_t* header =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
431 PacketHeaderNToH(header, header);
435 int JackNetMasterInterface::Send(
size_t size,
int flags)
438 packet_header_t* header =
reinterpret_cast<packet_header_t*
>(fTxBuffer);
439 PacketHeaderHToN(header, header);
441 if (((tx_bytes = fSocket.Send(fTxBuffer, size, flags)) == SOCKET_ERROR) && fRunning) {
447 bool JackNetMasterInterface::IsSynched()
449 return (fCurrentCycleOffset <= fMaxCycleOffset);
452 int JackNetMasterInterface::SyncSend()
457 fTxHeader.fSubCycle = 0;
458 fTxHeader.fDataType =
's';
459 fTxHeader.fIsLastPckt = (fParams.fSendMidiChannels == 0 && fParams.fSendAudioChannels == 0) ? 1 : 0;
460 fTxHeader.fPacketSize = fParams.fMtu;
462 memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE);
464 return Send(fTxHeader.fPacketSize, 0);
467 int JackNetMasterInterface::DataSend()
469 if (MidiSend(fNetMidiCaptureBuffer, fParams.fSendMidiChannels, fParams.fSendAudioChannels) == SOCKET_ERROR) {
472 return AudioSend(fNetAudioCaptureBuffer, fParams.fSendAudioChannels);
475 int JackNetMasterInterface::SyncRecv()
478 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
482 rx_bytes = Recv(fParams.fMtu, MSG_PEEK);
484 if (rx_bytes == SOCKET_ERROR) {
488 while ((strcmp(rx_head->fPacketType,
"header") != 0) && (rx_head->fDataType !=
's'));
490 fCurrentCycleOffset = fTxHeader.fCycle - rx_head->fCycle;
492 if (fCurrentCycleOffset < fMaxCycleOffset) {
493 jack_info(
"Synching with latency = %d", fCurrentCycleOffset);
496 rx_bytes = Recv(rx_head->fPacketSize, 0);
497 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
502 int JackNetMasterInterface::DataRecv()
505 uint recvd_midi_pckt = 0;
506 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
508 while (!fRxHeader.fIsLastPckt) {
510 rx_bytes = Recv(fParams.fMtu, MSG_PEEK);
513 if (rx_bytes == SOCKET_ERROR) {
517 if (rx_bytes && (rx_head->fDataStream ==
'r') && (rx_head->fID == fParams.fID)) {
519 switch (rx_head->fDataType) {
522 rx_bytes = MidiRecv(rx_head, fNetMidiPlaybackBuffer, recvd_midi_pckt);
526 rx_bytes = AudioRecv(rx_head, fNetAudioPlaybackBuffer);
530 jack_info(
"NetMaster : overloaded, skipping receive from '%s'", fParams.fName);
531 return FinishRecv(fNetAudioPlaybackBuffer);
539 void JackNetMasterInterface::EncodeSyncPacket()
543 memset(fTxData, 0, PACKET_AVAILABLE_SIZE(&fParams));
546 if (fParams.fTransportSync) {
547 EncodeTransportData();
548 TransportDataHToN(&fSendTransportData, &fSendTransportData);
550 memcpy(fTxData, &fSendTransportData,
sizeof(net_transport_data_t));
558 fTxHeader.fActivePorts = (fNetAudioPlaybackBuffer) ? fNetAudioPlaybackBuffer->ActivePortsToNetwork(fTxData) : 0;
561 void JackNetMasterInterface::DecodeSyncPacket()
565 if (fParams.fTransportSync) {
567 memcpy(&fReturnTransportData, fRxData,
sizeof(net_transport_data_t));
568 TransportDataNToH(&fReturnTransportData, &fReturnTransportData);
569 DecodeTransportData();
575 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
578 if (fNetAudioCaptureBuffer) {
579 fNetAudioCaptureBuffer->ActivePortsFromNetwork(fRxData, rx_head->fActivePorts);
585 uint JackNetSlaveInterface::fSlaveCounter = 0;
587 void JackNetSlaveInterface::InitAPI()
590 if (fSlaveCounter++ == 0) {
591 if (SocketAPIInit() < 0) {
592 jack_error(
"Can't init Socket API, exiting...");
593 throw std::bad_alloc();
598 bool JackNetSlaveInterface::Init()
600 jack_log(
"JackNetSlaveInterface::Init()");
603 strcpy(fParams.fPacketType,
"params");
604 fParams.fProtocolVersion = SLAVE_PROTOCOL;
605 SetPacketType(&fParams, SLAVE_AVAILABLE);
612 status = SendAvailableToMaster();
613 if (status == NET_SOCKET_ERROR) {
617 while (status != NET_CONNECTED);
620 jack_info(
"Initializing connection with %s...", fParams.fMasterNetName);
621 status = SendStartToMaster();
622 if (status == NET_ERROR) {
626 while (status != NET_ROLLING);
632 bool JackNetSlaveInterface::InitConnection(
int time_out_sec)
634 jack_log(
"JackNetSlaveInterface::InitConnection()");
635 uint try_count = (time_out_sec > 0) ? ((1000000 * time_out_sec) / SLAVE_INIT_TIMEOUT) : LONG_MAX;
638 strcpy(fParams.fPacketType,
"params");
639 fParams.fProtocolVersion = SLAVE_PROTOCOL;
640 SetPacketType(&fParams, SLAVE_AVAILABLE);
645 status = SendAvailableToMaster(try_count);
646 if (status == NET_SOCKET_ERROR) {
650 while (status != NET_CONNECTED && --try_count > 0);
652 return (try_count != 0);
655 bool JackNetSlaveInterface::InitRendering()
657 jack_log(
"JackNetSlaveInterface::InitRendering()");
662 jack_info(
"Initializing connection with %s...", fParams.fMasterNetName);
663 status = SendStartToMaster();
664 if (status == NET_ERROR) {
668 while (status != NET_ROLLING);
673 net_status_t JackNetSlaveInterface::SendAvailableToMaster(
long try_count)
675 jack_log(
"JackNetSlaveInterface::SendAvailableToMaster()");
677 session_params_t host_params;
681 if (fSocket.NewSocket() == SOCKET_ERROR) {
682 jack_error(
"Fatal error : network unreachable - %s", StrError(NET_ERROR_CODE));
683 return NET_SOCKET_ERROR;
686 if (fSocket.IsLocal(fMulticastIP)) {
690 if (fSocket.Bind() == SOCKET_ERROR) {
691 jack_error(
"Can't bind the socket : %s", StrError(NET_ERROR_CODE));
692 return NET_SOCKET_ERROR;
697 if (fSocket.SetTimeOut(SLAVE_INIT_TIMEOUT) == SOCKET_ERROR) {
698 jack_error(
"Can't set init timeout : %s", StrError(NET_ERROR_CODE));
702 if (fSocket.SetLocalLoop() == SOCKET_ERROR) {
703 jack_error(
"Can't disable multicast loop : %s", StrError(NET_ERROR_CODE));
710 session_params_t net_params;
711 memset(&net_params, 0,
sizeof(session_params_t));
712 SessionParamsHToN(&fParams, &net_params);
713 if (fSocket.SendTo(&net_params,
sizeof(session_params_t), 0, fMulticastIP) == SOCKET_ERROR) {
714 jack_error(
"Error in data send : %s", StrError(NET_ERROR_CODE));
718 memset(&net_params, 0,
sizeof(session_params_t));
719 rx_bytes = fSocket.CatchHost(&net_params,
sizeof(session_params_t), 0);
720 SessionParamsNToH(&net_params, &host_params);
721 if ((rx_bytes == SOCKET_ERROR) && (fSocket.GetError() != NET_NO_DATA)) {
722 jack_error(
"Can't receive : %s", StrError(NET_ERROR_CODE));
723 return NET_RECV_ERROR;
726 while (strcmp(host_params.fPacketType, fParams.fPacketType) && (GetPacketType(&host_params) != SLAVE_SETUP) && (--try_count > 0));
729 if (try_count == 0) {
731 return NET_CONNECT_ERROR;
735 fParams = host_params;
738 if (fSocket.Connect() == SOCKET_ERROR) {
739 jack_error(
"Error in connect : %s", StrError(NET_ERROR_CODE));
740 return NET_CONNECT_ERROR;
742 return NET_CONNECTED;
745 net_status_t JackNetSlaveInterface::SendStartToMaster()
747 jack_log(
"JackNetSlaveInterface::SendStartToMaster");
750 session_params_t net_params;
751 memset(&net_params, 0,
sizeof(session_params_t));
752 SetPacketType(&fParams, START_MASTER);
753 SessionParamsHToN(&fParams, &net_params);
754 if (fSocket.Send(&net_params,
sizeof(session_params_t), 0) == SOCKET_ERROR) {
755 jack_error(
"Error in send : %s", StrError(NET_ERROR_CODE));
756 return (fSocket.GetError() == NET_CONN_ERROR) ? NET_ERROR : NET_SEND_ERROR;
761 bool JackNetSlaveInterface::SetParams()
763 jack_log(
"JackNetSlaveInterface::SetParams audio in = %d audio out = %d MIDI in = %d MIDI out = %d",
764 fParams.fSendAudioChannels, fParams.fReturnAudioChannels,
765 fParams.fSendMidiChannels, fParams.fReturnMidiChannels);
767 JackNetInterface::SetParams();
769 fTxHeader.fDataStream =
'r';
770 fRxHeader.fDataStream =
's';
773 if (fParams.fSendMidiChannels > 0) {
774 fNetMidiCaptureBuffer =
new NetMidiBuffer(&fParams, fParams.fSendMidiChannels, fRxData);
777 if (fParams.fReturnMidiChannels > 0) {
778 fNetMidiPlaybackBuffer =
new NetMidiBuffer(&fParams, fParams.fReturnMidiChannels, fTxData);
784 if (fParams.fSendAudioChannels > 0) {
785 fNetAudioCaptureBuffer = AudioBufferFactory(fParams.fSendAudioChannels, fRxData);
786 assert(fNetAudioCaptureBuffer);
789 if (fParams.fReturnAudioChannels > 0) {
790 fNetAudioPlaybackBuffer = AudioBufferFactory(fParams.fReturnAudioChannels, fTxData);
791 assert(fNetAudioPlaybackBuffer);
794 }
catch (exception&) {
795 jack_error(
"NetAudioBuffer allocation error...");
800 if (SetNetBufferSize() == SOCKET_ERROR) {
801 jack_error(
"Can't set net buffer sizes : %s", StrError(NET_ERROR_CODE));
808 FreeNetworkBuffers();
812 void JackNetSlaveInterface::FatalRecvError()
814 jack_error(
"Recv connection lost error = %s", StrError(NET_ERROR_CODE));
815 throw JackNetException();
818 void JackNetSlaveInterface::FatalSendError()
820 jack_error(
"Send connection lost error = %s", StrError(NET_ERROR_CODE));
821 throw JackNetException();
824 int JackNetSlaveInterface::Recv(
size_t size,
int flags)
826 int rx_bytes = fSocket.Recv(fRxBuffer, size, flags);
829 if (rx_bytes == SOCKET_ERROR) {
833 packet_header_t* header =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
834 PacketHeaderNToH(header, header);
838 int JackNetSlaveInterface::Send(
size_t size,
int flags)
840 packet_header_t* header =
reinterpret_cast<packet_header_t*
>(fTxBuffer);
841 PacketHeaderHToN(header, header);
842 int tx_bytes = fSocket.Send(fTxBuffer, size, flags);
845 if (tx_bytes == SOCKET_ERROR) {
852 int JackNetSlaveInterface::SyncRecv()
855 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
859 rx_bytes = Recv(fParams.fMtu, 0);
861 if (rx_bytes == SOCKET_ERROR) {
865 while ((strcmp(rx_head->fPacketType,
"header") != 0) && (rx_head->fDataType !=
's'));
867 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
873 int JackNetSlaveInterface::DataRecv()
876 uint recvd_midi_pckt = 0;
877 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
879 while (!fRxHeader.fIsLastPckt) {
881 rx_bytes = Recv(fParams.fMtu, MSG_PEEK);
884 if (rx_bytes == SOCKET_ERROR) {
888 if (rx_bytes && (rx_head->fDataStream ==
's') && (rx_head->fID == fParams.fID)) {
890 switch (rx_head->fDataType) {
893 rx_bytes = MidiRecv(rx_head, fNetMidiCaptureBuffer, recvd_midi_pckt);
897 rx_bytes = AudioRecv(rx_head, fNetAudioCaptureBuffer);
901 jack_info(
"NetSlave : overloaded, skipping receive");
902 return FinishRecv(fNetAudioCaptureBuffer);
907 fRxHeader.fCycle = rx_head->fCycle;
911 int JackNetSlaveInterface::SyncSend()
914 if (fParams.fSlaveSyncMode) {
915 fTxHeader.fCycle = fRxHeader.fCycle;
919 fTxHeader.fSubCycle = 0;
920 fTxHeader.fDataType =
's';
921 fTxHeader.fIsLastPckt = (fParams.fReturnMidiChannels == 0 && fParams.fReturnAudioChannels == 0) ? 1 : 0;
922 fTxHeader.fPacketSize = fParams.fMtu;
924 memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE);
926 return Send(fTxHeader.fPacketSize, 0);
929 int JackNetSlaveInterface::DataSend()
931 if (MidiSend(fNetMidiPlaybackBuffer, fParams.fReturnMidiChannels, fParams.fReturnAudioChannels) == SOCKET_ERROR) {
934 return AudioSend(fNetAudioPlaybackBuffer, fParams.fReturnAudioChannels);
938 void JackNetSlaveInterface::EncodeSyncPacket()
942 memset(fTxData, 0, PACKET_AVAILABLE_SIZE(&fParams));
945 if (fParams.fTransportSync) {
946 EncodeTransportData();
947 TransportDataHToN(&fReturnTransportData, &fReturnTransportData);
949 memcpy(fTxData, &fReturnTransportData,
sizeof(net_transport_data_t));
957 fTxHeader.fActivePorts = (fNetAudioCaptureBuffer) ? fNetAudioCaptureBuffer->ActivePortsToNetwork(fTxData) : 0;
960 void JackNetSlaveInterface::DecodeSyncPacket()
964 if (fParams.fTransportSync) {
966 memcpy(&fSendTransportData, fRxData,
sizeof(net_transport_data_t));
967 TransportDataNToH(&fSendTransportData, &fSendTransportData);
968 DecodeTransportData();
974 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
977 if (fNetAudioPlaybackBuffer) {
978 fNetAudioPlaybackBuffer->ActivePortsFromNetwork(fRxData, rx_head->fActivePorts);
SERVER_EXPORT void jack_error(const char *fmt,...)
SERVER_EXPORT void jack_info(const char *fmt,...)
SERVER_EXPORT void jack_log(const char *fmt,...)