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));
66 fPacketTimeOut = PACKET_TIMEOUT * NETWORK_DEFAULT_LATENCY;
69 void JackNetInterface::FreeNetworkBuffers()
71 delete fNetMidiCaptureBuffer;
72 delete fNetMidiPlaybackBuffer;
73 delete fNetAudioCaptureBuffer;
74 delete fNetAudioPlaybackBuffer;
75 fNetMidiCaptureBuffer = NULL;
76 fNetMidiPlaybackBuffer = NULL;
77 fNetAudioCaptureBuffer = NULL;
78 fNetAudioPlaybackBuffer = NULL;
81 JackNetInterface::~JackNetInterface()
83 jack_log(
"JackNetInterface::~JackNetInterface");
88 delete fNetAudioCaptureBuffer;
89 delete fNetAudioPlaybackBuffer;
90 delete fNetMidiCaptureBuffer;
91 delete fNetMidiPlaybackBuffer;
94 int JackNetInterface::SetNetBufferSize()
97 float audio_size = (fNetAudioCaptureBuffer)
98 ? fNetAudioCaptureBuffer->GetCycleSize()
99 : (fNetAudioPlaybackBuffer) ? fNetAudioPlaybackBuffer->GetCycleSize() : 0;
100 jack_log(
"audio_size %f", audio_size);
103 float midi_size = (fNetMidiCaptureBuffer)
104 ? fNetMidiCaptureBuffer->GetCycleSize()
105 : (fNetMidiPlaybackBuffer) ? fNetMidiPlaybackBuffer->GetCycleSize() : 0;
106 jack_log(
"midi_size %f", midi_size);
109 int bufsize = NETWORK_MAX_LATENCY * (fParams.fMtu + (int)audio_size + (
int)midi_size);
110 jack_log(
"SetNetBufferSize bufsize = %d", bufsize);
113 if (fSocket.SetOption(SOL_SOCKET, SO_SNDBUF, &bufsize,
sizeof(bufsize)) == SOCKET_ERROR) {
118 if (fSocket.SetOption(SOL_SOCKET, SO_RCVBUF, &bufsize,
sizeof(bufsize)) == SOCKET_ERROR) {
125 bool JackNetInterface::SetParams()
128 memset(&fTxHeader, 0,
sizeof(fTxHeader));
129 strcpy(fTxHeader.fPacketType,
"header");
130 fTxHeader.fID = fParams.fID;
131 fTxHeader.fCycle = 0;
132 fTxHeader.fSubCycle = 0;
133 fTxHeader.fIsLastPckt = 0;
136 memset(&fRxHeader, 0,
sizeof(fTxHeader));
137 strcpy(fRxHeader.fPacketType,
"header");
138 fRxHeader.fID = fParams.fID;
139 fRxHeader.fCycle = 0;
140 fRxHeader.fSubCycle = 0;
141 fRxHeader.fIsLastPckt = 0;
144 fTxBuffer =
new char[fParams.fMtu];
145 fRxBuffer =
new char[fParams.fMtu];
150 fTxData = fTxBuffer + HEADER_SIZE;
151 fRxData = fRxBuffer + HEADER_SIZE;
156 int JackNetInterface::MidiSend(NetMidiBuffer* buffer,
int midi_channnels,
int audio_channels)
158 if (midi_channnels > 0) {
160 fTxHeader.fDataType =
'm';
161 uint data_size = buffer->RenderFromJackPorts();
162 fTxHeader.fNumPacket = buffer->GetNumPackets(data_size, PACKET_AVAILABLE_SIZE(&fParams));
164 for (uint subproc = 0; subproc < fTxHeader.fNumPacket; subproc++) {
165 fTxHeader.fSubCycle = subproc;
166 fTxHeader.fIsLastPckt = ((subproc == (fTxHeader.fNumPacket - 1)) && audio_channels == 0) ? 1 : 0;
167 fTxHeader.fPacketSize = HEADER_SIZE + buffer->RenderToNetwork(subproc, data_size);
168 memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE);
170 if (Send(fTxHeader.fPacketSize, 0) == SOCKET_ERROR) {
178 int JackNetInterface::AudioSend(NetAudioBuffer* buffer,
int audio_channels)
181 if (audio_channels > 0) {
182 fTxHeader.fDataType =
'a';
183 fTxHeader.fActivePorts = buffer->RenderFromJackPorts(fTxHeader.fFrames);
184 fTxHeader.fNumPacket = buffer->GetNumPackets(fTxHeader.fActivePorts);
186 for (uint subproc = 0; subproc < fTxHeader.fNumPacket; subproc++) {
187 fTxHeader.fSubCycle = subproc;
188 fTxHeader.fIsLastPckt = (subproc == (fTxHeader.fNumPacket - 1)) ? 1 : 0;
189 fTxHeader.fPacketSize = HEADER_SIZE + buffer->RenderToNetwork(subproc, fTxHeader.fActivePorts);
190 memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE);
192 if (Send(fTxHeader.fPacketSize, 0) == SOCKET_ERROR) {
200 int JackNetInterface::MidiRecv(packet_header_t* rx_head, NetMidiBuffer* buffer, uint& recvd_midi_pckt)
202 int rx_bytes = Recv(rx_head->fPacketSize, 0);
203 fRxHeader.fCycle = rx_head->fCycle;
204 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
205 buffer->RenderFromNetwork(rx_head->fSubCycle, rx_bytes - HEADER_SIZE);
208 if (++recvd_midi_pckt == rx_head->fNumPacket) {
209 buffer->RenderToJackPorts();
215 int JackNetInterface::AudioRecv(packet_header_t* rx_head, NetAudioBuffer* buffer)
217 int rx_bytes = Recv(rx_head->fPacketSize, 0);
218 fRxHeader.fCycle = rx_head->fCycle;
219 fRxHeader.fSubCycle = rx_head->fSubCycle;
220 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
221 fRxHeader.fActivePorts = rx_head->fActivePorts;
222 fRxHeader.fFrames = rx_head->fFrames;
223 rx_bytes = buffer->RenderFromNetwork(rx_head->fCycle, rx_head->fSubCycle, fRxHeader.fActivePorts);
226 if (fRxHeader.fIsLastPckt) {
227 buffer->RenderToJackPorts(fRxHeader.fFrames);
233 int JackNetInterface::FinishRecv(NetAudioBuffer* buffer)
236 buffer->RenderToJackPorts(fRxHeader.fFrames);
240 return DATA_PACKET_ERROR;
243 NetAudioBuffer* JackNetInterface::AudioBufferFactory(
int nports,
char* buffer)
245 switch (fParams.fSampleEncoder) {
247 case JackFloatEncoder:
248 return new NetFloatAudioBuffer(&fParams, nports, buffer);
251 return new NetIntAudioBuffer(&fParams, nports, buffer);
254 case JackCeltEncoder:
255 return new NetCeltAudioBuffer(&fParams, nports, buffer, fParams.fKBps);
258 case JackOpusEncoder:
259 return new NetOpusAudioBuffer(&fParams, nports, buffer, fParams.fKBps);
263 throw std::bad_alloc();
266 void JackNetInterface::SetRcvTimeOut()
269 if (fSocket.SetTimeOut(fPacketTimeOut) == SOCKET_ERROR) {
270 jack_error(
"Can't set rx timeout : %s", StrError(NET_ERROR_CODE));
279 bool JackNetMasterInterface::Init()
281 jack_log(
"JackNetMasterInterface::Init : ID %u", fParams.fID);
283 session_params_t host_params;
288 if (fSocket.NewSocket() == SOCKET_ERROR) {
289 jack_error(
"Can't create socket : %s", StrError(NET_ERROR_CODE));
294 if (fSocket.SetTimeOut(MASTER_INIT_TIMEOUT) < 0) {
295 jack_error(
"Can't set init timeout : %s", StrError(NET_ERROR_CODE));
299 if (fSocket.Connect() == SOCKET_ERROR) {
300 jack_error(
"Can't connect : %s", StrError(NET_ERROR_CODE));
305 jack_info(
"Sending parameters to %s...", fParams.fSlaveNetName);
308 session_params_t net_params;
309 memset(&net_params, 0,
sizeof(session_params_t));
310 SetPacketType(&fParams, SLAVE_SETUP);
311 SessionParamsHToN(&fParams, &net_params);
313 if (fSocket.Send(&net_params,
sizeof(session_params_t), 0) == SOCKET_ERROR) {
314 jack_error(
"Error in send : %s", StrError(NET_ERROR_CODE));
317 memset(&net_params, 0,
sizeof(session_params_t));
318 if (((rx_bytes = fSocket.Recv(&net_params,
sizeof(session_params_t), 0)) == SOCKET_ERROR) && (fSocket.GetError() != NET_NO_DATA)) {
323 SessionParamsNToH(&net_params, &host_params);
325 while ((GetPacketType(&host_params) != START_MASTER) && (++attempt < SLAVE_SETUP_RETRY));
327 if (attempt == SLAVE_SETUP_RETRY) {
335 bool JackNetMasterInterface::SetParams()
337 jack_log(
"JackNetMasterInterface::SetParams audio in = %d audio out = %d MIDI in = %d MIDI out = %d",
338 fParams.fSendAudioChannels, fParams.fReturnAudioChannels,
339 fParams.fSendMidiChannels, fParams.fReturnMidiChannels);
341 JackNetInterface::SetParams();
343 fTxHeader.fDataStream =
's';
344 fRxHeader.fDataStream =
'r';
346 fMaxCycleOffset = fParams.fNetworkLatency;
349 if (fParams.fSendMidiChannels > 0) {
350 fNetMidiCaptureBuffer =
new NetMidiBuffer(&fParams, fParams.fSendMidiChannels, fTxData);
353 if (fParams.fReturnMidiChannels > 0) {
354 fNetMidiPlaybackBuffer =
new NetMidiBuffer(&fParams, fParams.fReturnMidiChannels, fRxData);
360 if (fParams.fSendAudioChannels > 0) {
361 fNetAudioCaptureBuffer = AudioBufferFactory(fParams.fSendAudioChannels, fTxData);
362 assert(fNetAudioCaptureBuffer);
365 if (fParams.fReturnAudioChannels > 0) {
366 fNetAudioPlaybackBuffer = AudioBufferFactory(fParams.fReturnAudioChannels, fRxData);
367 assert(fNetAudioPlaybackBuffer);
370 }
catch (exception&) {
371 jack_error(
"NetAudioBuffer on master allocation error...");
376 if (SetNetBufferSize() == SOCKET_ERROR) {
377 jack_error(
"Can't set net buffer sizes : %s", StrError(NET_ERROR_CODE));
384 FreeNetworkBuffers();
388 void JackNetMasterInterface::Exit()
390 jack_log(
"JackNetMasterInterface::Exit, ID %u", fParams.fID);
396 jack_info(
"Exiting '%s' %s", fParams.fName, fMulticastIP);
397 SetPacketType(&fParams, KILL_MASTER);
398 JackNetSocket mcast_socket(fMulticastIP, fSocket.GetPort());
400 session_params_t net_params;
401 memset(&net_params, 0,
sizeof(session_params_t));
402 SessionParamsHToN(&fParams, &net_params);
404 if (mcast_socket.NewSocket() == SOCKET_ERROR) {
405 jack_error(
"Can't create socket : %s", StrError(NET_ERROR_CODE));
407 if (mcast_socket.SendTo(&net_params,
sizeof(session_params_t), 0, fMulticastIP) == SOCKET_ERROR) {
408 jack_error(
"Can't send suicide request : %s", StrError(NET_ERROR_CODE));
411 mcast_socket.Close();
414 void JackNetMasterInterface::FatalRecvError()
417 jack_error(
"Recv connection lost error = %s, '%s' exiting", StrError(NET_ERROR_CODE), fParams.fName);
424 void JackNetMasterInterface::FatalSendError()
427 jack_error(
"Send connection lost error = %s, '%s' exiting", StrError(NET_ERROR_CODE), fParams.fName);
434 int JackNetMasterInterface::Recv(
size_t size,
int flags)
438 if (((rx_bytes = fSocket.Recv(fRxBuffer, size, flags)) == SOCKET_ERROR) && fRunning) {
442 packet_header_t* header =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
443 PacketHeaderNToH(header, header);
447 int JackNetMasterInterface::Send(
size_t size,
int flags)
450 packet_header_t* header =
reinterpret_cast<packet_header_t*
>(fTxBuffer);
451 PacketHeaderHToN(header, header);
453 if (((tx_bytes = fSocket.Send(fTxBuffer, size, flags)) == SOCKET_ERROR) && fRunning) {
459 int JackNetMasterInterface::SyncSend()
464 fTxHeader.fSubCycle = 0;
465 fTxHeader.fDataType =
's';
466 fTxHeader.fIsLastPckt = (fParams.fSendMidiChannels == 0 && fParams.fSendAudioChannels == 0) ? 1 : 0;
467 fTxHeader.fPacketSize = HEADER_SIZE + fTxHeader.fActivePorts *
sizeof(int);
469 memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE);
471 return Send(fTxHeader.fPacketSize, 0);
474 int JackNetMasterInterface::DataSend()
476 if (MidiSend(fNetMidiCaptureBuffer, fParams.fSendMidiChannels, fParams.fSendAudioChannels) == SOCKET_ERROR) {
479 return AudioSend(fNetAudioCaptureBuffer, fParams.fSendAudioChannels);
482 int JackNetMasterInterface::SyncRecv()
485 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
489 rx_bytes = Recv(fParams.fMtu, MSG_PEEK);
491 if (rx_bytes == SOCKET_ERROR) {
495 while (strcmp(rx_head->fPacketType,
"header") != 0);
498 if (rx_head->fDataType !=
's') {
499 jack_error(
"Wrong packet type : %c", rx_head->fDataType);
501 fRxHeader.fIsLastPckt = 0;
502 return SYNC_PACKET_ERROR;
505 fCurrentCycleOffset = fTxHeader.fCycle - rx_head->fCycle;
507 if (fCurrentCycleOffset < fMaxCycleOffset && !fSynched) {
508 jack_info(
"Synching with latency = %d", fCurrentCycleOffset);
511 if (fCurrentCycleOffset == fMaxCycleOffset) {
515 rx_bytes = Recv(rx_head->fPacketSize, 0);
516 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
521 int JackNetMasterInterface::DataRecv()
524 uint recvd_midi_pckt = 0;
525 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
527 while (!fRxHeader.fIsLastPckt) {
529 rx_bytes = Recv(fParams.fMtu, MSG_PEEK);
532 if (rx_bytes == SOCKET_ERROR) {
536 if (rx_bytes && (rx_head->fDataStream ==
'r') && (rx_head->fID == fParams.fID)) {
538 switch (rx_head->fDataType) {
541 rx_bytes = MidiRecv(rx_head, fNetMidiPlaybackBuffer, recvd_midi_pckt);
545 rx_bytes = AudioRecv(rx_head, fNetAudioPlaybackBuffer);
549 jack_info(
"NetMaster : missing last data packet from '%s'", fParams.fName);
550 return FinishRecv(fNetAudioPlaybackBuffer);
558 void JackNetMasterInterface::EncodeSyncPacket(
int frames)
562 memset(fTxData, 0, PACKET_AVAILABLE_SIZE(&fParams));
578 fTxHeader.fActivePorts = (fNetAudioPlaybackBuffer) ? fNetAudioPlaybackBuffer->ActivePortsToNetwork(fTxData) : 0;
579 fTxHeader.fFrames = frames;
582 void JackNetMasterInterface::DecodeSyncPacket(
int& frames)
599 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
602 if (fNetAudioCaptureBuffer) {
603 fNetAudioCaptureBuffer->ActivePortsFromNetwork(fRxData, rx_head->fActivePorts);
605 frames = rx_head->fFrames;
610 uint JackNetSlaveInterface::fSlaveCounter = 0;
612 void JackNetSlaveInterface::InitAPI()
615 if (fSlaveCounter++ == 0) {
616 if (SocketAPIInit() < 0) {
617 jack_error(
"Can't init Socket API, exiting...");
618 throw std::bad_alloc();
623 bool JackNetSlaveInterface::Init()
625 jack_log(
"JackNetSlaveInterface::Init()");
628 strcpy(fParams.fPacketType,
"params");
629 fParams.fProtocolVersion = NETWORK_PROTOCOL;
630 SetPacketType(&fParams, SLAVE_AVAILABLE);
637 status = SendAvailableToMaster();
638 if (status == NET_SOCKET_ERROR) {
642 while (status != NET_CONNECTED);
645 jack_info(
"Initializing connection with %s...", fParams.fMasterNetName);
646 status = SendStartToMaster();
647 if (status == NET_ERROR) {
651 while (status != NET_ROLLING);
657 bool JackNetSlaveInterface::InitConnection(
int time_out_sec)
659 jack_log(
"JackNetSlaveInterface::InitConnection time_out_sec = %d", time_out_sec);
660 int try_count = (time_out_sec > 0) ?
int((1000000.f *
float(time_out_sec)) / float(SLAVE_INIT_TIMEOUT)) : INT_MAX;
663 strcpy(fParams.fPacketType,
"params");
664 fParams.fProtocolVersion = NETWORK_PROTOCOL;
665 SetPacketType(&fParams, SLAVE_AVAILABLE);
667 return (SendAvailableToMaster(try_count) == NET_CONNECTED);
670 bool JackNetSlaveInterface::InitRendering()
672 jack_log(
"JackNetSlaveInterface::InitRendering()");
677 jack_info(
"Initializing connection with %s...", fParams.fMasterNetName);
678 status = SendStartToMaster();
679 if (status == NET_ERROR) {
683 while (status != NET_ROLLING);
688 net_status_t JackNetSlaveInterface::SendAvailableToMaster(
int try_count)
690 jack_log(
"JackNetSlaveInterface::SendAvailableToMaster try_count = %d", try_count);
692 session_params_t host_params;
696 if (fSocket.NewSocket() == SOCKET_ERROR) {
697 jack_error(
"Fatal error : network unreachable - %s", StrError(NET_ERROR_CODE));
698 return NET_SOCKET_ERROR;
701 if (fSocket.IsLocal(fMulticastIP)) {
705 if (fSocket.Bind() == SOCKET_ERROR) {
706 jack_error(
"Can't bind the socket : %s", StrError(NET_ERROR_CODE));
707 return NET_SOCKET_ERROR;
712 if (fSocket.SetTimeOut(SLAVE_INIT_TIMEOUT) == SOCKET_ERROR) {
713 jack_error(
"Can't set init timeout : %s", StrError(NET_ERROR_CODE));
717 if (fSocket.SetLocalLoop() == SOCKET_ERROR) {
718 jack_error(
"Can't disable multicast loop : %s", StrError(NET_ERROR_CODE));
726 session_params_t net_params;
727 memset(&net_params, 0,
sizeof(session_params_t));
728 SessionParamsHToN(&fParams, &net_params);
729 if (fSocket.SendTo(&net_params,
sizeof(session_params_t), 0, fMulticastIP) == SOCKET_ERROR) {
730 jack_error(
"Error in data send : %s", StrError(NET_ERROR_CODE));
734 memset(&net_params, 0,
sizeof(session_params_t));
735 rx_bytes = fSocket.CatchHost(&net_params,
sizeof(session_params_t), 0);
736 SessionParamsNToH(&net_params, &host_params);
737 if ((rx_bytes == SOCKET_ERROR) && (fSocket.GetError() != NET_NO_DATA)) {
738 jack_error(
"Can't receive : %s", StrError(NET_ERROR_CODE));
739 return NET_RECV_ERROR;
742 while (strcmp(host_params.fPacketType, fParams.fPacketType) && (GetPacketType(&host_params) != SLAVE_SETUP) && (--try_count > 0));
745 if (try_count == 0) {
747 return NET_CONNECT_ERROR;
751 fParams = host_params;
754 if (fSocket.Connect() == SOCKET_ERROR) {
755 jack_error(
"Error in connect : %s", StrError(NET_ERROR_CODE));
756 return NET_CONNECT_ERROR;
759 return NET_CONNECTED;
762 net_status_t JackNetSlaveInterface::SendStartToMaster()
764 jack_log(
"JackNetSlaveInterface::SendStartToMaster");
767 session_params_t net_params;
768 memset(&net_params, 0,
sizeof(session_params_t));
769 SetPacketType(&fParams, START_MASTER);
770 SessionParamsHToN(&fParams, &net_params);
771 if (fSocket.Send(&net_params,
sizeof(session_params_t), 0) == SOCKET_ERROR) {
772 jack_error(
"Error in send : %s", StrError(NET_ERROR_CODE));
773 return (fSocket.GetError() == NET_CONN_ERROR) ? NET_ERROR : NET_SEND_ERROR;
778 bool JackNetSlaveInterface::SetParams()
780 jack_log(
"JackNetSlaveInterface::SetParams audio in = %d audio out = %d MIDI in = %d MIDI out = %d",
781 fParams.fSendAudioChannels, fParams.fReturnAudioChannels,
782 fParams.fSendMidiChannels, fParams.fReturnMidiChannels);
784 JackNetInterface::SetParams();
786 fTxHeader.fDataStream =
'r';
787 fRxHeader.fDataStream =
's';
790 if (fParams.fSendMidiChannels > 0) {
791 fNetMidiCaptureBuffer =
new NetMidiBuffer(&fParams, fParams.fSendMidiChannels, fRxData);
794 if (fParams.fReturnMidiChannels > 0) {
795 fNetMidiPlaybackBuffer =
new NetMidiBuffer(&fParams, fParams.fReturnMidiChannels, fTxData);
801 if (fParams.fSendAudioChannels > 0) {
802 fNetAudioCaptureBuffer = AudioBufferFactory(fParams.fSendAudioChannels, fRxData);
803 assert(fNetAudioCaptureBuffer);
806 if (fParams.fReturnAudioChannels > 0) {
807 fNetAudioPlaybackBuffer = AudioBufferFactory(fParams.fReturnAudioChannels, fTxData);
808 assert(fNetAudioPlaybackBuffer);
811 }
catch (exception&) {
812 jack_error(
"NetAudioBuffer on slave allocation error...");
817 if (SetNetBufferSize() == SOCKET_ERROR) {
818 jack_error(
"Can't set net buffer sizes : %s", StrError(NET_ERROR_CODE));
825 FreeNetworkBuffers();
829 void JackNetSlaveInterface::FatalRecvError()
831 throw JackNetException(
"Recv connection lost error");
834 void JackNetSlaveInterface::FatalSendError()
836 throw JackNetException(
"Send connection lost error");
839 int JackNetSlaveInterface::Recv(
size_t size,
int flags)
841 int rx_bytes = fSocket.Recv(fRxBuffer, size, flags);
844 if (rx_bytes == SOCKET_ERROR) {
848 packet_header_t* header =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
849 PacketHeaderNToH(header, header);
853 int JackNetSlaveInterface::Send(
size_t size,
int flags)
855 packet_header_t* header =
reinterpret_cast<packet_header_t*
>(fTxBuffer);
856 PacketHeaderHToN(header, header);
857 int tx_bytes = fSocket.Send(fTxBuffer, size, flags);
860 if (tx_bytes == SOCKET_ERROR) {
867 int JackNetSlaveInterface::SyncRecv()
872 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
876 rx_bytes = Recv(fParams.fMtu, 0);
878 if (rx_bytes == SOCKET_ERROR) {
882 while (strcmp(rx_head->fPacketType,
"header") != 0);
884 if (rx_head->fDataType !=
's') {
885 jack_error(
"Wrong packet type : %c", rx_head->fDataType);
887 fRxHeader.fIsLastPckt = 0;
888 return SYNC_PACKET_ERROR;
892 fRxHeader.fIsLastPckt = rx_head->fIsLastPckt;
896 int JackNetSlaveInterface::DataRecv()
899 uint recvd_midi_pckt = 0;
900 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
902 while (!fRxHeader.fIsLastPckt) {
904 rx_bytes = Recv(fParams.fMtu, MSG_PEEK);
907 if (rx_bytes == SOCKET_ERROR) {
911 if (rx_bytes && (rx_head->fDataStream ==
's') && (rx_head->fID == fParams.fID)) {
913 switch (rx_head->fDataType) {
916 rx_bytes = MidiRecv(rx_head, fNetMidiCaptureBuffer, recvd_midi_pckt);
920 rx_bytes = AudioRecv(rx_head, fNetAudioCaptureBuffer);
924 jack_info(
"NetSlave : missing last data packet");
925 return FinishRecv(fNetAudioCaptureBuffer);
930 fRxHeader.fCycle = rx_head->fCycle;
934 int JackNetSlaveInterface::SyncSend()
937 if (fParams.fSlaveSyncMode) {
938 fTxHeader.fCycle = fRxHeader.fCycle;
942 fTxHeader.fSubCycle = 0;
943 fTxHeader.fDataType =
's';
944 fTxHeader.fIsLastPckt = (fParams.fReturnMidiChannels == 0 && fParams.fReturnAudioChannels == 0) ? 1 : 0;
945 fTxHeader.fPacketSize = HEADER_SIZE + fTxHeader.fActivePorts *
sizeof(int);
947 memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE);
949 return Send(fTxHeader.fPacketSize, 0);
952 int JackNetSlaveInterface::DataSend()
954 if (MidiSend(fNetMidiPlaybackBuffer, fParams.fReturnMidiChannels, fParams.fReturnAudioChannels) == SOCKET_ERROR) {
957 return AudioSend(fNetAudioPlaybackBuffer, fParams.fReturnAudioChannels);
961 void JackNetSlaveInterface::EncodeSyncPacket(
int frames)
965 memset(fTxData, 0, PACKET_AVAILABLE_SIZE(&fParams));
981 fTxHeader.fActivePorts = (fNetAudioCaptureBuffer) ? fNetAudioCaptureBuffer->ActivePortsToNetwork(fTxData) : 0;
982 fTxHeader.fFrames = frames;
985 void JackNetSlaveInterface::DecodeSyncPacket(
int& frames)
1002 packet_header_t* rx_head =
reinterpret_cast<packet_header_t*
>(fRxBuffer);
1005 if (fNetAudioPlaybackBuffer) {
1006 fNetAudioPlaybackBuffer->ActivePortsFromNetwork(fRxData, rx_head->fActivePorts);
1009 frames = rx_head->fFrames;
SERVER_EXPORT void jack_error(const char *fmt,...)
SERVER_EXPORT void jack_info(const char *fmt,...)
SERVER_EXPORT void jack_log(const char *fmt,...)