/ - Diff - BeagleRTClockSync - Sound Software .ac.uk

     	((myClock_t*)((char*)buffer+sizeof(int)))[0]=timestamp;
+    }
     void ClockSync::print(){
     	 printf("type: %d, timestamp: %lld\n",*((int*)buffer),*((myClock_t*)(((int*)buffer)+1)));
     	 //printf("type: %d, timestamp: %lld\n",*((int*)buffer),*((myClock_t*)(((int*)buffer)+1)));
+    }
     void ClockSync::setPort(int aPort){
     	if(aPort>0){
-...
     		int outPort=isSlave() ? aPort+1: aPort;
     		server.bindToPort(inPort);
     		client.setPort(outPort);
     		printf("Receiving on port %d\n", inPort);
     		printf("Sending to port %d\n", outPort);
     		//printf("Receiving on port %d\n", inPort);
     		//printf("Sending to port %d\n", outPort);
+    	}
+    }
     /**
-...
     	ret=server.read(buffer, bufferLength, false);
     	myClock_t timestamp=(myClock_t)virtualClock->getNow();
     	if(timestamp==0){
     		printf("The virtualClock period is <=0\n");
     		//printf("The virtualClock period is <=0\n");
     		return -3;
+    	}
     	if(ret==-1){
-...
     		return -1;
+    	}
     	if(ret!=bufferLength){
     		printf("Received a clockSync of the wrong size: %d\n", ret);
     		//printf("Received a clockSync of the wrong size: %d\n", ret);
     		return -2;
+    	}
     	//  print();
-...
     int ClockSync::masterSendSync(){
     	//let's send a sync clockSync!
     	printf("Sending a sync clockSync\n");
     	//printf("Sending a sync clockSync\n");
     	setType(kSync);
     	setTimestamp(-1);//do not care about sending the timestamp, a more accurate one will be sent in the follow up
     	localTimestamp=send();
     	if(localTimestamp<0){
     		printf("Could not send sync clockSync\n");
     		//printf("Could not send sync clockSync\n");
     		return -1; //error, don't retry, start over
+    	}
     	//let's send a followUp
     	printf("sent a sync clockSync\n");
     	//printf("sent a sync clockSync\n");
     	setType(kFollowUp);
     	setTimestamp(localTimestamp);
     	if(localTimestamp<0){
     		printf("Could not send followup clockSync\n");
     		//printf("Could not send followup clockSync\n");
     		return -2; //error, don't retry, start over
+    	}
     	int ret=send();
     	if(ret<0){
     		printf("Error while sending followup\n");
     		//printf("Error while sending followup\n");
     		return -3;
+    	}
     	printf("sent a followUp clockSync\n");
     	//printf("sent a followUp clockSync\n");
     	expectedClockSyncType=kDelayReq;
     	return 1;
+    }
     #ifdef USE_JUCE
     #define NOTGSHOULDSTOP 1
     #else
     extern bool gShouldStop;
     #define NOTGSHOULDSTOP (!gShouldStop)
     #endif /* USE_JUCE */
     int ClockSync::receiveLoop(){
     	int receiveLoopElapsed=0;
     	while(isSlave() || (receiveLoopElapsed<receiveLoopTimeout)){ //when slave, does not timeout!
     	while( NOTGSHOULDSTOP && (isSlave() || (receiveLoopElapsed<receiveLoopTimeout))){ //when slave, does not timeout!
     		receiveLoopElapsed+=receiveLoopSleepUs;
     		usleep(receiveLoopSleepUs); //how often to check for new clockSyncs;
     		//   printf("waiting for clockSyncs\n");
     		//   //printf("waiting for clockSyncs\n");
     		localTimestamp=receive();
     		if(localTimestamp<=0){
     			if(localTimestamp==0){
     				//  printf("Socket not ready to be read: %lld\n", localTimestamp);
     				//  //printf("Socket not ready to be read: %lld\n", localTimestamp);
+    			}
     			else if(localTimestamp==-1)
     				printf("Error while receiving: %lld\n", localTimestamp);
     			else if(localTimestamp==-1){
     				//printf("Error while receiving: %lld\n", localTimestamp);
+    			}
     			else if(localTimestamp==-2){
     				//  printf("Wrong size of the received clockSync: %lld\n", localTimestamp);
     				//  //printf("Wrong size of the received clockSync: %lld\n", localTimestamp);
+    			}
     			continue ; //keep waiting
+    		}
     		clockSyncType=getType();
     		clockSyncTimestamp=getTimestamp();
     		if(clockSyncType!=expectedClockSyncType){
     			printf("Wrong clockSync type: %d, expected: %d\n",clockSyncType, expectedClockSyncType);
     			//printf("Wrong clockSync type: %d, expected: %d\n",clockSyncType, expectedClockSyncType);
     			return -2; //start over
+    		}
     		printf("Received clockSync type: %d, clockSyncTimestamp: %lld\n", clockSyncType, clockSyncTimestamp);
     		//printf("Received clockSync type: %d, clockSyncTimestamp: %lld\n", clockSyncType, clockSyncTimestamp);
     		if(isSlave()==true){
     			int ret=slaveHandleMessage();
     			if(ret==1 && clockSyncType==kDelayResp){ //we are done, end of a cycle!
-...
+    			}
+    		}
+    	}
     	printf("Receive loop timeout\n");
     	//printf("Receive loop timeout\n");
     	return -1;
+    }
-...
     			setTimestamp(-1);
     			T2=send();
     			if(T2<0){
     				printf("Error while sending delayReq\n");
     				//printf("Error while sending delayReq\n");
     				return -1;
+    			}
     			expectedClockSyncType=kDelayResp;
-...
     			break;
+    		}
     		default:
     			printf("Unexpected message type\n"); // we should never get here
     			//printf("Unexpected message type\n"); // we should never get here
     			return -1;
+    	}
     	return 1;
-...
     int ClockSync::sendReceiveLoop(){
     	if(isSlave()==true){
     		 printf("Waiting for a sync clockSync\n");
     		 //printf("Waiting for a sync clockSync\n");
     	} else { //if this is master
     		usleep(1000000); //this times (roughly) how often sync clockSyncs are being sent.
     		usleep(100000); //this times (roughly) how often sync clockSyncs are being sent.
     		int ret=masterSendSync();
     		if(ret<=0)
     			return -1;

     #include "ClockSyncThread.h"
     #ifdef USE_JUCE
     #else //declare static members TODO: rather refactor this similar to other threads so that only run and clockSyncTask are static
     	myClock_t ClockSyncThread::lastTime; // Used for clock synchronization
     	bool ClockSyncThread::listening;
     	ClockSync ClockSyncThread::clockSync;
     	VirtualClock* ClockSyncThread::virtualClock;
     	bool ClockSyncThread::threadIsExiting;
     	AuxiliaryTask ClockSyncThread::clockSyncTask;
     #endif
     #ifdef USE_JUCE
     ClockSyncThread::ClockSyncThread(const String &threadName) :
     			Thread(threadName)
-...
     	stopThread();
     #endif /* USE_JUCE */
+    }
     void ClockSyncThread::init(int aPort, int aBlockSize, VirtualClock &aVirtualClock){
     void ClockSyncThread::init(bool isSlave, int aPort, VirtualClock &aVirtualClock){
     	setVirtualClock(aVirtualClock);
     	listening=false;
     	clockSync.init(false, aPort, *virtualClock);
     	clockSync.init(isSlave, aPort, *virtualClock);
     #ifdef USE_JUCE
     	startThread(5);
     #else
     	threadIsExiting=false;
     	clockSyncTask=BeagleRT_createAuxiliaryTask(&ClockSyncThread::run,98, "clockSyncTask");
     	//TODO: the thread cannot be started here at the moment because init() is called in setup(), where tasks cannot be scheduled
     #endif /* USE_JUCE */
+    }
-...
     #ifdef USE_JUCE
     #else
     void ClockSyncThread::startThread(){
     	BeagleRT_scheduleAuxiliaryTask(receiveDataTask);
     	printf("starting\n");
     	BeagleRT_scheduleAuxiliaryTask(clockSyncTask);
     	printf("started\n");
+    }
     void ClockSyncThread::stopThread(){
     	threadIsExiting=true;
-...
     void ClockSyncThread::run(){
     	while(!threadShouldExit()){
     		//  usleep(100000);
     		clockSync.sendReceiveLoop();
     		double now=virtualClock->getNow();
     		//  printf("now: %f\n", now*blockSize/44100.0f);
     		usleep(5000);
     //		double now=virtualClock->getNow();
     //		printf("th(end+1)=%f;\n", now/44100.0f);
     //		printf("act(end+1)=%lld;\n", Clock::getTimeUs());
+    	}
     	printf("Thread is not running \n");
+    }
+    }

     #ifdef USE_JUCE
     #include <JuceHeader.h>
     #define IS_STATIC
     #else
     #define IS_STATIC static
     #include <BeagleRT.h>
     #endif /*USE_JUCE*/
     #include "ClockSync.h"
-...
     class ClockSyncThread {
     #endif /* USE_JUCE */
     private:
     	myClock_t lastTime; // Used for clock synchronization
     	bool listening;
     	ClockSync clockSync;
     	int blockSize;
     	VirtualClock *virtualClock;
     	IS_STATIC myClock_t lastTime; // Used for clock synchronization
     	IS_STATIC bool listening;
     	IS_STATIC ClockSync clockSync;
     	IS_STATIC VirtualClock *virtualClock;
     #ifdef USE_JUCE
     #else
     	IS_STATIC bool threadIsExiting;
     	IS_STATIC AuxiliaryTask clockSyncTask;
     #endif /* USE_JUCE */
     public:
     #ifdef USE_JUCE
         ClockSyncThread(const String &threadName);
     #else
         ClockSyncThread();
     #endif
     #endif /* USE_JUCE */
         ~ClockSyncThread();
         void init(int aPort, int aBlockSize, VirtualClock &aVirtualClock);
     	void setVirtualClock(VirtualClock &aVirtualClock);
         IS_STATIC void init(bool isSlave, int aPort, VirtualClock &aVirtualClock);
         IS_STATIC void setVirtualClock(VirtualClock &aVirtualClock);
         void run();
         IS_STATIC void run();
     #ifdef USE_JUCE
     #else
         void startThread();
         void stopThread();
         IS_STATIC void startThread();
         IS_STATIC void stopThread();
         IS_STATIC bool threadShouldExit();
     #endif // USE_JUCE
     };
     #endif  // CLOCK_SYNC_THREAD_H_INCLUDED

     	// Use this method as the place to do any pre-playback
     	// initialisation that you need..
     	virtualClock.init();
     	clockSyncThread.init(5000, samplesPerBlock, virtualClock);
     	clockSyncThread.init(false, 5000, virtualClock);
     	_samplesPerBlock=samplesPerBlock;
+    }
     void ClockSyncAudioProcessor::releaseResources()
-...
     void ClockSyncAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
+    {
     	//  printf("period: %lld\n",virtualClock.getPeriod());
     	virtualClock.sync();
     	virtualClock.sync(_samplesPerBlock);
     	double now=virtualClock.getNow();
     	//  printf("now(end+1)=%f;\n", now);
     	// In case we have more outputs than inputs, this code clears any output
     	// channels that didn't contain input data, (because these aren't
     	// guaranteed to be empty - they may contain garbage).

Source/PluginProcessor.h
66	66	void getStateInformation (MemoryBlock& destData) override;
67	67	void setStateInformation (const void* data, int sizeInBytes) override;
68	68	private:
	69	int _samplesPerBlock;
69	70	VirtualClock virtualClock;
70	71	ClockSyncThread clockSyncThread;
71	72	//==============================================================================

     	init();
+    }
     void VirtualClock::sync(){
     	sync(1);
+    }
     void VirtualClock::sync(double count){
     	myClock_t currentTime=Clock::getTimeUs();
     	if(firstRun==true){
     		firstRun=false;
     		startTime=currentTime;
     	} else {
     		period=movingAverage.add(currentTime-lastSync); //TODO: replace with Kalman filter
     		period=movingAverage.add((currentTime-lastSync)/count); //TODO: replace with Kalman filter
+    	}
     	//  printf("lastPeriod(end+1)= %lld;\n", currentTime-lastSync);
     	lastSync=currentTime;
+    }
     double VirtualClock::getNow(){
     	myClock_t now=Clock::getTimeUs();
     	myClock_t now=Clock::getTimeUs();
     	if(period<=0){
     		return now;
+    	}
     	double beginningOfPeriod=lastSync; // TODO: if sync() does not get called every time (but e.g. only every so often),
     	//  double beginningOfPeriod=lastSync; // TODO: if sync() does not get called every time (but e.g. only every so often),
     													 // then this line (and the class) needs editing
     	myClock_t elapsed=(now-startTime);
     	double frac=elapsed/(double)period;
-...
     	return frac;
+    }
     myClock_t VirtualClock::getPeriod(){
     double VirtualClock::getPeriod(){
     	return period;
+    }
+    }

     	myClock_t startTime;
     	myClock_t lastSync;
     	bool firstRun;
     	myClock_t period;
     	MovingAverage<myClock_t> movingAverage;
     	double period;
     	MovingAverage<double> movingAverage;
     public:
     	void init();
     	VirtualClock();
-...
     /**
     	Call this method asynchronously, passing a number of equally spaced events that have elapsed since the last call.
     */
     	void sync(long long int count);
     	void sync(double count);
     /**
     	Get the current time according to the VirtualClock.
-...
     	Get the length of the period (difference between calls to sync() after various filtering operations)
     */
     	myClock_t getPeriod();
     	double getPeriod();
     };
     #endif /* VIRTUAL_CLOCK_H_INCLUDED */
     #endif /* VIRTUAL_CLOCK_H_INCLUDED */

Bela » UdpIoPlugin »

BeagleRTClockSync

Revision