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 copy_size = sizeof ( JackMidiBuffer ) + fPortBuffer[port_index]->event_count * sizeof ( JackMidiEvent );
00080 memcpy ( fBuffer + pos, fPortBuffer[port_index], copy_size );
00081 pos += copy_size;
00082 memcpy ( fBuffer + pos, fPortBuffer[port_index] + ( fPortBuffer[port_index]->buffer_size - fPortBuffer[port_index]->write_pos ),
00083 fPortBuffer[port_index]->write_pos );
00084 pos += fPortBuffer[port_index]->write_pos;
00085 }
00086 return pos;
00087 }
00088
00089 int NetMidiBuffer::RenderToJackPorts()
00090 {
00091 int pos = 0;
00092 int copy_size;
00093 for ( int port_index = 0; port_index < fNPorts; port_index++ )
00094 {
00095 copy_size = sizeof ( JackMidiBuffer ) + reinterpret_cast<JackMidiBuffer*> ( fBuffer + pos )->event_count * sizeof ( JackMidiEvent );
00096 memcpy ( fPortBuffer[port_index], fBuffer + pos, copy_size );
00097 pos += copy_size;
00098 memcpy ( fPortBuffer[port_index] + ( fPortBuffer[port_index]->buffer_size - fPortBuffer[port_index]->write_pos ),
00099 fBuffer + pos, fPortBuffer[port_index]->write_pos );
00100 pos += fPortBuffer[port_index]->write_pos;
00101 }
00102 return pos;
00103 }
00104
00105 int NetMidiBuffer::RenderFromNetwork ( int subcycle, size_t copy_size )
00106 {
00107 memcpy ( fBuffer + subcycle * fMaxPcktSize, fNetBuffer, copy_size );
00108 return copy_size;
00109 }
00110
00111 int NetMidiBuffer::RenderToNetwork ( int subcycle, size_t total_size )
00112 {
00113 int size = total_size - subcycle * fMaxPcktSize;
00114 int copy_size = ( size <= fMaxPcktSize ) ? size : fMaxPcktSize;
00115 memcpy ( fNetBuffer, fBuffer + subcycle * fMaxPcktSize, copy_size );
00116 return copy_size;
00117 }
00118
00119
00120
00121 NetAudioBuffer::NetAudioBuffer ( session_params_t* params, uint32_t nports, char* net_buffer )
00122 {
00123 fNPorts = nports;
00124 fPeriodSize = params->fPeriodSize;
00125 fSubPeriodSize = params->fFramesPerPacket;
00126 fSubPeriodBytesSize = fSubPeriodSize * sizeof ( sample_t );
00127 fPortBuffer = new sample_t* [fNPorts];
00128 for ( int port_index = 0; port_index < fNPorts; port_index++ )
00129 fPortBuffer[port_index] = NULL;
00130 fNetBuffer = net_buffer;
00131 }
00132
00133 NetAudioBuffer::~NetAudioBuffer()
00134 {
00135 delete[] fPortBuffer;
00136 }
00137
00138 size_t NetAudioBuffer::GetSize()
00139 {
00140 return fNPorts * fSubPeriodBytesSize;
00141 }
00142
00143 void NetAudioBuffer::SetBuffer ( int index, sample_t* buffer )
00144 {
00145 fPortBuffer[index] = buffer;
00146 }
00147
00148 sample_t* NetAudioBuffer::GetBuffer ( int index )
00149 {
00150 return fPortBuffer[index];
00151 }
00152
00153 void NetAudioBuffer::RenderFromJackPorts ( int subcycle )
00154 {
00155 for ( int port_index = 0; port_index < fNPorts; port_index++ )
00156 memcpy ( fNetBuffer + port_index * fSubPeriodBytesSize, fPortBuffer[port_index] + subcycle * fSubPeriodSize, fSubPeriodBytesSize );
00157 }
00158
00159 void NetAudioBuffer::RenderToJackPorts ( int subcycle )
00160 {
00161 for ( int port_index = 0; port_index < fNPorts; port_index++ )
00162 memcpy ( fPortBuffer[port_index] + subcycle * fSubPeriodSize, fNetBuffer + port_index * fSubPeriodBytesSize, fSubPeriodBytesSize );
00163 }
00164
00165
00166
00167 SERVER_EXPORT void SessionParamsHToN ( session_params_t* params )
00168 {
00169 params->fPacketID = htonl ( params->fPacketID );
00170 params->fMtu = htonl ( params->fMtu );
00171 params->fID = htonl ( params->fID );
00172 params->fTransportSync = htonl ( params->fTransportSync );
00173 params->fSendAudioChannels = htonl ( params->fSendAudioChannels );
00174 params->fReturnAudioChannels = htonl ( params->fReturnAudioChannels );
00175 params->fSendMidiChannels = htonl ( params->fSendMidiChannels );
00176 params->fReturnMidiChannels = htonl ( params->fReturnMidiChannels );
00177 params->fSampleRate = htonl ( params->fSampleRate );
00178 params->fPeriodSize = htonl ( params->fPeriodSize );
00179 params->fFramesPerPacket = htonl ( params->fFramesPerPacket );
00180 params->fBitdepth = htonl ( params->fBitdepth );
00181 params->fSlaveSyncMode = htonl ( params->fSlaveSyncMode );
00182 }
00183
00184 SERVER_EXPORT void SessionParamsNToH ( session_params_t* params )
00185 {
00186 params->fPacketID = ntohl ( params->fPacketID );
00187 params->fMtu = ntohl ( params->fMtu );
00188 params->fID = ntohl ( params->fID );
00189 params->fTransportSync = ntohl ( params->fTransportSync );
00190 params->fSendAudioChannels = ntohl ( params->fSendAudioChannels );
00191 params->fReturnAudioChannels = ntohl ( params->fReturnAudioChannels );
00192 params->fSendMidiChannels = ntohl ( params->fSendMidiChannels );
00193 params->fReturnMidiChannels = ntohl ( params->fReturnMidiChannels );
00194 params->fSampleRate = ntohl ( params->fSampleRate );
00195 params->fPeriodSize = ntohl ( params->fPeriodSize );
00196 params->fFramesPerPacket = ntohl ( params->fFramesPerPacket );
00197 params->fBitdepth = ntohl ( params->fBitdepth );
00198 params->fSlaveSyncMode = ntohl ( params->fSlaveSyncMode );
00199 }
00200
00201 SERVER_EXPORT void SessionParamsDisplay ( session_params_t* params )
00202 {
00203 char bitdepth[16];
00204 ( params->fBitdepth ) ? sprintf ( bitdepth, "%u", params->fBitdepth ) : sprintf ( bitdepth, "%s", "float" );
00205 char mode[8];
00206 switch ( params->fNetworkMode )
00207 {
00208 case 's' :
00209 strcpy ( mode, "slow" );
00210 break;
00211 case 'n' :
00212 strcpy ( mode, "normal" );
00213 break;
00214 case 'f' :
00215 strcpy ( mode, "fast" );
00216 break;
00217 }
00218 jack_info ( "**************** Network parameters ****************" );
00219 jack_info ( "Name : %s", params->fName );
00220 jack_info ( "Protocol revision : %c", params->fProtocolVersion );
00221 jack_info ( "MTU : %u", params->fMtu );
00222 jack_info ( "Master name : %s", params->fMasterNetName );
00223 jack_info ( "Slave name : %s", params->fSlaveNetName );
00224 jack_info ( "ID : %u", params->fID );
00225 jack_info ( "Transport Sync : %s", ( params->fTransportSync ) ? "yes" : "no" );
00226 jack_info ( "Send channels (audio - midi) : %d - %d", params->fSendAudioChannels, params->fSendMidiChannels );
00227 jack_info ( "Return channels (audio - midi) : %d - %d", params->fReturnAudioChannels, params->fReturnMidiChannels );
00228 jack_info ( "Sample rate : %u frames per second", params->fSampleRate );
00229 jack_info ( "Period size : %u frames per period", params->fPeriodSize );
00230 jack_info ( "Frames per packet : %u", params->fFramesPerPacket );
00231 jack_info ( "Packet per period : %u", params->fPeriodSize / params->fFramesPerPacket );
00232 jack_info ( "Bitdepth : %s", bitdepth );
00233 jack_info ( "Slave mode : %s", ( params->fSlaveSyncMode ) ? "sync" : "async" );
00234 jack_info ( "Network mode : %s", mode );
00235 jack_info ( "****************************************************" );
00236 }
00237
00238 SERVER_EXPORT sync_packet_type_t GetPacketType ( session_params_t* params )
00239 {
00240 switch ( params->fPacketID )
00241 {
00242 case 0:
00243 return SLAVE_AVAILABLE;
00244 case 1:
00245 return SLAVE_SETUP;
00246 case 2:
00247 return START_MASTER;
00248 case 3:
00249 return START_SLAVE;
00250 case 4:
00251 return KILL_MASTER;
00252 }
00253 return INVALID;
00254 }
00255
00256 SERVER_EXPORT int SetPacketType ( session_params_t* params, sync_packet_type_t packet_type )
00257 {
00258 switch ( packet_type )
00259 {
00260 case INVALID:
00261 return -1;
00262 case SLAVE_AVAILABLE:
00263 params->fPacketID = 0;
00264 break;
00265 case SLAVE_SETUP:
00266 params->fPacketID = 1;
00267 break;
00268 case START_MASTER:
00269 params->fPacketID = 2;
00270 break;
00271 case START_SLAVE:
00272 params->fPacketID = 3;
00273 break;
00274 case KILL_MASTER:
00275 params->fPacketID = 4;
00276 }
00277 return 0;
00278 }
00279
00280
00281
00282 SERVER_EXPORT void PacketHeaderHToN ( packet_header_t* header )
00283 {
00284 header->fID = htonl ( header->fID );
00285 header->fMidiDataSize = htonl ( header->fMidiDataSize );
00286 header->fBitdepth = htonl ( header->fBitdepth );
00287 header->fNMidiPckt = htonl ( header->fNMidiPckt );
00288 header->fPacketSize = htonl ( header->fPacketSize );
00289 header->fCycle = ntohl ( header->fCycle );
00290 header->fSubCycle = htonl ( header->fSubCycle );
00291 header->fIsLastPckt = htonl ( header->fIsLastPckt );
00292 }
00293
00294 SERVER_EXPORT void PacketHeaderNToH ( packet_header_t* header )
00295 {
00296 header->fID = ntohl ( header->fID );
00297 header->fMidiDataSize = ntohl ( header->fMidiDataSize );
00298 header->fBitdepth = ntohl ( header->fBitdepth );
00299 header->fNMidiPckt = ntohl ( header->fNMidiPckt );
00300 header->fPacketSize = ntohl ( header->fPacketSize );
00301 header->fCycle = ntohl ( header->fCycle );
00302 header->fSubCycle = ntohl ( header->fSubCycle );
00303 header->fIsLastPckt = ntohl ( header->fIsLastPckt );
00304 }
00305
00306 SERVER_EXPORT void PacketHeaderDisplay ( packet_header_t* header )
00307 {
00308 char bitdepth[16];
00309 ( header->fBitdepth ) ? sprintf ( bitdepth, "%u", header->fBitdepth ) : sprintf ( bitdepth, "%s", "float" );
00310 jack_info ( "********************Header********************" );
00311 jack_info ( "Data type : %c", header->fDataType );
00312 jack_info ( "Data stream : %c", header->fDataStream );
00313 jack_info ( "ID : %u", header->fID );
00314 jack_info ( "Cycle : %u", header->fCycle );
00315 jack_info ( "SubCycle : %u", header->fSubCycle );
00316 jack_info ( "Midi packets : %u", header->fNMidiPckt );
00317 jack_info ( "Midi data size : %u", header->fMidiDataSize );
00318 jack_info ( "Last packet : '%s'", ( header->fIsLastPckt ) ? "yes" : "no" );
00319 jack_info ( "Bitdepth : %s", bitdepth );
00320 jack_info ( "**********************************************" );
00321 }
00322
00323
00324
00325 SERVER_EXPORT int SocketAPIInit()
00326 {
00327 #ifdef WIN32
00328 WORD wVersionRequested = MAKEWORD ( 2, 2 );
00329 WSADATA wsaData;
00330
00331 if ( WSAStartup ( wVersionRequested, &wsaData ) != 0 )
00332 {
00333 jack_error ( "WSAStartup error : %s", strerror ( NET_ERROR_CODE ) );
00334 return -1;
00335 }
00336
00337 if ( LOBYTE ( wsaData.wVersion ) != 2 || HIBYTE ( wsaData.wVersion ) != 2 )
00338 {
00339 jack_error ( "Could not find a useable version of Winsock.dll\n" );
00340 WSACleanup();
00341 return -1;
00342 }
00343 #endif
00344 return 0;
00345 }
00346
00347 SERVER_EXPORT int SocketAPIEnd()
00348 {
00349 #ifdef WIN32
00350 return WSACleanup();
00351 #endif
00352 return 0;
00353 }
00354
00355 SERVER_EXPORT const char* GetTransportState ( int transport_state )
00356 {
00357 switch ( transport_state )
00358 {
00359 case JackTransportRolling :
00360 return "rolling";
00361 case JackTransportStarting :
00362 return "starting";
00363 case JackTransportStopped :
00364 return "stopped";
00365 case JackTransportNetStarting :
00366 return "netstarting";
00367 }
00368 return NULL;
00369 }
00370 }