comparison scripts/hvresources/heavy_render.cpp @ 482:4d5edf7ee953 prerelease

heavy: support for signal-rate digitals and Scope.

  *
  */
 
 #include <Bela.h>
 #include <Midi.h>
+#include <Scope.h>
 #include <cmath>
-#include "Heavy_bbb.h"
+#include <Heavy_bbb.h>
 #include <string.h>
 #include <stdlib.h>
 #include <string.h>
 #include <DigitalChannelManager.h>
 

 
 /*
  * SETUP, RENDER LOOP & CLEANUP
  */
 
-
-
-// Midi
+// 2 audio + (up to)8 analog + (up to) 16 digital + 4 scope outputs
+static const unsigned int gChannelsInUse = 30;
+static unsigned int gAnalogChannelsInUse = 8; // hard-coded for the moment, TODO: get it at run-time from hv_context
+//static const unsigned int gFirstAudioChannel = 0;
+static const unsigned int gFirstAnalogChannel = 2;
+static const unsigned int gFirstDigitalChannel = 10;
+static const unsigned int gFirstScopeChannel = 26;
+static unsigned int gDigitalSigInChannelsInUse;
+static unsigned int gDigitalSigOutChannelsInUse;
+
+// Bela Midi
 Midi midi;
 unsigned int hvMidiHashes[7];
+// Bela Scope
+Scope scope;
+const unsigned int gMaxScopeChannels = 4;
+unsigned int gScopeChannelsInUse;
+float* gScopeOut;
 
 
 bool setup(BelaContext *context, void *userData)	{
-
-	printf("top o setup\n");
 	/* HEAVY */
 	hvMidiHashes[kmmNoteOn] = hv_stringToHash("__hv_notein");
 	hvMidiHashes[kmmNoteOff] = hv_stringToHash("noteoff"); // this is handled differently, see the render function
 	hvMidiHashes[kmmControlChange] = hv_stringToHash("__hv_ctlin");
 	hvMidiHashes[kmmProgramChange] = hv_stringToHash("pgmin");
 	hvMidiHashes[kmmPolyphonicKeyPressure] = hv_stringToHash("polytouchin");
 	hvMidiHashes[kmmChannelPressure] = hv_stringToHash("touchin");
 	hvMidiHashes[kmmPitchBend] = hv_stringToHash("bendin");
 
-	printf("after midi o setup\n");
 	gHeavyContext = hv_bbb_new(context->audioSampleRate);
 
-	printf("aftet new  o setup\n");
 	gHvInputChannels = hv_getNumInputChannels(gHeavyContext);
 	gHvOutputChannels = hv_getNumOutputChannels(gHeavyContext);
 
-	rt_printf("Starting Heavy context with %d input channels and %d output channels\n",
+	gScopeChannelsInUse = gHvOutputChannels > gFirstScopeChannel ?
+			gHvOutputChannels - gFirstScopeChannel : 0;
+	gDigitalSigInChannelsInUse = gHvInputChannels > gFirstDigitalChannel ?
+			gHvInputChannels - gFirstDigitalChannel : 0;
+	gDigitalSigOutChannelsInUse = gHvOutputChannels > gFirstDigitalChannel ?
+			gHvOutputChannels - gFirstDigitalChannel - gScopeChannelsInUse: 0;
+
+	printf("Starting Heavy context with %d input channels and %d output channels\n",
 			  gHvInputChannels, gHvOutputChannels);
+	printf("Channels in use:\n");
+	printf("Digital in : %u, Digital out: %u\n", gDigitalSigInChannelsInUse, gDigitalSigOutChannelsInUse);
+	printf("Scope out: %u\n", gScopeChannelsInUse);
 
 	if(gHvInputChannels != 0) {
 		gHvInputBuffers = (float *)calloc(gHvInputChannels * context->audioFrames,sizeof(float));
 	}
 	if(gHvOutputChannels != 0) {
 		gHvOutputBuffers = (float *)calloc(gHvOutputChannels * context->audioFrames,sizeof(float));
 	}
-	printf("mid o setup\n");
 
 	gInverseSampleRate = 1.0 / context->audioSampleRate;
 
 	// Set heavy print hook
 	hv_setPrintHook(gHeavyContext, printHook);

 	// TODO: change these hardcoded port values and actually change them in the Midi class
 	midi.readFrom(0);
 	midi.writeTo(0);
 	midi.enableParser(true);
 
+	if(gScopeChannelsInUse > 0){
+		// block below copy/pasted from libpd, except
+		scope.setup(gScopeChannelsInUse, context->audioSampleRate);
+		gScopeOut = new float[gScopeChannelsInUse];
+	}
 	// Bela digital
 	dcm.setCallback(sendDigitalMessage);
 	if(context->digitalChannels > 0){
 		for(unsigned int ch = 0; ch < context->digitalChannels; ++ch){
 			dcm.setCallbackArgument(ch, hvDigitalInHashes[ch]);
 		}
 	}
 	// unlike libpd, no need here to bind the bela_digitalOut.. receivers
 
-	printf("end o setup\n");
 	return true;
 }
 
 
 void render(BelaContext *context, void *userData)

 		}
 	}
 
 	// Bela digital in
 	// note: in multiple places below we assume that the number of digital frames is same as number of audio
-	// digital in at message-rate
+	// Bela digital in at message-rate
 	dcm.processInput(context->digital, context->digitalFrames);
 
 	// Bela digital in at signal-rate
-	// TODO: not really straightforward to implement as Heavy determines the number of channels in use at compile time
-	// on the basis of the number of adc~ / dac~ of the patch ... Maybe we should always include
-	// a dummy [adc~ 27] [dac~ 27] to make sure all channels are always allocated and then leave them all unprocessed ?
+	if(gDigitalSigInChannelsInUse > 0)
+	{
+		unsigned int j, k;
+		float *p0, *p1;
+		const unsigned int gLibpdBlockSize = context->audioFrames;
+		const unsigned int  audioFrameBase = 0;
+		float* gInBuf = gHvInputBuffers;
+		// block below copy/pasted from libpd, except
+		// 16 has been replaced with gDigitalSigInChannelsInUse
+		for (j = 0, p0 = gInBuf; j < gLibpdBlockSize; j++, p0++) {
+			unsigned int digitalFrame = audioFrameBase + j;
+			for (k = 0, p1 = p0 + gLibpdBlockSize * gFirstDigitalChannel;
+					k < gDigitalSigInChannelsInUse; ++k, p1 += gLibpdBlockSize) {
+				if(dcm.isSignalRate(k) && dcm.isInput(k)){ // only process input channels that are handled at signal rate
+					*p1 = digitalRead(context, digitalFrame, k);
+				}
+			}
+		}
+	}
+
 
 	// replacement for bang~ object
 	//hv_vscheduleMessageForReceiver(gHeavyContext, "bbb_bang", 0.0f, "b");
 
 	hv_bbb_process_inline(gHeavyContext, gHvInputBuffers, gHvOutputBuffers, context->audioFrames);
 
 	// Bela digital out
-	// digital out at signal-rate
-	// TODO: see note above.
-
-	// digital out at message-rate
+	// Bela digital out at signal-rate
+	if(gDigitalSigOutChannelsInUse > 0)
+	{
+			unsigned int j, k;
+			float *p0, *p1;
+			const unsigned int gLibpdBlockSize = context->audioFrames;
+			const unsigned int  audioFrameBase = 0;
+			float* gOutBuf = gHvOutputBuffers;
+			// block below copy/pasted from libpd, except
+			// context->digitalChannels has been replaced with gDigitalSigOutChannelsInUse
+			for (j = 0, p0 = gOutBuf; j < gLibpdBlockSize; ++j, ++p0) {
+				unsigned int digitalFrame = (audioFrameBase + j);
+				for (k = 0, p1 = p0  + gLibpdBlockSize * gFirstDigitalChannel;
+						k < gDigitalSigOutChannelsInUse; k++, p1 += gLibpdBlockSize) {
+					if(dcm.isSignalRate(k) && dcm.isOutput(k)){ // only process output channels that are handled at signal rate
+						digitalWriteOnce(context, digitalFrame, k, *p1 > 0.5);
+					}
+				}
+			}
+	}
+	// Bela digital out at message-rate
 	dcm.processOutput(context->digital, context->digitalFrames);
+
+	// Bela scope
+	if(gScopeChannelsInUse > 0)
+	{
+		unsigned int j, k;
+		float *p0, *p1;
+		const unsigned int gLibpdBlockSize = context->audioFrames;
+		const unsigned int  audioFrameBase = 0;
+		float* gOutBuf = gHvOutputBuffers;
+
+		// block below copy/pasted from libpd
+		for (j = 0, p0 = gOutBuf; j < gLibpdBlockSize; ++j, ++p0) {
+			for (k = 0, p1 = p0  + gLibpdBlockSize * gFirstScopeChannel; k < gScopeChannelsInUse; k++, p1 += gLibpdBlockSize) {
+				gScopeOut[k] = *p1;
+			}
+			scope.log(gScopeOut[0], gScopeOut[1], gScopeOut[2], gScopeOut[3]);
+		}
+	}
 
 	// Interleave the output data
 	if(gHvOutputBuffers != NULL) {
 		for(unsigned int n = 0; n < context->audioFrames; n++) {
 

 	hv_bbb_free(gHeavyContext);
 	if(gHvInputBuffers != NULL)
 		free(gHvInputBuffers);
 	if(gHvOutputBuffers != NULL)
 		free(gHvOutputBuffers);
-
-}
+	delete[] gScopeOut;
+}