Stretch v2

classes/DirtEvent.sc

@@ -110,6 +110,7 @@ DirtEvent {
 
 		~fadeTime = min(~fadeTime.value, sustain * 0.19098);
 		~fadeInTime = if(~begin != 0) { ~fadeTime } { 0.0 };
+		if (~timescale.notNil) {sustain = sustain * ~timescale };
 		~sustain = sustain - (~fadeTime + ~fadeInTime);
 		~speed = speed;
 		~endSpeed = endSpeed;

classes/DirtSoundLibrary.sc

@@ -247,6 +247,7 @@ DirtSoundLibrary {
 		^(
 			buffer: buffer.bufnum,
 			instrument: this.instrumentForBuffer(buffer),
+			stretchInstrument: this.stretchInstrumentForBuffer(buffer),
 			bufNumFrames: buffer.numFrames,
 			bufNumChannels: buffer.numChannels,
 			unitDuration: { buffer.duration * baseFreq / ~freq.value },
@@ -262,6 +263,10 @@ DirtSoundLibrary {
 		^format(synthName, buffer.numChannels, this.numChannels).asSymbol
 	}
 
+	stretchInstrumentForBuffer { |buffer|
+		^format("dirt_stretchsample_%_%", buffer.numChannels, this.numChannels).asSymbol
+	}
+
 	openFolder { |name, index = 0|
 		var buf, list;
 		list = buffers.at(name);
@@ -281,7 +286,8 @@ DirtSoundLibrary {
 		numChannels = n;
 		bufferEvents = bufferEvents.collect { |list|
 			list.do { |event|
-				event[\instrument] = this.instrumentForBuffer(event[\buffer])
+				event[\instrument] = this.instrumentForBuffer(event[\buffer]);
+				event[\stretchInstrument] = this.stretchInstrumentForBuffer(event[\buffer]);
 			}
 		}
 	}

synths/core-modules.scd

@@ -37,8 +37,9 @@ this may be refacored later.
 	{ |dirtEvent|
 		if(~diversion.value.isNil) {
 			if(~buffer.notNil) {
-				// argumets could be omitted using getMsgFunc, but for making it easier to understand, we write them out
-				dirtEvent.sendSynth(~instrument,  [
+				// arguments could be omitted using getMsgFunc, but for making it easier to understand, we write them out
+				var instrument;
+				var args = [
 					bufnum: ~buffer,
 					sustain: ~sustain,
 					speed: ~speed,
@@ -48,7 +49,17 @@ this may be refacored later.
 					end: ~end,
 					pan: ~pan,
 					out: ~out
-				])
+				];
+
+				if(~timescale.notNil) {
+					instrument = ~stretchInstrument;
+					args = args.add(\timescale).add(~timescale).add(\timescalewin).add(~timescalewin ? 1);
+				} {
+					instrument = ~instrument;
+				};
+
+				dirtEvent.sendSynth(instrument, args);
+
 			} {
 				if(~instrument.isNil) {
 					"module 'sound': instrument not found: %".format(~s).postln

synths/core-synths.scd

@@ -98,6 +98,62 @@ live coding them requires that you have your SuperDirt instance in an environmen
 		}, [\ir, \ir, \ir, \ir, \ir, \ir, \ir, \ir, \kr]).add; // pan can be modulated
 	};
 
+	// this is the time-stretching sample player, based on an overlap-add method
+	(1..SuperDirt.maxSampleNumChannels).do { |sampleNumChannels|
+
+		var name = format("dirt_stretchsample_%_%", sampleNumChannels, numChannels);
+
+		SynthDef(name, { |out, bufnum, sustain = 1, begin = 0, end = 1, speed = 1, endSpeed = 1, freq = 440, pan = 0, timescale = 1, timescalewin = 1|
+
+			var sound, rate, phase, sawrate, numFrames, index, windowIndex, window, timescaleStep;
+			var sound0, sound1, windowSize;
+
+			// playback speed
+			rate = Line.kr(speed, endSpeed, sustain) * (freq / 60.midicps);
+
+			// sample phase
+			// BufSampleRate adjusts the rate if the sound file doesn't have the same rate as the soundcard
+			//phase =  Sweep.ar(1, rate * BufSampleRate.ir(bufnum)) + (BufFrames.ir(bufnum) * begin);
+
+			numFrames = BufFrames.ir(bufnum);
+			// Picking the right window size is a tricky thing, something around 2000 samples is usually
+			// OK for sounds of moderate length (around 0.5 to several seconds long).
+			// But this is also scaled below to be a bit smaller/larger based on desired playback rate.
+			// If it's still not good, you can use the "timescalewin" parameter to multiply the window size
+			windowSize = timescale.clip(0.1,2) * 0.05 * BufSampleRate.ir(bufnum) * timescalewin;
+			timescaleStep = windowSize / timescale;
+			sawrate = rate * BufSampleRate.ir(bufnum) / (absdif(begin, end) * timescale * numFrames);
+			phase = (speed.sign * LFSaw.ar(sawrate, 1)).range(begin,end) * numFrames * timescale;
+			// do the overlap-add by running through a pair of indices, shifting weights with the window function
+			index = (phase.div(timescaleStep) - [1.0, 0.0]) * (timescaleStep / timescale - timescaleStep) + phase;
+			windowIndex = phase - (phase.div(timescaleStep) - [1.0, 0.0] * timescaleStep);
+			// Gaussian window, the "50" means it's about 3.5 sigma to the edge of the window
+			window = exp(-50 * squared(windowIndex/windowSize - 0.5));
+
+			sound0 = window[0] * BufRd.ar(
+				numChannels: sampleNumChannels,
+				bufnum: bufnum,
+				phase: index[0],
+				loop: 0,
+				interpolation: 4 // cubic interpolation
+			);
+			sound1 = window[1] * BufRd.ar(
+				numChannels: sampleNumChannels,
+				bufnum: bufnum,
+				phase: index[1],
+				loop: 0,
+				interpolation: 4 // cubic interpolation
+			);
+			sound = (sound0 + sound1) / window.sum;
+
+			sound = DirtPan.ar(sound, numChannels, pan);
+
+			Out.ar(out, sound)
+		}, [\ir, \ir, \ir, \ir, \ir, \ir, \ir, \ir, \kr, \ir, \ir]).add;
+	};
+
+
+
 	/*
 
 	Bus Routing Monitor