common/JackNetTool.cpp

   1 /*
   2 Copyright (C) 2008-2011 Romain Moret at Grame
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "JackNetTool.h"
  21 #include "JackError.h"
  22
  23 #ifdef __APPLE__
  24
  25 #include <mach/mach_time.h>
  26
  27 class HardwareClock
  28 {
  29     public:
  30
  31         HardwareClock();
  32
  33         void Reset();
  34         void Update();
  35
  36         float GetDeltaTime() const;
  37         double GetTime() const;
  38
  39     private:
  40
  41         double m_clockToSeconds;
  42
  43         uint64_t m_startAbsTime;
  44         uint64_t m_lastAbsTime;
  45
  46         double m_time;
  47         float m_deltaTime;
  48 };
  49
  50 HardwareClock::HardwareClock()
  51 {
  52         mach_timebase_info_data_t info;
  53         mach_timebase_info(&info);
  54         m_clockToSeconds = (double)info.numer/info.denom/1000000000.0;
  55         Reset();
  56 }
  57
  58 void HardwareClock::Reset()
  59 {
  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;
  64 }
  65
  66 void HardwareClock::Update()
  67 {
  68         const uint64_t currentTime = mach_absolute_time();
  69         const uint64_t dt = currentTime - m_lastAbsTime;
  70
  71         m_time = currentTime*m_clockToSeconds;
  72         m_deltaTime = (double)dt*m_clockToSeconds;
  73         m_lastAbsTime = currentTime;
  74 }
  75
  76 float HardwareClock::GetDeltaTime() const
  77 {
  78         return m_deltaTime;
  79 }
  80
  81 double HardwareClock::GetTime() const
  82 {
  83         return m_time;
  84 }
  85
  86 #endif
  87
  88 using namespace std;
  89
  90 namespace Jack
  91 {
  92 // NetMidiBuffer**********************************************************************************
  93
  94     NetMidiBuffer::NetMidiBuffer(session_params_t* params, uint32_t nports, char* net_buffer)
  95     {
  96         fNPorts = nports;
  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;
 103         }
 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)));
 108     }
 109
 110     NetMidiBuffer::~NetMidiBuffer()
 111     {
 112         delete[] fBuffer;
 113         delete[] fPortBuffer;
 114     }
 115
 116     size_t NetMidiBuffer::GetCycleSize()
 117     {
 118         return fCycleBytesSize;
 119     }
 120
 121     int NetMidiBuffer::GetNumPackets(int data_size, int max_size)
 122     {
 123         int res1 = data_size % max_size;
 124         int res2 = data_size / max_size;
 125         return (res1) ? res2 + 1 : res2;
 126     }
 127
 128     void NetMidiBuffer::SetBuffer(int index, JackMidiBuffer* buffer)
 129     {
 130         fPortBuffer[index] = buffer;
 131     }
 132
 133     JackMidiBuffer* NetMidiBuffer::GetBuffer(int index)
 134     {
 135         return fPortBuffer[index];
 136     }
 137
 138     void NetMidiBuffer::DisplayEvents()
 139     {
 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);
 146                 }
 147             }
 148         }
 149     }
 150
 151     int NetMidiBuffer::RenderFromJackPorts()
 152     {
 153         int pos = 0;
 154         size_t copy_size;
 155
 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);
 160             pos += 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);
 167         }
 168         return pos;
 169     }
 170
 171     void NetMidiBuffer::RenderToJackPorts()
 172     {
 173         int pos = 0;
 174         size_t copy_size;
 175
 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);
 181             pos += copy_size;
 182             memcpy(fPortBuffer[port_index] + (fPortBuffer[port_index]->buffer_size - fPortBuffer[port_index]->write_pos),
 183                     fBuffer + pos,
 184                     fPortBuffer[port_index]->write_pos);
 185             pos += fPortBuffer[port_index]->write_pos;
 186         }
 187     }
 188
 189     void NetMidiBuffer::RenderFromNetwork(int sub_cycle, size_t copy_size)
 190     {
 191         memcpy(fBuffer + sub_cycle * fMaxPcktSize, fNetBuffer, copy_size);
 192     }
 193
 194     int NetMidiBuffer::RenderToNetwork(int sub_cycle, size_t total_size)
 195     {
 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);
 199         return copy_size;
 200     }
 201
 202 // net audio buffer *********************************************************************************
 203
 204     NetAudioBuffer::NetAudioBuffer(session_params_t* params, uint32_t nports, char* net_buffer)
 205     {
 206         fNPorts = nports;
 207         fNetBuffer = net_buffer;
 208         fNumPackets = 0;
 209
 210         fPortBuffer = new sample_t*[fNPorts];
 211         fConnectedPorts = new bool[fNPorts];
 212
 213         for (int port_index = 0; port_index < fNPorts; port_index++) {
 214             fPortBuffer[port_index] = NULL;
 215             fConnectedPorts[port_index] = true;
 216         }
 217
 218         fLastSubCycle = 0;
 219         fPeriodSize = 0;
 220         fSubPeriodSize = 0;
 221         fSubPeriodBytesSize = 0;
 222         fCycleDuration = 0.f;
 223         fCycleBytesSize = 0;
 224     }
 225
 226     NetAudioBuffer::~NetAudioBuffer()
 227     {
 228         delete [] fConnectedPorts;
 229         delete [] fPortBuffer;
 230     }
 231
 232     void NetAudioBuffer::SetBuffer(int index, sample_t* buffer)
 233     {
 234         fPortBuffer[index] = buffer;
 235     }
 236
 237     sample_t* NetAudioBuffer::GetBuffer(int index)
 238     {
 239         return fPortBuffer[index];
 240     }
 241
 242     int NetAudioBuffer::CheckPacket(int cycle, int sub_cycle)
 243     {
 244         int res;
 245
 246         if (sub_cycle != fLastSubCycle + 1) {
 247             jack_error("Packet(s) missing from... %d %d", fLastSubCycle, sub_cycle);
 248             res = DATA_PACKET_ERROR;
 249         } else {
 250             res = 0;
 251         }
 252
 253         fLastSubCycle = sub_cycle;
 254         return res;
 255     }
 256
 257     void NetAudioBuffer::NextCycle()
 258     {
 259         // reset for next cycle
 260         fLastSubCycle = -1;
 261     }
 262
 263     void NetAudioBuffer::Cleanup()
 264     {
 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));
 268             }
 269         }
 270     }
 271
 272     //network<->buffer
 273
 274     int NetAudioBuffer::ActivePortsToNetwork(char* net_buffer)
 275     {
 276         int active_ports = 0;
 277         int* active_port_address = (int*)net_buffer;
 278
 279         for (int port_index = 0; port_index < fNPorts; port_index++) {
 280             // Write the active port number
 281             if (fPortBuffer[port_index]) {
 282                 *active_port_address = htonl(port_index);
 283                 active_port_address++;
 284                 active_ports++;
 285                 assert(active_ports < 256);
 286             }
 287         }
 288
 289         return active_ports;
 290     }
 291
 292     void NetAudioBuffer::ActivePortsFromNetwork(char* net_buffer, uint32_t port_num)
 293     {
 294         int* active_port_address = (int*)net_buffer;
 295
 296         for (int port_index = 0; port_index < fNPorts; port_index++) {
 297             fConnectedPorts[port_index] = false;
 298         }
 299
 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++;
 305         }
 306     }
 307
 308     int NetAudioBuffer::RenderFromJackPorts(int unused_frames)
 309     {
 310         // Count active ports
 311         int active_ports = 0;
 312         for (int port_index = 0; port_index < fNPorts; port_index++) {
 313             if (fPortBuffer[port_index]) {
 314                 active_ports++;
 315             }
 316         }
 317
 318         return active_ports;
 319     }
 320
 321     void NetAudioBuffer::RenderToJackPorts(int unused_frames)
 322     {
 323         // Nothing to do
 324         NextCycle();
 325     }
 326
 327     // Float converter
 328
 329     NetFloatAudioBuffer::NetFloatAudioBuffer(session_params_t* params, uint32_t nports, char* net_buffer)
 330         : NetAudioBuffer(params, nports, net_buffer)
 331     {
 332         fPeriodSize = params->fPeriodSize;
 333         fPacketSize = PACKET_AVAILABLE_SIZE(params);
 334
 335         UpdateParams(max(params->fReturnAudioChannels, params->fSendAudioChannels));
 336
 337         fCycleDuration = float(fSubPeriodSize) / float(params->fSampleRate);
 338         fCycleBytesSize = params->fMtu * (fPeriodSize / fSubPeriodSize);
 339
 340         fLastSubCycle = -1;
 341     }
 342
 343     NetFloatAudioBuffer::~NetFloatAudioBuffer()
 344     {}
 345
 346     // needed size in bytes for an entire cycle
 347     size_t NetFloatAudioBuffer::GetCycleSize()
 348     {
 349         return fCycleBytesSize;
 350     }
 351
 352     // cycle duration in sec
 353     float NetFloatAudioBuffer::GetCycleDuration()
 354     {
 355         return fCycleDuration;
 356     }
 357
 358     void NetFloatAudioBuffer::UpdateParams(int active_ports)
 359     {
 360         if (active_ports == 0) {
 361             fSubPeriodSize = fPeriodSize;
 362         } else {
 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;
 365         }
 366
 367         fSubPeriodBytesSize = fSubPeriodSize * sizeof(sample_t) + sizeof(int); // The port number in coded on 4 bytes
 368         fNumPackets = fPeriodSize / fSubPeriodSize; // At least one packet
 369     }
 370
 371     int NetFloatAudioBuffer::GetNumPackets(int active_ports)
 372     {
 373         UpdateParams(active_ports);
 374
 375         /*
 376         jack_log("GetNumPackets packet = %d fPeriodSize = %d fSubPeriodSize = %d fSubPeriodBytesSize = %d",
 377             fPeriodSize / fSubPeriodSize, fPeriodSize, fSubPeriodSize, fSubPeriodBytesSize);
 378         */
 379         return fNumPackets;
 380     }
 381
 382     //jack<->buffer
 383
 384     int NetFloatAudioBuffer::RenderFromNetwork(int cycle, int sub_cycle, uint32_t port_num)
 385     {
 386         // Cleanup all JACK ports at the beginning of the cycle
 387         if (sub_cycle == 0) {
 388             Cleanup();
 389         }
 390
 391         if (port_num > 0)  {
 392             UpdateParams(port_num);
 393             for (uint32_t port_index = 0; port_index < port_num; port_index++) {
 394                 // Only copy to active ports : read the active port number then audio data
 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);
 398             }
 399         }
 400
 401         return CheckPacket(cycle, sub_cycle);
 402     }
 403
 404     int NetFloatAudioBuffer::RenderToNetwork(int sub_cycle, uint32_t port_num)
 405     {
 406         int active_ports = 0;
 407
 408         for (int port_index = 0; port_index < fNPorts; port_index++) {
 409             // Only copy from active ports : write the active port number then audio data
 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);
 414                 active_ports++;
 415             }
 416         }
 417
 418         return port_num * fSubPeriodBytesSize;
 419     }
 420
 421 #ifdef __BIG_ENDIAN__
 422
 423     static inline jack_default_audio_sample_t SwapFloat(jack_default_audio_sample_t f)
 424     {
 425           union
 426           {
 427             jack_default_audio_sample_t f;
 428             unsigned char b[4];
 429           } dat1, dat2;
 430
 431           dat1.f = 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];
 436           return dat2.f;
 437     }
 438
 439     void NetFloatAudioBuffer::RenderFromNetwork(char* net_buffer, int active_port, int sub_cycle)
 440     {
 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]);
 446             }
 447         }
 448     }
 449
 450     void NetFloatAudioBuffer::RenderToNetwork(char* net_buffer, int active_port, int sub_cycle)
 451     {
 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]);
 457             }
 458         }
 459     }
 460
 461 #else
 462
 463     void NetFloatAudioBuffer::RenderFromNetwork(char* net_buffer, int active_port, int sub_cycle)
 464     {
 465         if (fPortBuffer[active_port]) {
 466             memcpy(fPortBuffer[active_port] + sub_cycle * fSubPeriodSize, net_buffer, fSubPeriodBytesSize - sizeof(int));
 467         }
 468     }
 469
 470     void NetFloatAudioBuffer::RenderToNetwork(char* net_buffer, int active_port, int sub_cycle)
 471     {
 472         memcpy(net_buffer, fPortBuffer[active_port] + sub_cycle * fSubPeriodSize, fSubPeriodBytesSize - sizeof(int));
 473     }
 474
 475 #endif
 476     // Celt audio buffer *********************************************************************************
 477
 478 #if HAVE_CELT
 479
 480     #define KPS 32
 481     #define KPS_DIV 8
 482
 483     NetCeltAudioBuffer::NetCeltAudioBuffer(session_params_t* params, uint32_t nports, char* net_buffer, int kbps)
 484         :NetAudioBuffer(params, nports, net_buffer)
 485     {
 486         fCeltMode = new CELTMode*[fNPorts];
 487         fCeltEncoder = new CELTEncoder*[fNPorts];
 488         fCeltDecoder = new CELTDecoder*[fNPorts];
 489
 490         memset(fCeltMode, 0, fNPorts * sizeof(CELTMode*));
 491         memset(fCeltEncoder, 0, fNPorts * sizeof(CELTEncoder*));
 492         memset(fCeltDecoder, 0, fNPorts * sizeof(CELTDecoder*));
 493
 494         int error = CELT_OK;
 495
 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);
 500                 goto error;
 501             }
 502
 503     #if HAVE_CELT_API_0_11
 504
 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);
 508                 goto error;
 509             }
 510             celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
 511
 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);
 515                 goto error;
 516             }
 517             celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
 518
 519     #elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8
 520
 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);
 524                 goto error;
 525             }
 526             celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
 527
 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);
 531                 goto error;
 532             }
 533             celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
 534
 535     #else
 536
 537             fCeltEncoder[i] = celt_encoder_create(fCeltMode[i]);
 538             if (error != CELT_OK) {
 539                 jack_log("NetCeltAudioBuffer celt_encoder_create err = %d", error);
 540                 goto error;
 541             }
 542             celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1));
 543
 544             fCeltDecoder[i] = celt_decoder_create(fCeltMode[i]);
 545             if (error != CELT_OK) {
 546                 jack_log("NetCeltAudioBuffer celt_decoder_create err = %d", error);
 547                 goto error;
 548             }
 549             celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1));
 550
 551     #endif
 552         }
 553
 554         {
 555             fPeriodSize = params->fPeriodSize;
 556
 557             fCompressedSizeByte = (kbps * params->fPeriodSize * 1024) / (params->fSampleRate * 8);
 558             jack_log("NetCeltAudioBuffer fCompressedSizeByte %d", fCompressedSizeByte);
 559
 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));
 564             }
 565
 566             int res1 = (fNPorts * fCompressedSizeByte) % PACKET_AVAILABLE_SIZE(params);
 567             int res2 = (fNPorts * fCompressedSizeByte) / PACKET_AVAILABLE_SIZE(params);
 568
 569             fNumPackets = (res1) ? (res2 + 1) : res2;
 570
 571             jack_log("NetCeltAudioBuffer res1 = %d res2 = %d", res1, res2);
 572
 573             fSubPeriodBytesSize = fCompressedSizeByte / fNumPackets;
 574             fLastSubPeriodBytesSize = fSubPeriodBytesSize + fCompressedSizeByte % fNumPackets;
 575
 576             jack_log("NetCeltAudioBuffer fNumPackets = %d fSubPeriodBytesSize = %d, fLastSubPeriodBytesSize = %d", fNumPackets, fSubPeriodBytesSize, fLastSubPeriodBytesSize);
 577
 578             fCycleDuration = float(fSubPeriodBytesSize / sizeof(sample_t)) / float(params->fSampleRate);
 579             fCycleBytesSize = params->fMtu * fNumPackets;
 580
 581             fLastSubCycle = -1;
 582             return;
 583         }
 584
 585     error:
 586
 587         FreeCelt();
 588         throw std::bad_alloc();
 589     }
 590
 591     NetCeltAudioBuffer::~NetCeltAudioBuffer()
 592     {
 593         FreeCelt();
 594
 595         for (int port_index = 0; port_index < fNPorts; port_index++) {
 596             delete [] fCompressedBuffer[port_index];
 597         }
 598
 599         delete [] fCompressedBuffer;
 600     }
 601
 602     void NetCeltAudioBuffer::FreeCelt()
 603     {
 604         for (int i = 0; i < fNPorts; i++)  {
 605             if (fCeltEncoder[i]) {
 606                 celt_encoder_destroy(fCeltEncoder[i]);
 607             }
 608             if (fCeltDecoder[i]) {
 609                 celt_decoder_destroy(fCeltDecoder[i]);
 610             }
 611             if (fCeltMode[i]) {
 612                 celt_mode_destroy(fCeltMode[i]);
 613             }
 614         }
 615
 616         delete [] fCeltMode;
 617         delete [] fCeltEncoder;
 618         delete [] fCeltDecoder;
 619     }
 620
 621     size_t NetCeltAudioBuffer::GetCycleSize()
 622     {
 623         return fCycleBytesSize;
 624     }
 625
 626     float NetCeltAudioBuffer::GetCycleDuration()
 627     {
 628         return fCycleDuration;
 629     }
 630
 631     int NetCeltAudioBuffer::GetNumPackets(int active_ports)
 632     {
 633         return fNumPackets;
 634     }
 635
 636     int NetCeltAudioBuffer::RenderFromJackPorts(int nframes)
 637     {
 638         float buffer[BUFFER_SIZE_MAX];
 639
 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));
 643             } else {
 644                 memset(buffer, 0, fPeriodSize * sizeof(sample_t));
 645             }
 646         #if HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11
 647             //int res = celt_encode_float(fCeltEncoder[port_index], buffer, fPeriodSize, fCompressedBuffer[port_index], fCompressedSizeByte);
 648             int res = celt_encode_float(fCeltEncoder[port_index], buffer, nframes, fCompressedBuffer[port_index], fCompressedSizeByte);
 649         #else
 650             int res = celt_encode_float(fCeltEncoder[port_index], buffer, NULL, fCompressedBuffer[port_index], fCompressedSizeByte);
 651         #endif
 652             if (res != fCompressedSizeByte) {
 653                 jack_error("celt_encode_float error fCompressedSizeByte = %d res = %d", fCompressedSizeByte, res);
 654             }
 655         }
 656
 657         // All ports active
 658         return fNPorts;
 659     }
 660
 661     void NetCeltAudioBuffer::RenderToJackPorts(int nframes)
 662     {
 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
 666                 //int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index], fPeriodSize);
 667                 int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index], nframes);
 668             #else
 669                 int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index]);
 670             #endif
 671                 if (res != CELT_OK) {
 672                     jack_error("celt_decode_float error fCompressedSizeByte = %d res = %d", fCompressedSizeByte, res);
 673                 }
 674             }
 675         }
 676
 677         NextCycle();
 678     }
 679
 680     //network<->buffer
 681     int NetCeltAudioBuffer::RenderFromNetwork(int cycle, int sub_cycle, uint32_t port_num)
 682     {
 683         // Cleanup all JACK ports at the beginning of the cycle
 684         if (sub_cycle == 0) {
 685             Cleanup();
 686         }
 687
 688         if (port_num > 0) {
 689
 690             int sub_period_bytes_size;
 691
 692             // Last packet of the cycle
 693             if (sub_cycle == fNumPackets - 1) {
 694                 sub_period_bytes_size = fLastSubPeriodBytesSize;
 695             } else {
 696                 sub_period_bytes_size = fSubPeriodBytesSize;
 697             }
 698
 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);
 701             }
 702         }
 703
 704         return CheckPacket(cycle, sub_cycle);
 705     }
 706
 707     int NetCeltAudioBuffer::RenderToNetwork(int sub_cycle, uint32_t port_num)
 708     {
 709         int sub_period_bytes_size;
 710
 711         // Last packet of the cycle
 712         if (sub_cycle == fNumPackets - 1) {
 713             sub_period_bytes_size = fLastSubPeriodBytesSize;
 714         } else {
 715             sub_period_bytes_size = fSubPeriodBytesSize;
 716         }
 717
 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);
 720         }
 721         return fNPorts * sub_period_bytes_size;
 722     }
 723
 724 #endif
 725
 726
 727 #if HAVE_OPUS
 728 #define CDO (sizeof(short)) ///< compressed data offset (first 2 bytes are length)
 729     NetOpusAudioBuffer::NetOpusAudioBuffer(session_params_t* params, uint32_t nports, char* net_buffer, int kbps)
 730         :NetAudioBuffer(params, nports, net_buffer)
 731     {
 732         fOpusMode = new OpusCustomMode*[fNPorts];
 733         fOpusEncoder = new OpusCustomEncoder*[fNPorts];
 734         fOpusDecoder = new OpusCustomDecoder*[fNPorts];
 735         fCompressedSizesByte = new unsigned short[fNPorts];
 736
 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));
 741
 742         int error = OPUS_OK;
 743
 744         for (int i = 0; i < fNPorts; i++)  {
 745             /* Allocate en/decoders */
 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);
 749                 goto error;
 750             }
 751
 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);
 755                 goto error;
 756             }
 757
 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);
 761                 goto error;
 762             }
 763
 764             opus_custom_encoder_ctl(fOpusEncoder[i], OPUS_SET_BITRATE(kbps*1024)); // bits per second
 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));
 768         }
 769
 770         {
 771             fCompressedMaxSizeByte = (kbps * params->fPeriodSize * 1024) / (params->fSampleRate * 8);
 772             fPeriodSize = params->fPeriodSize;
 773             jack_log("NetOpusAudioBuffer fCompressedMaxSizeByte %d", fCompressedMaxSizeByte);
 774
 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));
 779             }
 780
 781             int res1 = (fNPorts * (fCompressedMaxSizeByte + CDO)) % PACKET_AVAILABLE_SIZE(params);
 782             int res2 = (fNPorts * (fCompressedMaxSizeByte + CDO)) / PACKET_AVAILABLE_SIZE(params);
 783
 784             fNumPackets = (res1) ? (res2 + 1) : res2;
 785
 786             jack_log("NetOpusAudioBuffer res1 = %d res2 = %d", res1, res2);
 787
 788             fSubPeriodBytesSize = (fCompressedMaxSizeByte + CDO) / fNumPackets;
 789             fLastSubPeriodBytesSize = fSubPeriodBytesSize + (fCompressedMaxSizeByte + CDO) % fNumPackets;
 790
 791             if (fNumPackets == 1) {
 792                 fSubPeriodBytesSize = fLastSubPeriodBytesSize;
 793             }
 794
 795             jack_log("NetOpusAudioBuffer fNumPackets = %d fSubPeriodBytesSize = %d, fLastSubPeriodBytesSize = %d", fNumPackets, fSubPeriodBytesSize, fLastSubPeriodBytesSize);
 796
 797             fCycleDuration = float(fSubPeriodBytesSize / sizeof(sample_t)) / float(params->fSampleRate);
 798             fCycleBytesSize = params->fMtu * fNumPackets;
 799
 800             fLastSubCycle = -1;
 801             return;
 802         }
 803
 804     error:
 805
 806         FreeOpus();
 807         throw std::bad_alloc();
 808     }
 809
 810     NetOpusAudioBuffer::~NetOpusAudioBuffer()
 811     {
 812         FreeOpus();
 813
 814         for (int port_index = 0; port_index < fNPorts; port_index++) {
 815             delete [] fCompressedBuffer[port_index];
 816         }
 817
 818         delete [] fCompressedBuffer;
 819         delete [] fCompressedSizesByte;
 820     }
 821
 822     void NetOpusAudioBuffer::FreeOpus()
 823     {
 824         for (int i = 0; i < fNPorts; i++)  {
 825             if (fOpusEncoder[i]) {
 826                 opus_custom_encoder_destroy(fOpusEncoder[i]);
 827                 fOpusEncoder[i] = 0;
 828             }
 829             if (fOpusDecoder[i]) {
 830                 opus_custom_decoder_destroy(fOpusDecoder[i]);
 831                 fOpusDecoder[i] = 0;
 832             }
 833             if (fOpusMode[i]) {
 834                 opus_custom_mode_destroy(fOpusMode[i]);
 835                 fOpusMode[i] = 0;
 836             }
 837         }
 838
 839         delete [] fOpusEncoder;
 840         delete [] fOpusDecoder;
 841         delete [] fOpusMode;
 842     }
 843
 844     size_t NetOpusAudioBuffer::GetCycleSize()
 845     {
 846         return fCycleBytesSize;
 847     }
 848
 849     float NetOpusAudioBuffer::GetCycleDuration()
 850     {
 851         return fCycleDuration;
 852     }
 853
 854     int NetOpusAudioBuffer::GetNumPackets(int active_ports)
 855     {
 856         return fNumPackets;
 857     }
 858
 859     int NetOpusAudioBuffer::RenderFromJackPorts(int nframes)
 860     {
 861         float buffer[BUFFER_SIZE_MAX];
 862
 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));
 866             } else {
 867                 memset(buffer, 0, fPeriodSize * sizeof(sample_t));
 868             }
 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;
 873             } else {
 874                 fCompressedSizesByte[port_index] = res;
 875             }
 876         }
 877
 878         // All ports active
 879         return fNPorts;
 880     }
 881
 882     void NetOpusAudioBuffer::RenderToJackPorts(int nframes)
 883     {
 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) ? (int)fPeriodSize : nframes)) {
 888                     jack_error("opus_custom_decode_float error fCompressedSizeByte = %d res = %d", fCompressedSizesByte[port_index], res);
 889                 }
 890             }
 891         }
 892
 893         NextCycle();
 894     }
 895
 896     //network<->buffer
 897     int NetOpusAudioBuffer::RenderFromNetwork(int cycle, int sub_cycle, uint32_t port_num)
 898     {
 899         // Cleanup all JACK ports at the beginning of the cycle
 900         if (sub_cycle == 0) {
 901             Cleanup();
 902         }
 903
 904         if (port_num > 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);
 910                 }
 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);
 914                 }
 915             } else {
 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);
 918                 }
 919             }
 920         }
 921
 922         return CheckPacket(cycle, sub_cycle);
 923     }
 924
 925     int NetOpusAudioBuffer::RenderToNetwork(int sub_cycle, uint32_t port_num)
 926     {
 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);
 932             }
 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);
 937             }
 938             return fNPorts * fLastSubPeriodBytesSize;
 939         } else {
 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);
 942             }
 943             return fNPorts * fSubPeriodBytesSize;
 944         }
 945     }
 946
 947 #endif
 948
 949     NetIntAudioBuffer::NetIntAudioBuffer(session_params_t* params, uint32_t nports, char* net_buffer)
 950         : NetAudioBuffer(params, nports, net_buffer)
 951     {
 952         fPeriodSize = params->fPeriodSize;
 953
 954         fCompressedSizeByte = (params->fPeriodSize * sizeof(short));
 955         jack_log("NetIntAudioBuffer fCompressedSizeByte %d", fCompressedSizeByte);
 956
 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));
 961         }
 962
 963         int res1 = (fNPorts * fCompressedSizeByte) % PACKET_AVAILABLE_SIZE(params);
 964         int res2 = (fNPorts * fCompressedSizeByte) / PACKET_AVAILABLE_SIZE(params);
 965
 966         jack_log("NetIntAudioBuffer res1 = %d res2 = %d", res1, res2);
 967
 968         fNumPackets = (res1) ? (res2 + 1) : res2;
 969
 970         fSubPeriodBytesSize = fCompressedSizeByte / fNumPackets;
 971         fLastSubPeriodBytesSize = fSubPeriodBytesSize + fCompressedSizeByte % fNumPackets;
 972
 973         fSubPeriodSize = fSubPeriodBytesSize / sizeof(short);
 974
 975         jack_log("NetIntAudioBuffer fNumPackets = %d fSubPeriodBytesSize = %d, fLastSubPeriodBytesSize = %d", fNumPackets, fSubPeriodBytesSize, fLastSubPeriodBytesSize);
 976
 977         fCycleDuration = float(fSubPeriodBytesSize / sizeof(sample_t)) / float(params->fSampleRate);
 978         fCycleBytesSize = params->fMtu * fNumPackets;
 979
 980         fLastSubCycle = -1;
 981     }
 982
 983     NetIntAudioBuffer::~NetIntAudioBuffer()
 984     {
 985         for (int port_index = 0; port_index < fNPorts; port_index++) {
 986             delete [] fIntBuffer[port_index];
 987         }
 988
 989         delete [] fIntBuffer;
 990     }
 991
 992     size_t NetIntAudioBuffer::GetCycleSize()
 993     {
 994         return fCycleBytesSize;
 995     }
 996
 997     float NetIntAudioBuffer::GetCycleDuration()
 998     {
 999         return fCycleDuration;
1000     }
1001
1002     int NetIntAudioBuffer::GetNumPackets(int active_ports)
1003     {
1004         return fNumPackets;
1005     }
1006
1007     int NetIntAudioBuffer::RenderFromJackPorts(int nframes)
1008     {
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);
1013                 }
1014             } else {
1015                 memset(fIntBuffer[port_index], 0, fPeriodSize * sizeof(short));
1016             }
1017         }
1018
1019         // All ports active
1020         return fNPorts;
1021     }
1022
1023     void NetIntAudioBuffer::RenderToJackPorts(int nframes)
1024     {
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);
1030                 }
1031             }
1032         }
1033
1034         NextCycle();
1035     }
1036
1037     //network<->buffer
1038     int NetIntAudioBuffer::RenderFromNetwork(int cycle, int sub_cycle, uint32_t port_num)
1039     {
1040         // Cleanup all JACK ports at the beginning of the cycle
1041         if (sub_cycle == 0) {
1042             Cleanup();
1043         }
1044
1045         if (port_num > 0)  {
1046             int sub_period_bytes_size;
1047
1048             // Last packet
1049             if (sub_cycle == fNumPackets - 1) {
1050                 sub_period_bytes_size = fLastSubPeriodBytesSize;
1051             } else {
1052                 sub_period_bytes_size = fSubPeriodBytesSize;
1053             }
1054
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);
1057             }
1058         }
1059
1060         return CheckPacket(cycle, sub_cycle);
1061     }
1062
1063     int NetIntAudioBuffer::RenderToNetwork(int sub_cycle, uint32_t port_num)
1064     {
1065         int sub_period_bytes_size;
1066
1067         // Last packet
1068         if (sub_cycle == fNumPackets - 1) {
1069             sub_period_bytes_size = fLastSubPeriodBytesSize;
1070         } else {
1071             sub_period_bytes_size = fSubPeriodBytesSize;
1072         }
1073
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);
1076         }
1077         return fNPorts * sub_period_bytes_size;
1078     }
1079
1080 // SessionParams ************************************************************************************
1081
1082     SERVER_EXPORT void SessionParamsHToN(session_params_t* src_params, session_params_t* dst_params)
1083     {
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);
1100     }
1101
1102     SERVER_EXPORT void SessionParamsNToH(session_params_t* src_params, session_params_t* dst_params)
1103     {
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);
1120     }
1121
1122     SERVER_EXPORT void SessionParamsDisplay(session_params_t* params)
1123     {
1124         char encoder[16];
1125         switch (params->fSampleEncoder)
1126         {
1127             case JackFloatEncoder:
1128                 strcpy(encoder, "float");
1129                 break;
1130             case JackIntEncoder:
1131                 strcpy(encoder, "integer");
1132                 break;
1133             case JackCeltEncoder:
1134                 strcpy(encoder, "CELT");
1135                 break;
1136             case JackOpusEncoder:
1137                 strcpy(encoder, "OPUS");
1138                 break;
1139         }
1140
1141         jack_info("**************** Network parameters ****************");
1142         jack_info("Name : %s", params->fName);
1143         jack_info("Protocol revision : %d", params->fProtocolVersion);
1144         jack_info("MTU : %u", params->fMtu);
1145         jack_info("Master name : %s", params->fMasterNetName);
1146         jack_info("Slave name : %s", params->fSlaveNetName);
1147         jack_info("ID : %u", params->fID);
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");
1157                 break;
1158             case (JackIntEncoder):
1159                 jack_info("SampleEncoder : %s", "16 bits integer");
1160                 break;
1161             case (JackCeltEncoder):
1162                 jack_info("SampleEncoder : %s", "CELT");
1163                 jack_info("kBits : %d", params->fKBps);
1164                 break;
1165             case (JackOpusEncoder):
1166                 jack_info("SampleEncoder : %s", "OPUS");
1167                 jack_info("kBits : %d", params->fKBps);
1168                 break;
1169         };
1170         jack_info("Slave mode : %s", (params->fSlaveSyncMode) ? "sync" : "async");
1171         jack_info("****************************************************");
1172     }
1173
1174     SERVER_EXPORT sync_packet_type_t GetPacketType(session_params_t* params)
1175     {
1176         switch (params->fPacketID)
1177         {
1178             case 0:
1179                 return SLAVE_AVAILABLE;
1180             case 1:
1181                 return SLAVE_SETUP;
1182             case 2:
1183                 return START_MASTER;
1184             case 3:
1185                 return START_SLAVE;
1186             case 4:
1187                 return KILL_MASTER;
1188         }
1189         return INVALID;
1190     }
1191
1192     SERVER_EXPORT int SetPacketType(session_params_t* params, sync_packet_type_t packet_type)
1193     {
1194         switch (packet_type)
1195         {
1196             case INVALID:
1197                 return -1;
1198             case SLAVE_AVAILABLE:
1199                 params->fPacketID = 0;
1200                 break;
1201             case SLAVE_SETUP:
1202                 params->fPacketID = 1;
1203                 break;
1204             case START_MASTER:
1205                 params->fPacketID = 2;
1206                 break;
1207             case START_SLAVE:
1208                 params->fPacketID = 3;
1209                 break;
1210             case KILL_MASTER:
1211                 params->fPacketID = 4;
1212         }
1213         return 0;
1214     }
1215
1216 // Packet header **********************************************************************************
1217
1218     SERVER_EXPORT void PacketHeaderHToN(packet_header_t* src_header, packet_header_t* dst_header)
1219     {
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);
1231     }
1232
1233     SERVER_EXPORT void PacketHeaderNToH(packet_header_t* src_header, packet_header_t* dst_header)
1234     {
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);
1246     }
1247
1248     SERVER_EXPORT void PacketHeaderDisplay(packet_header_t* header)
1249     {
1250         jack_info("********************Header********************");
1251         jack_info("Data type : %c", header->fDataType);
1252         jack_info("Data stream : %c", header->fDataStream);
1253         jack_info("ID : %u", header->fID);
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("**********************************************");
1262     }
1263
1264     SERVER_EXPORT void NetTransportDataDisplay(net_transport_data_t* data)
1265     {
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("**********************************************");
1271     }
1272
1273     SERVER_EXPORT void MidiBufferHToN(JackMidiBuffer* src_buffer, JackMidiBuffer* dst_buffer)
1274     {
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);
1281     }
1282
1283     SERVER_EXPORT void MidiBufferNToH(JackMidiBuffer* src_buffer, JackMidiBuffer* dst_buffer)
1284     {
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);
1291     }
1292
1293     SERVER_EXPORT void TransportDataHToN(net_transport_data_t* src_params, net_transport_data_t* dst_params)
1294     {
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);
1317     }
1318
1319     SERVER_EXPORT void TransportDataNToH(net_transport_data_t* src_params, net_transport_data_t* dst_params)
1320     {
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);
1343     }
1344
1345 // Utility *******************************************************************************************************
1346
1347     SERVER_EXPORT int SocketAPIInit()
1348     {
1349 #ifdef WIN32
1350         WORD wVersionRequested = MAKEWORD(2, 2);
1351         WSADATA wsaData;
1352
1353         if (WSAStartup(wVersionRequested, &wsaData) != 0) {
1354             jack_error("WSAStartup error : %s", strerror(NET_ERROR_CODE));
1355             return -1;
1356         }
1357
1358         if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
1359             jack_error("Could not find a usable version of Winsock.dll\n");
1360             WSACleanup();
1361             return -1;
1362         }
1363 #endif
1364         return 0;
1365     }
1366
1367     SERVER_EXPORT int SocketAPIEnd()
1368     {
1369 #ifdef WIN32
1370         return WSACleanup();
1371 #endif
1372         return 0;
1373     }
1374
1375     SERVER_EXPORT const char* GetTransportState(int transport_state)
1376     {
1377         switch (transport_state)
1378         {
1379             case JackTransportRolling:
1380                 return "rolling";
1381             case JackTransportStarting:
1382                 return "starting";
1383             case JackTransportStopped:
1384                 return "stopped";
1385             case JackTransportNetStarting:
1386                 return "netstarting";
1387         }
1388         return NULL;
1389     }
1390 }