comparison projects/basic_network/render.cpp @ 41:4255ecbb9bec ultra-staging

Timers to measure performances, ultra experimental

 #include "../../include/render.h"
 #include <cmath>
 #include "../../include/client.h"
 #include "../../include/RTAudio.h"	// to schedule lower prio parallel process
 #include <rtdk.h>
+#include <native/timer.h>
+#include "../../include/PRU.h"
 float gFrequency;
 float gPhase;
 float gInverseSampleRate;
 int gCount=0;
 networkData networkObject;
-AuxiliaryTask transmitReceiveDataTask;
+networkAudio netAudio;
+extern PRU *gPRU;
+AuxiliaryTask printIntervalTask;
+AuxiliaryTask transmitReceiveAudioTask;
+void transmitReceiveData(){ //transmit and receive asynchronous messages
+//   	printf("transmitReceiveData auxiliary task has started\n");
+//	while(!gShouldStop){
+//		sendMessage(&networkObject);
+//		receiveMessage(networkObject);
+//		usleep(1000);
+//	}
+//	closeSockets();
+}
 
-void transmitReceiveData(){
-   	printf("transmitReceiveData auxiliary task has started\n");
-	while(!gShouldStop){
-		sendMessage(networkObject);
-		receiveMessage(networkObject);
-		usleep(1000);
-	}
-	closeSockets();
+void transmitReceiveAudio(){ //transmit and receive audio buffers
+	sendAudio(&netAudio);
 }
+
 
 // initialise_render() is called once before the audio rendering starts.
 // Use it to perform any initialisation and allocation which is dependent
 // on the period size or sample rate.
 //

 	gFrequency = *(float *)userData;
 
 	gInverseSampleRate = 1.0 / audioSampleRate;
 	gPhase = 0.0;
 
-	networkObject.counter=&gCount;
-	networkObject.variables[0]=&gFrequency;
-	networkObject.variables[1]=&gPhase;
-	networkObject.numVariables=2;
-	setupSockets(settings->receivePort, settings->transmitPort, settings->serverName);
-	transmitReceiveDataTask=createAuxiliaryTaskLoop(*transmitReceiveData, 80, "transmit-receive-data");
-	//scheduleAuxiliaryTask(transmitReceiveDataTask); //here it does not work
+//	networkObject.counter=&gCount;
+//	networkObject.variables[0]=&gFrequency;
+//	networkObject.variables[1]=&gPhase;
+//	networkObject.numVariables=2;
+//	netAudio.doneOnTime=1;
+//	netAudio.index=0;
+//	netAudio.currentBuffer=0;
+//	setupSockets(settings->receivePort, settings->transmitPort, settings->serverName);
+////	transmitReceiveDataTask=createAuxiliaryTaskLoop(*transmitReceiveData, 10, "transmit-receive-data");
+////	scheduleAuxiliaryTask(transmitReceiveDataTask); //here it does not work
+//	transmitReceiveAudioTask=createAuxiliaryTaskLoop(*transmitReceiveAudio, 98, "transmit-receive-audio");
 	return true;
 }
 
 // render() is called regularly at the highest priority by the audio engine.
 // Input and output are given from the audio hardware and the other

 void render(int numAnalogFrames, int numAudioFrames, int numDigitalFrames, float *audioIn, float *audioOut,
 		float *analogIn, float *analogOut, uint32_t *digital)
 {
 	for(int n = 0; n < numAudioFrames; n++) {
 		float out = 0.7f * sinf(gPhase);
+		float fake=0.1;
+		for(int a=0; a<24; a++){
+			fake = 0.7f * sinf(fake+out);
+		}
+		fake/=1000000000000000;
 		gPhase += 2.0 * M_PI * gFrequency * gInverseSampleRate;
 		if(gPhase > 2.0 * M_PI)
 			gPhase -= 2.0 * M_PI;
 
-		for(int channel = 0; channel < gNumAudioChannels; channel++)
-			audioOut[n * gNumAudioChannels + channel] = out;
-		if(gCount==0){
-			scheduleAuxiliaryTask(transmitReceiveDataTask);
+//		for(int channel = 0; channel < gNumAudioChannels; channel++)
+//			audioOut[n * gNumAudioChannels + channel] = audioIn[n * gNumAudioChannels + 0]+audioIn[n * gNumAudioChannels + 1];
+		audioOut[n * gNumAudioChannels] = fake*0.0000000001;
+		audioOut[n * gNumAudioChannels+1]=out;
+		if(0==gCount){
+//			scheduleAuxiliaryTask(transmitReceiveDataTask);
 		}
+//		if(netAudio.index==(NETWORK_AUDIO_BUFFER_SIZE)){ // when the buffer is ready ...
+//			netAudio.index=0; //reset the counter
+//			if(netAudio.doneOnTime==0)
+//				rt_printf("Network buffer underrun :-{\n");
+//			netAudio.timestamp=gCount;
+//			netAudio.currentBuffer=!netAudio.currentBuffer; //switch buffer
+//			netAudio.doneOnTime=0;
+//			scheduleAuxiliaryTask(transmitReceiveAudioTask); //send the buffer
+//		}
+//		netAudio.buffers[netAudio.currentBuffer][netAudio.index++]=audioOut[n*gNumAudioChannels + 0];//copy channel 0 to the buffer
 		gCount++;
 	}
 }
 
 // cleanup_render() is called once at the end, after the audio has stopped.
 // Release any resources that were allocated in initialise_render().
 
 void cleanup_render()
 {
+//	closeSockets();
 }