00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "JackNetTool.h"
00021
00022 using namespace std;
00023
00024 namespace Jack
00025 {
00026
00027
00028 NetMidiBuffer::NetMidiBuffer ( session_params_t* params, uint32_t nports, char* net_buffer )
00029 {
00030 fNPorts = nports;
00031 fMaxBufsize = fNPorts * sizeof ( sample_t ) * params->fPeriodSize ;
00032 fMaxPcktSize = params->fMtu - sizeof ( packet_header_t );
00033 fBuffer = new char[fMaxBufsize];
00034 fPortBuffer = new JackMidiBuffer* [fNPorts];
00035 for ( int port_index = 0; port_index < fNPorts; port_index++ )
00036 fPortBuffer[port_index] = NULL;
00037 fNetBuffer = net_buffer;
00038 }
00039
00040 NetMidiBuffer::~NetMidiBuffer()
00041 {
00042 delete[] fBuffer;
00043 delete[] fPortBuffer;
00044 }
00045
00046 size_t NetMidiBuffer::GetSize()
00047 {
00048 return fMaxBufsize;
00049 }
00050
00051 void NetMidiBuffer::SetBuffer ( int index, JackMidiBuffer* buffer )
00052 {
00053 fPortBuffer[index] = buffer;
00054 }
00055
00056 JackMidiBuffer* NetMidiBuffer::GetBuffer ( int index )
00057 {
00058 return fPortBuffer[index];
00059 }
00060
00061 void NetMidiBuffer::DisplayEvents()
00062 {
00063 for ( int port_index = 0; port_index < fNPorts; port_index++ )
00064 {
00065 for ( uint event = 0; event < fPortBuffer[port_index]->event_count; event++ )
00066 if ( fPortBuffer[port_index]->IsValid() )
00067 jack_info ( "port %d : midi event %u/%u -> time : %u, size : %u",
00068 port_index + 1, event + 1, fPortBuffer[port_index]->event_count,
00069 fPortBuffer[port_index]->events[event].time, fPortBuffer[port_index]->events[event].size );
00070 }
00071 }
00072
00073 int NetMidiBuffer::RenderFromJackPorts()
00074 {
00075 int pos = 0;
00076 size_t copy_size;
00077 for ( int port_index = 0; port_index < fNPorts; port_index++ )
00078 {
00079 char* write_pos = fBuffer + pos;
00080
00081 copy_size = sizeof ( JackMidiBuffer ) + fPortBuffer[port_index]->event_count * sizeof ( JackMidiEvent );
00082 memcpy ( fBuffer + pos, fPortBuffer[port_index], copy_size );
00083 pos += copy_size;
00084 memcpy ( fBuffer + pos, fPortBuffer[port_index] + ( fPortBuffer[port_index]->buffer_size - fPortBuffer[port_index]->write_pos ),
00085 fPortBuffer[port_index]->write_pos );
00086 pos += fPortBuffer[port_index]->write_pos;
00087
00088 JackMidiBuffer* midi_buffer = reinterpret_cast<JackMidiBuffer*>(write_pos);
00089 MidiBufferHToN(midi_buffer, midi_buffer);
00090 }
00091 return pos;
00092 }
00093
00094 int NetMidiBuffer::RenderToJackPorts()
00095 {
00096 int pos = 0;
00097 int copy_size;
00098 for ( int port_index = 0; port_index < fNPorts; port_index++ )
00099 {
00100 JackMidiBuffer* midi_buffer = reinterpret_cast<JackMidiBuffer*>(fBuffer + pos);
00101 MidiBufferNToH(midi_buffer, midi_buffer);
00102
00103 copy_size = sizeof ( JackMidiBuffer ) + reinterpret_cast<JackMidiBuffer*> ( fBuffer + pos )->event_count * sizeof ( JackMidiEvent );
00104 memcpy ( fPortBuffer[port_index], fBuffer + pos, copy_size );
00105 pos += copy_size;
00106 memcpy ( fPortBuffer[port_index] + ( fPortBuffer[port_index]->buffer_size - fPortBuffer[port_index]->write_pos ),
00107 fBuffer + pos, fPortBuffer[port_index]->write_pos );
00108 pos += fPortBuffer[port_index]->write_pos;
00109 }
00110 return pos;
00111 }
00112
00113 int NetMidiBuffer::RenderFromNetwork ( int subcycle, size_t copy_size )
00114 {
00115 memcpy ( fBuffer + subcycle * fMaxPcktSize, fNetBuffer, copy_size );
00116 return copy_size;
00117 }
00118
00119 int NetMidiBuffer::RenderToNetwork ( int subcycle, size_t total_size )
00120 {
00121 int size = total_size - subcycle * fMaxPcktSize;
00122 int copy_size = ( size <= fMaxPcktSize ) ? size : fMaxPcktSize;
00123 memcpy ( fNetBuffer, fBuffer + subcycle * fMaxPcktSize, copy_size );
00124 return copy_size;
00125 }
00126
00127
00128
00129
00130 NetAudioBuffer::NetAudioBuffer ( session_params_t* params, uint32_t nports, char* net_buffer )
00131 {
00132 fNPorts = nports;
00133 fPeriodSize = params->fPeriodSize;
00134 fSubPeriodSize = params->fFramesPerPacket;
00135 fSubPeriodBytesSize = fSubPeriodSize * sizeof ( sample_t );
00136 fPortBuffer = new sample_t* [fNPorts];
00137 for ( int port_index = 0; port_index < fNPorts; port_index++ )
00138 fPortBuffer[port_index] = NULL;
00139 fNetBuffer = net_buffer;
00140 }
00141
00142 NetAudioBuffer::~NetAudioBuffer()
00143 {
00144 delete[] fPortBuffer;
00145 }
00146
00147 size_t NetAudioBuffer::GetSize()
00148 {
00149 return fNPorts * fSubPeriodBytesSize;
00150 }
00151
00152 void NetAudioBuffer::SetBuffer ( int index, sample_t* buffer )
00153 {
00154 fPortBuffer[index] = buffer;
00155 }
00156
00157 sample_t* NetAudioBuffer::GetBuffer ( int index )
00158 {
00159 return fPortBuffer[index];
00160 }
00161
00162 #ifdef __BIG_ENDIAN__
00163
00164 static inline jack_default_audio_sample_t SwapFloat(jack_default_audio_sample_t f)
00165 {
00166 union
00167 {
00168 jack_default_audio_sample_t f;
00169 unsigned char b[4];
00170 } dat1, dat2;
00171
00172 dat1.f = f;
00173 dat2.b[0] = dat1.b[3];
00174 dat2.b[1] = dat1.b[2];
00175 dat2.b[2] = dat1.b[1];
00176 dat2.b[3] = dat1.b[0];
00177 return dat2.f;
00178 }
00179
00180 void NetAudioBuffer::RenderFromJackPorts ( int subcycle )
00181 {
00182 for ( int port_index = 0; port_index < fNPorts; port_index++ ) {
00183 jack_default_audio_sample_t* src = (jack_default_audio_sample_t*)(fPortBuffer[port_index] + subcycle * fSubPeriodSize);
00184 jack_default_audio_sample_t* dst = (jack_default_audio_sample_t*)(fNetBuffer + port_index * fSubPeriodBytesSize);
00185 for (unsigned int sample = 0; sample < fSubPeriodBytesSize / sizeof(jack_default_audio_sample_t); sample++) {
00186 dst[sample] = SwapFloat(src[sample]);
00187 }
00188 }
00189 }
00190
00191 void NetAudioBuffer::RenderToJackPorts ( int subcycle )
00192 {
00193 for ( int port_index = 0; port_index < fNPorts; port_index++ ) {
00194 jack_default_audio_sample_t* src = (jack_default_audio_sample_t*)(fNetBuffer + port_index * fSubPeriodBytesSize);
00195 jack_default_audio_sample_t* dst = (jack_default_audio_sample_t*)(fPortBuffer[port_index] + subcycle * fSubPeriodSize);
00196 for (unsigned int sample = 0; sample < fSubPeriodBytesSize / sizeof(jack_default_audio_sample_t); sample++) {
00197 dst[sample] = SwapFloat(src[sample]);
00198 }
00199 }
00200 }
00201
00202 #else
00203
00204 void NetAudioBuffer::RenderFromJackPorts ( int subcycle )
00205 {
00206 for ( int port_index = 0; port_index < fNPorts; port_index++ )
00207 memcpy ( fNetBuffer + port_index * fSubPeriodBytesSize, fPortBuffer[port_index] + subcycle * fSubPeriodSize, fSubPeriodBytesSize );
00208 }
00209
00210 void NetAudioBuffer::RenderToJackPorts ( int subcycle )
00211 {
00212 for ( int port_index = 0; port_index < fNPorts; port_index++ )
00213 memcpy ( fPortBuffer[port_index] + subcycle * fSubPeriodSize, fNetBuffer + port_index * fSubPeriodBytesSize, fSubPeriodBytesSize );
00214 }
00215
00216 #endif
00217
00218
00219
00220 SERVER_EXPORT void SessionParamsHToN ( session_params_t* src_params, session_params_t* dst_params )
00221 {
00222 memcpy(dst_params, src_params, sizeof(session_params_t));
00223 dst_params->fPacketID = htonl ( src_params->fPacketID );
00224 dst_params->fMtu = htonl ( src_params->fMtu );
00225 dst_params->fID = htonl ( src_params->fID );
00226 dst_params->fTransportSync = htonl ( src_params->fTransportSync );
00227 dst_params->fSendAudioChannels = htonl ( src_params->fSendAudioChannels );
00228 dst_params->fReturnAudioChannels = htonl ( src_params->fReturnAudioChannels );
00229 dst_params->fSendMidiChannels = htonl ( src_params->fSendMidiChannels );
00230 dst_params->fReturnMidiChannels = htonl ( src_params->fReturnMidiChannels );
00231 dst_params->fSampleRate = htonl ( src_params->fSampleRate );
00232 dst_params->fPeriodSize = htonl ( src_params->fPeriodSize );
00233 dst_params->fFramesPerPacket = htonl ( src_params->fFramesPerPacket );
00234 dst_params->fBitdepth = htonl ( src_params->fBitdepth );
00235 dst_params->fSlaveSyncMode = htonl ( src_params->fSlaveSyncMode );
00236 }
00237
00238 SERVER_EXPORT void SessionParamsNToH ( session_params_t* src_params, session_params_t* dst_params )
00239 {
00240 memcpy(dst_params, src_params, sizeof(session_params_t));
00241 dst_params->fPacketID = ntohl ( src_params->fPacketID );
00242 dst_params->fMtu = ntohl ( src_params->fMtu );
00243 dst_params->fID = ntohl ( src_params->fID );
00244 dst_params->fTransportSync = ntohl ( src_params->fTransportSync );
00245 dst_params->fSendAudioChannels = ntohl ( src_params->fSendAudioChannels );
00246 dst_params->fReturnAudioChannels = ntohl ( src_params->fReturnAudioChannels );
00247 dst_params->fSendMidiChannels = ntohl ( src_params->fSendMidiChannels );
00248 dst_params->fReturnMidiChannels = ntohl ( src_params->fReturnMidiChannels );
00249 dst_params->fSampleRate = ntohl ( src_params->fSampleRate );
00250 dst_params->fPeriodSize = ntohl ( src_params->fPeriodSize );
00251 dst_params->fFramesPerPacket = ntohl ( src_params->fFramesPerPacket );
00252 dst_params->fBitdepth = ntohl ( src_params->fBitdepth );
00253 dst_params->fSlaveSyncMode = ntohl ( src_params->fSlaveSyncMode );
00254 }
00255
00256 SERVER_EXPORT void SessionParamsDisplay ( session_params_t* params )
00257 {
00258 char bitdepth[16];
00259 ( params->fBitdepth ) ? sprintf ( bitdepth, "%u", params->fBitdepth ) : sprintf ( bitdepth, "%s", "float" );
00260 char mode[8];
00261 switch ( params->fNetworkMode )
00262 {
00263 case 's' :
00264 strcpy ( mode, "slow" );
00265 break;
00266 case 'n' :
00267 strcpy ( mode, "normal" );
00268 break;
00269 case 'f' :
00270 strcpy ( mode, "fast" );
00271 break;
00272 }
00273 jack_info ( "**************** Network parameters ****************" );
00274 jack_info ( "Name : %s", params->fName );
00275 jack_info ( "Protocol revision : %d", params->fProtocolVersion );
00276 jack_info ( "MTU : %u", params->fMtu );
00277 jack_info ( "Master name : %s", params->fMasterNetName );
00278 jack_info ( "Slave name : %s", params->fSlaveNetName );
00279 jack_info ( "ID : %u", params->fID );
00280 jack_info ( "Transport Sync : %s", ( params->fTransportSync ) ? "yes" : "no" );
00281 jack_info ( "Send channels (audio - midi) : %d - %d", params->fSendAudioChannels, params->fSendMidiChannels );
00282 jack_info ( "Return channels (audio - midi) : %d - %d", params->fReturnAudioChannels, params->fReturnMidiChannels );
00283 jack_info ( "Sample rate : %u frames per second", params->fSampleRate );
00284 jack_info ( "Period size : %u frames per period", params->fPeriodSize );
00285 jack_info ( "Frames per packet : %u", params->fFramesPerPacket );
00286 jack_info ( "Packet per period : %u", (params->fFramesPerPacket != 0) ? params->fPeriodSize / params->fFramesPerPacket : 0);
00287 jack_info ( "Bitdepth : %s", bitdepth );
00288 jack_info ( "Slave mode : %s", ( params->fSlaveSyncMode ) ? "sync" : "async" );
00289 jack_info ( "Network mode : %s", mode );
00290 jack_info ( "****************************************************" );
00291 }
00292
00293 SERVER_EXPORT sync_packet_type_t GetPacketType ( session_params_t* params )
00294 {
00295 switch ( params->fPacketID )
00296 {
00297 case 0:
00298 return SLAVE_AVAILABLE;
00299 case 1:
00300 return SLAVE_SETUP;
00301 case 2:
00302 return START_MASTER;
00303 case 3:
00304 return START_SLAVE;
00305 case 4:
00306 return KILL_MASTER;
00307 }
00308 return INVALID;
00309 }
00310
00311 SERVER_EXPORT int SetPacketType ( session_params_t* params, sync_packet_type_t packet_type )
00312 {
00313 switch ( packet_type )
00314 {
00315 case INVALID:
00316 return -1;
00317 case SLAVE_AVAILABLE:
00318 params->fPacketID = 0;
00319 break;
00320 case SLAVE_SETUP:
00321 params->fPacketID = 1;
00322 break;
00323 case START_MASTER:
00324 params->fPacketID = 2;
00325 break;
00326 case START_SLAVE:
00327 params->fPacketID = 3;
00328 break;
00329 case KILL_MASTER:
00330 params->fPacketID = 4;
00331 }
00332 return 0;
00333 }
00334
00335
00336
00337 SERVER_EXPORT void PacketHeaderHToN ( packet_header_t* src_header, packet_header_t* dst_header )
00338 {
00339 memcpy(dst_header, src_header, sizeof(packet_header_t));
00340 dst_header->fID = htonl ( src_header->fID );
00341 dst_header->fMidiDataSize = htonl ( src_header->fMidiDataSize );
00342 dst_header->fBitdepth = htonl ( src_header->fBitdepth );
00343 dst_header->fNMidiPckt = htonl ( src_header->fNMidiPckt );
00344 dst_header->fPacketSize = htonl ( src_header->fPacketSize );
00345 dst_header->fCycle = htonl ( src_header->fCycle );
00346 dst_header->fSubCycle = htonl ( src_header->fSubCycle );
00347 dst_header->fIsLastPckt = htonl ( src_header->fIsLastPckt );
00348 }
00349
00350 SERVER_EXPORT void PacketHeaderNToH ( packet_header_t* src_header, packet_header_t* dst_header )
00351 {
00352 memcpy(dst_header, src_header, sizeof(packet_header_t));
00353 dst_header->fID = ntohl ( src_header->fID );
00354 dst_header->fMidiDataSize = ntohl ( src_header->fMidiDataSize );
00355 dst_header->fBitdepth = ntohl ( src_header->fBitdepth );
00356 dst_header->fNMidiPckt = ntohl ( src_header->fNMidiPckt );
00357 dst_header->fPacketSize = ntohl ( src_header->fPacketSize );
00358 dst_header->fCycle = ntohl ( src_header->fCycle );
00359 dst_header->fSubCycle = ntohl ( src_header->fSubCycle );
00360 dst_header->fIsLastPckt = ntohl ( src_header->fIsLastPckt );
00361 }
00362
00363 SERVER_EXPORT void PacketHeaderDisplay ( packet_header_t* header )
00364 {
00365 char bitdepth[16];
00366 ( header->fBitdepth ) ? sprintf ( bitdepth, "%u", header->fBitdepth ) : sprintf ( bitdepth, "%s", "float" );
00367 jack_info ( "********************Header********************" );
00368 jack_info ( "Data type : %c", header->fDataType );
00369 jack_info ( "Data stream : %c", header->fDataStream );
00370 jack_info ( "ID : %u", header->fID );
00371 jack_info ( "Cycle : %u", header->fCycle );
00372 jack_info ( "SubCycle : %u", header->fSubCycle );
00373 jack_info ( "Midi packets : %u", header->fNMidiPckt );
00374 jack_info ( "Midi data size : %u", header->fMidiDataSize );
00375 jack_info ( "Last packet : '%s'", ( header->fIsLastPckt ) ? "yes" : "no" );
00376 jack_info ( "Bitdepth : %s", bitdepth );
00377 jack_info ( "**********************************************" );
00378 }
00379
00380 SERVER_EXPORT void NetTransportDataDisplay ( net_transport_data_t* data )
00381 {
00382 jack_info ( "********************Network Transport********************" );
00383 jack_info ( "Transport new state : %u", data->fNewState );
00384 jack_info ( "Transport timebase master : %u", data->fTimebaseMaster );
00385 jack_info ( "Transport cycle state : %u", data->fState );
00386 jack_info ( "**********************************************" );
00387 }
00388
00389 SERVER_EXPORT void MidiBufferHToN ( JackMidiBuffer* src_buffer, JackMidiBuffer* dst_buffer )
00390 {
00391 dst_buffer->magic = htonl(src_buffer->magic);
00392 dst_buffer->buffer_size = htonl(src_buffer->buffer_size);
00393 dst_buffer->nframes = htonl(src_buffer->nframes);
00394 dst_buffer->write_pos = htonl(src_buffer->write_pos);
00395 dst_buffer->event_count = htonl(src_buffer->event_count);
00396 dst_buffer->lost_events = htonl(src_buffer->lost_events);
00397 dst_buffer->mix_index = htonl(src_buffer->mix_index);
00398 }
00399
00400 SERVER_EXPORT void MidiBufferNToH ( JackMidiBuffer* src_buffer, JackMidiBuffer* dst_buffer )
00401 {
00402 dst_buffer->magic = ntohl(src_buffer->magic);
00403 dst_buffer->buffer_size = ntohl(src_buffer->buffer_size);
00404 dst_buffer->nframes = ntohl(src_buffer->nframes);
00405 dst_buffer->write_pos = ntohl(src_buffer->write_pos);
00406 dst_buffer->event_count = ntohl(src_buffer->event_count);
00407 dst_buffer->lost_events = ntohl(src_buffer->lost_events);
00408 dst_buffer->mix_index = ntohl(src_buffer->mix_index);
00409 }
00410
00411 SERVER_EXPORT void TransportDataHToN ( net_transport_data_t* src_params, net_transport_data_t* dst_params )
00412 {
00413 dst_params->fNewState = htonl(src_params->fNewState);
00414 dst_params->fTimebaseMaster = htonl(src_params->fTimebaseMaster);
00415 dst_params->fState = htonl(src_params->fState);
00416 dst_params->fPosition.unique_1 = htonll(src_params->fPosition.unique_1);
00417 dst_params->fPosition.usecs = htonl(src_params->fPosition.usecs);
00418 dst_params->fPosition.frame_rate = htonl(src_params->fPosition.frame_rate);
00419 dst_params->fPosition.frame = htonl(src_params->fPosition.frame);
00420 dst_params->fPosition.valid = (jack_position_bits_t)htonl((uint32_t)src_params->fPosition.valid);
00421 dst_params->fPosition.bar = htonl(src_params->fPosition.bar);
00422 dst_params->fPosition.beat = htonl(src_params->fPosition.beat);
00423 dst_params->fPosition.tick = htonl(src_params->fPosition.tick);
00424 dst_params->fPosition.bar_start_tick = htonll((uint64_t)src_params->fPosition.bar_start_tick);
00425 dst_params->fPosition.beats_per_bar = htonl((uint32_t)src_params->fPosition.beats_per_bar);
00426 dst_params->fPosition.beat_type = htonl((uint32_t)src_params->fPosition.beat_type);
00427 dst_params->fPosition.ticks_per_beat = htonll((uint64_t)src_params->fPosition.ticks_per_beat);
00428 dst_params->fPosition.beats_per_minute = htonll((uint64_t)src_params->fPosition.beats_per_minute);
00429 dst_params->fPosition.frame_time = htonll((uint64_t)src_params->fPosition.frame_time);
00430 dst_params->fPosition.next_time = htonll((uint64_t)src_params->fPosition.next_time);
00431 dst_params->fPosition.bbt_offset = htonl(src_params->fPosition.bbt_offset);
00432 dst_params->fPosition.audio_frames_per_video_frame = htonl((uint32_t)src_params->fPosition.audio_frames_per_video_frame);
00433 dst_params->fPosition.video_offset = htonl(src_params->fPosition.video_offset);
00434 dst_params->fPosition.unique_2 = htonll(src_params->fPosition.unique_2);
00435 }
00436
00437 SERVER_EXPORT void TransportDataNToH ( net_transport_data_t* src_params, net_transport_data_t* dst_params )
00438 {
00439 dst_params->fNewState = ntohl(src_params->fNewState);
00440 dst_params->fTimebaseMaster = ntohl(src_params->fTimebaseMaster);
00441 dst_params->fState = ntohl(src_params->fState);
00442 dst_params->fPosition.unique_1 = ntohll(src_params->fPosition.unique_1);
00443 dst_params->fPosition.usecs = ntohl(src_params->fPosition.usecs);
00444 dst_params->fPosition.frame_rate = ntohl(src_params->fPosition.frame_rate);
00445 dst_params->fPosition.frame = ntohl(src_params->fPosition.frame);
00446 dst_params->fPosition.valid = (jack_position_bits_t)ntohl((uint32_t)src_params->fPosition.valid);
00447 dst_params->fPosition.bar = ntohl(src_params->fPosition.bar);
00448 dst_params->fPosition.beat = ntohl(src_params->fPosition.beat);
00449 dst_params->fPosition.tick = ntohl(src_params->fPosition.tick);
00450 dst_params->fPosition.bar_start_tick = ntohll((uint64_t)src_params->fPosition.bar_start_tick);
00451 dst_params->fPosition.beats_per_bar = ntohl((uint32_t)src_params->fPosition.beats_per_bar);
00452 dst_params->fPosition.beat_type = ntohl((uint32_t)src_params->fPosition.beat_type);
00453 dst_params->fPosition.ticks_per_beat = ntohll((uint64_t)src_params->fPosition.ticks_per_beat);
00454 dst_params->fPosition.beats_per_minute = ntohll((uint64_t)src_params->fPosition.beats_per_minute);
00455 dst_params->fPosition.frame_time = ntohll((uint64_t)src_params->fPosition.frame_time);
00456 dst_params->fPosition.next_time = ntohll((uint64_t)src_params->fPosition.next_time);
00457 dst_params->fPosition.bbt_offset = ntohl(src_params->fPosition.bbt_offset);
00458 dst_params->fPosition.audio_frames_per_video_frame = ntohl((uint32_t)src_params->fPosition.audio_frames_per_video_frame);
00459 dst_params->fPosition.video_offset = ntohl(src_params->fPosition.video_offset);
00460 dst_params->fPosition.unique_2 = ntohll(src_params->fPosition.unique_2);
00461 }
00462
00463
00464
00465 SERVER_EXPORT int SocketAPIInit()
00466 {
00467 #ifdef WIN32
00468 WORD wVersionRequested = MAKEWORD ( 2, 2 );
00469 WSADATA wsaData;
00470
00471 if ( WSAStartup ( wVersionRequested, &wsaData ) != 0 )
00472 {
00473 jack_error ( "WSAStartup error : %s", strerror ( NET_ERROR_CODE ) );
00474 return -1;
00475 }
00476
00477 if ( LOBYTE ( wsaData.wVersion ) != 2 || HIBYTE ( wsaData.wVersion ) != 2 )
00478 {
00479 jack_error ( "Could not find a useable version of Winsock.dll\n" );
00480 WSACleanup();
00481 return -1;
00482 }
00483 #endif
00484 return 0;
00485 }
00486
00487 SERVER_EXPORT int SocketAPIEnd()
00488 {
00489 #ifdef WIN32
00490 return WSACleanup();
00491 #endif
00492 return 0;
00493 }
00494
00495 SERVER_EXPORT const char* GetTransportState ( int transport_state )
00496 {
00497 switch ( transport_state )
00498 {
00499 case JackTransportRolling:
00500 return "rolling";
00501 case JackTransportStarting:
00502 return "starting";
00503 case JackTransportStopped:
00504 return "stopped";
00505 case JackTransportNetStarting:
00506 return "netstarting";
00507 }
00508 return NULL;
00509 }
00510 }