Jack2 1.9.8
|
00001 /* 00002 Copyright (C) 2008-2011 Romain Moret at Grame 00003 00004 This program is free software; you can redistribute it and/or modify 00005 it under the terms of the GNU General Public License as published by 00006 the Free Software Foundation; either version 2 of the License, or 00007 (at your option) any later version. 00008 00009 This program is distributed in the hope that it will be useful, 00010 but WITHOUT ANY WARRANTY; without even the implied warranty of 00011 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00012 GNU General Public License for more details. 00013 00014 You should have received a copy of the GNU General Public License 00015 along with this program; if not, write to the Free Software 00016 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 00017 00018 */ 00019 00020 #include "JackNetTool.h" 00021 00022 #ifdef __APPLE__ 00023 00024 #include <mach/mach_time.h> 00025 00026 class HardwareClock 00027 { 00028 public: 00029 00030 HardwareClock(); 00031 00032 void Reset(); 00033 void Update(); 00034 00035 float GetDeltaTime() const; 00036 double GetTime() const; 00037 00038 private: 00039 00040 double m_clockToSeconds; 00041 00042 uint64_t m_startAbsTime; 00043 uint64_t m_lastAbsTime; 00044 00045 double m_time; 00046 float m_deltaTime; 00047 }; 00048 00049 HardwareClock::HardwareClock() 00050 { 00051 mach_timebase_info_data_t info; 00052 mach_timebase_info(&info); 00053 m_clockToSeconds = (double)info.numer/info.denom/1000000000.0; 00054 Reset(); 00055 } 00056 00057 void HardwareClock::Reset() 00058 { 00059 m_startAbsTime = mach_absolute_time(); 00060 m_lastAbsTime = m_startAbsTime; 00061 m_time = m_startAbsTime*m_clockToSeconds; 00062 m_deltaTime = 1.0f/60.0f; 00063 } 00064 00065 void HardwareClock::Update() 00066 { 00067 const uint64_t currentTime = mach_absolute_time(); 00068 const uint64_t dt = currentTime - m_lastAbsTime; 00069 00070 m_time = currentTime*m_clockToSeconds; 00071 m_deltaTime = (double)dt*m_clockToSeconds; 00072 m_lastAbsTime = currentTime; 00073 } 00074 00075 float HardwareClock::GetDeltaTime() const 00076 { 00077 return m_deltaTime; 00078 } 00079 00080 double HardwareClock::GetTime() const 00081 { 00082 return m_time; 00083 } 00084 00085 #endif 00086 00087 using namespace std; 00088 00089 namespace Jack 00090 { 00091 // NetMidiBuffer********************************************************************************** 00092 00093 NetMidiBuffer::NetMidiBuffer(session_params_t* params, uint32_t nports, char* net_buffer) 00094 { 00095 fNPorts = nports; 00096 fMaxBufsize = fNPorts * sizeof(sample_t) * params->fPeriodSize ; 00097 fMaxPcktSize = params->fMtu - sizeof(packet_header_t); 00098 fBuffer = new char[fMaxBufsize]; 00099 fPortBuffer = new JackMidiBuffer* [fNPorts]; 00100 for (int port_index = 0; port_index < fNPorts; port_index++) { 00101 fPortBuffer[port_index] = NULL; 00102 } 00103 fNetBuffer = net_buffer; 00104 00105 fCycleBytesSize = params->fMtu 00106 * (max(params->fSendMidiChannels, params->fReturnMidiChannels) 00107 * params->fPeriodSize * sizeof(sample_t) / (params->fMtu - sizeof(packet_header_t))); 00108 } 00109 00110 NetMidiBuffer::~NetMidiBuffer() 00111 { 00112 delete[] fBuffer; 00113 delete[] fPortBuffer; 00114 } 00115 00116 size_t NetMidiBuffer::GetCycleSize() 00117 { 00118 return fCycleBytesSize; 00119 } 00120 00121 int NetMidiBuffer::GetNumPackets(int data_size, int max_size) 00122 { 00123 int res1 = data_size % max_size; 00124 int res2 = data_size / max_size; 00125 return (res1) ? res2 + 1 : res2; 00126 } 00127 00128 void NetMidiBuffer::SetBuffer(int index, JackMidiBuffer* buffer) 00129 { 00130 fPortBuffer[index] = buffer; 00131 } 00132 00133 JackMidiBuffer* NetMidiBuffer::GetBuffer(int index) 00134 { 00135 return fPortBuffer[index]; 00136 } 00137 00138 void NetMidiBuffer::DisplayEvents() 00139 { 00140 for (int port_index = 0; port_index < fNPorts; port_index++) { 00141 for (uint event = 0; event < fPortBuffer[port_index]->event_count; event++) { 00142 if (fPortBuffer[port_index]->IsValid()) { 00143 jack_info("port %d : midi event %u/%u -> time : %u, size : %u", 00144 port_index + 1, event + 1, fPortBuffer[port_index]->event_count, 00145 fPortBuffer[port_index]->events[event].time, fPortBuffer[port_index]->events[event].size); 00146 } 00147 } 00148 } 00149 } 00150 00151 int NetMidiBuffer::RenderFromJackPorts() 00152 { 00153 int pos = 0; 00154 size_t copy_size; 00155 00156 for (int port_index = 0; port_index < fNPorts; port_index++) { 00157 char* write_pos = fBuffer + pos; 00158 copy_size = sizeof(JackMidiBuffer) + fPortBuffer[port_index]->event_count * sizeof(JackMidiEvent); 00159 memcpy(fBuffer + pos, fPortBuffer[port_index], copy_size); 00160 pos += copy_size; 00161 memcpy(fBuffer + pos, 00162 fPortBuffer[port_index] + (fPortBuffer[port_index]->buffer_size - fPortBuffer[port_index]->write_pos), 00163 fPortBuffer[port_index]->write_pos); 00164 pos += fPortBuffer[port_index]->write_pos; 00165 00166 JackMidiBuffer* midi_buffer = reinterpret_cast<JackMidiBuffer*>(write_pos); 00167 MidiBufferHToN(midi_buffer, midi_buffer); 00168 } 00169 return pos; 00170 } 00171 00172 void NetMidiBuffer::RenderToJackPorts() 00173 { 00174 int pos = 0; 00175 size_t copy_size; 00176 00177 for (int port_index = 0; port_index < fNPorts; port_index++) { 00178 JackMidiBuffer* midi_buffer = reinterpret_cast<JackMidiBuffer*>(fBuffer + pos); 00179 MidiBufferNToH(midi_buffer, midi_buffer); 00180 copy_size = sizeof(JackMidiBuffer) + reinterpret_cast<JackMidiBuffer*>(fBuffer + pos)->event_count * sizeof(JackMidiEvent); 00181 memcpy(fPortBuffer[port_index], fBuffer + pos, copy_size); 00182 pos += copy_size; 00183 memcpy(fPortBuffer[port_index] + (fPortBuffer[port_index]->buffer_size - fPortBuffer[port_index]->write_pos), 00184 fBuffer + pos, 00185 fPortBuffer[port_index]->write_pos); 00186 pos += fPortBuffer[port_index]->write_pos; 00187 } 00188 } 00189 00190 void NetMidiBuffer::RenderFromNetwork(int sub_cycle, size_t copy_size) 00191 { 00192 memcpy(fBuffer + sub_cycle * fMaxPcktSize, fNetBuffer, copy_size); 00193 } 00194 00195 int NetMidiBuffer::RenderToNetwork(int sub_cycle, size_t total_size) 00196 { 00197 int size = total_size - sub_cycle * fMaxPcktSize; 00198 int copy_size = (size <= fMaxPcktSize) ? size : fMaxPcktSize; 00199 memcpy(fNetBuffer, fBuffer + sub_cycle * fMaxPcktSize, copy_size); 00200 return copy_size; 00201 } 00202 00203 // net audio buffer ********************************************************************************* 00204 00205 NetAudioBuffer::NetAudioBuffer(session_params_t* params, uint32_t nports, char* net_buffer) 00206 { 00207 fNPorts = nports; 00208 fNetBuffer = net_buffer; 00209 00210 fPortBuffer = new sample_t* [fNPorts]; 00211 fConnectedPorts = new bool[fNPorts]; 00212 for (int port_index = 0; port_index < fNPorts; port_index++) { 00213 fPortBuffer[port_index] = NULL; 00214 fConnectedPorts[port_index] = true; 00215 } 00216 } 00217 00218 NetAudioBuffer::~NetAudioBuffer() 00219 { 00220 delete [] fConnectedPorts; 00221 delete [] fPortBuffer; 00222 } 00223 00224 void NetAudioBuffer::SetBuffer(int index, sample_t* buffer) 00225 { 00226 fPortBuffer[index] = buffer; 00227 } 00228 00229 sample_t* NetAudioBuffer::GetBuffer(int index) 00230 { 00231 return fPortBuffer[index]; 00232 } 00233 00234 int NetAudioBuffer::CheckPacket(int cycle, int sub_cycle) 00235 { 00236 int res; 00237 00238 if (sub_cycle != fLastSubCycle + 1) { 00239 jack_error("Packet(s) missing from... %d %d", fLastSubCycle, sub_cycle); 00240 res = NET_PACKET_ERROR; 00241 } else { 00242 res = 0; 00243 } 00244 00245 fLastSubCycle = sub_cycle; 00246 return res; 00247 } 00248 00249 void NetAudioBuffer::NextCycle() 00250 { 00251 // reset for next cycle 00252 fLastSubCycle = -1; 00253 } 00254 00255 void NetAudioBuffer::Cleanup() 00256 { 00257 for (int port_index = 0; port_index < fNPorts; port_index++) { 00258 if (fPortBuffer[port_index]) { 00259 memset(fPortBuffer[port_index], 0, fPeriodSize * sizeof(sample_t)); 00260 } 00261 } 00262 } 00263 00264 //network<->buffer 00265 00266 int NetAudioBuffer::ActivePortsToNetwork(char* net_buffer) 00267 { 00268 int active_ports = 0; 00269 int* active_port_address = (int*)net_buffer; 00270 00271 for (int port_index = 0; port_index < fNPorts; port_index++) { 00272 // Write the active port number 00273 if (fPortBuffer[port_index]) { 00274 *active_port_address = htonl(port_index); 00275 active_port_address++; 00276 active_ports++; 00277 assert(active_ports < 256); 00278 } 00279 } 00280 00281 return active_ports; 00282 } 00283 00284 void NetAudioBuffer::ActivePortsFromNetwork(char* net_buffer, uint32_t port_num) 00285 { 00286 int* active_port_address = (int*)net_buffer; 00287 00288 for (int port_index = 0; port_index < fNPorts; port_index++) { 00289 fConnectedPorts[port_index] = false; 00290 } 00291 00292 for (uint port_index = 0; port_index < port_num; port_index++) { 00293 // Use -1 when port is actually connected on other side 00294 int active_port = ntohl(*active_port_address); 00295 if (active_port >= 0 && active_port < fNPorts) { 00296 fConnectedPorts[active_port] = true; 00297 } else { 00298 jack_error("ActivePortsFromNetwork: incorrect port = %d", active_port); 00299 } 00300 active_port_address++; 00301 } 00302 } 00303 00304 int NetAudioBuffer::RenderFromJackPorts() 00305 { 00306 // Count active ports 00307 int active_ports = 0; 00308 for (int port_index = 0; port_index < fNPorts; port_index++) { 00309 00310 if (fPortBuffer[port_index]) { 00311 active_ports++; 00312 } 00313 } 00314 //jack_info("active_ports %d", active_ports); 00315 return active_ports; 00316 } 00317 00318 void NetAudioBuffer::RenderToJackPorts() 00319 { 00320 // Nothing to do 00321 NextCycle(); 00322 } 00323 00324 // Float converter 00325 00326 NetFloatAudioBuffer::NetFloatAudioBuffer(session_params_t* params, uint32_t nports, char* net_buffer) 00327 : NetAudioBuffer(params, nports, net_buffer) 00328 { 00329 fPeriodSize = params->fPeriodSize; 00330 fPacketSize = PACKET_AVAILABLE_SIZE(params); 00331 00332 UpdateParams(max(params->fReturnAudioChannels, params->fSendAudioChannels)); 00333 00334 fSubPeriodBytesSize = fSubPeriodSize * sizeof(sample_t); 00335 00336 fCycleDuration = float(fSubPeriodSize) / float(params->fSampleRate); 00337 fCycleBytesSize = params->fMtu * (fPeriodSize / fSubPeriodSize); 00338 00339 fLastSubCycle = -1; 00340 } 00341 00342 NetFloatAudioBuffer::~NetFloatAudioBuffer() 00343 {} 00344 00345 // needed size in bytes for an entire cycle 00346 size_t NetFloatAudioBuffer::GetCycleSize() 00347 { 00348 return fCycleBytesSize; 00349 } 00350 00351 // cycle duration in sec 00352 float NetFloatAudioBuffer::GetCycleDuration() 00353 { 00354 return fCycleDuration; 00355 } 00356 00357 void NetFloatAudioBuffer::UpdateParams(int active_ports) 00358 { 00359 if (active_ports == 0) { 00360 fSubPeriodSize = fPeriodSize; 00361 } else { 00362 jack_nframes_t period = (int) powf(2.f, (int)(log(float(fPacketSize) / (active_ports * sizeof(sample_t))) / log(2.))); 00363 fSubPeriodSize = (period > fPeriodSize) ? fPeriodSize : period; 00364 } 00365 00366 fSubPeriodBytesSize = fSubPeriodSize * sizeof(sample_t) + sizeof(int); // The port number in coded on 4 bytes 00367 } 00368 00369 int NetFloatAudioBuffer::GetNumPackets(int active_ports) 00370 { 00371 UpdateParams(active_ports); 00372 00373 /* 00374 jack_log("GetNumPackets packet = %d fPeriodSize = %d fSubPeriodSize = %d fSubPeriodBytesSize = %d", 00375 fPeriodSize / fSubPeriodSize, fPeriodSize, fSubPeriodSize, fSubPeriodBytesSize); 00376 */ 00377 return fPeriodSize / fSubPeriodSize; // At least one packet 00378 } 00379 00380 //jack<->buffer 00381 00382 int NetFloatAudioBuffer::RenderFromNetwork(int cycle, int sub_cycle, uint32_t port_num) 00383 { 00384 // Cleanup all JACK ports at the beginning of the cycle 00385 if (sub_cycle == 0) { 00386 Cleanup(); 00387 } 00388 00389 if (port_num > 0) { 00390 UpdateParams(port_num); 00391 for (uint32_t port_index = 0; port_index < port_num; port_index++) { 00392 // Only copy to active ports : read the active port number then audio data 00393 int* active_port_address = (int*)(fNetBuffer + port_index * fSubPeriodBytesSize); 00394 int active_port = ntohl(*active_port_address); 00395 RenderFromNetwork((char*)(active_port_address + 1), active_port, sub_cycle); 00396 } 00397 } 00398 00399 return CheckPacket(cycle, sub_cycle); 00400 } 00401 00402 00403 int NetFloatAudioBuffer::RenderToNetwork(int sub_cycle, uint32_t port_num) 00404 { 00405 int active_ports = 0; 00406 00407 for (int port_index = 0; port_index < fNPorts; port_index++) { 00408 // Only copy from active ports : write the active port number then audio data 00409 if (fPortBuffer[port_index]) { 00410 int* active_port_address = (int*)(fNetBuffer + active_ports * fSubPeriodBytesSize); 00411 *active_port_address = htonl(port_index); 00412 RenderToNetwork((char*)(active_port_address + 1), port_index, sub_cycle); 00413 active_ports++; 00414 } 00415 } 00416 00417 return port_num * fSubPeriodBytesSize; 00418 } 00419 00420 #ifdef __BIG_ENDIAN__ 00421 00422 static inline jack_default_audio_sample_t SwapFloat(jack_default_audio_sample_t f) 00423 { 00424 union 00425 { 00426 jack_default_audio_sample_t f; 00427 unsigned char b[4]; 00428 } dat1, dat2; 00429 00430 dat1.f = f; 00431 dat2.b[0] = dat1.b[3]; 00432 dat2.b[1] = dat1.b[2]; 00433 dat2.b[2] = dat1.b[1]; 00434 dat2.b[3] = dat1.b[0]; 00435 return dat2.f; 00436 } 00437 00438 void NetFloatAudioBuffer::RenderFromNetwork(char* net_buffer, int active_port, int sub_cycle) 00439 { 00440 if (fPortBuffer[active_port]) { 00441 jack_default_audio_sample_t* src = (jack_default_audio_sample_t*)(net_buffer); 00442 jack_default_audio_sample_t* dst = (jack_default_audio_sample_t*)(fPortBuffer[active_port] + sub_cycle * fSubPeriodSize); 00443 for (unsigned int sample = 0; sample < (fSubPeriodBytesSize - sizeof(int)) / sizeof(jack_default_audio_sample_t); sample++) { 00444 dst[sample] = SwapFloat(src[sample]); 00445 } 00446 } 00447 } 00448 00449 void NetFloatAudioBuffer::RenderToNetwork(char* net_buffer, int active_port, int sub_cycle) 00450 { 00451 for (int port_index = 0; port_index < fNPorts; port_index++ ) { 00452 jack_default_audio_sample_t* src = (jack_default_audio_sample_t*)(fPortBuffer[active_port] + sub_cycle * fSubPeriodSize); 00453 jack_default_audio_sample_t* dst = (jack_default_audio_sample_t*)(net_buffer); 00454 for (unsigned int sample = 0; sample < (fSubPeriodBytesSize - sizeof(int)) / sizeof(jack_default_audio_sample_t); sample++) { 00455 dst[sample] = SwapFloat(src[sample]); 00456 } 00457 } 00458 } 00459 00460 #else 00461 00462 void NetFloatAudioBuffer::RenderFromNetwork(char* net_buffer, int active_port, int sub_cycle) 00463 { 00464 if (fPortBuffer[active_port]) { 00465 memcpy(fPortBuffer[active_port] + sub_cycle * fSubPeriodSize, net_buffer, fSubPeriodBytesSize - sizeof(int)); 00466 } 00467 } 00468 00469 void NetFloatAudioBuffer::RenderToNetwork(char* net_buffer, int active_port, int sub_cycle) 00470 { 00471 memcpy(net_buffer, fPortBuffer[active_port] + sub_cycle * fSubPeriodSize, fSubPeriodBytesSize - sizeof(int)); 00472 } 00473 00474 #endif 00475 // Celt audio buffer ********************************************************************************* 00476 00477 #if HAVE_CELT 00478 00479 #define KPS 32 00480 #define KPS_DIV 8 00481 00482 NetCeltAudioBuffer::NetCeltAudioBuffer(session_params_t* params, uint32_t nports, char* net_buffer, int kbps) 00483 :NetAudioBuffer(params, nports, net_buffer) 00484 { 00485 fCeltMode = new CELTMode *[fNPorts]; 00486 fCeltEncoder = new CELTEncoder *[fNPorts]; 00487 fCeltDecoder = new CELTDecoder *[fNPorts]; 00488 00489 memset(fCeltMode, 0, fNPorts * sizeof(CELTMode*)); 00490 memset(fCeltEncoder, 0, fNPorts * sizeof(CELTEncoder*)); 00491 memset(fCeltDecoder, 0, fNPorts * sizeof(CELTDecoder*)); 00492 00493 int error = CELT_OK; 00494 00495 for (int i = 0; i < fNPorts; i++) { 00496 fCeltMode[i] = celt_mode_create(params->fSampleRate, params->fPeriodSize, &error); 00497 if (error != CELT_OK) { 00498 goto error; 00499 } 00500 00501 #if HAVE_CELT_API_0_11 00502 00503 fCeltEncoder[i] = celt_encoder_create_custom(fCeltMode[i], 1, &error); 00504 if (error != CELT_OK) { 00505 goto error; 00506 } 00507 celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1)); 00508 00509 fCeltDecoder[i] = celt_decoder_create_custom(fCeltMode[i], 1, &error); 00510 if (error != CELT_OK) { 00511 goto error; 00512 } 00513 celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1)); 00514 00515 #elif HAVE_CELT_API_0_7 || HAVE_CELT_API_0_8 00516 00517 fCeltEncoder[i] = celt_encoder_create(fCeltMode[i], 1, &error); 00518 if (error != CELT_OK) { 00519 goto error; 00520 } 00521 celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1)); 00522 00523 fCeltDecoder[i] = celt_decoder_create(fCeltMode[i], 1, &error); 00524 if (error != CELT_OK) { 00525 goto error; 00526 } 00527 celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1)); 00528 00529 #else 00530 00531 fCeltEncoder[i] = celt_encoder_create(fCeltMode[i]); 00532 if (error != CELT_OK) { 00533 goto error; 00534 } 00535 celt_encoder_ctl(fCeltEncoder[i], CELT_SET_COMPLEXITY(1)); 00536 00537 fCeltDecoder[i] = celt_decoder_create(fCeltMode[i]); 00538 if (error != CELT_OK) { 00539 goto error; 00540 } 00541 celt_decoder_ctl(fCeltDecoder[i], CELT_SET_COMPLEXITY(1)); 00542 00543 #endif 00544 } 00545 00546 { 00547 fPeriodSize = params->fPeriodSize; 00548 00549 fCompressedSizeByte = (kbps * params->fPeriodSize * 1024) / (params->fSampleRate * 8); 00550 jack_log("NetCeltAudioBuffer fCompressedSizeByte %d", fCompressedSizeByte); 00551 00552 fCompressedBuffer = new unsigned char* [fNPorts]; 00553 for (int port_index = 0; port_index < fNPorts; port_index++) { 00554 fCompressedBuffer[port_index] = new unsigned char[fCompressedSizeByte]; 00555 memset(fCompressedBuffer[port_index], 0, fCompressedSizeByte * sizeof(char)); 00556 } 00557 00558 int res1 = (fNPorts * fCompressedSizeByte) % PACKET_AVAILABLE_SIZE(params); 00559 int res2 = (fNPorts * fCompressedSizeByte) / PACKET_AVAILABLE_SIZE(params); 00560 00561 fNumPackets = (res1) ? (res2 + 1) : res2; 00562 00563 jack_log("NetCeltAudioBuffer res1 = %d res2 = %d", res1, res2); 00564 00565 fSubPeriodBytesSize = fCompressedSizeByte / fNumPackets; 00566 fLastSubPeriodBytesSize = fSubPeriodBytesSize + fCompressedSizeByte % fNumPackets; 00567 00568 jack_log("NetCeltAudioBuffer fNumPackets = %d fSubPeriodBytesSize = %d, fLastSubPeriodBytesSize = %d", fNumPackets, fSubPeriodBytesSize, fLastSubPeriodBytesSize); 00569 00570 fCycleDuration = float(fSubPeriodBytesSize / sizeof(sample_t)) / float(params->fSampleRate); 00571 fCycleBytesSize = params->fMtu * fNumPackets; 00572 00573 fLastSubCycle = -1; 00574 return; 00575 } 00576 00577 error: 00578 00579 FreeCelt(); 00580 throw std::bad_alloc(); 00581 } 00582 00583 NetCeltAudioBuffer::~NetCeltAudioBuffer() 00584 { 00585 FreeCelt(); 00586 00587 for (int port_index = 0; port_index < fNPorts; port_index++) { 00588 delete [] fCompressedBuffer[port_index]; 00589 } 00590 00591 delete [] fCompressedBuffer; 00592 } 00593 00594 void NetCeltAudioBuffer::FreeCelt() 00595 { 00596 for (int i = 0; i < fNPorts; i++) { 00597 if (fCeltEncoder[i]) { 00598 celt_encoder_destroy(fCeltEncoder[i]); 00599 } 00600 if (fCeltDecoder[i]) { 00601 celt_decoder_destroy(fCeltDecoder[i]); 00602 } 00603 if (fCeltMode[i]) { 00604 celt_mode_destroy(fCeltMode[i]); 00605 } 00606 } 00607 00608 delete [] fCeltMode; 00609 delete [] fCeltEncoder; 00610 delete [] fCeltDecoder; 00611 } 00612 00613 size_t NetCeltAudioBuffer::GetCycleSize() 00614 { 00615 return fCycleBytesSize; 00616 } 00617 00618 float NetCeltAudioBuffer::GetCycleDuration() 00619 { 00620 return fCycleDuration; 00621 } 00622 00623 int NetCeltAudioBuffer::GetNumPackets(int active_ports) 00624 { 00625 return fNumPackets; 00626 } 00627 00628 int NetCeltAudioBuffer::RenderFromJackPorts() 00629 { 00630 float buffer[fPeriodSize]; 00631 00632 for (int port_index = 0; port_index < fNPorts; port_index++) { 00633 if (fPortBuffer[port_index]) { 00634 memcpy(buffer, fPortBuffer[port_index], fPeriodSize * sizeof(sample_t)); 00635 } else { 00636 memset(buffer, 0, fPeriodSize * sizeof(sample_t)); 00637 } 00638 #if HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11 00639 int res = celt_encode_float(fCeltEncoder[port_index], buffer, fPeriodSize, fCompressedBuffer[port_index], fCompressedSizeByte); 00640 #else 00641 int res = celt_encode_float(fCeltEncoder[port_index], buffer, NULL, fCompressedBuffer[port_index], fCompressedSizeByte); 00642 #endif 00643 if (res != fCompressedSizeByte) { 00644 jack_error("celt_encode_float error fCompressedSizeByte = %d res = %d", fCompressedSizeByte, res); 00645 } 00646 } 00647 00648 // All ports active 00649 return fNPorts; 00650 } 00651 00652 void NetCeltAudioBuffer::RenderToJackPorts() 00653 { 00654 for (int port_index = 0; port_index < fNPorts; port_index++) { 00655 if (fPortBuffer[port_index]) { 00656 #if HAVE_CELT_API_0_8 || HAVE_CELT_API_0_11 00657 int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index], fPeriodSize); 00658 #else 00659 int res = celt_decode_float(fCeltDecoder[port_index], fCompressedBuffer[port_index], fCompressedSizeByte, fPortBuffer[port_index]); 00660 #endif 00661 if (res != CELT_OK) { 00662 jack_error("celt_decode_float error fCompressedSizeByte = %d res = %d", fCompressedSizeByte, res); 00663 } 00664 } 00665 } 00666 00667 NextCycle(); 00668 } 00669 00670 //network<->buffer 00671 int NetCeltAudioBuffer::RenderFromNetwork(int cycle, int sub_cycle, uint32_t port_num) 00672 { 00673 // Cleanup all JACK ports at the beginning of the cycle 00674 if (sub_cycle == 0) { 00675 Cleanup(); 00676 } 00677 00678 if (port_num > 0) { 00679 // Last packet of the cycle 00680 if (sub_cycle == fNumPackets - 1) { 00681 for (int port_index = 0; port_index < fNPorts; port_index++) { 00682 memcpy(fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, fNetBuffer + port_index * fLastSubPeriodBytesSize, fLastSubPeriodBytesSize); 00683 } 00684 } else { 00685 for (int port_index = 0; port_index < fNPorts; port_index++) { 00686 memcpy(fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, fNetBuffer + port_index * fSubPeriodBytesSize, fSubPeriodBytesSize); 00687 } 00688 } 00689 } 00690 00691 return CheckPacket(cycle, sub_cycle); 00692 } 00693 00694 int NetCeltAudioBuffer::RenderToNetwork(int sub_cycle, uint32_t port_num) 00695 { 00696 // Last packet of the cycle 00697 if (sub_cycle == fNumPackets - 1) { 00698 for (int port_index = 0; port_index < fNPorts; port_index++) { 00699 memcpy(fNetBuffer + port_index * fLastSubPeriodBytesSize, fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, fLastSubPeriodBytesSize); 00700 } 00701 return fNPorts * fLastSubPeriodBytesSize; 00702 } else { 00703 for (int port_index = 0; port_index < fNPorts; port_index++) { 00704 memcpy(fNetBuffer + port_index * fSubPeriodBytesSize, fCompressedBuffer[port_index] + sub_cycle * fSubPeriodBytesSize, fSubPeriodBytesSize); 00705 } 00706 return fNPorts * fSubPeriodBytesSize; 00707 } 00708 } 00709 00710 #endif 00711 00712 NetIntAudioBuffer::NetIntAudioBuffer(session_params_t* params, uint32_t nports, char* net_buffer) 00713 : NetAudioBuffer(params, nports, net_buffer) 00714 { 00715 fPeriodSize = params->fPeriodSize; 00716 00717 fCompressedSizeByte = (params->fPeriodSize * sizeof(short)); 00718 jack_log("NetIntAudioBuffer fCompressedSizeByte %d", fCompressedSizeByte); 00719 00720 fIntBuffer = new short* [fNPorts]; 00721 for (int port_index = 0; port_index < fNPorts; port_index++) { 00722 fIntBuffer[port_index] = new short[fPeriodSize]; 00723 memset(fIntBuffer[port_index], 0, fPeriodSize * sizeof(short)); 00724 } 00725 00726 int res1 = (fNPorts * fCompressedSizeByte) % PACKET_AVAILABLE_SIZE(params); 00727 int res2 = (fNPorts * fCompressedSizeByte) / PACKET_AVAILABLE_SIZE(params); 00728 00729 jack_log("NetIntAudioBuffer res1 = %d res2 = %d", res1, res2); 00730 00731 fNumPackets = (res1) ? (res2 + 1) : res2; 00732 00733 fSubPeriodBytesSize = fCompressedSizeByte / fNumPackets; 00734 fLastSubPeriodBytesSize = fSubPeriodBytesSize + fCompressedSizeByte % fNumPackets; 00735 00736 fSubPeriodSize = fSubPeriodBytesSize / sizeof(short); 00737 00738 jack_log("NetIntAudioBuffer fNumPackets = %d fSubPeriodBytesSize = %d, fLastSubPeriodBytesSize = %d", fNumPackets, fSubPeriodBytesSize, fLastSubPeriodBytesSize); 00739 00740 fCycleDuration = float(fSubPeriodBytesSize / sizeof(sample_t)) / float(params->fSampleRate); 00741 fCycleBytesSize = params->fMtu * fNumPackets; 00742 00743 fLastSubCycle = -1; 00744 return; 00745 } 00746 00747 NetIntAudioBuffer::~NetIntAudioBuffer() 00748 { 00749 for (int port_index = 0; port_index < fNPorts; port_index++) { 00750 delete [] fIntBuffer[port_index]; 00751 } 00752 00753 delete [] fIntBuffer; 00754 } 00755 00756 size_t NetIntAudioBuffer::GetCycleSize() 00757 { 00758 return fCycleBytesSize; 00759 } 00760 00761 float NetIntAudioBuffer::GetCycleDuration() 00762 { 00763 return fCycleDuration; 00764 } 00765 00766 int NetIntAudioBuffer::GetNumPackets(int active_ports) 00767 { 00768 return fNumPackets; 00769 } 00770 00771 int NetIntAudioBuffer::RenderFromJackPorts() 00772 { 00773 for (int port_index = 0; port_index < fNPorts; port_index++) { 00774 if (fPortBuffer[port_index]) { 00775 for (uint frame = 0; frame < fPeriodSize; frame++) { 00776 fIntBuffer[port_index][frame] = short(fPortBuffer[port_index][frame] * 32768.f); 00777 } 00778 } 00779 } 00780 00781 // All ports active 00782 return fNPorts; 00783 } 00784 00785 void NetIntAudioBuffer::RenderToJackPorts() 00786 { 00787 float coef = 1.f / 32768.f; 00788 for (int port_index = 0; port_index < fNPorts; port_index++) { 00789 if (fPortBuffer[port_index]) { 00790 for (uint frame = 0; frame < fPeriodSize; frame++) { 00791 fPortBuffer[port_index][frame] = float(fIntBuffer[port_index][frame] * coef); 00792 } 00793 } 00794 } 00795 00796 NextCycle(); 00797 } 00798 00799 //network<->buffer 00800 int NetIntAudioBuffer::RenderFromNetwork(int cycle, int sub_cycle, uint32_t port_num) 00801 { 00802 // Cleanup all JACK ports at the beginning of the cycle 00803 if (sub_cycle == 0) { 00804 Cleanup(); 00805 } 00806 00807 if (port_num > 0) { 00808 if (sub_cycle == fNumPackets - 1) { 00809 for (int port_index = 0; port_index < fNPorts; port_index++) { 00810 memcpy(fIntBuffer[port_index] + sub_cycle * fSubPeriodSize, fNetBuffer + port_index * fLastSubPeriodBytesSize, fLastSubPeriodBytesSize); 00811 } 00812 } else { 00813 for (int port_index = 0; port_index < fNPorts; port_index++) { 00814 memcpy(fIntBuffer[port_index] + sub_cycle * fSubPeriodSize, fNetBuffer + port_index * fSubPeriodBytesSize, fSubPeriodBytesSize); 00815 } 00816 } 00817 } 00818 00819 return CheckPacket(cycle, sub_cycle); 00820 } 00821 00822 int NetIntAudioBuffer::RenderToNetwork(int sub_cycle, uint32_t port_num) 00823 { 00824 // Last packet of the cycle 00825 if (sub_cycle == fNumPackets - 1) { 00826 for (int port_index = 0; port_index < fNPorts; port_index++) { 00827 memcpy(fNetBuffer + port_index * fLastSubPeriodBytesSize, fIntBuffer[port_index] + sub_cycle * fSubPeriodSize, fLastSubPeriodBytesSize); 00828 } 00829 return fNPorts * fLastSubPeriodBytesSize; 00830 } else { 00831 for (int port_index = 0; port_index < fNPorts; port_index++) { 00832 memcpy(fNetBuffer + port_index * fSubPeriodBytesSize, fIntBuffer[port_index] + sub_cycle * fSubPeriodSize, fSubPeriodBytesSize); 00833 } 00834 return fNPorts * fSubPeriodBytesSize; 00835 } 00836 } 00837 00838 // SessionParams ************************************************************************************ 00839 00840 SERVER_EXPORT void SessionParamsHToN(session_params_t* src_params, session_params_t* dst_params) 00841 { 00842 memcpy(dst_params, src_params, sizeof(session_params_t)); 00843 dst_params->fPacketID = htonl(src_params->fPacketID); 00844 dst_params->fMtu = htonl(src_params->fMtu); 00845 dst_params->fID = htonl(src_params->fID); 00846 dst_params->fTransportSync = htonl(src_params->fTransportSync); 00847 dst_params->fSendAudioChannels = htonl(src_params->fSendAudioChannels); 00848 dst_params->fReturnAudioChannels = htonl(src_params->fReturnAudioChannels); 00849 dst_params->fSendMidiChannels = htonl(src_params->fSendMidiChannels); 00850 dst_params->fReturnMidiChannels = htonl(src_params->fReturnMidiChannels); 00851 dst_params->fSampleRate = htonl(src_params->fSampleRate); 00852 dst_params->fPeriodSize = htonl(src_params->fPeriodSize); 00853 dst_params->fSampleEncoder = htonl(src_params->fSampleEncoder); 00854 dst_params->fKBps = htonl(src_params->fKBps); 00855 dst_params->fSlaveSyncMode = htonl(src_params->fSlaveSyncMode); 00856 dst_params->fNetworkLatency = htonl(src_params->fNetworkLatency); 00857 } 00858 00859 SERVER_EXPORT void SessionParamsNToH(session_params_t* src_params, session_params_t* dst_params) 00860 { 00861 memcpy(dst_params, src_params, sizeof(session_params_t)); 00862 dst_params->fPacketID = ntohl(src_params->fPacketID); 00863 dst_params->fMtu = ntohl(src_params->fMtu); 00864 dst_params->fID = ntohl(src_params->fID); 00865 dst_params->fTransportSync = ntohl(src_params->fTransportSync); 00866 dst_params->fSendAudioChannels = ntohl(src_params->fSendAudioChannels); 00867 dst_params->fReturnAudioChannels = ntohl(src_params->fReturnAudioChannels); 00868 dst_params->fSendMidiChannels = ntohl(src_params->fSendMidiChannels); 00869 dst_params->fReturnMidiChannels = ntohl(src_params->fReturnMidiChannels); 00870 dst_params->fSampleRate = ntohl(src_params->fSampleRate); 00871 dst_params->fPeriodSize = ntohl(src_params->fPeriodSize); 00872 dst_params->fSampleEncoder = ntohl(src_params->fSampleEncoder); 00873 dst_params->fKBps = ntohl(src_params->fKBps); 00874 dst_params->fSlaveSyncMode = ntohl(src_params->fSlaveSyncMode); 00875 dst_params->fNetworkLatency = ntohl(src_params->fNetworkLatency); 00876 } 00877 00878 SERVER_EXPORT void SessionParamsDisplay(session_params_t* params) 00879 { 00880 char encoder[16]; 00881 switch (params->fSampleEncoder) 00882 { 00883 case JackFloatEncoder: 00884 strcpy(encoder, "float"); 00885 break; 00886 case JackIntEncoder: 00887 strcpy(encoder, "integer"); 00888 break; 00889 case JackCeltEncoder: 00890 strcpy(encoder, "CELT"); 00891 break; 00892 } 00893 00894 jack_info("**************** Network parameters ****************"); 00895 jack_info("Name : %s", params->fName); 00896 jack_info("Protocol revision : %d", params->fProtocolVersion); 00897 jack_info("MTU : %u", params->fMtu); 00898 jack_info("Master name : %s", params->fMasterNetName); 00899 jack_info("Slave name : %s", params->fSlaveNetName); 00900 jack_info("ID : %u", params->fID); 00901 jack_info("Transport Sync : %s", (params->fTransportSync) ? "yes" : "no"); 00902 jack_info("Send channels (audio - midi) : %d - %d", params->fSendAudioChannels, params->fSendMidiChannels); 00903 jack_info("Return channels (audio - midi) : %d - %d", params->fReturnAudioChannels, params->fReturnMidiChannels); 00904 jack_info("Sample rate : %u frames per second", params->fSampleRate); 00905 jack_info("Period size : %u frames per period", params->fPeriodSize); 00906 jack_info("Network latency : %u cycles", params->fNetworkLatency); 00907 switch (params->fSampleEncoder) { 00908 case (JackFloatEncoder): 00909 jack_info("SampleEncoder : %s", "Float"); 00910 break; 00911 case (JackIntEncoder): 00912 jack_info("SampleEncoder : %s", "16 bits integer"); 00913 break; 00914 case (JackCeltEncoder): 00915 jack_info("SampleEncoder : %s", "CELT"); 00916 jack_info("kBits : %d", params->fKBps); 00917 break; 00918 }; 00919 jack_info("Slave mode : %s", (params->fSlaveSyncMode) ? "sync" : "async"); 00920 jack_info("****************************************************"); 00921 } 00922 00923 SERVER_EXPORT sync_packet_type_t GetPacketType(session_params_t* params) 00924 { 00925 switch (params->fPacketID) 00926 { 00927 case 0: 00928 return SLAVE_AVAILABLE; 00929 case 1: 00930 return SLAVE_SETUP; 00931 case 2: 00932 return START_MASTER; 00933 case 3: 00934 return START_SLAVE; 00935 case 4: 00936 return KILL_MASTER; 00937 } 00938 return INVALID; 00939 } 00940 00941 SERVER_EXPORT int SetPacketType(session_params_t* params, sync_packet_type_t packet_type) 00942 { 00943 switch (packet_type) 00944 { 00945 case INVALID: 00946 return -1; 00947 case SLAVE_AVAILABLE: 00948 params->fPacketID = 0; 00949 break; 00950 case SLAVE_SETUP: 00951 params->fPacketID = 1; 00952 break; 00953 case START_MASTER: 00954 params->fPacketID = 2; 00955 break; 00956 case START_SLAVE: 00957 params->fPacketID = 3; 00958 break; 00959 case KILL_MASTER: 00960 params->fPacketID = 4; 00961 } 00962 return 0; 00963 } 00964 00965 // Packet header ********************************************************************************** 00966 00967 SERVER_EXPORT void PacketHeaderHToN(packet_header_t* src_header, packet_header_t* dst_header) 00968 { 00969 memcpy(dst_header, src_header, sizeof(packet_header_t)); 00970 dst_header->fID = htonl(src_header->fID); 00971 dst_header->fNumPacket = htonl(src_header->fNumPacket); 00972 dst_header->fPacketSize = htonl(src_header->fPacketSize); 00973 dst_header->fActivePorts = htonl(src_header->fActivePorts); 00974 dst_header->fCycle = htonl(src_header->fCycle); 00975 dst_header->fSubCycle = htonl(src_header->fSubCycle); 00976 dst_header->fIsLastPckt = htonl(src_header->fIsLastPckt); 00977 } 00978 00979 SERVER_EXPORT void PacketHeaderNToH(packet_header_t* src_header, packet_header_t* dst_header) 00980 { 00981 memcpy(dst_header, src_header, sizeof(packet_header_t)); 00982 dst_header->fID = ntohl(src_header->fID); 00983 dst_header->fNumPacket = ntohl(src_header->fNumPacket); 00984 dst_header->fPacketSize = ntohl(src_header->fPacketSize); 00985 dst_header->fActivePorts = ntohl(src_header->fActivePorts); 00986 dst_header->fCycle = ntohl(src_header->fCycle); 00987 dst_header->fSubCycle = ntohl(src_header->fSubCycle); 00988 dst_header->fIsLastPckt = ntohl(src_header->fIsLastPckt); 00989 } 00990 00991 SERVER_EXPORT void PacketHeaderDisplay(packet_header_t* header) 00992 { 00993 char bitdepth[16]; 00994 jack_info("********************Header********************"); 00995 jack_info("Data type : %c", header->fDataType); 00996 jack_info("Data stream : %c", header->fDataStream); 00997 jack_info("ID : %u", header->fID); 00998 jack_info("Cycle : %u", header->fCycle); 00999 jack_info("SubCycle : %u", header->fSubCycle); 01000 jack_info("Active ports : %u", header->fActivePorts); 01001 jack_info("DATA packets : %u", header->fNumPacket); 01002 jack_info("DATA size : %u", header->fPacketSize); 01003 jack_info("Last packet : '%s'", (header->fIsLastPckt) ? "yes" : "no"); 01004 jack_info("Bitdepth : %s", bitdepth); 01005 jack_info("**********************************************"); 01006 } 01007 01008 SERVER_EXPORT void NetTransportDataDisplay(net_transport_data_t* data) 01009 { 01010 jack_info("********************Network Transport********************"); 01011 jack_info("Transport new state : %u", data->fNewState); 01012 jack_info("Transport timebase master : %u", data->fTimebaseMaster); 01013 jack_info("Transport cycle state : %u", data->fState); 01014 jack_info("**********************************************"); 01015 } 01016 01017 SERVER_EXPORT void MidiBufferHToN(JackMidiBuffer* src_buffer, JackMidiBuffer* dst_buffer) 01018 { 01019 dst_buffer->magic = htonl(src_buffer->magic); 01020 dst_buffer->buffer_size = htonl(src_buffer->buffer_size); 01021 dst_buffer->nframes = htonl(src_buffer->nframes); 01022 dst_buffer->write_pos = htonl(src_buffer->write_pos); 01023 dst_buffer->event_count = htonl(src_buffer->event_count); 01024 dst_buffer->lost_events = htonl(src_buffer->lost_events); 01025 dst_buffer->mix_index = htonl(src_buffer->mix_index); 01026 } 01027 01028 SERVER_EXPORT void MidiBufferNToH(JackMidiBuffer* src_buffer, JackMidiBuffer* dst_buffer) 01029 { 01030 dst_buffer->magic = ntohl(src_buffer->magic); 01031 dst_buffer->buffer_size = ntohl(src_buffer->buffer_size); 01032 dst_buffer->nframes = ntohl(src_buffer->nframes); 01033 dst_buffer->write_pos = ntohl(src_buffer->write_pos); 01034 dst_buffer->event_count = ntohl(src_buffer->event_count); 01035 dst_buffer->lost_events = ntohl(src_buffer->lost_events); 01036 dst_buffer->mix_index = ntohl(src_buffer->mix_index); 01037 } 01038 01039 SERVER_EXPORT void TransportDataHToN(net_transport_data_t* src_params, net_transport_data_t* dst_params) 01040 { 01041 dst_params->fNewState = htonl(src_params->fNewState); 01042 dst_params->fTimebaseMaster = htonl(src_params->fTimebaseMaster); 01043 dst_params->fState = htonl(src_params->fState); 01044 dst_params->fPosition.unique_1 = htonll(src_params->fPosition.unique_1); 01045 dst_params->fPosition.usecs = htonl(src_params->fPosition.usecs); 01046 dst_params->fPosition.frame_rate = htonl(src_params->fPosition.frame_rate); 01047 dst_params->fPosition.frame = htonl(src_params->fPosition.frame); 01048 dst_params->fPosition.valid = (jack_position_bits_t)htonl((uint32_t)src_params->fPosition.valid); 01049 dst_params->fPosition.bar = htonl(src_params->fPosition.bar); 01050 dst_params->fPosition.beat = htonl(src_params->fPosition.beat); 01051 dst_params->fPosition.tick = htonl(src_params->fPosition.tick); 01052 dst_params->fPosition.bar_start_tick = htonll((uint64_t)src_params->fPosition.bar_start_tick); 01053 dst_params->fPosition.beats_per_bar = htonl((uint32_t)src_params->fPosition.beats_per_bar); 01054 dst_params->fPosition.beat_type = htonl((uint32_t)src_params->fPosition.beat_type); 01055 dst_params->fPosition.ticks_per_beat = htonll((uint64_t)src_params->fPosition.ticks_per_beat); 01056 dst_params->fPosition.beats_per_minute = htonll((uint64_t)src_params->fPosition.beats_per_minute); 01057 dst_params->fPosition.frame_time = htonll((uint64_t)src_params->fPosition.frame_time); 01058 dst_params->fPosition.next_time = htonll((uint64_t)src_params->fPosition.next_time); 01059 dst_params->fPosition.bbt_offset = htonl(src_params->fPosition.bbt_offset); 01060 dst_params->fPosition.audio_frames_per_video_frame = htonl((uint32_t)src_params->fPosition.audio_frames_per_video_frame); 01061 dst_params->fPosition.video_offset = htonl(src_params->fPosition.video_offset); 01062 dst_params->fPosition.unique_2 = htonll(src_params->fPosition.unique_2); 01063 } 01064 01065 SERVER_EXPORT void TransportDataNToH(net_transport_data_t* src_params, net_transport_data_t* dst_params) 01066 { 01067 dst_params->fNewState = ntohl(src_params->fNewState); 01068 dst_params->fTimebaseMaster = ntohl(src_params->fTimebaseMaster); 01069 dst_params->fState = ntohl(src_params->fState); 01070 dst_params->fPosition.unique_1 = ntohll(src_params->fPosition.unique_1); 01071 dst_params->fPosition.usecs = ntohl(src_params->fPosition.usecs); 01072 dst_params->fPosition.frame_rate = ntohl(src_params->fPosition.frame_rate); 01073 dst_params->fPosition.frame = ntohl(src_params->fPosition.frame); 01074 dst_params->fPosition.valid = (jack_position_bits_t)ntohl((uint32_t)src_params->fPosition.valid); 01075 dst_params->fPosition.bar = ntohl(src_params->fPosition.bar); 01076 dst_params->fPosition.beat = ntohl(src_params->fPosition.beat); 01077 dst_params->fPosition.tick = ntohl(src_params->fPosition.tick); 01078 dst_params->fPosition.bar_start_tick = ntohll((uint64_t)src_params->fPosition.bar_start_tick); 01079 dst_params->fPosition.beats_per_bar = ntohl((uint32_t)src_params->fPosition.beats_per_bar); 01080 dst_params->fPosition.beat_type = ntohl((uint32_t)src_params->fPosition.beat_type); 01081 dst_params->fPosition.ticks_per_beat = ntohll((uint64_t)src_params->fPosition.ticks_per_beat); 01082 dst_params->fPosition.beats_per_minute = ntohll((uint64_t)src_params->fPosition.beats_per_minute); 01083 dst_params->fPosition.frame_time = ntohll((uint64_t)src_params->fPosition.frame_time); 01084 dst_params->fPosition.next_time = ntohll((uint64_t)src_params->fPosition.next_time); 01085 dst_params->fPosition.bbt_offset = ntohl(src_params->fPosition.bbt_offset); 01086 dst_params->fPosition.audio_frames_per_video_frame = ntohl((uint32_t)src_params->fPosition.audio_frames_per_video_frame); 01087 dst_params->fPosition.video_offset = ntohl(src_params->fPosition.video_offset); 01088 dst_params->fPosition.unique_2 = ntohll(src_params->fPosition.unique_2); 01089 } 01090 01091 // Utility ******************************************************************************************************* 01092 01093 SERVER_EXPORT int SocketAPIInit() 01094 { 01095 #ifdef WIN32 01096 WORD wVersionRequested = MAKEWORD(2, 2); 01097 WSADATA wsaData; 01098 01099 if (WSAStartup(wVersionRequested, &wsaData) != 0) { 01100 jack_error("WSAStartup error : %s", strerror(NET_ERROR_CODE)); 01101 return -1; 01102 } 01103 01104 if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) { 01105 jack_error("Could not find a useable version of Winsock.dll\n"); 01106 WSACleanup(); 01107 return -1; 01108 } 01109 #endif 01110 return 0; 01111 } 01112 01113 SERVER_EXPORT int SocketAPIEnd() 01114 { 01115 #ifdef WIN32 01116 return WSACleanup(); 01117 #endif 01118 return 0; 01119 } 01120 01121 SERVER_EXPORT const char* GetTransportState(int transport_state) 01122 { 01123 switch (transport_state) 01124 { 01125 case JackTransportRolling: 01126 return "rolling"; 01127 case JackTransportStarting: 01128 return "starting"; 01129 case JackTransportStopped: 01130 return "stopped"; 01131 case JackTransportNetStarting: 01132 return "netstarting"; 01133 } 01134 return NULL; 01135 } 01136 }