comparison examples/basic_libpd/render.cpp @ 342:860c42b3830e prerelease

Updated basic_libpd, now slightly more efficient with less memory operations. Requires the API change in libpd operated in libpd:99a2be8

 #include <I2c_Codec.h>
 #include <PRU.h>
 #include <stdio.h>
 #include "z_libpd.h"
 #include "z_queued.h"
+#include "s_stuff.h"
 #include <UdpServer.h>
 #include <Midi.h>
 
 
 // setup() is called once before the audio rendering starts.

 
 void Bela_printHook(const char *recv){
 	rt_printf("%s", recv);
 }
 
-UdpServer udpServer;
-
 void libpdReadFilesLoop(){
     while(!gShouldStop){
     	// check for modified sockets/file descriptors
     	// (libpd would normally do this every block WITHIN the audio thread)
     	// not sure if this is thread-safe at the moment

 #define PARSE_MIDI
 AuxiliaryTask libpdReadFilesTask;
 AuxiliaryTask libpdProcessMessageQueueTask;
 AuxiliaryTask libpdProcessMidiQueueTask;
 Midi midi;
+//UdpServer udpServer;
 
 bool setup(BelaContext *context, void *userData)
 {
 	midi.readFrom(0);
 	midi.writeTo(0);

 	midi.enableParser(true);
 #else
 	midi.enableParser(false);
 #endif /* PARSE_MIDI */
 	gChannelsInUse = min((int)(context->analogChannels+context->audioChannels), (int)gChannelsInUse);
-	udpServer.bindToPort(1234);
+//	udpServer.bindToPort(1234);
 
 	gLibpdBlockSize = libpd_blocksize();
 	// check that we are not running with a blocksize smaller than gLibPdBlockSize
 	// it would still work, but the load would be executed unevenly between calls to render
 	if(context->audioFrames < gLibpdBlockSize){

 	libpd_start_message(1); // one entry in list
 	libpd_add_float(1.0f);
 	libpd_finish_message("pd", "dsp");
 
 	gBufLength = max(gLibpdBlockSize, context->audioFrames);
-	unsigned int bufferSize = sizeof(float)*gChannelsInUse*gBufLength;
-	gInBuf = (float*)malloc(bufferSize);
-	gOutBuf = (float*)malloc(bufferSize);
-	// no need to memset to zero
 
 	char file[] = "_main.pd";
 	char folder[] = "./";
 	// open patch       [; pd open file folder(
 	libpd_openfile(file, folder);
-    
+	gInBuf = libpd_get_sys_soundin();
+	gOutBuf = libpd_get_sys_soundout();
 	libpdReadFilesTask = Bela_createAuxiliaryTask(libpdReadFilesLoop, 60, "libpdReadFiles");
 	Bela_scheduleAuxiliaryTask(libpdReadFilesTask);
 
 	// Higher priority for the midi queue and lower priority for the message queue. Adjust to taste
 	libpdProcessMidiQueueTask = Bela_createAuxiliaryTask(libpd_queued_receive_midi_messages, 80, "libpdProcessMidiQueue");

 	while((input = midi.getInput()) >= 0){
 		libpd_midibyte(0, input);
 	}
 #endif /* PARSE_MIDI */
 
-	unsigned int inW = 0;
-	unsigned int outR = 0;
 /*
  *	NOTE: if you are only using audio (or only analogs) and you are using interleaved buffers
  *	 and the blocksize of Bela is the same as gLibPdBlockSize, then you probably
  *	 do not need the for loops before and after libpd_process_float, so you can save quite some
  *	 memory operations.
  */
 	static unsigned int analogChannelsInUse = min(context->analogChannels, gChannelsInUse - context->audioChannels);
 	static unsigned int numberOfPdBlocksToProcess = gBufLength / gLibpdBlockSize;
-	// rt_printf("channelsInUse: %d, analogChannels in Use: %d\n", gChannelsInUse, analogChannelsInUse);
 	for(unsigned int j = 0; j < numberOfPdBlocksToProcess; ++j){
-		int oldInW = inW;
+		unsigned int inW = 0;
+		unsigned int outR = 0;
+
 		for(unsigned int n = 0; n < gLibpdBlockSize; ++n){ //pd buffers are interleaved
 			for(unsigned int ch = 0; ch < context->audioChannels; ++ch){ //first two channels are audio
 				gInBuf[inW++] = audioRead(context, n, ch);
 			}
 			// then analogs

 				for(unsigned int analogCh = 0; analogCh < analogChannelsInUse; ++analogCh){
 					gInBuf[inW++] = analogRead(context, n*2, analogCh);
 				}
 			}
 		}
-		// TODO: see if we can rewrite libpd_process_float so that it takes a buffer
-		// of interleaved channels of arbitrary length rather than a series of
-		// stacked buffers of size gLibPdBlockSize as it currently does.
-		// This would allow to use the buffers as they are rather than having to copy them
-		libpd_process_float(1, &gInBuf[oldInW], &gOutBuf[oldInW]);
+		libpd_process_sys(); // process the block
 		for(unsigned int n = 0; n < gLibpdBlockSize; ++n){ //pd buffers are interleaved
-			unsigned int outAudioFrame = n + j * gLibpdBlockSize;
+			unsigned int outAudioFrame = 0;
 			for(unsigned int ch = 0; ch < context->audioChannels; ++ch){
 				audioWrite(context, outAudioFrame, ch, gOutBuf[outR++]);
 			}
 			//and analogs
 			if(context->analogChannels == 8){

 // Release any resources that were allocated in setup().
 
 void cleanup(BelaContext *context, void *userData)
 {
 	libpd_queued_release();
-	free(gInBuf);
-	free(gOutBuf);
-}
+//	free(gInBuf);
+//	free(gOutBuf);
+}