Add AudioSynthWaveformDc

Audio.h

 #include "synth_tonesweep.h"
 #include "synth_sine.h"
 #include "synth_waveform.h"
+#include "synth_dc.h"
 #include "multiplier.h"
 
 // TODO: more audio processing objects....

gui/list.html

 </script>
 
 
+<script type="text/javascript">
+	RED.nodes.registerType('AudioSynthWaveformDc',{
+	shortName: "dc",
+		inputs:0,
+		outputs:1,
+		category: 'synth-function',
+		color:"#E6E0F8",
+		icon: "arrow-in.png"
+	});
+</script>
+<script type="text/x-red" data-help-name="AudioSynthWaveformDc">
+	<h3>Summary</h3>
+	<p>Create constant (DC) signal, useful for control of objects that take
+		a modulation or control input signal.  This constant level can be
+		used to modify other waveforms using mixer or multiplier objects</p>
+	<h3>Audio Connections</h3>
+	<table class=doc align=center cellpadding=3>
+		<tr class=top><th>Port</th><th>Purpose</th></tr>
+		<tr class=odd><td align=center>Out 0</td><td>Output constant DC level</td></tr>
+	</table>
+	<h3>Functions</h3>
+	<p class=func><span class=keyword>amplitude</span>(level);</p>
+	<p class=desc>Set the output.  Level is -1.0 to 1.0.  The output is
+		changed immediately.
+	</p>
+	<p class=func><span class=keyword>amplitude</span>(level, milliseconds);</p>
+	<p class=desc>Set the output.  Level is -1.0 to 1.0.  The output is
+		gradually changed over a "milliseconds" time period.  Any time may
+		be specified, but periods longer than 1 second may be automatically
+		shortened for small level changes, due to numerical precision limits.
+	</p>
+	<h3>Notes</h3>
+	<p>Of course, the term "DC", for Direct Current, doesn't properly apply
+		to a pure digital stream of numerical values.  But the term is widely
+		understood in audio applications, so hopefully it's not too confusing?</p>
+</script>
+<script type="text/x-red" data-template-name="AudioSynthWaveformDc">
+	<div class="form-row">
+		<label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+		<input type="text" id="node-input-name" placeholder="Name">
+	</div>
+</script>
+
+
 
 <script type="text/javascript">
 	RED.nodes.registerType('AudioEffectFade',{

keywords.txt

 AudioSynthWaveform	KEYWORD2
 AudioSynthWaveformSine	KEYWORD2
 AudioSynthWaveformSineModulated	KEYWORD2
+AudioSynthWaveformDc	KEYWORD2
 isPlaying	KEYWORD2
 positionMillis	KEYWORD2
 lengthMillis	KEYWORD2

synth_dc.cpp

+/* Audio Library for Teensy 3.X
+ * Copyright (c) 2014, Paul Stoffregen, paul@pjrc.com
+ *
+ * Development of this audio library was funded by PJRC.COM, LLC by sales of
+ * Teensy and Audio Adaptor boards.  Please support PJRC's efforts to develop
+ * open source software by purchasing Teensy or other PJRC products.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice, development funding notice, and this permission
+ * notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "synth_dc.h"
+
+void AudioSynthWaveformDc::update(void)
+{
+	audio_block_t *block;
+	uint32_t *p, *end, val;
+	int32_t count, t1, t2, t3, t4;
+
+	block = allocate();
+	if (!block) return;
+	p = (uint32_t *)(block->data);
+	end = p + AUDIO_BLOCK_SAMPLES/2;
+
+	if (state == 0) {
+		// steady DC output, simply fill the buffer with fixed value
+		val = pack_16t_16t(magnitude, magnitude);
+		do {
+			*p++ = val;
+			*p++ = val;
+			*p++ = val;
+			*p++ = val;
+			*p++ = val;
+			*p++ = val;
+			*p++ = val;
+			*p++ = val;
+		} while (p < end);
+	} else {
+		// transitioning to a new DC level
+		//count = (target - magnitude) / increment;
+		count = substract_int32_then_divide_int32(target, magnitude, increment);
+		if (count >= 128) {
+			// this update will not reach the target
+			do {
+				magnitude += increment;
+				t1 = magnitude;
+				magnitude += increment;
+				t1 = pack_16t_16t(magnitude, t1);
+				magnitude += increment;
+				t2 = magnitude;
+				magnitude += increment;
+				t2 = pack_16t_16t(magnitude, t2);
+				magnitude += increment;
+				t3 = magnitude;
+				magnitude += increment;
+				t3 = pack_16t_16t(magnitude, t3);
+				magnitude += increment;
+				t4 = magnitude;
+				magnitude += increment;
+				t4 = pack_16t_16t(magnitude, t4);
+				*p++ = t1;
+				*p++ = t2;
+				*p++ = t3;
+				*p++ = t4;
+			} while (p < end);
+		} else {
+			// this update reaches the target
+			while (count >= 2) {
+				count -= 2;
+				magnitude += increment;
+				t1 = magnitude;
+				magnitude += increment;
+				t1 = pack_16t_16t(magnitude, t1);
+				*p++ = t1;
+			}
+			if (count) {
+				t1 = pack_16t_16t(target, magnitude + increment);
+				*p++ = t1;
+			}
+			magnitude = target;
+			state = 0;
+			val = pack_16t_16t(magnitude, magnitude);
+			while (p < end) {
+				*p++ = val;
+			}
+		}
+	}
+	transmit(block);
+	release(block);
+}
+
+
+

synth_dc.h

+/* Audio Library for Teensy 3.X
+ * Copyright (c) 2014, Paul Stoffregen, paul@pjrc.com
+ *
+ * Development of this audio library was funded by PJRC.COM, LLC by sales of
+ * Teensy and Audio Adaptor boards.  Please support PJRC's efforts to develop
+ * open source software by purchasing Teensy or other PJRC products.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice, development funding notice, and this permission
+ * notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef synth_dc_h_
+#define synth_dc_h_
+#include "AudioStream.h"
+#include "utility/dspinst.h"
+
+// compute (a - b) / c
+// handling 32 bit interger overflow at every step
+// without resorting to slow 64 bit math
+#if 0
+// TODO: write this in assembly....
+static inline int32_t substract_32_then_divide(int32_t a, int32_t b, int32_t c) __attribute__((always_inline, unused));
+static inline int32_t substract_32_then_divide(int32_t a, int32_t b, int32_t c)
+{
+	int32_t diff = substract_32_saturate(a, b);
+	// if only C language provided a way to test Q status bit....
+	if (diff != 0x7FFFFFFF && diff != 0x80000000) {
+		return diff / c;
+	} else {
+		diff = substract_32_saturate(a/2, b/2);
+		if (c == 1 || c == -1) c *= 2; // <-- horrible, incorrect hack
+		return (diff / c) * 2;
+	}
+}
+#else
+static inline int32_t substract_int32_then_divide_int32(int32_t a, int32_t b, int32_t c) __attribute__((always_inline, unused));
+static inline int32_t substract_int32_then_divide_int32(int32_t a, int32_t b, int32_t c)
+{
+	uint32_t diff;
+	uint8_t negative;
+
+	if (a >= 0) {
+		if (b >= 0) {
+			if (a >= b) {
+				diff = a - b;
+				negative = 0;
+			} else {
+				diff = b - a;
+				negative = 1;
+			}
+		} else {
+			diff = a + (b * -1); // assumes 0x80000000 * -1 == 0x80000000
+			negative = 0;
+		}
+	} else {
+		if (b >= 0) {
+			diff = (a * -1) + b; // assumes 0x80000000 * -1 == 0x80000000
+			negative = 1;
+		} else {
+			if (a >= b) {
+				diff = a - b;
+				negative = 0;
+			} else {
+				diff = b - a;
+				negative = 1;
+			}
+		}
+	}
+	if (c >= 0) {
+		diff = diff / (uint32_t)c;
+	} else {
+		diff = diff / (uint32_t)(c * -1);
+		negative ^= 1;
+	}
+	if (negative) {
+		if (diff > 0x7FFFFFFF) return 0x80000000;
+		return (int32_t)diff * -1;
+	} else {
+		if (diff > 0x7FFFFFFF) return 0x7FFFFFFF;
+		return (int32_t)diff;
+	}
+}
+
+#endif
+
+class AudioSynthWaveformDc : public AudioStream
+{
+public:
+	AudioSynthWaveformDc() : AudioStream(0, NULL), state(0), magnitude(0) {}
+	// immediately jump to the new DC level
+	void amplitude(float n) {
+		if (n > 1.0) n = 1.0;
+		else if (n < -1.0) n = -1.0;
+		int32_t m = (int32_t)(n * 2147418112.0);
+		__disable_irq();
+		magnitude = m;
+		state = 0;
+		__enable_irq();
+	}
+	// slowly transition to the new DC level
+	void amplitude(float n, float milliseconds) {
+		if (milliseconds <= 0.0) {
+			amplitude(n);
+			return;
+		}
+		if (n > 1.0) n = 1.0;
+		else if (n < -1.0) n = -1.0;
+		int32_t c = (int32_t)(milliseconds*(AUDIO_SAMPLE_RATE_EXACT/1000.0));
+		if (c == 0) {
+			amplitude(n);
+			return;
+		}
+		int32_t t = (int32_t)(n * 2147418112.0);
+		__disable_irq();
+		target = t;
+		if (target == magnitude) {
+			state = 0;
+			__enable_irq();
+			return;
+		}
+		increment = substract_int32_then_divide_int32(target, magnitude, c);
+		if (increment == 0) {
+			increment = (target > magnitude) ? 1 : -1;
+		}
+		state = 1;
+		__enable_irq();
+	}
+	virtual void update(void);
+private:
+	uint8_t  state;     // 0=steady output, 1=transitioning
+	int32_t  magnitude; // current output
+	int32_t  target;    // designed output (while transitiong)
+	int32_t  increment; // adjustment per sample (while transitiong)
+};
+
+#endif

utility/dspinst.h

 	return out;
 }
 
+// computes (a - b), result saturated to 32 bit integer range
+static inline int32_t substract_32_saturate(uint32_t a, uint32_t b) __attribute__((always_inline, unused));
+static inline int32_t substract_32_saturate(uint32_t a, uint32_t b)
+{
+	int32_t out;
+	asm volatile("qsub %0, %1, %2" : "=r" (out) : "r" (a), "r" (b));
+	return out;
+}
+
+
 
 #endif