Add sync packets in both NetDriver and NetManager - Sync packets will carry network sync, transport and other auxiliary data

git-svn-id: http://subversion.jackaudio.org/jack/jack2/trunk/jackmp@2709 0c269be4-1314-0410-8aa9-9f06e86f4224

common/JackNetDriver.cpp

@@ -43,7 +43,7 @@ namespace Jack
         fParams.fReturnMidiChannels = midi_output_ports;
         strcpy ( fParams.fName, net_name );
         fSocket.GetName ( fParams.fSlaveNetName );
-        fTransportSync = transport_sync;
+        fParams.fTransportSync = transport_sync;
     }
 
     JackNetDriver::~JackNetDriver()
@@ -102,7 +102,7 @@ namespace Jack
         fParams.fReturnAudioChannels = fPlaybackChannels;
 
         //is transport sync ?
-        if ( fTransportSync )
+        if ( fParams.fTransportSync )
             jack_info ( "NetDriver started with Master's Transport Sync." );
 
         //init loop : get a master and start, do it until connection is ok
@@ -290,6 +290,9 @@ namespace Jack
         fAudioTxLen = sizeof ( packet_header_t ) + fNetAudioPlaybackBuffer->GetSize();
         fAudioRxLen = sizeof ( packet_header_t ) + fNetAudioCaptureBuffer->GetSize();
 
+		//payload size
+        fPayloadSize = fParams.fMtu - sizeof ( packet_header_t );
+
         return 0;
     }
 
@@ -403,6 +406,18 @@ namespace Jack
         return static_cast<JackMidiBuffer*> ( fGraphManager->GetBuffer ( fMidiPlaybackPortList[port_index], fEngineControl->fBufferSize ) );
     }
 
+    int JackNetDriver::SetSyncPacket()
+    {
+        if ( fParams.fTransportSync )
+        {
+            //set the TransportData
+
+            //copy to TxBuffer
+            memcpy ( fTxData, &fTransportData, sizeof ( net_transport_data_t ) );
+        }
+        return 0;
+    }
+
     int JackNetDriver::Recv ( size_t size, int flags )
     {
         int rx_bytes;
@@ -434,9 +449,7 @@ namespace Jack
         {
             net_error_t error = fSocket.GetError();
             if ( error == NET_CONN_ERROR )
-            {
                 throw JackDriverException ( "Connection lost." );
-            }
             else
                 jack_error ( "Error in send : %s", StrError ( NET_ERROR_CODE ) );
         }
@@ -463,12 +476,13 @@ namespace Jack
         //receive sync (launch the cycle)
         do
         {
-            rx_bytes = Recv ( sizeof ( packet_header_t ), 0 );
+            rx_bytes = Recv ( fParams.fMtu, 0 );
             if ( ( rx_bytes == 0 ) || ( rx_bytes == SOCKET_ERROR ) )
                 return rx_bytes;
         }
         while ( !rx_bytes && ( rx_head->fDataType != 's' ) );
 
+        //take the time at the beginning of the cycle
         JackDriver::CycleTakeBeginTime();
 
         //audio, midi or sync if driver is late
@@ -476,8 +490,7 @@ namespace Jack
         {
             do
             {
-                rx_bytes = Recv ( fParams.fMtu, MSG_PEEK );
-                if ( rx_bytes < 1 )
+                if ( ( rx_bytes = Recv ( fParams.fMtu, MSG_PEEK ) ) == SOCKET_ERROR )
                     return rx_bytes;
                 if ( rx_bytes && ( rx_head->fDataStream == 's' ) && ( rx_head->fID == fParams.fID ) )
                 {
@@ -527,6 +540,14 @@ namespace Jack
         for ( audio_port_index = 0; audio_port_index < fPlaybackChannels; audio_port_index++ )
             fNetAudioPlaybackBuffer->SetBuffer(audio_port_index, GetOutputBuffer ( audio_port_index ));
 
+        //sync
+        fTxHeader.fDataType = 's';
+        if ( !fParams.fSendMidiChannels && !fParams.fSendAudioChannels )
+            fTxHeader.fIsLastPckt = 'y';
+        memset ( fTxData, 0, fPayloadSize );
+        SetSyncPacket();
+        tx_bytes = Send ( fParams.fMtu, 0 );
+
         //midi
         if ( fParams.fReturnMidiChannels )
         {

common/JackNetDriver.h

@@ -33,26 +33,32 @@ namespace Jack
         char* fMulticastIP;
         JackNetSocket fSocket;
         uint fNSubProcess;
-        uint fTransportSync;
+        net_transport_data_t fTransportData;
 
+		//jack ports
         jack_port_id_t* fMidiCapturePortList;
         jack_port_id_t* fMidiPlaybackPortList;
 
+		//headers
         packet_header_t fTxHeader;
         packet_header_t fRxHeader;
 
+		//network buffers
         char* fTxBuffer;
         char* fRxBuffer;
         char* fTxData;
         char* fRxData;
 
+		//jack buffers
         NetMidiBuffer* fNetMidiCaptureBuffer;
         NetMidiBuffer* fNetMidiPlaybackBuffer;
         NetAudioBuffer* fNetAudioCaptureBuffer;
         NetAudioBuffer* fNetAudioPlaybackBuffer;
 
+		//sizes
         int fAudioRxLen;
         int fAudioTxLen;
+        int fPayloadSize;
 
         bool Init();
         net_status_t GetNetMaster();
@@ -68,6 +74,9 @@ namespace Jack
         int Recv ( size_t size, int flags );
         int Send ( size_t size, int flags );
 
+		int SetSyncPacket();
+        int TransportSync();
+
     public:
         JackNetDriver ( const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table,
                         const char* ip, int port, int mtu, int midi_input_ports, int midi_output_ports, const char* master_name, uint transport_sync );

common/JackNetManager.cpp

@@ -18,9 +18,6 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
 #include "JackNetManager.h"
-#include "JackError.h"
-#include "JackExports.h"
-#include "driver_interface.h"
 
 #define DEFAULT_MULTICAST_IP "225.3.19.154"
 #define DEFAULT_PORT 19000
@@ -43,6 +40,7 @@ namespace Jack
         fNetJumpCnt = 0;
         fJackClient = NULL;
         fRunning = false;
+        fSyncState = 1;
         uint port_index;
 
         //jack audio ports
@@ -97,6 +95,9 @@ namespace Jack
         //audio netbuffer length
         fAudioTxLen = sizeof ( packet_header_t ) + fNetAudioCaptureBuffer->GetSize();
         fAudioRxLen = sizeof ( packet_header_t ) + fNetAudioPlaybackBuffer->GetSize();
+
+        //payload size
+        fPayloadSize = fParams.fMtu - sizeof ( packet_header_t );
     }
 
     JackNetMaster::~JackNetMaster()
@@ -197,7 +198,7 @@ namespace Jack
             sprintf ( name, "to_slave_%d", i+1 );
             if ( ( fAudioCapturePorts[i] = jack_port_register ( fJackClient, name, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0 ) ) == NULL )
                 goto fail;
-			jack_port_set_latency ( fAudioCapturePorts[i], port_latency );
+            jack_port_set_latency ( fAudioCapturePorts[i], port_latency );
         }
         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;
         for ( i = 0; i < fParams.fReturnAudioChannels; i++ )
@@ -205,7 +206,7 @@ namespace Jack
             sprintf ( name, "from_slave_%d", i+1 );
             if ( ( fAudioPlaybackPorts[i] = jack_port_register ( fJackClient, name, JACK_DEFAULT_AUDIO_TYPE, port_flags, 0 ) ) == NULL )
                 goto fail;
-			jack_port_set_latency ( fAudioPlaybackPorts[i], port_latency );
+            jack_port_set_latency ( fAudioPlaybackPorts[i], port_latency );
         }
         //midi
         port_flags = JackPortIsInput | JackPortIsPhysical | JackPortIsTerminal;
@@ -214,7 +215,7 @@ namespace Jack
             sprintf ( name, "midi_to_slave_%d", i+1 );
             if ( ( fMidiCapturePorts[i] = jack_port_register ( fJackClient, name, JACK_DEFAULT_MIDI_TYPE, port_flags, 0 ) ) == NULL )
                 goto fail;
-			jack_port_set_latency ( fMidiCapturePorts[i], port_latency );
+            jack_port_set_latency ( fMidiCapturePorts[i], port_latency );
         }
         port_flags = JackPortIsOutput | JackPortIsPhysical | JackPortIsTerminal;
         for ( i = 0; i < fParams.fReturnMidiChannels; i++ )
@@ -222,7 +223,7 @@ namespace Jack
             sprintf ( name, "midi_from_slave_%d", i+1 );
             if ( ( fMidiPlaybackPorts[i] = jack_port_register ( fJackClient, name, JACK_DEFAULT_MIDI_TYPE, port_flags, 0 ) ) == NULL )
                 goto fail;
-			jack_port_set_latency ( fMidiPlaybackPorts[i], port_latency );
+            jack_port_set_latency ( fMidiPlaybackPorts[i], port_latency );
         }
 
         fRunning = true;
@@ -279,6 +280,18 @@ fail:
         mcast_socket.Close();
     }
 
+    int JackNetMaster::SetSyncPacket()
+    {
+        if ( fParams.fTransportSync )
+        {
+            //set the TransportData
+
+            //copy to TxBuffer
+            memcpy ( fTxData, &fTransportData, sizeof ( net_transport_data_t ) );
+        }
+        return 0;
+    }
+
     int JackNetMaster::Send ( char* buffer, size_t size, int flags )
     {
         int tx_bytes;
@@ -308,7 +321,7 @@ fail:
             if ( error == NET_NO_DATA )
             {
                 //too much receive failure, react...
-                if ( ++fNetJumpCnt == 100 )
+                if ( ++fNetJumpCnt == 50 )
                 {
                     jack_error ( "Connection lost, is %s still running ?", fParams.fName );
                     fNetJumpCnt = 0;
@@ -351,23 +364,25 @@ fail:
         uint port_index;
         for ( port_index = 0; port_index < fParams.fSendMidiChannels; port_index++ )
             fNetMidiCaptureBuffer->SetBuffer(port_index,
-                static_cast<JackMidiBuffer*> ( jack_port_get_buffer ( fMidiCapturePorts[port_index], fParams.fPeriodSize )));
+                                             static_cast<JackMidiBuffer*> ( jack_port_get_buffer ( fMidiCapturePorts[port_index], fParams.fPeriodSize )));
         for ( port_index = 0; port_index < fParams.fSendAudioChannels; port_index++ )
             fNetAudioCaptureBuffer->SetBuffer(port_index,
-                static_cast<sample_t*> ( jack_port_get_buffer ( fAudioCapturePorts[port_index], fParams.fPeriodSize )));
+                                              static_cast<sample_t*> ( jack_port_get_buffer ( fAudioCapturePorts[port_index], fParams.fPeriodSize )));
         for ( port_index = 0; port_index < fParams.fReturnMidiChannels; port_index++ )
             fNetMidiPlaybackBuffer->SetBuffer(port_index,
-                static_cast<JackMidiBuffer*> ( jack_port_get_buffer ( fMidiPlaybackPorts[port_index], fParams.fPeriodSize )));
+                                              static_cast<JackMidiBuffer*> ( jack_port_get_buffer ( fMidiPlaybackPorts[port_index], fParams.fPeriodSize )));
         for ( port_index = 0; port_index < fParams.fReturnAudioChannels; port_index++ )
             fNetAudioPlaybackBuffer->SetBuffer(port_index,
-                static_cast<sample_t*> ( jack_port_get_buffer ( fAudioPlaybackPorts[port_index], fParams.fPeriodSize )));
+                                               static_cast<sample_t*> ( jack_port_get_buffer ( fAudioPlaybackPorts[port_index], fParams.fPeriodSize )));
 
         //send ------------------------------------------------------------------------------------------------------------------
         //sync
         fTxHeader.fDataType = 's';
         if ( !fParams.fSendMidiChannels && !fParams.fSendAudioChannels )
             fTxHeader.fIsLastPckt = 'y';
-        tx_bytes = Send ( reinterpret_cast<char*> ( &fTxHeader ), sizeof ( packet_header_t ), 0 );
+        memset ( fTxData, 0, fPayloadSize );
+        SetSyncPacket();
+        tx_bytes = Send ( fTxBuffer, fParams.fMtu, 0 );
         if ( ( tx_bytes == 0 ) || ( tx_bytes == SOCKET_ERROR ) )
             return tx_bytes;
 
@@ -408,12 +423,25 @@ fail:
         }
 
         //receive ( if there is stg to receive...)-------------------------------------------------------------------------------------
+        //sync
+        if ( fParams.fTransportSync )
+        {
+            do
+            {
+                rx_bytes = Recv ( fParams.fMtu, 0 );
+                if ( ( rx_bytes == 0 ) || ( rx_bytes == SOCKET_ERROR ) )
+                    return rx_bytes;
+            }
+            while ( !rx_bytes && ( rx_head->fDataType != 's' ) );
+            //then update fSyncState from received sync packet
+        }
+
+
         if ( fParams.fReturnMidiChannels || fParams.fReturnAudioChannels )
         {
             do
             {
-                rx_bytes = Recv ( fParams.fMtu, MSG_PEEK );
-                if ( rx_bytes < 1 )
+                if ( ( rx_bytes = Recv ( fParams.fMtu, MSG_PEEK ) ) == SOCKET_ERROR )
                     return rx_bytes;
                 if ( rx_bytes && ( rx_head->fDataStream == 'r' ) && ( rx_head->fID == fParams.fID ) )
                 {
@@ -437,6 +465,10 @@ fail:
                         fNetAudioPlaybackBuffer->RenderToJackPorts ( rx_head->fSubCycle );
                         fNetJumpCnt = 0;
                         break;
+                    case 's':	//sync
+                        jack_error ( "NetMaster receive sync packets instead of data." );
+                        fRxHeader.fCycle = rx_head->fCycle;
+                        return 0;
                     }
                 }
             }
@@ -472,11 +504,12 @@ fail:
             }
         }
 
-		jack_set_sync_callback ( fManagerClient, SetSyncCallback, this );
+        //set sync callback
+        jack_set_sync_callback ( fManagerClient, SetSyncCallback, this );
 
-        //activate the client
+        //activate the client (for sync callback)
         if ( jack_activate ( fManagerClient ) != 0 )
-			jack_error ( "Can't activate the network manager client, transport disables." );
+            jack_error ( "Can't activate the network manager client, transport disabled." );
 
         //launch the manager thread
         if ( jack_client_create_thread ( fManagerClient, &fManagerThread, 0, 0, NetManagerThread, this ) )
@@ -496,9 +529,19 @@ fail:
 
     int JackNetMasterManager::SetSyncCallback ( jack_transport_state_t state, jack_position_t* pos, void* arg )
     {
-    	JackNetMasterManager* master_manager = static_cast<JackNetMasterManager*>(arg);
-    	master_manager->SyncCallback ( state, pos );
-		return 1;
+        JackNetMasterManager* master_manager = static_cast<JackNetMasterManager*>(arg);
+        return master_manager->SyncCallback ( state, pos );
+    }
+
+    int JackNetMasterManager::SyncCallback ( jack_transport_state_t state, jack_position_t* pos )
+    {
+        //check sync state for every master in the list
+        int ret = 1;
+        master_list_it_t it;
+        for ( it = fMasterList.begin(); it != fMasterList.end(); it++ )
+            if ( ( *it )->fSyncState == 0 )
+                ret = 0;
+        jack_log ( "JackNetMasterManager::SyncCallback returns '%s'", ( ret ) ? "true" : "false" );
     }
 
     void* JackNetMasterManager::NetManagerThread ( void* arg )
@@ -510,12 +553,6 @@ fail:
         return NULL;
     }
 
-	int JackNetMasterManager::SyncCallback ( jack_transport_state_t state, jack_position_t* pos )
-	{
-		jack_log ( "JackNetMasterManager::SyncCallback" );
-		return 0;
-	}
-
     void JackNetMasterManager::Run()
     {
         jack_log ( "JackNetMasterManager::Run" );

common/JackNetManager.h

@@ -43,34 +43,47 @@ namespace Jack
         int fNetJumpCnt;
         bool fRunning;
 
+		//jack client
         jack_client_t* fJackClient;
         const char* fClientName;
 
+		//jack ports
         jack_port_t** fAudioCapturePorts;
         jack_port_t** fAudioPlaybackPorts;
         jack_port_t** fMidiCapturePorts;
         jack_port_t** fMidiPlaybackPorts;
 
+		//sync and transport
+        int fSyncState;
+        net_transport_data_t fTransportData;
+
+		//network headers
         packet_header_t fTxHeader;
         packet_header_t fRxHeader;
 
+		//network buffers
         char* fTxBuffer;
         char* fRxBuffer;
         char* fTxData;
         char* fRxData;
 
+		//jack buffers
         NetAudioBuffer* fNetAudioCaptureBuffer;
         NetAudioBuffer* fNetAudioPlaybackBuffer;
         NetMidiBuffer* fNetMidiCaptureBuffer;
         NetMidiBuffer* fNetMidiPlaybackBuffer;
 
+		//sizes
         int fAudioTxLen;
         int fAudioRxLen;
+        int fPayloadSize;
 
         bool Init();
         void FreePorts();
         void Exit();
 
+		int SetSyncPacket();
+
         int Send ( char* buffer, size_t size, int flags );
         int Recv ( size_t size, int flags );
         int Process();
@@ -86,7 +99,7 @@ namespace Jack
     {
         friend class JackNetMaster;
     private:
-		static int SetSyncCallback ( jack_transport_state_t state, jack_position_t* pos, void* arg );
+        static int SetSyncCallback ( jack_transport_state_t state, jack_position_t* pos, void* arg );
         static void* NetManagerThread ( void* arg );
 
         jack_client_t* fManagerClient;

common/JackNetSocket.h

@@ -28,9 +28,9 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #include <errno.h>
 
 namespace Jack
-{
-	//get host name*********************************	
-	EXPORT int GetHostName ( char * name, int size );
+{
+	//get host name*********************************
+	EXPORT int GetHostName ( char * name, int size );
 
 	//net errors ***********************************
 	enum _net_error
@@ -38,6 +38,7 @@ namespace Jack
 		NET_CONN_ERROR = 10000,
 		NET_OP_ERROR,
 		NET_NO_DATA,
+		NET_NO_NETWORK,
 		NET_NO_ERROR
 	};
 

common/JackNetTool.cpp

@@ -47,7 +47,7 @@ namespace Jack
     {
         return fMaxBufsize;
     }
-    
+
     void NetMidiBuffer::SetBuffer(int index, JackMidiBuffer* buffer)
     {
         fPortBuffer[index] = buffer;
@@ -134,7 +134,7 @@ namespace Jack
     {
         return fNPorts * fSubPeriodBytesSize;
     }
-    
+
     void NetAudioBuffer::SetBuffer(int index, sample_t* buffer)
     {
         fPortBuffer[index] = buffer;
@@ -159,6 +159,7 @@ namespace Jack
         params->fPacketID = htonl ( params->fPacketID );
         params->fMtu = htonl ( params->fMtu );
         params->fID = htonl ( params->fID );
+        params->fTransportSync = htonl ( params->fTransportSync );
         params->fSendAudioChannels = htonl ( params->fSendAudioChannels );
         params->fReturnAudioChannels = htonl ( params->fReturnAudioChannels );
         params->fSendMidiChannels = htonl ( params->fSendMidiChannels );
@@ -174,6 +175,7 @@ namespace Jack
         params->fPacketID = ntohl ( params->fPacketID );
         params->fMtu = ntohl ( params->fMtu );
         params->fID = ntohl ( params->fID );
+        params->fTransportSync = ntohl ( params->fTransportSync );
         params->fSendAudioChannels = ntohl ( params->fSendAudioChannels );
         params->fReturnAudioChannels = ntohl ( params->fReturnAudioChannels );
         params->fSendMidiChannels = ntohl ( params->fSendMidiChannels );
@@ -186,21 +188,24 @@ namespace Jack
 
     EXPORT void SessionParamsDisplay ( session_params_t* params )
     {
-        jack_info ( "---->Network parameters of '%s'<----", params->fName );
+    	char bitdepth[16];
+    	( params->fBitdepth ) ? sprintf ( bitdepth, "%u", params->fBitdepth ) : sprintf ( bitdepth, "%s", "float" );
+        jack_info ( "**************** Network parameters ****************" );
+        jack_info ( "Name : %s", params->fName );
         jack_info ( "Protocol revision : %c", params->fProtocolVersion );
         jack_info ( "MTU : %u", params->fMtu );
         jack_info ( "Master name : %s", params->fMasterNetName );
         jack_info ( "Slave name : %s", params->fSlaveNetName );
         jack_info ( "ID : %u", params->fID );
+        jack_info ( "Transport Sync : %s", (params->fTransportSync) ? "yes" : "no" );
         jack_info ( "Send channels (audio - midi) : %d - %d", params->fSendAudioChannels, params->fSendMidiChannels );
         jack_info ( "Return channels (audio - midi) : %d - %d", params->fReturnAudioChannels, params->fReturnMidiChannels );
         jack_info ( "Sample rate : %u frames per second", params->fSampleRate );
         jack_info ( "Period size : %u frames per period", params->fPeriodSize );
         jack_info ( "Frames per packet : %u", params->fFramesPerPacket );
         jack_info ( "Packet per period : %u", params->fPeriodSize / params->fFramesPerPacket );
-        jack_info ( "Bitdepth (0 for float) : %u", params->fBitdepth );
-        jack_info ( "Name : %s", params->fName );
-        jack_info ( "---------------------------------------------" );
+        jack_info ( "Bitdepth : %s", bitdepth );
+        jack_info ( "****************************************************" );
     }
 
     EXPORT sync_packet_type_t GetPacketType ( session_params_t* params )
@@ -269,6 +274,8 @@ namespace Jack
 
     EXPORT void PacketHeaderDisplay ( packet_header_t* header )
     {
+    	char bitdepth[16];
+    	( header->fBitdepth ) ? sprintf ( bitdepth, "%u", header->fBitdepth ) : sprintf ( bitdepth, "%s", "float" );
         jack_info ( "********************Header********************" );
         jack_info ( "Data type : %c", header->fDataType );
         jack_info ( "Data stream : %c", header->fDataStream );
@@ -278,7 +285,7 @@ namespace Jack
         jack_info ( "Midi packets : %u", header->fNMidiPckt );
         jack_info ( "Midi data size : %u", header->fMidiDataSize );
         jack_info ( "Last packet : '%c'", header->fIsLastPckt );
-        jack_info ( "Bitdepth : %u (0 for float)", header->fBitdepth );
+        jack_info ( "Bitdepth : %s", bitdepth );
         jack_info ( "**********************************************" );
     }
 

common/JackNetTool.h

@@ -33,6 +33,7 @@ namespace Jack
 {
     typedef struct _session_params session_params_t;
     typedef struct _packet_header packet_header_t;
+    typedef struct _net_transport_data net_transport_data_t;
     typedef struct sockaddr socket_address_t;
     typedef struct in_addr address_t;
     typedef jack_default_audio_sample_t sample_t;
@@ -41,21 +42,22 @@ namespace Jack
 
     struct _session_params
     {
-        char fPacketType[7];		//packet type ('param')
-        char fProtocolVersion;		//version
-        uint32_t fPacketID;			//indicates the packet type
-        char fMasterNetName[256];	//master hostname (network)
-        char fSlaveNetName[256];	//slave hostname (network)
-        uint32_t fMtu;				//connection mtu
-        uint32_t fID;				//slave's ID
-        uint32_t fSendAudioChannels;	//number of master->slave channels
-        uint32_t fReturnAudioChannels;	//number of slave->master channels
-        uint32_t fSendMidiChannels;		//number of master->slave midi channels
-        uint32_t fReturnMidiChannels;	//number of slave->master midi channels
-        uint32_t fSampleRate;			//session sample rate
-        uint32_t fPeriodSize;			//period size
-        uint32_t fFramesPerPacket;		//complete frames per packet
-        uint32_t fBitdepth;             //samples bitdepth (unused)
+        char fPacketType[7];				//packet type ('param')
+        char fProtocolVersion;				//version
+        uint32_t fPacketID;					//indicates the packet type
+        char fMasterNetName[256];			//master hostname (network)
+        char fSlaveNetName[256];			//slave hostname (network)
+        uint32_t fMtu;						//connection mtu
+        uint32_t fID;						//slave's ID
+        uint32_t fTransportSync;			//is the transport synced ?
+        uint32_t fSendAudioChannels;		//number of master->slave channels
+        uint32_t fReturnAudioChannels;		//number of slave->master channels
+        uint32_t fSendMidiChannels;			//number of master->slave midi channels
+        uint32_t fReturnMidiChannels;		//number of slave->master midi channels
+        uint32_t fSampleRate;				//session sample rate
+        uint32_t fPeriodSize;				//period size
+        uint32_t fFramesPerPacket;			//complete frames per packet
+        uint32_t fBitdepth;             	//samples bitdepth (unused)
         char fName[JACK_CLIENT_NAME_SIZE];	//slave's name
     };
 
@@ -95,18 +97,27 @@ namespace Jack
     struct _packet_header
     {
         char fPacketType[7];		//packet type ( 'headr' )
-        char fDataType;			//a for audio, m for midi
-        char fDataStream;		//s for send, r for return
-        uint32_t fID;			//to identify the slave
-        uint32_t fBitdepth;		//bitdepth of the data samples
+        char fDataType;				//a for audio, m for midi
+        char fDataStream;			//s for send, r for return
+        uint32_t fID;				//to identify the slave
+        uint32_t fBitdepth;			//bitdepth of the data samples
         uint32_t fMidiDataSize;		//size of midi data (if packet is 'midi typed') in bytes
         uint32_t fNMidiPckt;		//number of midi packets of the cycle
-        uint32_t fCycle;		//process cycle counter
-        uint32_t fSubCycle;		//midi/audio subcycle counter
-        char fIsLastPckt;		//is it the last packet of a given cycle ('y' or 'n')
-        char fFree[13];             	//unused
+        uint32_t fCycle;			//process cycle counter
+        uint32_t fSubCycle;			//midi/audio subcycle counter
+        char fIsLastPckt;			//is it the last packet of a given cycle ('y' or 'n')
+        char fFree[13];             //unused
     };
 
+//transport data ******************************************************************************
+
+	struct _net_transport_data
+	{
+		char fTransportType[10];				//test value ('transport')
+		jack_position_t fCurPos;
+		jack_transport_state_t fCurState;
+	};
+
 //midi data ***********************************************************************************
 
     class EXPORT NetMidiBuffer
@@ -115,7 +126,6 @@ namespace Jack
         int fNPorts;
         size_t fMaxBufsize;
         int fMaxPcktSize;
-        //data
         char* fBuffer;
         char* fNetBuffer;
         JackMidiBuffer** fPortBuffer;
@@ -135,7 +145,7 @@ namespace Jack
         int RenderFromNetwork ( int subcycle, size_t copy_size );
         int RenderToNetwork ( int subcycle, size_t total_size );
 
-         void SetBuffer(int index, JackMidiBuffer* buffer);
+		void SetBuffer(int index, JackMidiBuffer* buffer);
     };
 
 // audio data *********************************************************************************