20 #include "JackNetTool.h"
21 #include "JackError.h"
25 #include <mach/mach_time.h>
36 float GetDeltaTime()
const;
37 double GetTime()
const;
41 double m_clockToSeconds;
43 uint64_t m_startAbsTime;
44 uint64_t m_lastAbsTime;
50 HardwareClock::HardwareClock()
52 mach_timebase_info_data_t info;
53 mach_timebase_info(&info);
54 m_clockToSeconds = (double)info.numer/info.denom/1000000000.0;
58 void HardwareClock::Reset()
60 m_startAbsTime = mach_absolute_time();
61 m_lastAbsTime = m_startAbsTime;
62 m_time = m_startAbsTime*m_clockToSeconds;
63 m_deltaTime = 1.0f/60.0f;
66 void HardwareClock::Update()
68 const uint64_t currentTime = mach_absolute_time();
69 const uint64_t dt = currentTime - m_lastAbsTime;
71 m_time = currentTime*m_clockToSeconds;
72 m_deltaTime = (double)dt*m_clockToSeconds;
73 m_lastAbsTime = currentTime;
76 float HardwareClock::GetDeltaTime()
const
81 double HardwareClock::GetTime()
const
94 NetMidiBuffer::NetMidiBuffer(session_params_t* params, uint32_t nports,
char* net_buffer)
97 fMaxBufsize = fNPorts *
sizeof(sample_t) * params->fPeriodSize ;
98 fMaxPcktSize = params->fMtu -
sizeof(packet_header_t);
99 fBuffer =
new char[fMaxBufsize];
100 fPortBuffer =
new JackMidiBuffer* [fNPorts];
101 for (
int port_index = 0; port_index < fNPorts; port_index++) {
102 fPortBuffer[port_index] = NULL;
104 fNetBuffer = net_buffer;
106 fCycleBytesSize = params->fMtu
107 * (max(params->fSendMidiChannels, params->fReturnMidiChannels)
108 * params->fPeriodSize *
sizeof(sample_t) / (params->fMtu -
sizeof(packet_header_t)));
111 NetMidiBuffer::~NetMidiBuffer()
114 delete[] fPortBuffer;
117 size_t NetMidiBuffer::GetCycleSize()
119 return fCycleBytesSize;
122 int NetMidiBuffer::GetNumPackets(
int data_size,
int max_size)
124 int res1 = data_size % max_size;
125 int res2 = data_size / max_size;
126 return (res1) ? res2 + 1 : res2;
129 void NetMidiBuffer::SetBuffer(
int index, JackMidiBuffer* buffer)
131 fPortBuffer[index] = buffer;
134 JackMidiBuffer* NetMidiBuffer::GetBuffer(
int index)
136 return fPortBuffer[index];
139 void NetMidiBuffer::DisplayEvents()
141 for (
int port_index = 0; port_index < fNPorts; port_index++) {
142 for (uint event = 0;
event < fPortBuffer[port_index]->event_count;
event++) {
143 if (fPortBuffer[port_index]->IsValid()) {
144 jack_info(
"port %d : midi event %u/%u -> time : %u, size : %u",
145 port_index + 1, event + 1, fPortBuffer[port_index]->event_count,
146 fPortBuffer[port_index]->events[event].time, fPortBuffer[port_index]->events[event].size);
152 int NetMidiBuffer::RenderFromJackPorts()
157 for (
int port_index = 0; port_index < fNPorts; port_index++) {
158 char* write_pos = fBuffer + pos;
159 copy_size =
sizeof(JackMidiBuffer) + fPortBuffer[port_index]->event_count *
sizeof(JackMidiEvent);
160 memcpy(fBuffer + pos, fPortBuffer[port_index], copy_size);
162 memcpy(fBuffer + pos,
163 fPortBuffer[port_index] + (fPortBuffer[port_index]->buffer_size - fPortBuffer[port_index]->write_pos),
164 fPortBuffer[port_index]->write_pos);
165 pos += fPortBuffer[port_index]->write_pos;
167 JackMidiBuffer* midi_buffer =
reinterpret_cast<JackMidiBuffer*
>(write_pos);
168 MidiBufferHToN(midi_buffer, midi_buffer);
173 void NetMidiBuffer::RenderToJackPorts()
178 for (
int port_index = 0; port_index < fNPorts; port_index++) {
179 JackMidiBuffer* midi_buffer =
reinterpret_cast<JackMidiBuffer*
>(fBuffer + pos);
180 MidiBufferNToH(midi_buffer, midi_buffer);
181 copy_size =
sizeof(JackMidiBuffer) + reinterpret_cast<JackMidiBuffer*>(fBuffer + pos)->event_count *
sizeof(JackMidiEvent);
182 memcpy(fPortBuffer[port_index], fBuffer + pos, copy_size);
184 memcpy(fPortBuffer[port_index] + (fPortBuffer[port_index]->buffer_size - fPortBuffer[port_index]->write_pos),
186 fPortBuffer[port_index]->write_pos);
187 pos += fPortBuffer[port_index]->write_pos;
191 void NetMidiBuffer::RenderFromNetwork(
int sub_cycle,
size_t copy_size)
193 memcpy(fBuffer + sub_cycle * fMaxPcktSize, fNetBuffer, copy_size);
196 int NetMidiBuffer::RenderToNetwork(
int sub_cycle,
size_t total_size)
198 int size = total_size - sub_cycle * fMaxPcktSize;
199 int copy_size = (size <= fMaxPcktSize) ? size : fMaxPcktSize;
200 memcpy(fNetBuffer, fBuffer + sub_cycle * fMaxPcktSize, copy_size);
206 NetAudioBuffer::NetAudioBuffer(session_params_t* params, uint32_t nports,
char* net_buffer)
209 fNetBuffer = net_buffer;
211 fPortBuffer =
new sample_t* [fNPorts];
212 fConnectedPorts =
new bool[fNPorts];
213 for (
int port_index = 0; port_index < fNPorts; port_index++) {
214 fPortBuffer[port_index] = NULL;
215 fConnectedPorts[port_index] =
true;
219 NetAudioBuffer::~NetAudioBuffer()
221 delete [] fConnectedPorts;
222 delete [] fPortBuffer;
225 void NetAudioBuffer::SetBuffer(
int index, sample_t* buffer)
227 fPortBuffer[index] = buffer;
230 sample_t* NetAudioBuffer::GetBuffer(
int index)
232 return fPortBuffer[index];
235 int NetAudioBuffer::CheckPacket(
int cycle,
int sub_cycle)
239 if (sub_cycle != fLastSubCycle + 1) {
240 jack_error(
"Packet(s) missing from... %d %d", fLastSubCycle, sub_cycle);
241 res = NET_PACKET_ERROR;
246 fLastSubCycle = sub_cycle;
250 void NetAudioBuffer::NextCycle()
256 void NetAudioBuffer::Cleanup()
258 for (
int port_index = 0; port_index < fNPorts; port_index++) {
259 if (fPortBuffer[port_index]) {
260 memset(fPortBuffer[port_index], 0, fPeriodSize *
sizeof(sample_t));
267 int NetAudioBuffer::ActivePortsToNetwork(
char* net_buffer)
269 int active_ports = 0;
270 int* active_port_address = (
int*)net_buffer;
272 for (
int port_index = 0; port_index < fNPorts; port_index++) {
274 if (fPortBuffer[port_index]) {
275 *active_port_address = htonl(port_index);
276 active_port_address++;
278 assert(active_ports < 256);
285 void NetAudioBuffer::ActivePortsFromNetwork(
char* net_buffer, uint32_t port_num)
287 int* active_port_address = (
int*)net_buffer;
289 for (
int port_index = 0; port_index < fNPorts; port_index++) {
290 fConnectedPorts[port_index] =
false;
293 for (uint port_index = 0; port_index < port_num; port_index++) {
295 int active_port = ntohl(*active_port_address);
296 if (active_port >= 0 && active_port < fNPorts) {
297 fConnectedPorts[active_port] =
true;
299 jack_error(
"ActivePortsFromNetwork: incorrect port = %d", active_port);
301 active_port_address++;
305 int NetAudioBuffer::RenderFromJackPorts()
308 int active_ports = 0;
309 for (
int port_index = 0; port_index < fNPorts; port_index++) {
310 if (fPortBuffer[port_index]) {
318 void NetAudioBuffer::RenderToJackPorts()
326 NetFloatAudioBuffer::NetFloatAudioBuffer(session_params_t* params, uint32_t nports,
char* net_buffer)
327 : NetAudioBuffer(params, nports, net_buffer)
329 fPeriodSize = params->fPeriodSize;
330 fPacketSize = PACKET_AVAILABLE_SIZE(params);
332 UpdateParams(max(params->fReturnAudioChannels, params->fSendAudioChannels));
334 fSubPeriodBytesSize = fSubPeriodSize *
sizeof(sample_t);
336 fCycleDuration = float(fSubPeriodSize) / float(params->fSampleRate);
337 fCycleBytesSize = params->fMtu * (fPeriodSize / fSubPeriodSize);
342 NetFloatAudioBuffer::~NetFloatAudioBuffer()
346 size_t NetFloatAudioBuffer::GetCycleSize()
348 return fCycleBytesSize;
352 float NetFloatAudioBuffer::GetCycleDuration()
354 return fCycleDuration;
357 void NetFloatAudioBuffer::UpdateParams(
int active_ports)
359 if (active_ports == 0) {
360 fSubPeriodSize = fPeriodSize;
362 jack_nframes_t period = (int) powf(2.f, (
int)(log(
float(fPacketSize) / (active_ports *
sizeof(sample_t))) / log(2.)));
363 fSubPeriodSize = (period > fPeriodSize) ? fPeriodSize : period;
366 fSubPeriodBytesSize = fSubPeriodSize *
sizeof(sample_t) +
sizeof(
int);
369 int NetFloatAudioBuffer::GetNumPackets(
int active_ports)
371 UpdateParams(active_ports);
377 return fPeriodSize / fSubPeriodSize;
382 int NetFloatAudioBuffer::RenderFromNetwork(
int cycle,
int sub_cycle, uint32_t port_num)
385 if (sub_cycle == 0) {
390 UpdateParams(port_num);
391 for (uint32_t port_index = 0; port_index < port_num; port_index++) {
393 int* active_port_address = (
int*)(fNetBuffer + port_index * fSubPeriodBytesSize);
394 int active_port = ntohl(*active_port_address);
395 RenderFromNetwork((
char*)(active_port_address + 1), active_port, sub_cycle);
399 return CheckPacket(cycle, sub_cycle);
403 int NetFloatAudioBuffer::RenderToNetwork(
int sub_cycle, uint32_t port_num)
405 int active_ports = 0;
407 for (
int port_index = 0; port_index < fNPorts; port_index++) {
409 if (fPortBuffer[port_index]) {
410 int* active_port_address = (
int*)(fNetBuffer + active_ports * fSubPeriodBytesSize);
411 *active_port_address = htonl(port_index);
412 RenderToNetwork((
char*)(active_port_address + 1), port_index, sub_cycle);
417 return port_num * fSubPeriodBytesSize;
420 #ifdef __BIG_ENDIAN__
422 static inline jack_default_audio_sample_t SwapFloat(jack_default_audio_sample_t f)
426 jack_default_audio_sample_t f;
431 dat2.b[0] = dat1.b[3];
432 dat2.b[1] = dat1.b[2];
433 dat2.b[2] = dat1.b[1];
434 dat2.b[3] = dat1.b[0];
438 void NetFloatAudioBuffer::RenderFromNetwork(
char* net_buffer,
int active_port,
int sub_cycle)
440 if (fPortBuffer[active_port]) {
441 jack_default_audio_sample_t* src = (jack_default_audio_sample_t*)(net_buffer);
442 jack_default_audio_sample_t* dst = (jack_default_audio_sample_t*)(fPortBuffer[active_port] + sub_cycle * fSubPeriodSize);
443 for (
unsigned int sample = 0; sample < (fSubPeriodBytesSize -
sizeof(int)) /
sizeof(jack_default_audio_sample_t); sample++) {
444 dst[sample] = SwapFloat(src[sample]);
449 void NetFloatAudioBuffer::RenderToNetwork(
char* net_buffer,
int active_port,
int sub_cycle)
451 for (
int port_index = 0; port_index < fNPorts; port_index++ ) {
452 jack_default_audio_sample_t* src = (jack_default_audio_sample_t*)(fPortBuffer[active_port] + sub_cycle * fSubPeriodSize);
453 jack_default_audio_sample_t* dst = (jack_default_audio_sample_t*)(net_buffer);
454 for (
unsigned int sample = 0; sample < (fSubPeriodBytesSize -
sizeof(int)) /
sizeof(jack_default_audio_sample_t); sample++) {
455 dst[sample] = SwapFloat(src[sample]);
462 void NetFloatAudioBuffer::RenderFromNetwork(
char* net_buffer,
int active_port,
int sub_cycle)
464 if (fPortBuffer[active_port]) {
465 memcpy(fPortBuffer[active_port] + sub_cycle * fSubPeriodSize, net_buffer, fSubPeriodBytesSize -
sizeof(
int));
469 void NetFloatAudioBuffer::RenderToNetwork(
char* net_buffer,
int active_port,
int sub_cycle)
471 memcpy(net_buffer, fPortBuffer[active_port] + sub_cycle * fSubPeriodSize, fSubPeriodBytesSize -
sizeof(
int));
482 NetCeltAudioBuffer::NetCeltAudioBuffer(session_params_t* params, uint32_t nports,
char* net_buffer,
int kbps)
483 :NetAudioBuffer(params, nports, net_buffer)
485 fCeltMode =
new CELTMode *[fNPorts];
486 fCeltEncoder =
new CELTEncoder *[fNPorts];
487 fCeltDecoder =
new CELTDecoder *[fNPorts];
489 memset(fCeltMode, 0, fNPorts *
sizeof(CELTMode*));
490 memset(fCeltEncoder, 0, fNPorts *
sizeof(CELTEncoder*));
491 memset(fCeltDecoder, 0, fNPorts *
sizeof(CELTDecoder*));
495 for (
int i = 0; i < fNPorts; i++) {
496 fCeltMode[i] = celt_mode_create(params->fSampleRate, params->fPeriodSize, &error);
497 if (error != CELT_OK) {
501 #if HAVE_CELT_API_0_11
503 fCeltEncoder[i] = celt_encoder_create_custom(fCeltMode[i], 1, &error);
504 if (error != CELT_OK) {
507 celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
509 fCeltDecoder[i] = celt_decoder_create_custom(fCeltMode[i], 1, &error);
510 if (error != CELT_OK) {
513 celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
515 #elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
517 fCeltEncoder[i] = celt_encoder_create(fCeltMode[i], 1, &error);
518 if (error != CELT_OK) {
521 celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
523 fCeltDecoder[i] = celt_decoder_create(fCeltMode[i], 1, &error);
524 if (error != CELT_OK) {
527 celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
531 fCeltEncoder[i] = celt_encoder_create(fCeltMode[i]);
532 if (error != CELT_OK) {
535 celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
537 fCeltDecoder[i] = celt_decoder_create(fCeltMode[i]);
538 if (error != CELT_OK) {
541 celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
547 fPeriodSize = params->fPeriodSize;
549 fCompressedSizeByte = (kbps * params->fPeriodSize * 1024) / (params->fSampleRate * 8);
550 jack_log(
"NetCeltAudioBuffer fCompressedSizeByte %d", fCompressedSizeByte);
552 fCompressedBuffer =
new unsigned char* [fNPorts];
553 for (
int port_index = 0; port_index < fNPorts; port_index++) {
554 fCompressedBuffer[port_index] =
new unsigned char[fCompressedSizeByte];
555 memset(fCompressedBuffer[port_index], 0, fCompressedSizeByte *
sizeof(
char));
558 int res1 = (fNPorts * fCompressedSizeByte) % PACKET_AVAILABLE_SIZE(params);
559 int res2 = (fNPorts * fCompressedSizeByte) / PACKET_AVAILABLE_SIZE(params);
561 fNumPackets = (res1) ? (res2 + 1) : res2;
563 jack_log(
"NetCeltAudioBuffer res1 = %d res2 = %d", res1, res2);
565 fSubPeriodBytesSize = fCompressedSizeByte / fNumPackets;
566 fLastSubPeriodBytesSize = fSubPeriodBytesSize + fCompressedSizeByte % fNumPackets;
568 jack_log(
"NetCeltAudioBuffer fNumPackets = %d fSubPeriodBytesSize = %d, fLastSubPeriodBytesSize = %d", fNumPackets, fSubPeriodBytesSize, fLastSubPeriodBytesSize);
570 fCycleDuration = float(fSubPeriodBytesSize /
sizeof(sample_t)) / float(params->fSampleRate);
571 fCycleBytesSize = params->fMtu * fNumPackets;
580 throw std::bad_alloc();
583 NetCeltAudioBuffer::~NetCeltAudioBuffer()
587 for (
int port_index = 0; port_index < fNPorts; port_index++) {
588 delete [] fCompressedBuffer[port_index];
591 delete [] fCompressedBuffer;
594 void NetCeltAudioBuffer::FreeCelt()
596 for (
int i = 0; i < fNPorts; i++) {
597 if (fCeltEncoder[i]) {
598 celt_encoder_destroy(fCeltEncoder[i]);
600 if (fCeltDecoder[i]) {
601 celt_decoder_destroy(fCeltDecoder[i]);
604 celt_mode_destroy(fCeltMode[i]);
609 delete [] fCeltEncoder;
610 delete [] fCeltDecoder;
613 size_t NetCeltAudioBuffer::GetCycleSize()
615 return fCycleBytesSize;
618 float NetCeltAudioBuffer::GetCycleDuration()
620 return fCycleDuration;
623 int NetCeltAudioBuffer::GetNumPackets(
int active_ports)
628 int NetCeltAudioBuffer::RenderFromJackPorts()
630 float buffer[BUFFER_SIZE_MAX];
632 for (
int port_index = 0; port_index < fNPorts; port_index++) {
633 if (fPortBuffer[port_index]) {
634 memcpy(buffer, fPortBuffer[port_index], fPeriodSize *
sizeof(sample_t));
636 memset(buffer, 0, fPeriodSize *
sizeof(sample_t));
638 #if HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11
639 int res = celt_encode_float(fCeltEncoder[port_index], buffer, fPeriodSize, fCompressedBuffer[port_index], fCompressedSizeByte);
641 int res = celt_encode_float(fCeltEncoder[port_index], buffer, NULL, fCompressedBuffer[port_index], fCompressedSizeByte);
643 if (res != fCompressedSizeByte) {
644 jack_error(
"celt_encode_float error fCompressedSizeByte = %d res = %d", fCompressedSizeByte, res);
652 void NetCeltAudioBuffer::RenderToJackPorts()
654 for (
int port_index = 0; port_index < fNPorts; port_index++) {
655 if (fPortBuffer[port_index]) {
656 #if HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11
657 int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index], fPeriodSize);
659 int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index]);
661 if (res != CELT_OK) {
662 jack_error(
"celt_decode_float error fCompressedSizeByte = %d res = %d", fCompressedSizeByte, res);
671 int NetCeltAudioBuffer::RenderFromNetwork(
int cycle,
int sub_cycle, uint32_t port_num)
674 if (sub_cycle == 0) {
680 if (sub_cycle == fNumPackets - 1) {
681 for (
int port_index = 0; port_index < fNPorts; port_index++) {
682 memcpy(fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, fNetBuffer + port_index * fLastSubPeriodBytesSize, fLastSubPeriodBytesSize);
685 for (
int port_index = 0; port_index < fNPorts; port_index++) {
686 memcpy(fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, fNetBuffer + port_index * fSubPeriodBytesSize, fSubPeriodBytesSize);
691 return CheckPacket(cycle, sub_cycle);
694 int NetCeltAudioBuffer::RenderToNetwork(
int sub_cycle, uint32_t port_num)
697 if (sub_cycle == fNumPackets - 1) {
698 for (
int port_index = 0; port_index < fNPorts; port_index++) {
699 memcpy(fNetBuffer + port_index * fLastSubPeriodBytesSize, fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, fLastSubPeriodBytesSize);
701 return fNPorts * fLastSubPeriodBytesSize;
703 for (
int port_index = 0; port_index < fNPorts; port_index++) {
704 memcpy(fNetBuffer + port_index * fSubPeriodBytesSize, fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, fSubPeriodBytesSize);
706 return fNPorts * fSubPeriodBytesSize;
713 #define CDO (sizeof(short))
715 NetOpusAudioBuffer::NetOpusAudioBuffer(session_params_t* params, uint32_t nports,
char* net_buffer,
int kbps)
716 :NetAudioBuffer(params, nports, net_buffer)
718 fOpusMode =
new OpusCustomMode *[fNPorts];
719 fOpusEncoder =
new OpusCustomEncoder *[fNPorts];
720 fOpusDecoder =
new OpusCustomDecoder *[fNPorts];
721 fCompressedSizesByte =
new unsigned short [fNPorts];
723 memset(fOpusMode, 0, fNPorts *
sizeof(OpusCustomMode*));
724 memset(fOpusEncoder, 0, fNPorts *
sizeof(OpusCustomEncoder*));
725 memset(fOpusDecoder, 0, fNPorts *
sizeof(OpusCustomDecoder*));
726 memset(fCompressedSizesByte, 0, fNPorts *
sizeof(
int));
730 for (
int i = 0; i < fNPorts; i++) {
732 fOpusMode[i] = opus_custom_mode_create(
733 params->fSampleRate, params->fPeriodSize, &error);
734 if (error != OPUS_OK) {
738 fOpusEncoder[i] = opus_custom_encoder_create(fOpusMode[i], 1,&error);
739 if (error != OPUS_OK) {
743 fOpusDecoder[i] = opus_custom_decoder_create(fOpusMode[i], 1, &error);
744 if (error != OPUS_OK) {
748 opus_custom_encoder_ctl(fOpusEncoder[i], OPUS_SET_BITRATE(kbps*1024));
749 opus_custom_encoder_ctl(fOpusEncoder[i], OPUS_SET_COMPLEXITY(10));
750 opus_custom_encoder_ctl(fOpusEncoder[i], OPUS_SET_SIGNAL(OPUS_SIGNAL_MUSIC));
751 opus_custom_encoder_ctl(fOpusEncoder[i], OPUS_SET_SIGNAL(OPUS_APPLICATION_RESTRICTED_LOWDELAY));
755 fCompressedMaxSizeByte = (kbps * params->fPeriodSize * 1024) / (params->fSampleRate * 8);
756 fPeriodSize = params->fPeriodSize;
757 jack_log(
"NetOpusAudioBuffer fCompressedMaxSizeByte %d", fCompressedMaxSizeByte);
759 fCompressedBuffer =
new unsigned char* [fNPorts];
760 for (
int port_index = 0; port_index < fNPorts; port_index++) {
761 fCompressedBuffer[port_index] =
new unsigned char[fCompressedMaxSizeByte];
762 memset(fCompressedBuffer[port_index], 0, fCompressedMaxSizeByte *
sizeof(
char));
765 int res1 = (fNPorts * fCompressedMaxSizeByte + CDO) % PACKET_AVAILABLE_SIZE(params);
766 int res2 = (fNPorts * fCompressedMaxSizeByte + CDO) / PACKET_AVAILABLE_SIZE(params);
768 fNumPackets = (res1) ? (res2 + 1) : res2;
770 jack_log(
"NetOpusAudioBuffer res1 = %d res2 = %d", res1, res2);
772 fSubPeriodBytesSize = (fCompressedMaxSizeByte + CDO) / fNumPackets;
773 fLastSubPeriodBytesSize = fSubPeriodBytesSize + (fCompressedMaxSizeByte + CDO) % fNumPackets;
775 if (fNumPackets == 1) {
776 fSubPeriodBytesSize = fLastSubPeriodBytesSize;
779 jack_log(
"NetOpusAudioBuffer fNumPackets = %d fSubPeriodBytesSize = %d, fLastSubPeriodBytesSize = %d", fNumPackets, fSubPeriodBytesSize, fLastSubPeriodBytesSize);
781 fCycleDuration = float(fSubPeriodBytesSize /
sizeof(sample_t)) / float(params->fSampleRate);
782 fCycleBytesSize = params->fMtu * fNumPackets;
791 throw std::bad_alloc();
794 NetOpusAudioBuffer::~NetOpusAudioBuffer()
798 for (
int port_index = 0; port_index < fNPorts; port_index++) {
799 delete [] fCompressedBuffer[port_index];
802 delete [] fCompressedBuffer;
803 delete [] fCompressedSizesByte;
806 void NetOpusAudioBuffer::FreeOpus()
808 for (
int i = 0; i < fNPorts; i++) {
809 if (fOpusEncoder[i]) {
810 opus_custom_encoder_destroy(fOpusEncoder[i]);
813 if (fOpusDecoder[i]) {
814 opus_custom_decoder_destroy(fOpusDecoder[i]);
818 opus_custom_mode_destroy(fOpusMode[i]);
823 delete [] fOpusEncoder;
824 delete [] fOpusDecoder;
828 size_t NetOpusAudioBuffer::GetCycleSize()
830 return fCycleBytesSize;
833 float NetOpusAudioBuffer::GetCycleDuration()
835 return fCycleDuration;
838 int NetOpusAudioBuffer::GetNumPackets(
int active_ports)
843 int NetOpusAudioBuffer::RenderFromJackPorts()
845 float buffer[BUFFER_SIZE_MAX];
847 for (
int port_index = 0; port_index < fNPorts; port_index++) {
848 if (fPortBuffer[port_index]) {
849 memcpy(buffer, fPortBuffer[port_index], fPeriodSize *
sizeof(sample_t));
851 memset(buffer, 0, fPeriodSize *
sizeof(sample_t));
853 int res = opus_custom_encode_float(fOpusEncoder[port_index], buffer, fPeriodSize, fCompressedBuffer[port_index], fCompressedMaxSizeByte);
854 if (res <0 || res >= 65535) {
855 fCompressedSizesByte[port_index] = 0;
857 fCompressedSizesByte[port_index] = res;
865 void NetOpusAudioBuffer::RenderToJackPorts()
867 for (
int port_index = 0; port_index < fNPorts; port_index++) {
868 if (fPortBuffer[port_index]) {
869 int res = opus_custom_decode_float(fOpusDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizesByte[port_index], fPortBuffer[port_index], fPeriodSize);
870 if (res < 0 || res != fPeriodSize) {
871 jack_error(
"opus_decode_float error fCompressedSizeByte = %d res = %d", fCompressedSizesByte[port_index], res);
880 int NetOpusAudioBuffer::RenderFromNetwork(
int cycle,
int sub_cycle, uint32_t port_num)
883 if (sub_cycle == 0) {
888 if (sub_cycle == 0) {
889 for (
int port_index = 0; port_index < fNPorts; port_index++) {
890 size_t len = *((
size_t*)(fNetBuffer + port_index * fSubPeriodBytesSize));
891 fCompressedSizesByte[port_index] = ntohs(len);
892 memcpy(fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, fNetBuffer + CDO + port_index * fSubPeriodBytesSize, fSubPeriodBytesSize - CDO);
894 }
else if (sub_cycle == fNumPackets - 1) {
895 for (
int port_index = 0; port_index < fNPorts; port_index++) {
896 memcpy(fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize - CDO, fNetBuffer + port_index * fLastSubPeriodBytesSize, fLastSubPeriodBytesSize);
899 for (
int port_index = 0; port_index < fNPorts; port_index++) {
900 memcpy(fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize - CDO, fNetBuffer + port_index * fSubPeriodBytesSize, fSubPeriodBytesSize);
905 return CheckPacket(cycle, sub_cycle);
908 int NetOpusAudioBuffer::RenderToNetwork(
int sub_cycle, uint32_t port_num)
910 if (sub_cycle == 0) {
911 for (
int port_index = 0; port_index < fNPorts; port_index++) {
912 unsigned short len = htons(fCompressedSizesByte[port_index]);
913 memcpy(fNetBuffer + port_index * fSubPeriodBytesSize, &len, CDO);
914 memcpy(fNetBuffer + port_index * fSubPeriodBytesSize + CDO, fCompressedBuffer[port_index], fSubPeriodBytesSize - CDO);
916 return fNPorts * fSubPeriodBytesSize;
917 }
else if (sub_cycle == fNumPackets - 1) {
918 for (
int port_index = 0; port_index < fNPorts; port_index++) {
919 memcpy(fNetBuffer + port_index * fLastSubPeriodBytesSize, fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize - CDO, fLastSubPeriodBytesSize);
921 return fNPorts * fLastSubPeriodBytesSize;
923 for (
int port_index = 0; port_index < fNPorts; port_index++) {
924 memcpy(fNetBuffer + port_index * fSubPeriodBytesSize, fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize - CDO, fSubPeriodBytesSize);
926 return fNPorts * fSubPeriodBytesSize;
933 NetIntAudioBuffer::NetIntAudioBuffer(session_params_t* params, uint32_t nports,
char* net_buffer)
934 : NetAudioBuffer(params, nports, net_buffer)
936 fPeriodSize = params->fPeriodSize;
938 fCompressedSizeByte = (params->fPeriodSize *
sizeof(short));
939 jack_log(
"NetIntAudioBuffer fCompressedSizeByte %d", fCompressedSizeByte);
941 fIntBuffer =
new short* [fNPorts];
942 for (
int port_index = 0; port_index < fNPorts; port_index++) {
943 fIntBuffer[port_index] =
new short[fPeriodSize];
944 memset(fIntBuffer[port_index], 0, fPeriodSize *
sizeof(
short));
947 int res1 = (fNPorts * fCompressedSizeByte) % PACKET_AVAILABLE_SIZE(params);
948 int res2 = (fNPorts * fCompressedSizeByte) / PACKET_AVAILABLE_SIZE(params);
950 jack_log(
"NetIntAudioBuffer res1 = %d res2 = %d", res1, res2);
952 fNumPackets = (res1) ? (res2 + 1) : res2;
954 fSubPeriodBytesSize = fCompressedSizeByte / fNumPackets;
955 fLastSubPeriodBytesSize = fSubPeriodBytesSize + fCompressedSizeByte % fNumPackets;
957 fSubPeriodSize = fSubPeriodBytesSize /
sizeof(short);
959 jack_log(
"NetIntAudioBuffer fNumPackets = %d fSubPeriodBytesSize = %d, fLastSubPeriodBytesSize = %d", fNumPackets, fSubPeriodBytesSize, fLastSubPeriodBytesSize);
961 fCycleDuration = float(fSubPeriodBytesSize /
sizeof(sample_t)) / float(params->fSampleRate);
962 fCycleBytesSize = params->fMtu * fNumPackets;
968 NetIntAudioBuffer::~NetIntAudioBuffer()
970 for (
int port_index = 0; port_index < fNPorts; port_index++) {
971 delete [] fIntBuffer[port_index];
974 delete [] fIntBuffer;
977 size_t NetIntAudioBuffer::GetCycleSize()
979 return fCycleBytesSize;
982 float NetIntAudioBuffer::GetCycleDuration()
984 return fCycleDuration;
987 int NetIntAudioBuffer::GetNumPackets(
int active_ports)
992 int NetIntAudioBuffer::RenderFromJackPorts()
994 for (
int port_index = 0; port_index < fNPorts; port_index++) {
995 if (fPortBuffer[port_index]) {
996 for (uint frame = 0; frame < fPeriodSize; frame++) {
997 fIntBuffer[port_index][frame] = short(fPortBuffer[port_index][frame] * 32768.f);
1006 void NetIntAudioBuffer::RenderToJackPorts()
1008 float coef = 1.f / 32768.f;
1009 for (
int port_index = 0; port_index < fNPorts; port_index++) {
1010 if (fPortBuffer[port_index]) {
1011 for (uint frame = 0; frame < fPeriodSize; frame++) {
1012 fPortBuffer[port_index][frame] = float(fIntBuffer[port_index][frame] * coef);
1021 int NetIntAudioBuffer::RenderFromNetwork(
int cycle,
int sub_cycle, uint32_t port_num)
1024 if (sub_cycle == 0) {
1029 if (sub_cycle == fNumPackets - 1) {
1030 for (
int port_index = 0; port_index < fNPorts; port_index++) {
1031 memcpy(fIntBuffer[port_index] + sub_cycle * fSubPeriodSize, fNetBuffer + port_index * fLastSubPeriodBytesSize, fLastSubPeriodBytesSize);
1034 for (
int port_index = 0; port_index < fNPorts; port_index++) {
1035 memcpy(fIntBuffer[port_index] + sub_cycle * fSubPeriodSize, fNetBuffer + port_index * fSubPeriodBytesSize, fSubPeriodBytesSize);
1040 return CheckPacket(cycle, sub_cycle);
1043 int NetIntAudioBuffer::RenderToNetwork(
int sub_cycle, uint32_t port_num)
1046 if (sub_cycle == fNumPackets - 1) {
1047 for (
int port_index = 0; port_index < fNPorts; port_index++) {
1048 memcpy(fNetBuffer + port_index * fLastSubPeriodBytesSize, fIntBuffer[port_index] + sub_cycle * fSubPeriodSize, fLastSubPeriodBytesSize);
1050 return fNPorts * fLastSubPeriodBytesSize;
1052 for (
int port_index = 0; port_index < fNPorts; port_index++) {
1053 memcpy(fNetBuffer + port_index * fSubPeriodBytesSize, fIntBuffer[port_index] + sub_cycle * fSubPeriodSize, fSubPeriodBytesSize);
1055 return fNPorts * fSubPeriodBytesSize;
1061 SERVER_EXPORT
void SessionParamsHToN(session_params_t* src_params, session_params_t* dst_params)
1063 memcpy(dst_params, src_params,
sizeof(session_params_t));
1064 dst_params->fProtocolVersion = htonl(src_params->fProtocolVersion);
1065 dst_params->fPacketID = htonl(src_params->fPacketID);
1066 dst_params->fMtu = htonl(src_params->fMtu);
1067 dst_params->fID = htonl(src_params->fID);
1068 dst_params->fTransportSync = htonl(src_params->fTransportSync);
1069 dst_params->fSendAudioChannels = htonl(src_params->fSendAudioChannels);
1070 dst_params->fReturnAudioChannels = htonl(src_params->fReturnAudioChannels);
1071 dst_params->fSendMidiChannels = htonl(src_params->fSendMidiChannels);
1072 dst_params->fReturnMidiChannels = htonl(src_params->fReturnMidiChannels);
1073 dst_params->fSampleRate = htonl(src_params->fSampleRate);
1074 dst_params->fPeriodSize = htonl(src_params->fPeriodSize);
1075 dst_params->fSampleEncoder = htonl(src_params->fSampleEncoder);
1076 dst_params->fKBps = htonl(src_params->fKBps);
1077 dst_params->fSlaveSyncMode = htonl(src_params->fSlaveSyncMode);
1078 dst_params->fNetworkLatency = htonl(src_params->fNetworkLatency);
1081 SERVER_EXPORT
void SessionParamsNToH(session_params_t* src_params, session_params_t* dst_params)
1083 memcpy(dst_params, src_params,
sizeof(session_params_t));
1084 dst_params->fProtocolVersion = ntohl(src_params->fProtocolVersion);
1085 dst_params->fPacketID = ntohl(src_params->fPacketID);
1086 dst_params->fMtu = ntohl(src_params->fMtu);
1087 dst_params->fID = ntohl(src_params->fID);
1088 dst_params->fTransportSync = ntohl(src_params->fTransportSync);
1089 dst_params->fSendAudioChannels = ntohl(src_params->fSendAudioChannels);
1090 dst_params->fReturnAudioChannels = ntohl(src_params->fReturnAudioChannels);
1091 dst_params->fSendMidiChannels = ntohl(src_params->fSendMidiChannels);
1092 dst_params->fReturnMidiChannels = ntohl(src_params->fReturnMidiChannels);
1093 dst_params->fSampleRate = ntohl(src_params->fSampleRate);
1094 dst_params->fPeriodSize = ntohl(src_params->fPeriodSize);
1095 dst_params->fSampleEncoder = ntohl(src_params->fSampleEncoder);
1096 dst_params->fKBps = ntohl(src_params->fKBps);
1097 dst_params->fSlaveSyncMode = ntohl(src_params->fSlaveSyncMode);
1098 dst_params->fNetworkLatency = ntohl(src_params->fNetworkLatency);
1101 SERVER_EXPORT
void SessionParamsDisplay(session_params_t* params)
1104 switch (params->fSampleEncoder)
1106 case JackFloatEncoder:
1107 strcpy(encoder,
"float");
1109 case JackIntEncoder:
1110 strcpy(encoder,
"integer");
1112 case JackCeltEncoder:
1113 strcpy(encoder,
"CELT");
1115 case JackOpusEncoder:
1116 strcpy(encoder,
"OPUS");
1120 jack_info(
"**************** Network parameters ****************");
1122 jack_info(
"Protocol revision : %d", params->fProtocolVersion);
1124 jack_info(
"Master name : %s", params->fMasterNetName);
1125 jack_info(
"Slave name : %s", params->fSlaveNetName);
1127 jack_info(
"Transport Sync : %s", (params->fTransportSync) ?
"yes" :
"no");
1128 jack_info(
"Send channels (audio - midi) : %d - %d", params->fSendAudioChannels, params->fSendMidiChannels);
1129 jack_info(
"Return channels (audio - midi) : %d - %d", params->fReturnAudioChannels, params->fReturnMidiChannels);
1130 jack_info(
"Sample rate : %u frames per second", params->fSampleRate);
1131 jack_info(
"Period size : %u frames per period", params->fPeriodSize);
1132 jack_info(
"Network latency : %u cycles", params->fNetworkLatency);
1133 switch (params->fSampleEncoder) {
1134 case (JackFloatEncoder):
1135 jack_info(
"SampleEncoder : %s",
"Float");
1137 case (JackIntEncoder):
1138 jack_info(
"SampleEncoder : %s",
"16 bits integer");
1140 case (JackCeltEncoder):
1141 jack_info(
"SampleEncoder : %s",
"CELT");
1144 case (JackOpusEncoder):
1145 jack_info(
"SampleEncoder : %s",
"OPUS");
1149 jack_info(
"Slave mode : %s", (params->fSlaveSyncMode) ?
"sync" :
"async");
1150 jack_info(
"****************************************************");
1153 SERVER_EXPORT sync_packet_type_t GetPacketType(session_params_t* params)
1155 switch (params->fPacketID)
1158 return SLAVE_AVAILABLE;
1162 return START_MASTER;
1171 SERVER_EXPORT
int SetPacketType(session_params_t* params, sync_packet_type_t packet_type)
1173 switch (packet_type)
1177 case SLAVE_AVAILABLE:
1178 params->fPacketID = 0;
1181 params->fPacketID = 1;
1184 params->fPacketID = 2;
1187 params->fPacketID = 3;
1190 params->fPacketID = 4;
1197 SERVER_EXPORT
void PacketHeaderHToN(packet_header_t* src_header, packet_header_t* dst_header)
1199 memcpy(dst_header, src_header,
sizeof(packet_header_t));
1200 dst_header->fDataType = htonl(src_header->fDataType);
1201 dst_header->fDataStream = htonl(src_header->fDataStream);
1202 dst_header->fID = htonl(src_header->fID);
1203 dst_header->fNumPacket = htonl(src_header->fNumPacket);
1204 dst_header->fPacketSize = htonl(src_header->fPacketSize);
1205 dst_header->fActivePorts = htonl(src_header->fActivePorts);
1206 dst_header->fCycle = htonl(src_header->fCycle);
1207 dst_header->fSubCycle = htonl(src_header->fSubCycle);
1208 dst_header->fIsLastPckt = htonl(src_header->fIsLastPckt);
1211 SERVER_EXPORT
void PacketHeaderNToH(packet_header_t* src_header, packet_header_t* dst_header)
1213 memcpy(dst_header, src_header,
sizeof(packet_header_t));
1214 dst_header->fDataType = ntohl(src_header->fDataType);
1215 dst_header->fDataStream = ntohl(src_header->fDataStream);
1216 dst_header->fID = ntohl(src_header->fID);
1217 dst_header->fNumPacket = ntohl(src_header->fNumPacket);
1218 dst_header->fPacketSize = ntohl(src_header->fPacketSize);
1219 dst_header->fActivePorts = ntohl(src_header->fActivePorts);
1220 dst_header->fCycle = ntohl(src_header->fCycle);
1221 dst_header->fSubCycle = ntohl(src_header->fSubCycle);
1222 dst_header->fIsLastPckt = ntohl(src_header->fIsLastPckt);
1225 SERVER_EXPORT
void PacketHeaderDisplay(packet_header_t* header)
1228 jack_info(
"********************Header********************");
1229 jack_info(
"Data type : %c", header->fDataType);
1230 jack_info(
"Data stream : %c", header->fDataStream);
1232 jack_info(
"Cycle : %u", header->fCycle);
1233 jack_info(
"SubCycle : %u", header->fSubCycle);
1234 jack_info(
"Active ports : %u", header->fActivePorts);
1235 jack_info(
"DATA packets : %u", header->fNumPacket);
1236 jack_info(
"DATA size : %u", header->fPacketSize);
1237 jack_info(
"Last packet : '%s'", (header->fIsLastPckt) ?
"yes" :
"no");
1239 jack_info(
"**********************************************");
1242 SERVER_EXPORT
void NetTransportDataDisplay(net_transport_data_t* data)
1244 jack_info(
"********************Network Transport********************");
1245 jack_info(
"Transport new state : %u", data->fNewState);
1246 jack_info(
"Transport timebase master : %u", data->fTimebaseMaster);
1247 jack_info(
"Transport cycle state : %u", data->fState);
1248 jack_info(
"**********************************************");
1251 SERVER_EXPORT
void MidiBufferHToN(JackMidiBuffer* src_buffer, JackMidiBuffer* dst_buffer)
1253 dst_buffer->magic = htonl(src_buffer->magic);
1254 dst_buffer->buffer_size = htonl(src_buffer->buffer_size);
1255 dst_buffer->nframes = htonl(src_buffer->nframes);
1256 dst_buffer->write_pos = htonl(src_buffer->write_pos);
1257 dst_buffer->event_count = htonl(src_buffer->event_count);
1258 dst_buffer->lost_events = htonl(src_buffer->lost_events);
1259 dst_buffer->mix_index = htonl(src_buffer->mix_index);
1262 SERVER_EXPORT
void MidiBufferNToH(JackMidiBuffer* src_buffer, JackMidiBuffer* dst_buffer)
1264 dst_buffer->magic = ntohl(src_buffer->magic);
1265 dst_buffer->buffer_size = ntohl(src_buffer->buffer_size);
1266 dst_buffer->nframes = ntohl(src_buffer->nframes);
1267 dst_buffer->write_pos = ntohl(src_buffer->write_pos);
1268 dst_buffer->event_count = ntohl(src_buffer->event_count);
1269 dst_buffer->lost_events = ntohl(src_buffer->lost_events);
1270 dst_buffer->mix_index = ntohl(src_buffer->mix_index);
1273 SERVER_EXPORT
void TransportDataHToN(net_transport_data_t* src_params, net_transport_data_t* dst_params)
1275 dst_params->fNewState = htonl(src_params->fNewState);
1276 dst_params->fTimebaseMaster = htonl(src_params->fTimebaseMaster);
1277 dst_params->fState = htonl(src_params->fState);
1278 dst_params->fPosition.unique_1 = htonll(src_params->fPosition.unique_1);
1279 dst_params->fPosition.usecs = htonl(src_params->fPosition.usecs);
1280 dst_params->fPosition.frame_rate = htonl(src_params->fPosition.frame_rate);
1281 dst_params->fPosition.frame = htonl(src_params->fPosition.frame);
1282 dst_params->fPosition.valid = (jack_position_bits_t)htonl((uint32_t)src_params->fPosition.valid);
1283 dst_params->fPosition.bar = htonl(src_params->fPosition.bar);
1284 dst_params->fPosition.beat = htonl(src_params->fPosition.beat);
1285 dst_params->fPosition.tick = htonl(src_params->fPosition.tick);
1286 dst_params->fPosition.bar_start_tick = htonll((uint64_t)src_params->fPosition.bar_start_tick);
1287 dst_params->fPosition.beats_per_bar = htonl((uint32_t)src_params->fPosition.beats_per_bar);
1288 dst_params->fPosition.beat_type = htonl((uint32_t)src_params->fPosition.beat_type);
1289 dst_params->fPosition.ticks_per_beat = htonll((uint64_t)src_params->fPosition.ticks_per_beat);
1290 dst_params->fPosition.beats_per_minute = htonll((uint64_t)src_params->fPosition.beats_per_minute);
1291 dst_params->fPosition.frame_time = htonll((uint64_t)src_params->fPosition.frame_time);
1292 dst_params->fPosition.next_time = htonll((uint64_t)src_params->fPosition.next_time);
1293 dst_params->fPosition.bbt_offset = htonl(src_params->fPosition.bbt_offset);
1294 dst_params->fPosition.audio_frames_per_video_frame = htonl((uint32_t)src_params->fPosition.audio_frames_per_video_frame);
1295 dst_params->fPosition.video_offset = htonl(src_params->fPosition.video_offset);
1296 dst_params->fPosition.unique_2 = htonll(src_params->fPosition.unique_2);
1299 SERVER_EXPORT
void TransportDataNToH(net_transport_data_t* src_params, net_transport_data_t* dst_params)
1301 dst_params->fNewState = ntohl(src_params->fNewState);
1302 dst_params->fTimebaseMaster = ntohl(src_params->fTimebaseMaster);
1303 dst_params->fState = ntohl(src_params->fState);
1304 dst_params->fPosition.unique_1 = ntohll(src_params->fPosition.unique_1);
1305 dst_params->fPosition.usecs = ntohl(src_params->fPosition.usecs);
1306 dst_params->fPosition.frame_rate = ntohl(src_params->fPosition.frame_rate);
1307 dst_params->fPosition.frame = ntohl(src_params->fPosition.frame);
1308 dst_params->fPosition.valid = (jack_position_bits_t)ntohl((uint32_t)src_params->fPosition.valid);
1309 dst_params->fPosition.bar = ntohl(src_params->fPosition.bar);
1310 dst_params->fPosition.beat = ntohl(src_params->fPosition.beat);
1311 dst_params->fPosition.tick = ntohl(src_params->fPosition.tick);
1312 dst_params->fPosition.bar_start_tick = ntohll((uint64_t)src_params->fPosition.bar_start_tick);
1313 dst_params->fPosition.beats_per_bar = ntohl((uint32_t)src_params->fPosition.beats_per_bar);
1314 dst_params->fPosition.beat_type = ntohl((uint32_t)src_params->fPosition.beat_type);
1315 dst_params->fPosition.ticks_per_beat = ntohll((uint64_t)src_params->fPosition.ticks_per_beat);
1316 dst_params->fPosition.beats_per_minute = ntohll((uint64_t)src_params->fPosition.beats_per_minute);
1317 dst_params->fPosition.frame_time = ntohll((uint64_t)src_params->fPosition.frame_time);
1318 dst_params->fPosition.next_time = ntohll((uint64_t)src_params->fPosition.next_time);
1319 dst_params->fPosition.bbt_offset = ntohl(src_params->fPosition.bbt_offset);
1320 dst_params->fPosition.audio_frames_per_video_frame = ntohl((uint32_t)src_params->fPosition.audio_frames_per_video_frame);
1321 dst_params->fPosition.video_offset = ntohl(src_params->fPosition.video_offset);
1322 dst_params->fPosition.unique_2 = ntohll(src_params->fPosition.unique_2);
1327 SERVER_EXPORT
int SocketAPIInit()
1330 WORD wVersionRequested = MAKEWORD(2, 2);
1333 if (WSAStartup(wVersionRequested, &wsaData) != 0) {
1334 jack_error(
"WSAStartup error : %s", strerror(NET_ERROR_CODE));
1338 if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
1339 jack_error(
"Could not find a useable version of Winsock.dll\n");
1347 SERVER_EXPORT
int SocketAPIEnd()
1350 return WSACleanup();
1355 SERVER_EXPORT
const char* GetTransportState(
int transport_state)
1357 switch (transport_state)
1359 case JackTransportRolling:
1361 case JackTransportStarting:
1363 case JackTransportStopped:
1365 case JackTransportNetStarting:
1366 return "netstarting";
SERVER_EXPORT void jack_error(const char *fmt,...)
SERVER_EXPORT void jack_info(const char *fmt,...)
SERVER_EXPORT void jack_log(const char *fmt,...)