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;
105 fCycleBytesSize = params->fMtu
106 * (max(params->fSendMidiChannels, params->fReturnMidiChannels)
107 * params->fPeriodSize *
sizeof(sample_t) / (params->fMtu -
sizeof(packet_header_t)));
110 NetMidiBuffer::~NetMidiBuffer()
113 delete[] fPortBuffer;
116 size_t NetMidiBuffer::GetCycleSize()
118 return fCycleBytesSize;
121 int NetMidiBuffer::GetNumPackets(
int data_size,
int max_size)
123 int res1 = data_size % max_size;
124 int res2 = data_size / max_size;
125 return (res1) ? res2 + 1 : res2;
128 void NetMidiBuffer::SetBuffer(
int index, JackMidiBuffer* buffer)
130 fPortBuffer[index] = buffer;
133 JackMidiBuffer* NetMidiBuffer::GetBuffer(
int index)
135 return fPortBuffer[index];
138 void NetMidiBuffer::DisplayEvents()
140 for (
int port_index = 0; port_index < fNPorts; port_index++) {
141 for (uint event = 0;
event < fPortBuffer[port_index]->event_count;
event++) {
142 if (fPortBuffer[port_index]->IsValid()) {
143 jack_info(
"port %d : midi event %u/%u -> time : %u, size : %u",
144 port_index + 1, event + 1, fPortBuffer[port_index]->event_count,
145 fPortBuffer[port_index]->events[event].time, fPortBuffer[port_index]->events[event].size);
151 int NetMidiBuffer::RenderFromJackPorts()
156 for (
int port_index = 0; port_index < fNPorts; port_index++) {
157 char* write_pos = fBuffer + pos;
158 copy_size =
sizeof(JackMidiBuffer) + fPortBuffer[port_index]->event_count *
sizeof(JackMidiEvent);
159 memcpy(fBuffer + pos, fPortBuffer[port_index], copy_size);
161 memcpy(fBuffer + pos,
162 fPortBuffer[port_index] + (fPortBuffer[port_index]->buffer_size - fPortBuffer[port_index]->write_pos),
163 fPortBuffer[port_index]->write_pos);
164 pos += fPortBuffer[port_index]->write_pos;
165 JackMidiBuffer* midi_buffer =
reinterpret_cast<JackMidiBuffer*
>(write_pos);
166 MidiBufferHToN(midi_buffer, midi_buffer);
171 void NetMidiBuffer::RenderToJackPorts()
176 for (
int port_index = 0; port_index < fNPorts; port_index++) {
177 JackMidiBuffer* midi_buffer =
reinterpret_cast<JackMidiBuffer*
>(fBuffer + pos);
178 MidiBufferNToH(midi_buffer, midi_buffer);
179 copy_size =
sizeof(JackMidiBuffer) + reinterpret_cast<JackMidiBuffer*>(fBuffer + pos)->event_count *
sizeof(JackMidiEvent);
180 memcpy(fPortBuffer[port_index], fBuffer + pos, copy_size);
182 memcpy(fPortBuffer[port_index] + (fPortBuffer[port_index]->buffer_size - fPortBuffer[port_index]->write_pos),
184 fPortBuffer[port_index]->write_pos);
185 pos += fPortBuffer[port_index]->write_pos;
189 void NetMidiBuffer::RenderFromNetwork(
int sub_cycle,
size_t copy_size)
191 memcpy(fBuffer + sub_cycle * fMaxPcktSize, fNetBuffer, copy_size);
194 int NetMidiBuffer::RenderToNetwork(
int sub_cycle,
size_t total_size)
196 int size = total_size - sub_cycle * fMaxPcktSize;
197 int copy_size = (size <= fMaxPcktSize) ? size : fMaxPcktSize;
198 memcpy(fNetBuffer, fBuffer + sub_cycle * fMaxPcktSize, copy_size);
204 NetAudioBuffer::NetAudioBuffer(session_params_t* params, uint32_t nports,
char* net_buffer)
207 fNetBuffer = net_buffer;
210 fPortBuffer =
new sample_t*[fNPorts];
211 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;
221 fSubPeriodBytesSize = 0;
222 fCycleDuration = 0.f;
226 NetAudioBuffer::~NetAudioBuffer()
228 delete [] fConnectedPorts;
229 delete [] fPortBuffer;
232 void NetAudioBuffer::SetBuffer(
int index, sample_t* buffer)
234 fPortBuffer[index] = buffer;
237 sample_t* NetAudioBuffer::GetBuffer(
int index)
239 return fPortBuffer[index];
242 int NetAudioBuffer::CheckPacket(
int cycle,
int sub_cycle)
246 if (sub_cycle != fLastSubCycle + 1) {
247 jack_error(
"Packet(s) missing from... %d %d", fLastSubCycle, sub_cycle);
248 res = DATA_PACKET_ERROR;
253 fLastSubCycle = sub_cycle;
257 void NetAudioBuffer::NextCycle()
263 void NetAudioBuffer::Cleanup()
265 for (
int port_index = 0; port_index < fNPorts; port_index++) {
266 if (fPortBuffer[port_index]) {
267 memset(fPortBuffer[port_index], 0, fPeriodSize *
sizeof(sample_t));
274 int NetAudioBuffer::ActivePortsToNetwork(
char* net_buffer)
276 int active_ports = 0;
277 int* active_port_address = (
int*)net_buffer;
279 for (
int port_index = 0; port_index < fNPorts; port_index++) {
281 if (fPortBuffer[port_index]) {
282 *active_port_address = htonl(port_index);
283 active_port_address++;
285 assert(active_ports < 256);
292 void NetAudioBuffer::ActivePortsFromNetwork(
char* net_buffer, uint32_t port_num)
294 int* active_port_address = (
int*)net_buffer;
296 for (
int port_index = 0; port_index < fNPorts; port_index++) {
297 fConnectedPorts[port_index] =
false;
300 for (uint port_index = 0; port_index < port_num; port_index++) {
301 int active_port = ntohl(*active_port_address);
302 assert(active_port < fNPorts);
303 fConnectedPorts[active_port] =
true;
304 active_port_address++;
308 int NetAudioBuffer::RenderFromJackPorts(
int unused_frames)
311 int active_ports = 0;
312 for (
int port_index = 0; port_index < fNPorts; port_index++) {
313 if (fPortBuffer[port_index]) {
321 void NetAudioBuffer::RenderToJackPorts(
int unused_frames)
329 NetFloatAudioBuffer::NetFloatAudioBuffer(session_params_t* params, uint32_t nports,
char* net_buffer)
330 : NetAudioBuffer(params, nports, net_buffer)
332 fPeriodSize = params->fPeriodSize;
333 fPacketSize = PACKET_AVAILABLE_SIZE(params);
335 UpdateParams(max(params->fReturnAudioChannels, params->fSendAudioChannels));
337 fCycleDuration = float(fSubPeriodSize) / float(params->fSampleRate);
338 fCycleBytesSize = params->fMtu * (fPeriodSize / fSubPeriodSize);
343 NetFloatAudioBuffer::~NetFloatAudioBuffer()
347 size_t NetFloatAudioBuffer::GetCycleSize()
349 return fCycleBytesSize;
353 float NetFloatAudioBuffer::GetCycleDuration()
355 return fCycleDuration;
358 void NetFloatAudioBuffer::UpdateParams(
int active_ports)
360 if (active_ports == 0) {
361 fSubPeriodSize = fPeriodSize;
363 jack_nframes_t period = int(powf(2.f,
int(log(
float(fPacketSize) / (active_ports *
sizeof(sample_t))) / log(2.))));
364 fSubPeriodSize = (period > fPeriodSize) ? fPeriodSize : period;
367 fSubPeriodBytesSize = fSubPeriodSize *
sizeof(sample_t) +
sizeof(
int);
368 fNumPackets = fPeriodSize / fSubPeriodSize;
371 int NetFloatAudioBuffer::GetNumPackets(
int active_ports)
373 UpdateParams(active_ports);
384 int NetFloatAudioBuffer::RenderFromNetwork(
int cycle,
int sub_cycle, uint32_t port_num)
387 if (sub_cycle == 0) {
392 UpdateParams(port_num);
393 for (uint32_t port_index = 0; port_index < port_num; port_index++) {
395 int* active_port_address = (
int*)(fNetBuffer + port_index * fSubPeriodBytesSize);
396 int active_port = ntohl(*active_port_address);
397 RenderFromNetwork((
char*)(active_port_address + 1), active_port, sub_cycle);
401 return CheckPacket(cycle, sub_cycle);
404 int NetFloatAudioBuffer::RenderToNetwork(
int sub_cycle, uint32_t port_num)
406 int active_ports = 0;
408 for (
int port_index = 0; port_index < fNPorts; port_index++) {
410 if (fPortBuffer[port_index]) {
411 int* active_port_address = (
int*)(fNetBuffer + active_ports * fSubPeriodBytesSize);
412 *active_port_address = htonl(port_index);
413 RenderToNetwork((
char*)(active_port_address + 1), port_index, sub_cycle);
418 return port_num * fSubPeriodBytesSize;
421 #ifdef __BIG_ENDIAN__
423 static inline jack_default_audio_sample_t SwapFloat(jack_default_audio_sample_t f)
427 jack_default_audio_sample_t f;
432 dat2.b[0] = dat1.b[3];
433 dat2.b[1] = dat1.b[2];
434 dat2.b[2] = dat1.b[1];
435 dat2.b[3] = dat1.b[0];
439 void NetFloatAudioBuffer::RenderFromNetwork(
char* net_buffer,
int active_port,
int sub_cycle)
441 if (fPortBuffer[active_port]) {
442 jack_default_audio_sample_t* src = (jack_default_audio_sample_t*)(net_buffer);
443 jack_default_audio_sample_t* dst = (jack_default_audio_sample_t*)(fPortBuffer[active_port] + sub_cycle * fSubPeriodSize);
444 for (
unsigned int sample = 0; sample < (fSubPeriodBytesSize -
sizeof(int)) /
sizeof(jack_default_audio_sample_t); sample++) {
445 dst[sample] = SwapFloat(src[sample]);
450 void NetFloatAudioBuffer::RenderToNetwork(
char* net_buffer,
int active_port,
int sub_cycle)
452 for (
int port_index = 0; port_index < fNPorts; port_index++ ) {
453 jack_default_audio_sample_t* src = (jack_default_audio_sample_t*)(fPortBuffer[active_port] + sub_cycle * fSubPeriodSize);
454 jack_default_audio_sample_t* dst = (jack_default_audio_sample_t*)(net_buffer);
455 for (
unsigned int sample = 0; sample < (fSubPeriodBytesSize -
sizeof(int)) /
sizeof(jack_default_audio_sample_t); sample++) {
456 dst[sample] = SwapFloat(src[sample]);
463 void NetFloatAudioBuffer::RenderFromNetwork(
char* net_buffer,
int active_port,
int sub_cycle)
465 if (fPortBuffer[active_port]) {
466 memcpy(fPortBuffer[active_port] + sub_cycle * fSubPeriodSize, net_buffer, fSubPeriodBytesSize -
sizeof(
int));
470 void NetFloatAudioBuffer::RenderToNetwork(
char* net_buffer,
int active_port,
int sub_cycle)
472 memcpy(net_buffer, fPortBuffer[active_port] + sub_cycle * fSubPeriodSize, fSubPeriodBytesSize -
sizeof(
int));
483 NetCeltAudioBuffer::NetCeltAudioBuffer(session_params_t* params, uint32_t nports,
char* net_buffer,
int kbps)
484 :NetAudioBuffer(params, nports, net_buffer)
486 fCeltMode =
new CELTMode*[fNPorts];
487 fCeltEncoder =
new CELTEncoder*[fNPorts];
488 fCeltDecoder =
new CELTDecoder*[fNPorts];
490 memset(fCeltMode, 0, fNPorts *
sizeof(CELTMode*));
491 memset(fCeltEncoder, 0, fNPorts *
sizeof(CELTEncoder*));
492 memset(fCeltDecoder, 0, fNPorts *
sizeof(CELTDecoder*));
496 for (
int i = 0; i < fNPorts; i++) {
497 fCeltMode[i] = celt_mode_create(params->fSampleRate, params->fPeriodSize, &error);
498 if (error != CELT_OK) {
499 jack_log(
"NetCeltAudioBuffer celt_mode_create err = %d", error);
503 #if HAVE_CELT_API_0_11
505 fCeltEncoder[i] = celt_encoder_create_custom(fCeltMode[i], 1, &error);
506 if (error != CELT_OK) {
507 jack_log(
"NetCeltAudioBuffer celt_encoder_create_custom err = %d", error);
510 celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
512 fCeltDecoder[i] = celt_decoder_create_custom(fCeltMode[i], 1, &error);
513 if (error != CELT_OK) {
514 jack_log(
"NetCeltAudioBuffer celt_decoder_create_custom err = %d", error);
517 celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
519 #elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
521 fCeltEncoder[i] = celt_encoder_create(fCeltMode[i], 1, &error);
522 if (error != CELT_OK) {
523 jack_log(
"NetCeltAudioBuffer celt_mode_create err = %d", error);
526 celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
528 fCeltDecoder[i] = celt_decoder_create(fCeltMode[i], 1, &error);
529 if (error != CELT_OK) {
530 jack_log(
"NetCeltAudioBuffer celt_decoder_create err = %d", error);
533 celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
537 fCeltEncoder[i] = celt_encoder_create(fCeltMode[i]);
538 if (error != CELT_OK) {
539 jack_log(
"NetCeltAudioBuffer celt_encoder_create err = %d", error);
542 celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
544 fCeltDecoder[i] = celt_decoder_create(fCeltMode[i]);
545 if (error != CELT_OK) {
546 jack_log(
"NetCeltAudioBuffer celt_decoder_create err = %d", error);
549 celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
555 fPeriodSize = params->fPeriodSize;
557 fCompressedSizeByte = (kbps * params->fPeriodSize * 1024) / (params->fSampleRate * 8);
558 jack_log(
"NetCeltAudioBuffer fCompressedSizeByte %d", fCompressedSizeByte);
560 fCompressedBuffer =
new unsigned char* [fNPorts];
561 for (
int port_index = 0; port_index < fNPorts; port_index++) {
562 fCompressedBuffer[port_index] =
new unsigned char[fCompressedSizeByte];
563 memset(fCompressedBuffer[port_index], 0, fCompressedSizeByte *
sizeof(
char));
566 int res1 = (fNPorts * fCompressedSizeByte) % PACKET_AVAILABLE_SIZE(params);
567 int res2 = (fNPorts * fCompressedSizeByte) / PACKET_AVAILABLE_SIZE(params);
569 fNumPackets = (res1) ? (res2 + 1) : res2;
571 jack_log(
"NetCeltAudioBuffer res1 = %d res2 = %d", res1, res2);
573 fSubPeriodBytesSize = fCompressedSizeByte / fNumPackets;
574 fLastSubPeriodBytesSize = fSubPeriodBytesSize + fCompressedSizeByte % fNumPackets;
576 jack_log(
"NetCeltAudioBuffer fNumPackets = %d fSubPeriodBytesSize = %d, fLastSubPeriodBytesSize = %d", fNumPackets, fSubPeriodBytesSize, fLastSubPeriodBytesSize);
578 fCycleDuration = float(fSubPeriodBytesSize /
sizeof(sample_t)) / float(params->fSampleRate);
579 fCycleBytesSize = params->fMtu * fNumPackets;
588 throw std::bad_alloc();
591 NetCeltAudioBuffer::~NetCeltAudioBuffer()
595 for (
int port_index = 0; port_index < fNPorts; port_index++) {
596 delete [] fCompressedBuffer[port_index];
599 delete [] fCompressedBuffer;
602 void NetCeltAudioBuffer::FreeCelt()
604 for (
int i = 0; i < fNPorts; i++) {
605 if (fCeltEncoder[i]) {
606 celt_encoder_destroy(fCeltEncoder[i]);
608 if (fCeltDecoder[i]) {
609 celt_decoder_destroy(fCeltDecoder[i]);
612 celt_mode_destroy(fCeltMode[i]);
617 delete [] fCeltEncoder;
618 delete [] fCeltDecoder;
621 size_t NetCeltAudioBuffer::GetCycleSize()
623 return fCycleBytesSize;
626 float NetCeltAudioBuffer::GetCycleDuration()
628 return fCycleDuration;
631 int NetCeltAudioBuffer::GetNumPackets(
int active_ports)
636 int NetCeltAudioBuffer::RenderFromJackPorts(
int nframes)
638 float buffer[BUFFER_SIZE_MAX];
640 for (
int port_index = 0; port_index < fNPorts; port_index++) {
641 if (fPortBuffer[port_index]) {
642 memcpy(buffer, fPortBuffer[port_index], fPeriodSize *
sizeof(sample_t));
644 memset(buffer, 0, fPeriodSize *
sizeof(sample_t));
646 #if HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11
648 int res = celt_encode_float(fCeltEncoder[port_index], buffer, nframes, fCompressedBuffer[port_index], fCompressedSizeByte);
650 int res = celt_encode_float(fCeltEncoder[port_index], buffer, NULL, fCompressedBuffer[port_index], fCompressedSizeByte);
652 if (res != fCompressedSizeByte) {
653 jack_error(
"celt_encode_float error fCompressedSizeByte = %d res = %d", fCompressedSizeByte, res);
661 void NetCeltAudioBuffer::RenderToJackPorts(
int nframes)
663 for (
int port_index = 0; port_index < fNPorts; port_index++) {
664 if (fPortBuffer[port_index]) {
665 #if HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11
667 int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index], nframes);
669 int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index]);
671 if (res != CELT_OK) {
672 jack_error(
"celt_decode_float error fCompressedSizeByte = %d res = %d", fCompressedSizeByte, res);
681 int NetCeltAudioBuffer::RenderFromNetwork(
int cycle,
int sub_cycle, uint32_t port_num)
684 if (sub_cycle == 0) {
690 int sub_period_bytes_size;
693 if (sub_cycle == fNumPackets - 1) {
694 sub_period_bytes_size = fLastSubPeriodBytesSize;
696 sub_period_bytes_size = fSubPeriodBytesSize;
699 for (
int port_index = 0; port_index < fNPorts; port_index++) {
700 memcpy(fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, fNetBuffer + port_index * sub_period_bytes_size, sub_period_bytes_size);
704 return CheckPacket(cycle, sub_cycle);
707 int NetCeltAudioBuffer::RenderToNetwork(
int sub_cycle, uint32_t port_num)
709 int sub_period_bytes_size;
712 if (sub_cycle == fNumPackets - 1) {
713 sub_period_bytes_size = fLastSubPeriodBytesSize;
715 sub_period_bytes_size = fSubPeriodBytesSize;
718 for (
int port_index = 0; port_index < fNPorts; port_index++) {
719 memcpy(fNetBuffer + port_index * sub_period_bytes_size, fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, sub_period_bytes_size);
721 return fNPorts * sub_period_bytes_size;
728 #define CDO (sizeof(short))
729 NetOpusAudioBuffer::NetOpusAudioBuffer(session_params_t* params, uint32_t nports, char* net_buffer, int kbps)
730 :NetAudioBuffer(params, nports, net_buffer)
732 fOpusMode =
new OpusCustomMode*[fNPorts];
733 fOpusEncoder =
new OpusCustomEncoder*[fNPorts];
734 fOpusDecoder =
new OpusCustomDecoder*[fNPorts];
735 fCompressedSizesByte =
new unsigned short[fNPorts];
737 memset(fOpusMode, 0, fNPorts *
sizeof(OpusCustomMode*));
738 memset(fOpusEncoder, 0, fNPorts *
sizeof(OpusCustomEncoder*));
739 memset(fOpusDecoder, 0, fNPorts *
sizeof(OpusCustomDecoder*));
740 memset(fCompressedSizesByte, 0, fNPorts *
sizeof(
short));
744 for (
int i = 0; i < fNPorts; i++) {
746 fOpusMode[i] = opus_custom_mode_create(params->fSampleRate, params->fPeriodSize, &error);
747 if (error != OPUS_OK) {
748 jack_log(
"NetOpusAudioBuffer opus_custom_mode_create err = %d", error);
752 fOpusEncoder[i] = opus_custom_encoder_create(fOpusMode[i], 1, &error);
753 if (error != OPUS_OK) {
754 jack_log(
"NetOpusAudioBuffer opus_custom_encoder_create err = %d", error);
758 fOpusDecoder[i] = opus_custom_decoder_create(fOpusMode[i], 1, &error);
759 if (error != OPUS_OK) {
760 jack_log(
"NetOpusAudioBuffer opus_custom_decoder_create err = %d", error);
764 opus_custom_encoder_ctl(fOpusEncoder[i], OPUS_SET_BITRATE(kbps*1024));
765 opus_custom_encoder_ctl(fOpusEncoder[i], OPUS_SET_COMPLEXITY(10));
766 opus_custom_encoder_ctl(fOpusEncoder[i], OPUS_SET_SIGNAL(OPUS_SIGNAL_MUSIC));
767 opus_custom_encoder_ctl(fOpusEncoder[i], OPUS_SET_SIGNAL(OPUS_APPLICATION_RESTRICTED_LOWDELAY));
771 fCompressedMaxSizeByte = (kbps * params->fPeriodSize * 1024) / (params->fSampleRate * 8);
772 fPeriodSize = params->fPeriodSize;
773 jack_log(
"NetOpusAudioBuffer fCompressedMaxSizeByte %d", fCompressedMaxSizeByte);
775 fCompressedBuffer =
new unsigned char* [fNPorts];
776 for (
int port_index = 0; port_index < fNPorts; port_index++) {
777 fCompressedBuffer[port_index] =
new unsigned char[fCompressedMaxSizeByte];
778 memset(fCompressedBuffer[port_index], 0, fCompressedMaxSizeByte *
sizeof(
char));
781 int res1 = (fNPorts * (fCompressedMaxSizeByte + CDO)) % PACKET_AVAILABLE_SIZE(params);
782 int res2 = (fNPorts * (fCompressedMaxSizeByte + CDO)) / PACKET_AVAILABLE_SIZE(params);
784 fNumPackets = (res1) ? (res2 + 1) : res2;
786 jack_log(
"NetOpusAudioBuffer res1 = %d res2 = %d", res1, res2);
788 fSubPeriodBytesSize = (fCompressedMaxSizeByte + CDO) / fNumPackets;
789 fLastSubPeriodBytesSize = fSubPeriodBytesSize + (fCompressedMaxSizeByte + CDO) % fNumPackets;
791 if (fNumPackets == 1) {
792 fSubPeriodBytesSize = fLastSubPeriodBytesSize;
795 jack_log(
"NetOpusAudioBuffer fNumPackets = %d fSubPeriodBytesSize = %d, fLastSubPeriodBytesSize = %d", fNumPackets, fSubPeriodBytesSize, fLastSubPeriodBytesSize);
797 fCycleDuration = float(fSubPeriodBytesSize /
sizeof(sample_t)) / float(params->fSampleRate);
798 fCycleBytesSize = params->fMtu * fNumPackets;
807 throw std::bad_alloc();
810 NetOpusAudioBuffer::~NetOpusAudioBuffer()
814 for (
int port_index = 0; port_index < fNPorts; port_index++) {
815 delete [] fCompressedBuffer[port_index];
818 delete [] fCompressedBuffer;
819 delete [] fCompressedSizesByte;
822 void NetOpusAudioBuffer::FreeOpus()
824 for (
int i = 0; i < fNPorts; i++) {
825 if (fOpusEncoder[i]) {
826 opus_custom_encoder_destroy(fOpusEncoder[i]);
829 if (fOpusDecoder[i]) {
830 opus_custom_decoder_destroy(fOpusDecoder[i]);
834 opus_custom_mode_destroy(fOpusMode[i]);
839 delete [] fOpusEncoder;
840 delete [] fOpusDecoder;
844 size_t NetOpusAudioBuffer::GetCycleSize()
846 return fCycleBytesSize;
849 float NetOpusAudioBuffer::GetCycleDuration()
851 return fCycleDuration;
854 int NetOpusAudioBuffer::GetNumPackets(
int active_ports)
859 int NetOpusAudioBuffer::RenderFromJackPorts(
int nframes)
861 float buffer[BUFFER_SIZE_MAX];
863 for (
int port_index = 0; port_index < fNPorts; port_index++) {
864 if (fPortBuffer[port_index]) {
865 memcpy(buffer, fPortBuffer[port_index], fPeriodSize *
sizeof(sample_t));
867 memset(buffer, 0, fPeriodSize *
sizeof(sample_t));
869 int res = opus_custom_encode_float(fOpusEncoder[port_index], buffer, ((nframes == -1) ? fPeriodSize : nframes), fCompressedBuffer[port_index], fCompressedMaxSizeByte);
870 if (res < 0 || res >= 65535) {
871 jack_error(
"opus_custom_encode_float error res = %d", res);
872 fCompressedSizesByte[port_index] = 0;
874 fCompressedSizesByte[port_index] = res;
882 void NetOpusAudioBuffer::RenderToJackPorts(
int nframes)
884 for (
int port_index = 0; port_index < fNPorts; port_index++) {
885 if (fPortBuffer[port_index]) {
886 int res = opus_custom_decode_float(fOpusDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizesByte[port_index], fPortBuffer[port_index], ((nframes == -1) ? fPeriodSize : nframes));
887 if (res < 0 || res != ((nframes == -1) ? fPeriodSize : nframes)) {
888 jack_error(
"opus_custom_decode_float error fCompressedSizeByte = %d res = %d", fCompressedSizesByte[port_index], res);
897 int NetOpusAudioBuffer::RenderFromNetwork(
int cycle,
int sub_cycle, uint32_t port_num)
900 if (sub_cycle == 0) {
905 if (sub_cycle == 0) {
906 for (
int port_index = 0; port_index < fNPorts; port_index++) {
907 size_t len = *((
size_t*)(fNetBuffer + port_index * fSubPeriodBytesSize));
908 fCompressedSizesByte[port_index] = ntohs(len);
909 memcpy(fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, fNetBuffer + CDO + port_index * fSubPeriodBytesSize, fSubPeriodBytesSize - CDO);
911 }
else if (sub_cycle == fNumPackets - 1) {
912 for (
int port_index = 0; port_index < fNPorts; port_index++) {
913 memcpy(fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize - CDO, fNetBuffer + port_index * fLastSubPeriodBytesSize, fLastSubPeriodBytesSize);
916 for (
int port_index = 0; port_index < fNPorts; port_index++) {
917 memcpy(fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize - CDO, fNetBuffer + port_index * fSubPeriodBytesSize, fSubPeriodBytesSize);
922 return CheckPacket(cycle, sub_cycle);
925 int NetOpusAudioBuffer::RenderToNetwork(
int sub_cycle, uint32_t port_num)
927 if (sub_cycle == 0) {
928 for (
int port_index = 0; port_index < fNPorts; port_index++) {
929 unsigned short len = htons(fCompressedSizesByte[port_index]);
930 memcpy(fNetBuffer + port_index * fSubPeriodBytesSize, &len, CDO);
931 memcpy(fNetBuffer + port_index * fSubPeriodBytesSize + CDO, fCompressedBuffer[port_index], fSubPeriodBytesSize - CDO);
933 return fNPorts * fSubPeriodBytesSize;
934 }
else if (sub_cycle == fNumPackets - 1) {
935 for (
int port_index = 0; port_index < fNPorts; port_index++) {
936 memcpy(fNetBuffer + port_index * fLastSubPeriodBytesSize, fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize - CDO, fLastSubPeriodBytesSize);
938 return fNPorts * fLastSubPeriodBytesSize;
940 for (
int port_index = 0; port_index < fNPorts; port_index++) {
941 memcpy(fNetBuffer + port_index * fSubPeriodBytesSize, fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize - CDO, fSubPeriodBytesSize);
943 return fNPorts * fSubPeriodBytesSize;
949 NetIntAudioBuffer::NetIntAudioBuffer(session_params_t* params, uint32_t nports,
char* net_buffer)
950 : NetAudioBuffer(params, nports, net_buffer)
952 fPeriodSize = params->fPeriodSize;
954 fCompressedSizeByte = (params->fPeriodSize *
sizeof(short));
955 jack_log(
"NetIntAudioBuffer fCompressedSizeByte %d", fCompressedSizeByte);
957 fIntBuffer =
new short* [fNPorts];
958 for (
int port_index = 0; port_index < fNPorts; port_index++) {
959 fIntBuffer[port_index] =
new short[fPeriodSize];
960 memset(fIntBuffer[port_index], 0, fPeriodSize *
sizeof(
short));
963 int res1 = (fNPorts * fCompressedSizeByte) % PACKET_AVAILABLE_SIZE(params);
964 int res2 = (fNPorts * fCompressedSizeByte) / PACKET_AVAILABLE_SIZE(params);
966 jack_log(
"NetIntAudioBuffer res1 = %d res2 = %d", res1, res2);
968 fNumPackets = (res1) ? (res2 + 1) : res2;
970 fSubPeriodBytesSize = fCompressedSizeByte / fNumPackets;
971 fLastSubPeriodBytesSize = fSubPeriodBytesSize + fCompressedSizeByte % fNumPackets;
973 fSubPeriodSize = fSubPeriodBytesSize /
sizeof(short);
975 jack_log(
"NetIntAudioBuffer fNumPackets = %d fSubPeriodBytesSize = %d, fLastSubPeriodBytesSize = %d", fNumPackets, fSubPeriodBytesSize, fLastSubPeriodBytesSize);
977 fCycleDuration = float(fSubPeriodBytesSize /
sizeof(sample_t)) / float(params->fSampleRate);
978 fCycleBytesSize = params->fMtu * fNumPackets;
983 NetIntAudioBuffer::~NetIntAudioBuffer()
985 for (
int port_index = 0; port_index < fNPorts; port_index++) {
986 delete [] fIntBuffer[port_index];
989 delete [] fIntBuffer;
992 size_t NetIntAudioBuffer::GetCycleSize()
994 return fCycleBytesSize;
997 float NetIntAudioBuffer::GetCycleDuration()
999 return fCycleDuration;
1002 int NetIntAudioBuffer::GetNumPackets(
int active_ports)
1007 int NetIntAudioBuffer::RenderFromJackPorts(
int nframes)
1009 for (
int port_index = 0; port_index < fNPorts; port_index++) {
1010 if (fPortBuffer[port_index]) {
1011 for (
int frame = 0; frame < nframes; frame++) {
1012 fIntBuffer[port_index][frame] = short(fPortBuffer[port_index][frame] * 32767.f);
1015 memset(fIntBuffer[port_index], 0, fPeriodSize *
sizeof(
short));
1023 void NetIntAudioBuffer::RenderToJackPorts(
int nframes)
1025 float coef = 1.f / 32767.f;
1026 for (
int port_index = 0; port_index < fNPorts; port_index++) {
1027 if (fPortBuffer[port_index]) {
1028 for (
int frame = 0; frame < nframes; frame++) {
1029 fPortBuffer[port_index][frame] = float(fIntBuffer[port_index][frame] * coef);
1038 int NetIntAudioBuffer::RenderFromNetwork(
int cycle,
int sub_cycle, uint32_t port_num)
1041 if (sub_cycle == 0) {
1046 int sub_period_bytes_size;
1049 if (sub_cycle == fNumPackets - 1) {
1050 sub_period_bytes_size = fLastSubPeriodBytesSize;
1052 sub_period_bytes_size = fSubPeriodBytesSize;
1055 for (
int port_index = 0; port_index < fNPorts; port_index++) {
1056 memcpy(fIntBuffer[port_index] + sub_cycle * fSubPeriodSize, fNetBuffer + port_index * sub_period_bytes_size, sub_period_bytes_size);
1060 return CheckPacket(cycle, sub_cycle);
1063 int NetIntAudioBuffer::RenderToNetwork(
int sub_cycle, uint32_t port_num)
1065 int sub_period_bytes_size;
1068 if (sub_cycle == fNumPackets - 1) {
1069 sub_period_bytes_size = fLastSubPeriodBytesSize;
1071 sub_period_bytes_size = fSubPeriodBytesSize;
1074 for (
int port_index = 0; port_index < fNPorts; port_index++) {
1075 memcpy(fNetBuffer + port_index * sub_period_bytes_size, fIntBuffer[port_index] + sub_cycle * fSubPeriodSize, sub_period_bytes_size);
1077 return fNPorts * sub_period_bytes_size;
1082 SERVER_EXPORT
void SessionParamsHToN(session_params_t* src_params, session_params_t* dst_params)
1084 memcpy(dst_params, src_params,
sizeof(session_params_t));
1085 dst_params->fProtocolVersion = htonl(src_params->fProtocolVersion);
1086 dst_params->fPacketID = htonl(src_params->fPacketID);
1087 dst_params->fMtu = htonl(src_params->fMtu);
1088 dst_params->fID = htonl(src_params->fID);
1089 dst_params->fTransportSync = htonl(src_params->fTransportSync);
1090 dst_params->fSendAudioChannels = htonl(src_params->fSendAudioChannels);
1091 dst_params->fReturnAudioChannels = htonl(src_params->fReturnAudioChannels);
1092 dst_params->fSendMidiChannels = htonl(src_params->fSendMidiChannels);
1093 dst_params->fReturnMidiChannels = htonl(src_params->fReturnMidiChannels);
1094 dst_params->fSampleRate = htonl(src_params->fSampleRate);
1095 dst_params->fPeriodSize = htonl(src_params->fPeriodSize);
1096 dst_params->fSampleEncoder = htonl(src_params->fSampleEncoder);
1097 dst_params->fKBps = htonl(src_params->fKBps);
1098 dst_params->fSlaveSyncMode = htonl(src_params->fSlaveSyncMode);
1099 dst_params->fNetworkLatency = htonl(src_params->fNetworkLatency);
1102 SERVER_EXPORT
void SessionParamsNToH(session_params_t* src_params, session_params_t* dst_params)
1104 memcpy(dst_params, src_params,
sizeof(session_params_t));
1105 dst_params->fProtocolVersion = ntohl(src_params->fProtocolVersion);
1106 dst_params->fPacketID = ntohl(src_params->fPacketID);
1107 dst_params->fMtu = ntohl(src_params->fMtu);
1108 dst_params->fID = ntohl(src_params->fID);
1109 dst_params->fTransportSync = ntohl(src_params->fTransportSync);
1110 dst_params->fSendAudioChannels = ntohl(src_params->fSendAudioChannels);
1111 dst_params->fReturnAudioChannels = ntohl(src_params->fReturnAudioChannels);
1112 dst_params->fSendMidiChannels = ntohl(src_params->fSendMidiChannels);
1113 dst_params->fReturnMidiChannels = ntohl(src_params->fReturnMidiChannels);
1114 dst_params->fSampleRate = ntohl(src_params->fSampleRate);
1115 dst_params->fPeriodSize = ntohl(src_params->fPeriodSize);
1116 dst_params->fSampleEncoder = ntohl(src_params->fSampleEncoder);
1117 dst_params->fKBps = ntohl(src_params->fKBps);
1118 dst_params->fSlaveSyncMode = ntohl(src_params->fSlaveSyncMode);
1119 dst_params->fNetworkLatency = ntohl(src_params->fNetworkLatency);
1122 SERVER_EXPORT
void SessionParamsDisplay(session_params_t* params)
1125 switch (params->fSampleEncoder)
1127 case JackFloatEncoder:
1128 strcpy(encoder,
"float");
1130 case JackIntEncoder:
1131 strcpy(encoder,
"integer");
1133 case JackCeltEncoder:
1134 strcpy(encoder,
"CELT");
1136 case JackOpusEncoder:
1137 strcpy(encoder,
"OPUS");
1141 jack_info(
"**************** Network parameters ****************");
1143 jack_info(
"Protocol revision : %d", params->fProtocolVersion);
1145 jack_info(
"Master name : %s", params->fMasterNetName);
1146 jack_info(
"Slave name : %s", params->fSlaveNetName);
1148 jack_info(
"Transport Sync : %s", (params->fTransportSync) ?
"yes" :
"no");
1149 jack_info(
"Send channels (audio - midi) : %d - %d", params->fSendAudioChannels, params->fSendMidiChannels);
1150 jack_info(
"Return channels (audio - midi) : %d - %d", params->fReturnAudioChannels, params->fReturnMidiChannels);
1151 jack_info(
"Sample rate : %u frames per second", params->fSampleRate);
1152 jack_info(
"Period size : %u frames per period", params->fPeriodSize);
1153 jack_info(
"Network latency : %u cycles", params->fNetworkLatency);
1154 switch (params->fSampleEncoder) {
1155 case (JackFloatEncoder):
1156 jack_info(
"SampleEncoder : %s",
"Float");
1158 case (JackIntEncoder):
1159 jack_info(
"SampleEncoder : %s",
"16 bits integer");
1161 case (JackCeltEncoder):
1162 jack_info(
"SampleEncoder : %s",
"CELT");
1165 case (JackOpusEncoder):
1166 jack_info(
"SampleEncoder : %s",
"OPUS");
1170 jack_info(
"Slave mode : %s", (params->fSlaveSyncMode) ?
"sync" :
"async");
1171 jack_info(
"****************************************************");
1174 SERVER_EXPORT sync_packet_type_t GetPacketType(session_params_t* params)
1176 switch (params->fPacketID)
1179 return SLAVE_AVAILABLE;
1183 return START_MASTER;
1192 SERVER_EXPORT
int SetPacketType(session_params_t* params, sync_packet_type_t packet_type)
1194 switch (packet_type)
1198 case SLAVE_AVAILABLE:
1199 params->fPacketID = 0;
1202 params->fPacketID = 1;
1205 params->fPacketID = 2;
1208 params->fPacketID = 3;
1211 params->fPacketID = 4;
1218 SERVER_EXPORT
void PacketHeaderHToN(packet_header_t* src_header, packet_header_t* dst_header)
1220 memcpy(dst_header, src_header,
sizeof(packet_header_t));
1221 dst_header->fDataType = htonl(src_header->fDataType);
1222 dst_header->fDataStream = htonl(src_header->fDataStream);
1223 dst_header->fID = htonl(src_header->fID);
1224 dst_header->fNumPacket = htonl(src_header->fNumPacket);
1225 dst_header->fPacketSize = htonl(src_header->fPacketSize);
1226 dst_header->fActivePorts = htonl(src_header->fActivePorts);
1227 dst_header->fCycle = htonl(src_header->fCycle);
1228 dst_header->fSubCycle = htonl(src_header->fSubCycle);
1229 dst_header->fFrames = htonl(src_header->fFrames);
1230 dst_header->fIsLastPckt = htonl(src_header->fIsLastPckt);
1233 SERVER_EXPORT
void PacketHeaderNToH(packet_header_t* src_header, packet_header_t* dst_header)
1235 memcpy(dst_header, src_header,
sizeof(packet_header_t));
1236 dst_header->fDataType = ntohl(src_header->fDataType);
1237 dst_header->fDataStream = ntohl(src_header->fDataStream);
1238 dst_header->fID = ntohl(src_header->fID);
1239 dst_header->fNumPacket = ntohl(src_header->fNumPacket);
1240 dst_header->fPacketSize = ntohl(src_header->fPacketSize);
1241 dst_header->fActivePorts = ntohl(src_header->fActivePorts);
1242 dst_header->fCycle = ntohl(src_header->fCycle);
1243 dst_header->fSubCycle = ntohl(src_header->fSubCycle);
1244 dst_header->fFrames = ntohl(src_header->fFrames);
1245 dst_header->fIsLastPckt = ntohl(src_header->fIsLastPckt);
1248 SERVER_EXPORT
void PacketHeaderDisplay(packet_header_t* header)
1250 jack_info(
"********************Header********************");
1251 jack_info(
"Data type : %c", header->fDataType);
1252 jack_info(
"Data stream : %c", header->fDataStream);
1254 jack_info(
"Cycle : %u", header->fCycle);
1255 jack_info(
"SubCycle : %u", header->fSubCycle);
1256 jack_info(
"Active ports : %u", header->fActivePorts);
1257 jack_info(
"DATA packets : %u", header->fNumPacket);
1258 jack_info(
"DATA size : %u", header->fPacketSize);
1259 jack_info(
"DATA frames : %d", header->fFrames);
1260 jack_info(
"Last packet : '%s'", (header->fIsLastPckt) ?
"yes" :
"no");
1261 jack_info(
"**********************************************");
1264 SERVER_EXPORT
void NetTransportDataDisplay(net_transport_data_t* data)
1266 jack_info(
"********************Network Transport********************");
1267 jack_info(
"Transport new state : %u", data->fNewState);
1268 jack_info(
"Transport timebase master : %u", data->fTimebaseMaster);
1269 jack_info(
"Transport cycle state : %u", data->fState);
1270 jack_info(
"**********************************************");
1273 SERVER_EXPORT
void MidiBufferHToN(JackMidiBuffer* src_buffer, JackMidiBuffer* dst_buffer)
1275 dst_buffer->magic = htonl(src_buffer->magic);
1276 dst_buffer->buffer_size = htonl(src_buffer->buffer_size);
1277 dst_buffer->nframes = htonl(src_buffer->nframes);
1278 dst_buffer->write_pos = htonl(src_buffer->write_pos);
1279 dst_buffer->event_count = htonl(src_buffer->event_count);
1280 dst_buffer->lost_events = htonl(src_buffer->lost_events);
1283 SERVER_EXPORT
void MidiBufferNToH(JackMidiBuffer* src_buffer, JackMidiBuffer* dst_buffer)
1285 dst_buffer->magic = ntohl(src_buffer->magic);
1286 dst_buffer->buffer_size = ntohl(src_buffer->buffer_size);
1287 dst_buffer->nframes = ntohl(src_buffer->nframes);
1288 dst_buffer->write_pos = ntohl(src_buffer->write_pos);
1289 dst_buffer->event_count = ntohl(src_buffer->event_count);
1290 dst_buffer->lost_events = ntohl(src_buffer->lost_events);
1293 SERVER_EXPORT
void TransportDataHToN(net_transport_data_t* src_params, net_transport_data_t* dst_params)
1295 dst_params->fNewState = htonl(src_params->fNewState);
1296 dst_params->fTimebaseMaster = htonl(src_params->fTimebaseMaster);
1297 dst_params->fState = htonl(src_params->fState);
1298 dst_params->fPosition.unique_1 = htonll(src_params->fPosition.unique_1);
1299 dst_params->fPosition.usecs = htonl(src_params->fPosition.usecs);
1300 dst_params->fPosition.frame_rate = htonl(src_params->fPosition.frame_rate);
1301 dst_params->fPosition.frame = htonl(src_params->fPosition.frame);
1302 dst_params->fPosition.valid = (jack_position_bits_t)htonl((uint32_t)src_params->fPosition.valid);
1303 dst_params->fPosition.bar = htonl(src_params->fPosition.bar);
1304 dst_params->fPosition.beat = htonl(src_params->fPosition.beat);
1305 dst_params->fPosition.tick = htonl(src_params->fPosition.tick);
1306 dst_params->fPosition.bar_start_tick = htonll((uint64_t)src_params->fPosition.bar_start_tick);
1307 dst_params->fPosition.beats_per_bar = htonl((uint32_t)src_params->fPosition.beats_per_bar);
1308 dst_params->fPosition.beat_type = htonl((uint32_t)src_params->fPosition.beat_type);
1309 dst_params->fPosition.ticks_per_beat = htonll((uint64_t)src_params->fPosition.ticks_per_beat);
1310 dst_params->fPosition.beats_per_minute = htonll((uint64_t)src_params->fPosition.beats_per_minute);
1311 dst_params->fPosition.frame_time = htonll((uint64_t)src_params->fPosition.frame_time);
1312 dst_params->fPosition.next_time = htonll((uint64_t)src_params->fPosition.next_time);
1313 dst_params->fPosition.bbt_offset = htonl(src_params->fPosition.bbt_offset);
1314 dst_params->fPosition.audio_frames_per_video_frame = htonl((uint32_t)src_params->fPosition.audio_frames_per_video_frame);
1315 dst_params->fPosition.video_offset = htonl(src_params->fPosition.video_offset);
1316 dst_params->fPosition.unique_2 = htonll(src_params->fPosition.unique_2);
1319 SERVER_EXPORT
void TransportDataNToH(net_transport_data_t* src_params, net_transport_data_t* dst_params)
1321 dst_params->fNewState = ntohl(src_params->fNewState);
1322 dst_params->fTimebaseMaster = ntohl(src_params->fTimebaseMaster);
1323 dst_params->fState = ntohl(src_params->fState);
1324 dst_params->fPosition.unique_1 = ntohll(src_params->fPosition.unique_1);
1325 dst_params->fPosition.usecs = ntohl(src_params->fPosition.usecs);
1326 dst_params->fPosition.frame_rate = ntohl(src_params->fPosition.frame_rate);
1327 dst_params->fPosition.frame = ntohl(src_params->fPosition.frame);
1328 dst_params->fPosition.valid = (jack_position_bits_t)ntohl((uint32_t)src_params->fPosition.valid);
1329 dst_params->fPosition.bar = ntohl(src_params->fPosition.bar);
1330 dst_params->fPosition.beat = ntohl(src_params->fPosition.beat);
1331 dst_params->fPosition.tick = ntohl(src_params->fPosition.tick);
1332 dst_params->fPosition.bar_start_tick = ntohll((uint64_t)src_params->fPosition.bar_start_tick);
1333 dst_params->fPosition.beats_per_bar = ntohl((uint32_t)src_params->fPosition.beats_per_bar);
1334 dst_params->fPosition.beat_type = ntohl((uint32_t)src_params->fPosition.beat_type);
1335 dst_params->fPosition.ticks_per_beat = ntohll((uint64_t)src_params->fPosition.ticks_per_beat);
1336 dst_params->fPosition.beats_per_minute = ntohll((uint64_t)src_params->fPosition.beats_per_minute);
1337 dst_params->fPosition.frame_time = ntohll((uint64_t)src_params->fPosition.frame_time);
1338 dst_params->fPosition.next_time = ntohll((uint64_t)src_params->fPosition.next_time);
1339 dst_params->fPosition.bbt_offset = ntohl(src_params->fPosition.bbt_offset);
1340 dst_params->fPosition.audio_frames_per_video_frame = ntohl((uint32_t)src_params->fPosition.audio_frames_per_video_frame);
1341 dst_params->fPosition.video_offset = ntohl(src_params->fPosition.video_offset);
1342 dst_params->fPosition.unique_2 = ntohll(src_params->fPosition.unique_2);
1347 SERVER_EXPORT
int SocketAPIInit()
1350 WORD wVersionRequested = MAKEWORD(2, 2);
1353 if (WSAStartup(wVersionRequested, &wsaData) != 0) {
1354 jack_error(
"WSAStartup error : %s", strerror(NET_ERROR_CODE));
1358 if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
1359 jack_error(
"Could not find a useable version of Winsock.dll\n");
1367 SERVER_EXPORT
int SocketAPIEnd()
1370 return WSACleanup();
1375 SERVER_EXPORT
const char* GetTransportState(
int transport_state)
1377 switch (transport_state)
1379 case JackTransportRolling:
1381 case JackTransportStarting:
1383 case JackTransportStopped:
1385 case JackTransportNetStarting:
1386 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,...)