def DoubleBandPassCoefficientsIIRFilter_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.EQ import DoubleBandPassCoefficientsIIRFilter from numpy.testing import assert_almost_equal input = np.sin(np.arange(1000, dtype=np.float64)[None,:] * 1000 * 2 * np.pi / 48000) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None,:]) inputfilter = DoubleInPointerFilter(input, False) EQfilter = DoubleBandPassCoefficientsIIRFilter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.set_output_sampling_rate(48000) EQfilter.set_input_sampling_rate(48000) EQfilter.set_Q(1) EQfilter.set_cut_frequency(1000) outputfilter.set_input_sampling_rate(48000) EQfilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, EQfilter, 0) outputfilter.process(1000) assert_almost_equal(input[0,500:], input[0,500] / output[0,500] * output[0,500:])
def filter(input, blend=0, feedback=0, feedforward=1):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
infilter = DoubleInPointerFilter(input, False)
infilter.set_output_sampling_rate(sample_rate)
generator = DoubleCachedSinusGeneratorFilter(1, 1)
generator.set_output_sampling_rate(sample_rate)
generator.set_volume(1e-3 * sample_rate)
generator.set_offset(1.5e-3 * sample_rate)
delayfilter = DoubleUniversalVariableDelayLineFilter(5000)
delayfilter.set_input_sampling_rate(sample_rate)
delayfilter.set_input_port(0, infilter, 0)
delayfilter.set_input_port(1, generator, 0)
delayfilter.set_blend(blend)
delayfilter.set_feedback(feedback)
delayfilter.set_feedforward(feedforward)
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(sample_rate)
outfilter.set_input_port(0, delayfilter, 0)
outfilter.process(input.shape[1])
return output
def filter(input, ratio=4, threshold=1, softness=1): import numpy as np output = np.zeros(input.shape, dtype=np.float64) input2 = input**2 in2filter = DoubleInPointerFilter(input2, False) in2filter.set_input_sampling_rate(sample_rate) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(sample_rate) gainfilter = DoubleGainExpanderFilter(1) gainfilter.set_input_sampling_rate(sample_rate) gainfilter.set_input_port(0, in2filter, 0) gainfilter.set_threshold(threshold) gainfilter.set_ratio(ratio) gainfilter.set_softness(softness) applygainfilter = DoubleApplyGainFilter(1) applygainfilter.set_input_sampling_rate(sample_rate) applygainfilter.set_input_port(0, gainfilter, 0) applygainfilter.set_input_port(1, infilter, 0) outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(sample_rate) outfilter.set_input_port(0, applygainfilter, 0) outfilter.process(input.shape[1]) return output
def filter_4(input):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
infilter = DoubleInPointerFilter(input, False)
infilter.set_input_sampling_rate(48000)
overfilter = DoubleOversampling6points5order_4Filter()
overfilter.set_input_sampling_rate(48000)
overfilter.set_output_sampling_rate(48000 * 4)
overfilter.set_input_port(0, infilter, 0)
overdrivefilter = DoubleSimpleOverdriveFilter()
overdrivefilter.set_input_sampling_rate(48000 * 4)
overdrivefilter.set_input_port(0, overfilter, 0)
lowpassfilter = DoubleButterworthLowPassFilter()
lowpassfilter.set_input_sampling_rate(48000 * 4)
lowpassfilter.set_cut_frequency(48000)
lowpassfilter.set_order(5)
lowpassfilter.set_input_port(0, overdrivefilter, 0)
decimationfilter = DoubleDecimationFilter(1)
decimationfilter.set_input_sampling_rate(48000 * 4)
decimationfilter.set_output_sampling_rate(48000)
decimationfilter.set_input_port(0, lowpassfilter, 0)
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(48000)
outfilter.set_input_port(0, decimationfilter, 0)
outfilter.process(input.shape[1])
return output
def Sum_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleSumFilter from numpy.testing import assert_almost_equal t = np.arange(1000, dtype=np.float64) input = np.sin(np.array((t, t)) * 1000 * 2 * np.pi / 48000) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None,:]) inputfilter = DoubleInPointerFilter(input, False) sumfilter = DoubleSumFilter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.set_output_sampling_rate(48000) sumfilter.set_input_sampling_rate(48000) outputfilter.set_input_sampling_rate(48000) sumfilter.set_input_port(0, inputfilter, 0) sumfilter.set_input_port(1, inputfilter, 1) outputfilter.set_input_port(0, sumfilter, 0) outputfilter.process(1000) assert_almost_equal(2*input[0], output[0])
def MiddleSide_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleMiddleSideFilter from numpy.testing import assert_almost_equal t = np.arange(1000, dtype=np.float64) input = np.sin(np.array((t, t)) * 1000 * 2 * np.pi / 48000) output = np.ascontiguousarray(np.zeros(2000, dtype=np.float64).reshape(2, -1)) inputfilter = DoubleInPointerFilter(input, False) msfilter = DoubleMiddleSideFilter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.set_output_sampling_rate(48000) msfilter.set_input_sampling_rate(48000) outputfilter.set_input_sampling_rate(48000) msfilter.set_input_port(0, inputfilter, 0) msfilter.set_input_port(1, inputfilter, 1) outputfilter.set_input_port(0, msfilter, 0) outputfilter.set_input_port(1, msfilter, 1) outputfilter.process(1000) assert_almost_equal(input[0], output[0]) assert_almost_equal(0, output[1])
def Decimation_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleDecimationFilter from numpy.testing import assert_almost_equal input = np.sin(np.arange(2000, dtype=np.float64)[None,:] * 1000 * 2 * np.pi / 96000) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None,:]) inputfilter = DoubleInPointerFilter(input, False) decimationfilter = DoubleDecimationFilter(1) outputfilter = DoubleOutPointerFilter(output, False) inputfilter.set_output_sampling_rate(96000) decimationfilter.set_input_sampling_rate(96000) decimationfilter.set_output_sampling_rate(48000) outputfilter.set_input_sampling_rate(48000) decimationfilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, decimationfilter, 0) outputfilter.process(1000) assert_almost_equal(input[:,::2], output)
def filter(input, blend=0, feedback=0, feedforward=1): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(sample_rate) noisefilter = DoubleCachedSinusGeneratorFilter(1, 2) noisefilter.set_input_sampling_rate(sample_rate) noisefilter.set_offset(10000) noisefilter.set_volume(2000) lowfilter = DoubleTimeVaryingBandPassCoefficientsIIRFilter() lowfilter.set_input_sampling_rate(sample_rate) lowfilter.set_Q(1) lowfilter.set_min_frequency(8000) lowfilter.set_max_frequency(12000) lowfilter.set_number_of_steps(10001) lowfilter.set_input_port(0, infilter, 0) lowfilter.set_input_port(1, noisefilter, 0) outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(sample_rate) outfilter.set_input_port(0, lowfilter, 0) outfilter.process(input.shape[1]) return output
def filter(input, ratio=4, threshold=1, softness=1): import numpy as np output = np.zeros(input.shape, dtype=np.float64) input2 = input**2 in2filter = DoubleInPointerFilter(input2, False) in2filter.set_input_sampling_rate(sample_rate) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(sample_rate) gainfilter = DoubleGainCompressorFilter(1) gainfilter.set_input_sampling_rate(sample_rate) gainfilter.set_input_port(0, in2filter, 0) gainfilter.set_threshold(threshold) gainfilter.set_ratio(ratio) gainfilter.set_softness(softness) applygainfilter = DoubleApplyGainFilter(1) applygainfilter.set_input_sampling_rate(sample_rate) applygainfilter.set_input_port(0, gainfilter, 0) applygainfilter.set_input_port(1, infilter, 0) outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(sample_rate) outfilter.set_input_port(0, applygainfilter, 0) outfilter.process(input.shape[1]) return output
def DoubleBandPassCoefficientsIIRFilter_test():
import numpy as np
from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter
from ATK.EQ import DoubleSecondOrderBandPassFilter
from numpy.testing import assert_almost_equal
input = np.sin(
np.arange(1000, dtype=np.float64)[None, :] * 1000 * 2 * np.pi / 48000)
output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None, :])
inputfilter = DoubleInPointerFilter(input, False)
EQfilter = DoubleSecondOrderBandPassFilter()
outputfilter = DoubleOutPointerFilter(output, False)
inputfilter.set_output_sampling_rate(48000)
EQfilter.set_input_sampling_rate(48000)
EQfilter.set_Q(1)
EQfilter.set_cut_frequency(1000)
outputfilter.set_input_sampling_rate(48000)
EQfilter.set_input_port(0, inputfilter, 0)
outputfilter.set_input_port(0, EQfilter, 0)
outputfilter.process(1000)
assert_almost_equal(input[0, 500:],
input[0, 500] / output[0, 500] * output[0, 500:])
def Volume_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleVolumeFilter from numpy.testing import assert_almost_equal input = np.sin(np.arange(1000, dtype=np.float64)[None,:] * 1000 * 2 * np.pi / 48000) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None,:]) inputfilter = DoubleInPointerFilter(input, False) volumefilter = DoubleVolumeFilter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.set_output_sampling_rate(48000) volumefilter.set_input_sampling_rate(48000) volumefilter.set_volume(.5) outputfilter.set_input_sampling_rate(48000) volumefilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, volumefilter, 0) outputfilter.process(1000) assert_almost_equal(.5 * input, output)
def filter_32(input): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(48000) overfilter = DoubleOversampling6points5order_32Filter() overfilter.set_input_sampling_rate(48000) overfilter.set_output_sampling_rate(48000 * 32) overfilter.set_input_port(0, infilter, 0) overdrivefilter = DoubleFollowerTransistorClassAFilter.build_standard_filter() overdrivefilter.set_input_sampling_rate(48000 * 32) overdrivefilter.set_input_port(0, overfilter, 0) lowpassfilter = DoubleButterworthLowPassFilter() lowpassfilter.set_input_sampling_rate(48000 * 32) lowpassfilter.set_cut_frequency(48000) lowpassfilter.set_order(5) lowpassfilter.set_input_port(0, overdrivefilter, 0) decimationfilter = DoubleDecimationFilter(1) decimationfilter.set_input_sampling_rate(48000 * 32) decimationfilter.set_output_sampling_rate(48000) decimationfilter.set_input_port(0, lowpassfilter, 0) outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(48000) outfilter.set_input_port(0, decimationfilter, 0) outfilter.process(input.shape[1]) return output
def Oversampling_16_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleOversampling6points5order_16Filter from numpy.testing import assert_almost_equal ref = np.sin(np.arange(16000, dtype=np.float64)[None,:] * 1000 * 2 * np.pi / 768000) input = np.ascontiguousarray(ref[:, ::16]) output = np.ascontiguousarray(np.zeros(16000, dtype=np.float64)[None,:]) inputfilter = DoubleInPointerFilter(input, False) oversamplingfilter = DoubleOversampling6points5order_16Filter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.set_output_sampling_rate(48000) oversamplingfilter.set_input_sampling_rate(48000) oversamplingfilter.set_output_sampling_rate(768000) outputfilter.set_input_sampling_rate(768000) oversamplingfilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, oversamplingfilter, 0) outputfilter.process(16000) assert_almost_equal(ref[:,952:-48], output[:,1000:], decimal=2)
def Sum_test():
import numpy as np
from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter
from ATK.Tools import DoubleSumFilter
from numpy.testing import assert_almost_equal
t = np.arange(1000, dtype=np.float64)
input = np.sin(np.array((t, t)) * 1000 * 2 * np.pi / 48000)
output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None, :])
inputfilter = DoubleInPointerFilter(input, False)
sumfilter = DoubleSumFilter()
outputfilter = DoubleOutPointerFilter(output, False)
inputfilter.set_output_sampling_rate(48000)
sumfilter.set_input_sampling_rate(48000)
outputfilter.set_input_sampling_rate(48000)
sumfilter.set_input_port(0, inputfilter, 0)
sumfilter.set_input_port(1, inputfilter, 1)
outputfilter.set_input_port(0, sumfilter, 0)
outputfilter.process(1000)
assert_almost_equal(2 * input[0], output[0])
def Volume_test():
import numpy as np
from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter
from ATK.Tools import DoubleVolumeFilter
from numpy.testing import assert_almost_equal
input = np.sin(
np.arange(1000, dtype=np.float64)[None, :] * 1000 * 2 * np.pi / 48000)
output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None, :])
inputfilter = DoubleInPointerFilter(input, False)
volumefilter = DoubleVolumeFilter()
outputfilter = DoubleOutPointerFilter(output, False)
inputfilter.set_output_sampling_rate(48000)
volumefilter.set_input_sampling_rate(48000)
volumefilter.set_volume(.5)
outputfilter.set_input_sampling_rate(48000)
volumefilter.set_input_port(0, inputfilter, 0)
outputfilter.set_input_port(0, volumefilter, 0)
outputfilter.process(1000)
assert_almost_equal(.5 * input, output)
def filter(input, blend=0, feedback=0, feedforward=1):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
infilter = DoubleInPointerFilter(input, False)
infilter.set_output_sampling_rate(sample_rate)
generator = DoubleCachedSinusGeneratorFilter(1, 1)
generator.set_output_sampling_rate(sample_rate)
generator.set_volume(1e-3 * sample_rate)
generator.set_offset(1.5e-3 * sample_rate)
delayfilter = DoubleUniversalVariableDelayLineFilter(5000)
delayfilter.set_input_sampling_rate(sample_rate)
delayfilter.set_input_port(0, infilter, 0)
delayfilter.set_input_port(1, generator, 0)
delayfilter.set_blend(blend)
delayfilter.set_feedback(feedback)
delayfilter.set_feedforward(feedforward)
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(sample_rate)
outfilter.set_input_port(0, delayfilter, 0)
outfilter.process(input.shape[1])
return output
def Decimation_test():
import numpy as np
from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter
from ATK.Tools import DoubleDecimationFilter
from numpy.testing import assert_almost_equal
input = np.sin(
np.arange(2000, dtype=np.float64)[None, :] * 1000 * 2 * np.pi / 96000)
output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None, :])
inputfilter = DoubleInPointerFilter(input, False)
decimationfilter = DoubleDecimationFilter(1)
outputfilter = DoubleOutPointerFilter(output, False)
inputfilter.set_output_sampling_rate(96000)
decimationfilter.set_input_sampling_rate(96000)
decimationfilter.set_output_sampling_rate(48000)
outputfilter.set_input_sampling_rate(48000)
decimationfilter.set_input_port(0, inputfilter, 0)
outputfilter.set_input_port(0, decimationfilter, 0)
outputfilter.process(1000)
assert_almost_equal(input[:, ::2], output)
def filter(input, blend=0, feedback=0, feedforward=1):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
infilter = DoubleInPointerFilter(input, False)
infilter.set_input_sampling_rate(sample_rate)
noisefilter = DoubleWhiteNoiseGeneratorFilter()
noisefilter.set_input_sampling_rate(sample_rate)
noisefilter.set_offset(50e-3 * sample_rate)
noisefilter.set_volume(25e-3 * sample_rate)
lownoisefilter = DoubleLowPassCoefficientsIIRFilter()
lownoisefilter.set_input_sampling_rate(sample_rate)
lownoisefilter.set_cut_frequency(5)
lownoisefilter.set_input_port(0, noisefilter, 0)
delayfilter = DoubleUniversalVariableDelayLineFilter(5000)
delayfilter.set_input_sampling_rate(sample_rate)
delayfilter.set_input_port(0, infilter, 0)
delayfilter.set_input_port(1, lownoisefilter, 0)
delayfilter.set_blend(blend)
delayfilter.set_feedback(feedback)
delayfilter.set_feedforward(feedforward)
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(sample_rate)
outfilter.set_input_port(0, delayfilter, 0)
outfilter.process(input.shape[1])
return output
def max_colored_filter(input, ratio=4, threshold=1, softness=1, quality=1, color=1, max_reduction=-10): import numpy as np output = np.zeros(input.shape, dtype=np.float64) input2 = input**2 in2filter = DoubleInPointerFilter(input2, False) in2filter.set_input_sampling_rate(sample_rate) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(sample_rate) gainfilter = DoubleGainMaxColoredExpanderFilter(1) gainfilter.set_input_sampling_rate(sample_rate) gainfilter.set_input_port(0, in2filter, 0) gainfilter.set_threshold(threshold) gainfilter.set_ratio(ratio) gainfilter.set_color(color) gainfilter.set_softness(softness) gainfilter.set_quality(quality) gainfilter.set_max_reduction_db(max_reduction) applygainfilter = DoubleApplyGainFilter(1) applygainfilter.set_input_sampling_rate(sample_rate) applygainfilter.set_input_port(0, gainfilter, 0) applygainfilter.set_input_port(1, infilter, 0) outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(sample_rate) outfilter.set_input_port(0, applygainfilter, 0) outfilter.process(input.shape[1]) return output
def filter(input, blend=0, feedback=0, feedforward=1): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(sample_rate) noisefilter = DoubleWhiteNoiseGeneratorFilter() noisefilter.set_input_sampling_rate(sample_rate) noisefilter.set_offset(50e-3 * sample_rate) noisefilter.set_volume(25e-3 * sample_rate) lownoisefilter = DoubleLowPassCoefficientsIIRFilter() lownoisefilter.set_input_sampling_rate(sample_rate) lownoisefilter.set_cut_frequency(5) lownoisefilter.set_input_port(0, noisefilter, 0) delayfilter = DoubleUniversalVariableDelayLineFilter(5000) delayfilter.set_input_sampling_rate(sample_rate) delayfilter.set_input_port(0, infilter, 0) delayfilter.set_input_port(1, lownoisefilter, 0) delayfilter.set_blend(blend) delayfilter.set_feedback(feedback) delayfilter.set_feedforward(feedforward) outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(sample_rate) outfilter.set_input_port(0, delayfilter, 0) outfilter.process(input.shape[1]) return output
def filter_8(input):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
infilter = DoubleInPointerFilter(input, False)
infilter.set_input_sampling_rate(sample_rate)
overfilter = DoubleOversampling6points5order_8Filter()
overfilter.set_input_sampling_rate(sample_rate)
overfilter.set_output_sampling_rate(sample_rate * 8)
overfilter.set_input_port(0, infilter, 0)
overdrivefilter = DoubleTransistorClassAFilter.build_standard_filter()
overdrivefilter.set_input_sampling_rate(sample_rate * 8)
overdrivefilter.set_input_port(0, overfilter, 0)
lowpassfilter = DoubleButterworthLowPassFilter()
lowpassfilter.set_input_sampling_rate(sample_rate * 8)
lowpassfilter.set_cut_frequency(20000)
lowpassfilter.set_order(10)
lowpassfilter.set_input_port(0, overdrivefilter, 0)
decimationfilter = DoubleDecimationFilter(1)
decimationfilter.set_input_sampling_rate(sample_rate * 8)
decimationfilter.set_output_sampling_rate(sample_rate)
decimationfilter.set_input_port(0, lowpassfilter, 0)
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(sample_rate)
outfilter.set_input_port(0, decimationfilter, 0)
outfilter.process(input.shape[1])
return output
def filter_4(input): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(48000) overfilter = DoubleOversampling6points5order_4Filter() overfilter.set_input_sampling_rate(48000) overfilter.set_output_sampling_rate(48000 * 4) overfilter.set_input_port(0, infilter, 0) overdrivefilter = DoubleSimpleOverdriveFilter() overdrivefilter.set_input_sampling_rate(48000 * 4) overdrivefilter.set_input_port(0, overfilter, 0) lowpassfilter = DoubleButterworthLowPassFilter() lowpassfilter.set_input_sampling_rate(48000 * 4) lowpassfilter.set_cut_frequency(48000) lowpassfilter.set_order(5) lowpassfilter.set_input_port(0, overdrivefilter, 0) decimationfilter = DoubleDecimationFilter(1) decimationfilter.set_input_sampling_rate(48000 * 4) decimationfilter.set_output_sampling_rate(48000) decimationfilter.set_input_port(0, lowpassfilter, 0) outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(48000) outfilter.set_input_port(0, decimationfilter, 0) outfilter.process(input.shape[1]) return output
def filter_ts9(input):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
inputfilter = DoubleInPointerFilter(input, False)
inputfilter.set_input_sampling_rate(sample_rate)
infilter = DoubleChamberlinFilter()
infilter.set_input_sampling_rate(sample_rate)
infilter.set_input_port(0, inputfilter, 0)
infilter.select(0)
infilter.set_attenuation(1)
infilter.set_cut_frequency(1000)
overfilter = DoubleOversampling6points5order_4Filter()
overfilter.set_input_sampling_rate(sample_rate)
overfilter.set_output_sampling_rate(sample_rate * 4)
overfilter.set_input_port(0, infilter, 0)
overdrivefilter = DoubleTS9OverdriveFilter()
overdrivefilter.set_input_sampling_rate(sample_rate * 4)
overdrivefilter.set_input_port(0, overfilter, 0)
overdrivefilter.set_drive(0.9)
lowpassfilter = DoubleButterworthLowPassFilter()
lowpassfilter.set_input_sampling_rate(sample_rate * 4)
lowpassfilter.set_cut_frequency(sample_rate)
lowpassfilter.set_order(5)
lowpassfilter.set_input_port(0, overdrivefilter, 0)
decimationfilter = DoubleDecimationFilter(1)
decimationfilter.set_input_sampling_rate(sample_rate * 4)
decimationfilter.set_output_sampling_rate(sample_rate)
decimationfilter.set_input_port(0, lowpassfilter, 0)
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(sample_rate)
outfilter.set_input_port(0, decimationfilter, 0)
outfilter.process(input.shape[1])
return output
def Oversampling_16_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleOversampling6points5order_16Filter from numpy.testing import assert_almost_equal ref = np.sin(np.arange(16000, dtype=np.float64)[None,:] * 1000 * 2 * np.pi / 768000) input = np.ascontiguousarray(ref[:, ::16]) output = np.ascontiguousarray(np.zeros(16000, dtype=np.float64)[None,:]) inputfilter = DoubleInPointerFilter(input, False) oversamplingfilter = DoubleOversampling6points5order_16Filter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.set_output_sampling_rate(48000) oversamplingfilter.set_input_sampling_rate(48000) oversamplingfilter.set_output_sampling_rate(768000) outputfilter.set_input_sampling_rate(768000) oversamplingfilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, oversamplingfilter, 0) outputfilter.process(16000) assert_almost_equal(ref[:,952:-48], output[:,1000:], decimal=1)
def MiddleSide_test():
import numpy as np
from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter
from ATK.Tools import DoubleMiddleSideFilter
from numpy.testing import assert_almost_equal
t = np.arange(1000, dtype=np.float64)
input = np.sin(np.array((t, t)) * 1000 * 2 * np.pi / 48000)
output = np.ascontiguousarray(
np.zeros(2000, dtype=np.float64).reshape(2, -1))
inputfilter = DoubleInPointerFilter(input, False)
msfilter = DoubleMiddleSideFilter()
outputfilter = DoubleOutPointerFilter(output, False)
inputfilter.set_output_sampling_rate(48000)
msfilter.set_input_sampling_rate(48000)
outputfilter.set_input_sampling_rate(48000)
msfilter.set_input_port(0, inputfilter, 0)
msfilter.set_input_port(1, inputfilter, 1)
outputfilter.set_input_port(0, msfilter, 0)
outputfilter.set_input_port(1, msfilter, 1)
outputfilter.process(1000)
assert_almost_equal(input[0] * 2, output[0])
assert_almost_equal(0, output[1])
def Pan_linear_left_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoublePanFilter from numpy.testing import assert_almost_equal t = np.arange(1000, dtype=np.float64)[None, :] input = np.sin(t * 1000 * 2 * np.pi / 48000) output = np.ascontiguousarray(np.zeros(2000, dtype=np.float64).reshape(2, -1)) inputfilter = DoubleInPointerFilter(input, False) panfilter = DoublePanFilter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.set_output_sampling_rate(48000) panfilter.set_input_sampling_rate(48000) panfilter.set_pan_law(DoublePanFilter.LINEAR_TAPER) panfilter.set_pan(-1) outputfilter.set_input_sampling_rate(48000) panfilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, panfilter, 0) outputfilter.set_input_port(1, panfilter, 1) outputfilter.process(1000) assert_almost_equal(input[0], output[0]) assert_almost_equal(0, output[1])
def filter_32(input):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
inputfilter = DoubleInPointerFilter(input, False)
inputfilter.set_input_sampling_rate(sample_rate)
infilter = DoubleChamberlinFilter()
infilter.set_input_sampling_rate(sample_rate)
infilter.set_input_port(0, inputfilter, 0)
infilter.select(0)
infilter.set_attenuation(1)
infilter.set_cut_frequency(1000)
overfilter = DoubleOversampling6points5order_32Filter()
overfilter.set_input_sampling_rate(sample_rate)
overfilter.set_output_sampling_rate(sample_rate * 32)
overfilter.set_input_port(0, infilter, 0)
overdrivefilter = DoubleSD1OverdriveFilter()
overdrivefilter.set_input_sampling_rate(sample_rate * 32)
overdrivefilter.set_input_port(0, overfilter, 0)
overdrivefilter.set_drive(0.9)
lowpassfilter = DoubleButterworthLowPassFilter()
lowpassfilter.set_input_sampling_rate(sample_rate * 32)
lowpassfilter.set_cut_frequency(20000)
lowpassfilter.set_order(5)
lowpassfilter.set_input_port(0, overdrivefilter, 0)
lowpassfilter2 = DoubleButterworthLowPassFilter()
lowpassfilter2.set_input_sampling_rate(sample_rate * 32)
lowpassfilter2.set_cut_frequency(20000)
lowpassfilter2.set_order(5)
lowpassfilter2.set_input_port(0, lowpassfilter, 0)
lowpassfilter3 = DoubleButterworthLowPassFilter()
lowpassfilter3.set_input_sampling_rate(sample_rate * 32)
lowpassfilter3.set_cut_frequency(20000)
lowpassfilter3.set_order(5)
lowpassfilter3.set_input_port(0, lowpassfilter2, 0)
decimationfilter = DoubleDecimationFilter(1)
decimationfilter.set_input_sampling_rate(sample_rate * 32)
decimationfilter.set_output_sampling_rate(sample_rate)
decimationfilter.set_input_port(0, lowpassfilter3, 0)
#tonefilter = DoubleSD1ToneFilter()
#tonefilter.set_input_sampling_rate(sample_rate)
#tonefilter.set_input_port(0, decimationfilter, 0)
#tonefilter.set_tone(1)
#highpassfilter = DoubleChamberlinFilter()
#highpassfilter.set_input_sampling_rate(sample_rate)
#highpassfilter.set_input_port(0, tonefilter, 0)
#highpassfilter.select(2)
#highpassfilter.set_attenuation(1)
#highpassfilter.set_cut_frequency(20)
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(sample_rate)
#outfilter.set_input_port(0, highpassfilter, 0)
outfilter.set_input_port(0, decimationfilter, 0)
outfilter.process(input.shape[1])
return output
def filter(inputl,
inputr,
blend_ch1=0,
blend_ch2=0,
feedback_ch1_ch1=0,
feedback_ch1_ch2=0,
feedback_ch2_ch1=0,
feedback_ch2_ch2=0,
feedforward_ch1_ch1=1,
feedforward_ch1_ch2=0,
feedforward_ch2_ch1=0,
feedforward_ch2_ch2=1):
import numpy as np
outputl = np.zeros(inputl.shape, dtype=np.float64)
outputr = np.zeros(inputl.shape, dtype=np.float64)
infilterL = DoubleInPointerFilter(inputl, False)
infilterL.set_input_sampling_rate(sample_rate)
infilterR = DoubleInPointerFilter(inputr, False)
infilterR.set_input_sampling_rate(sample_rate)
delayfilter = DoubleStereoUniversalFixedDelayLineFilter(100000)
delayfilter.set_input_sampling_rate(sample_rate)
delayfilter.set_input_port(0, infilterL, 0)
delayfilter.set_input_port(1, infilterR, 0)
delayfilter.set_delay_ch1(4800) #50ms
delayfilter.set_delay_ch2(3600) #37.5ms
delayfilter.set_blend_ch1(blend_ch1)
delayfilter.set_blend_ch1(blend_ch2)
delayfilter.set_feedback_ch1_ch1(feedback_ch1_ch1)
delayfilter.set_feedback_ch1_ch2(feedback_ch1_ch2)
delayfilter.set_feedback_ch2_ch1(feedback_ch2_ch1)
delayfilter.set_feedback_ch2_ch2(feedback_ch2_ch2)
delayfilter.set_feedforward_ch1_ch1(feedforward_ch1_ch1)
delayfilter.set_feedforward_ch1_ch2(feedforward_ch1_ch2)
delayfilter.set_feedforward_ch2_ch1(feedforward_ch2_ch1)
delayfilter.set_feedforward_ch2_ch2(feedforward_ch2_ch2)
outfilterl = DoubleOutPointerFilter(outputl, False)
outfilterl.set_input_sampling_rate(sample_rate)
outfilterl.set_input_port(0, delayfilter, 0)
outfilterr = DoubleOutPointerFilter(outputr, False)
outfilterr.set_input_sampling_rate(sample_rate)
outfilterr.set_input_port(0, delayfilter, 1)
pipelineend = PipelineGlobalSinkFilter()
pipelineend.set_input_sampling_rate(sample_rate)
pipelineend.add_filter(outfilterl)
pipelineend.add_filter(outfilterr)
pipelineend.process(inputl.shape[1])
return outputl, outputr
def DoublePointerFilter_new_test():
import numpy as np
from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter
from numpy.testing import assert_equal
input = np.ascontiguousarray(np.arange(1000, dtype=np.float64)[None, :])
output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None, :])
inputfilter = DoubleInPointerFilter(input, False)
outputfilter = DoubleOutPointerFilter(output, False)
outputfilter.set_input_port(0, inputfilter, 0)
inputfilter.set_output_sampling_rate(48000)
outputfilter.set_input_sampling_rate(48000)
outputfilter.process(1000)
assert_equal(input, output)
def DoublePointerFilter_new_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from numpy.testing import assert_equal input = np.ascontiguousarray(np.arange(1000, dtype=np.float64)[None,:]) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)[None,:]) inputfilter = DoubleInPointerFilter(input, False) outputfilter = DoubleOutPointerFilter(output, False) outputfilter.set_input_port(0, inputfilter, 0) inputfilter.set_output_sampling_rate(48000) outputfilter.set_input_sampling_rate(48000) outputfilter.process(1000) assert_equal(input, output)
def filter_32(input): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(sample_rate) overfilter = DoubleOversampling6points5order_32Filter() overfilter.set_input_sampling_rate(sample_rate) overfilter.set_output_sampling_rate(sample_rate * 32) overfilter.set_input_port(0, infilter, 0) overdrivefilter = DoubleSD1OverdriveFilter() overdrivefilter.set_input_sampling_rate(sample_rate * 32) overdrivefilter.set_input_port(0, overfilter, 0) overdrivefilter.set_drive(0.9) lowpassfilter = DoubleButterworthLowPassFilter() lowpassfilter.set_input_sampling_rate(sample_rate * 32) lowpassfilter.set_cut_frequency(20000) lowpassfilter.set_order(5) lowpassfilter.set_input_port(0, overdrivefilter, 0) lowpassfilter2 = DoubleButterworthLowPassFilter() lowpassfilter2.set_input_sampling_rate(sample_rate * 32) lowpassfilter2.set_cut_frequency(20000) lowpassfilter2.set_order(5) lowpassfilter2.set_input_port(0, lowpassfilter, 0) lowpassfilter3 = DoubleButterworthLowPassFilter() lowpassfilter3.set_input_sampling_rate(sample_rate * 32) lowpassfilter3.set_cut_frequency(20000) lowpassfilter3.set_order(5) lowpassfilter3.set_input_port(0, lowpassfilter2, 0) decimationfilter = DoubleDecimationFilter(1) decimationfilter.set_input_sampling_rate(sample_rate * 32) decimationfilter.set_output_sampling_rate(sample_rate) decimationfilter.set_input_port(0, lowpassfilter3, 0) tonefilter = DoubleSD1ToneFilter() tonefilter.set_input_sampling_rate(sample_rate) tonefilter.set_input_port(0, decimationfilter, 0) tonefilter.set_tone(1) highpassfilter = DoubleChamberlinFilter() highpassfilter.set_input_sampling_rate(sample_rate) highpassfilter.set_input_port(0, tonefilter, 0) highpassfilter.select(2) highpassfilter.set_attenuation(1) highpassfilter.set_cut_frequency(20) outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(sample_rate) outfilter.set_input_port(0, highpassfilter, 0) outfilter.process(input.shape[1]) return output
def tone_filter(input): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(sampling) tonefilter = DoubleSD1ToneFilter() tonefilter.set_input_sampling_rate(sampling) tonefilter.set_input_port(0, infilter, 0) tonefilter.set_tone(0.5) print tonefilter.get_coefficients_in() print tonefilter.get_coefficients_out() outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(sampling) outfilter.set_input_port(0, tonefilter, 0) outfilter.process(input.shape[1]) return output
def tone_filter(input):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
infilter = DoubleInPointerFilter(input, False)
infilter.set_input_sampling_rate(sampling)
tonefilter = DoubleSD1ToneFilter()
tonefilter.set_input_sampling_rate(sampling)
tonefilter.set_input_port(0, infilter, 0)
tonefilter.set_tone(0.5)
print tonefilter.get_coefficients_in()
print tonefilter.get_coefficients_out()
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(sampling)
outfilter.set_input_port(0, tonefilter, 0)
outfilter.process(input.shape[1])
return output
def filter_bandstop(input): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(48000) bandstopfilter = DoubleButterworthBandStopFilter() bandstopfilter.set_input_sampling_rate(48000) bandstopfilter.set_cut_frequencies(200, 1000) bandstopfilter.set_order(5) bandstopfilter.set_input_port(0, infilter, 0) print bandstopfilter.get_coefficients_in() print bandstopfilter.get_coefficients_out() outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(48000) outfilter.set_input_port(0, bandstopfilter, 0) outfilter.process(input.shape[1]) return output
def filter_bandstop(input):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
infilter = DoubleInPointerFilter(input, False)
infilter.set_input_sampling_rate(48000)
bandstopfilter = DoubleBesselBandStopFilter()
bandstopfilter.set_input_sampling_rate(48000)
bandstopfilter.set_cut_frequencies(200, 1000)
bandstopfilter.set_order(5)
bandstopfilter.set_input_port(0, infilter, 0)
print bandstopfilter.get_coefficients_in()
print bandstopfilter.get_coefficients_out()
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(48000)
outfilter.set_input_port(0, bandstopfilter, 0)
outfilter.process(input.shape[1])
return output
def filter_low(input):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
infilter = DoubleInPointerFilter(input, False)
infilter.set_input_sampling_rate(48000)
lowpassfilter = DoubleBesselLowPassFilter()
lowpassfilter.set_input_sampling_rate(48000)
lowpassfilter.set_cut_frequency(1000)
lowpassfilter.set_order(5)
lowpassfilter.set_input_port(0, infilter, 0)
print lowpassfilter.get_coefficients_in()
print lowpassfilter.get_coefficients_out()
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(48000)
outfilter.set_input_port(0, lowpassfilter, 0)
outfilter.process(input.shape[1])
return output
def filter_low(input): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(48000) lowpassfilter = DoubleButterworthLowPassFilter() lowpassfilter.set_input_sampling_rate(48000) lowpassfilter.set_cut_frequency(1000) lowpassfilter.set_order(5) lowpassfilter.set_input_port(0, infilter, 0) print lowpassfilter.get_coefficients_in() print lowpassfilter.get_coefficients_out() outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(48000) outfilter.set_input_port(0, lowpassfilter, 0) outfilter.process(input.shape[1]) return output
def filter(inputl, inputr, blend_ch1=0, blend_ch2=0,
feedback_ch1_ch1=0, feedback_ch1_ch2=0, feedback_ch2_ch1=0, feedback_ch2_ch2=0,
feedforward_ch1_ch1=1, feedforward_ch1_ch2=0, feedforward_ch2_ch1=0, feedforward_ch2_ch2=1):
import numpy as np
outputl = np.zeros(inputl.shape, dtype=np.float64)
outputr = np.zeros(inputl.shape, dtype=np.float64)
infilterL = DoubleInPointerFilter(inputl, False)
infilterL.set_input_sampling_rate(sample_rate)
infilterR = DoubleInPointerFilter(inputr, False)
infilterR.set_input_sampling_rate(sample_rate)
delayfilter = DoubleStereoUniversalFixedDelayLineFilter(5000)
delayfilter.set_input_sampling_rate(sample_rate)
delayfilter.set_input_port(0, infilterL, 0)
delayfilter.set_input_port(1, infilterR, 0)
delayfilter.set_delay_ch1(4800) #50ms
delayfilter.set_delay_ch2(3600) #37.5ms
delayfilter.set_blend_ch1(blend_ch1)
delayfilter.set_blend_ch1(blend_ch2)
delayfilter.set_feedback_ch1_ch1(feedback_ch1_ch1)
delayfilter.set_feedback_ch1_ch2(feedback_ch1_ch2)
delayfilter.set_feedback_ch2_ch1(feedback_ch2_ch1)
delayfilter.set_feedback_ch2_ch2(feedback_ch2_ch2)
delayfilter.set_feedforward_ch1_ch1(feedforward_ch1_ch1)
delayfilter.set_feedforward_ch1_ch2(feedforward_ch1_ch2)
delayfilter.set_feedforward_ch2_ch1(feedforward_ch2_ch1)
delayfilter.set_feedforward_ch2_ch2(feedforward_ch2_ch2)
outfilterl = DoubleOutPointerFilter(outputl, False)
outfilterl.set_input_sampling_rate(sample_rate)
outfilterl.set_input_port(0, delayfilter, 0)
outfilterr = DoubleOutPointerFilter(outputr, False)
outfilterr.set_input_sampling_rate(sample_rate)
outfilterr.set_input_port(0, delayfilter, 1)
pipelineend = PipelineGlobalSinkFilter()
pipelineend.set_input_sampling_rate(sample_rate)
pipelineend.add_filter(outfilterl)
pipelineend.add_filter(outfilterr)
pipelineend.process(inputl.shape[1])
return outputl, outputr
def filter_high(input): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(48000) highpassfilter = DoubleChebyshev2HighPassFilter() highpassfilter.set_input_sampling_rate(48000) highpassfilter.set_cut_frequency(1000) highpassfilter.set_order(5) highpassfilter.set_ripple(3) highpassfilter.set_input_port(0, infilter, 0) print highpassfilter.get_coefficients_in() print highpassfilter.get_coefficients_out() outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(48000) outfilter.set_input_port(0, highpassfilter, 0) outfilter.process(input.shape[1]) return output
def filter_high(input):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
infilter = DoubleInPointerFilter(input, False)
infilter.set_input_sampling_rate(48000)
highpassfilter = DoubleChebyshev2HighPassFilter()
highpassfilter.set_input_sampling_rate(48000)
highpassfilter.set_cut_frequency(1000)
highpassfilter.set_order(5)
highpassfilter.set_ripple(3)
highpassfilter.set_input_port(0, infilter, 0)
print highpassfilter.get_coefficients_in()
print highpassfilter.get_coefficients_out()
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(48000)
outfilter.set_input_port(0, highpassfilter, 0)
outfilter.process(input.shape[1])
return output
def filter(input):
import numpy as np
output = np.zeros((1, input.shape[1] * 32), dtype=np.float64)
infilter = DoubleInPointerFilter(input, False)
infilter.set_input_sampling_rate(sample_rate)
overfilter = DoubleOversampling6points5order_32Filter()
overfilter.set_input_sampling_rate(sample_rate)
overfilter.set_output_sampling_rate(sample_rate * 32)
overfilter.set_input_port(0, infilter, 0)
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(sample_rate * 32)
outfilter.set_input_port(0, overfilter, 0)
for i in range(10):
outfilter.process(input.shape[1] * 32 / 10)
return output
def filter(input, blend=0, feedback=0, feedforward=1): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(sample_rate) delayfilter = DoubleUniversalFixedDelayLineFilter(5000) delayfilter.set_input_sampling_rate(sample_rate) delayfilter.set_input_port(0, infilter, 0) delayfilter.set_delay(4800) #50ms delayfilter.set_blend(blend) delayfilter.set_feedback(feedback) delayfilter.set_feedforward(feedforward) outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(sample_rate) outfilter.set_input_port(0, delayfilter, 0) outfilter.process(input.shape[1]) return output
def filter(input, blend=0, feedback=0, feedforward=1):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
infilter = DoubleInPointerFilter(input, False)
infilter.set_input_sampling_rate(sample_rate)
delayfilter = DoubleUniversalFixedDelayLineFilter(5000)
delayfilter.set_input_sampling_rate(sample_rate)
delayfilter.set_input_port(0, infilter, 0)
delayfilter.set_delay(4800) #50ms
delayfilter.set_blend(blend)
delayfilter.set_feedback(feedback)
delayfilter.set_feedforward(feedforward)
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(sample_rate)
outfilter.set_input_port(0, delayfilter, 0)
outfilter.process(input.shape[1])
return output
def max_colored_filter(input,
ratio=4,
threshold=1,
softness=1,
quality=1,
color=1,
max_reduction=-10):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
input2 = input**2
in2filter = DoubleInPointerFilter(input2, False)
in2filter.set_input_sampling_rate(sample_rate)
infilter = DoubleInPointerFilter(input, False)
infilter.set_input_sampling_rate(sample_rate)
gainfilter = DoubleGainMaxColoredExpanderFilter(1)
gainfilter.set_input_sampling_rate(sample_rate)
gainfilter.set_input_port(0, in2filter, 0)
gainfilter.set_threshold(threshold)
gainfilter.set_ratio(ratio)
gainfilter.set_color(color)
gainfilter.set_softness(softness)
gainfilter.set_quality(quality)
gainfilter.set_max_reduction_db(max_reduction)
applygainfilter = DoubleApplyGainFilter(1)
applygainfilter.set_input_sampling_rate(sample_rate)
applygainfilter.set_input_port(0, gainfilter, 0)
applygainfilter.set_input_port(1, infilter, 0)
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(sample_rate)
outfilter.set_input_port(0, applygainfilter, 0)
outfilter.process(input.shape[1])
return output
def filter(input):
import numpy as np
output = np.zeros(input.shape, dtype=np.float64)
infilter = DoubleInPointerFilter(input, False)
infilter.set_input_sampling_rate(sample_rate)
sinusfilter = DoubleCachedSinusGeneratorFilter(20, 5)
sinusfilter.set_input_sampling_rate(sample_rate)
sinusfilter.set_offset(0.5)
sinusfilter.set_volume(0.5)
gainfilter = DoubleApplyGainFilter(1)
gainfilter.set_input_sampling_rate(sample_rate)
gainfilter.set_input_port(0, infilter, 0)
gainfilter.set_input_port(1, sinusfilter, 0)
outfilter = DoubleOutPointerFilter(output, False)
outfilter.set_input_sampling_rate(sample_rate)
outfilter.set_input_port(0, gainfilter, 0)
outfilter.process(input.shape[1])
return output
def filter(input): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(sample_rate) sinusfilter = DoubleCachedSinusGeneratorFilter(20, 5) sinusfilter.set_input_sampling_rate(sample_rate) sinusfilter.set_offset(0.5) sinusfilter.set_volume(0.5) gainfilter = DoubleApplyGainFilter(1) gainfilter.set_input_sampling_rate(sample_rate) gainfilter.set_input_port(0, infilter, 0) gainfilter.set_input_port(1, sinusfilter, 0) outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(sample_rate) outfilter.set_input_port(0, gainfilter, 0) outfilter.process(input.shape[1]) return output
def filter(input): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(sample_rate) powerfilter = DoublePowerFilter(1) powerfilter.set_input_sampling_rate(sample_rate) powerfilter.set_input_port(0, infilter, 0) powerfilter.set_memory(0) attackreleasefilter = DoubleAttackReleaseFilter(1) attackreleasefilter.set_input_sampling_rate(sample_rate) attackreleasefilter.set_input_port(0, powerfilter, 0) attackreleasefilter.set_attack(0) attackreleasefilter.set_release(np.exp(-1/(sample_rate*10e-3))) gainfilter = DoubleGainCompressorFilter(1) gainfilter.set_input_sampling_rate(sample_rate) gainfilter.set_input_port(0, attackreleasefilter, 0) gainfilter.set_threshold(0.0099) gainfilter.set_ratio(10000) gainfilter.set_softness(1) applygainfilter = DoubleApplyGainFilter(1) applygainfilter.set_input_sampling_rate(sample_rate) applygainfilter.set_input_port(0, gainfilter, 0) applygainfilter.set_input_port(1, infilter, 0) outfilter = DoubleOutPointerFilter(output, False) outfilter.set_input_sampling_rate(sample_rate) outfilter.set_input_port(0, applygainfilter, 0) outfilter.process(input.shape[1]) return output
data = np.sin(np.arange(processsize) * np.pi * 40 / sampling_rate).reshape(
-1, 1)
data = data**2
infilter = DoubleInPointerFilter(data, True)
infilter.set_output_sampling_rate(sampling_rate)
attackreleasefilter = DoubleAttackReleaseFilter(1)
attackreleasefilter.set_input_sampling_rate(sampling_rate)
attackreleasefilter.set_input_port(0, infilter, 0)
attackreleasefilter.set_attack(np.exp(-1 / (sampling_rate * 1e-3)))
attackreleasefilter.set_release(np.exp(-1 / (sampling_rate * 10e-3)))
outdata = np.zeros((processsize, 1), dtype=np.float64)
outfilter = DoubleOutPointerFilter(outdata, True)
outfilter.set_input_sampling_rate(sampling_rate)
outfilter.set_input_port(0, attackreleasefilter, 0)
attackreleasefilter2 = DoubleAttackReleaseHysteresisFilter(1)
attackreleasefilter2.set_input_sampling_rate(sampling_rate)
attackreleasefilter2.set_input_port(0, infilter, 0)
attackreleasefilter2.set_attack(np.exp(-1 / (sampling_rate * 1e-3)))
attackreleasefilter2.set_release(np.exp(-1 / (sampling_rate * 10e-3)))
attackreleasefilter2.set_release_hysteresis(.5)
attackreleasefilter2.set_attack_hysteresis(.9)
outdata2 = np.zeros((processsize, 1), dtype=np.float64)
outfilter_hyst = DoubleOutPointerFilter(outdata2, True)
outfilter_hyst.set_input_sampling_rate(sampling_rate)
outfilter_hyst.set_input_port(0, attackreleasefilter2, 0)
def filter(input, blend=0, feedback=0, feedforward=1): import numpy as np output1 = np.zeros(input.shape, dtype=np.float64) output2 = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.set_input_sampling_rate(sample_rate) allpass1filter = DoubleCustomIIRFilter() allpass1filter.set_input_sampling_rate(sample_rate) allpass1filter.set_input_port(0, infilter, 0) allpass1filter.set_coefficients_in((0.0000, 0.3855, 0.0000, 1.3313, 0.0000, 1.0000)[::-1]) allpass1filter.set_coefficients_out((-0.0000, -1.3313, 0.0000, -0.3855, 0)[::-1]) allpass2filter = DoubleCustomIIRFilter() allpass2filter.set_input_sampling_rate(sample_rate) allpass2filter.set_input_port(0, infilter, 0) allpass2filter.set_coefficients_in((0.0947, 0.0000, 0.8335, 0.0000, 1.0000)[::-1]) allpass2filter.set_coefficients_out((0.0000, -0.8335, 0.0000, -0.0947)[::-1]) sinusfilter = DoubleCachedSinusGeneratorFilter(100, 1) sinusfilter.set_input_sampling_rate(sample_rate) cosinusfilter = DoubleCachedCosinusGeneratorFilter(100, 1) cosinusfilter.set_input_sampling_rate(sample_rate) applygainFilter = DoubleApplyGainFilter(2) applygainFilter.set_input_sampling_rate(sample_rate) applygainFilter.set_input_port(0, allpass1filter, 0) applygainFilter.set_input_port(1, sinusfilter, 0) applygainFilter.set_input_port(2, allpass2filter, 0) applygainFilter.set_input_port(3, cosinusfilter, 0) volumeFilter = DoubleVolumeFilter() volumeFilter.set_input_sampling_rate(sample_rate) volumeFilter.set_volume(-1) volumeFilter.set_input_port(0, applygainFilter, 1) sum1Filter = DoubleSumFilter() sum1Filter.set_input_sampling_rate(sample_rate) sum1Filter.set_input_port(0, applygainFilter, 0) sum1Filter.set_input_port(1, volumeFilter, 0) sum2Filter = DoubleSumFilter() sum2Filter.set_input_sampling_rate(sample_rate) sum2Filter.set_input_port(0, applygainFilter, 0) sum2Filter.set_input_port(1, applygainFilter, 1) out1filter = DoubleOutPointerFilter(output1, False) out1filter.set_input_sampling_rate(sample_rate) out1filter.set_input_port(0, sum1Filter, 0) out2filter = DoubleOutPointerFilter(output2, False) out2filter.set_input_sampling_rate(sample_rate) out2filter.set_input_port(0, sum2Filter, 0) pipelinesink = PipelineGlobalSinkFilter() pipelinesink.set_input_sampling_rate(sample_rate) pipelinesink.add_filter(out1filter) pipelinesink.add_filter(out2filter) pipelinesink.process(input.shape[1]) return output1, output2
sampling_rate = 44100 data = np.sin(np.arange(processsize) * np.pi * 40 / sampling_rate).reshape(-1, 1) data = data ** 2 infilter = DoubleInPointerFilter(data, True) infilter.set_output_sampling_rate(sampling_rate) attackreleasefilter = DoubleAttackReleaseFilter(1) attackreleasefilter.set_input_sampling_rate(sampling_rate) attackreleasefilter.set_input_port(0, infilter, 0) attackreleasefilter.set_attack(np.exp(-1/(sampling_rate*1e-3))) attackreleasefilter.set_release(np.exp(-1/(sampling_rate*10e-3))) outdata = np.zeros((processsize, 1), dtype=np.float64) outfilter = DoubleOutPointerFilter(outdata, True) outfilter.set_input_sampling_rate(sampling_rate) outfilter.set_input_port(0, attackreleasefilter, 0) attackreleasefilter2 = DoubleAttackReleaseHysteresisFilter(1) attackreleasefilter2.set_input_sampling_rate(sampling_rate) attackreleasefilter2.set_input_port(0, infilter, 0) attackreleasefilter2.set_attack(np.exp(-1/(sampling_rate*1e-3))) attackreleasefilter2.set_release(np.exp(-1/(sampling_rate*10e-3))) attackreleasefilter2.set_release_hysteresis(.5) attackreleasefilter2.set_attack_hysteresis(.9) outdata2 = np.zeros((processsize, 1), dtype=np.float64) outfilter_hyst = DoubleOutPointerFilter(outdata2, True) outfilter_hyst.set_input_sampling_rate(sampling_rate) outfilter_hyst.set_input_port(0, attackreleasefilter2, 0)
def filter(input, blend=0, feedback=0, feedforward=1):
import numpy as np
output1 = np.zeros(input.shape, dtype=np.float64)
output2 = np.zeros(input.shape, dtype=np.float64)
infilter = DoubleInPointerFilter(input, False)
infilter.set_input_sampling_rate(sample_rate)
allpass1filter = DoubleCustomIIRFilter()
allpass1filter.set_input_sampling_rate(sample_rate)
allpass1filter.set_input_port(0, infilter, 0)
allpass1filter.set_coefficients_in(
(0.0000, 0.3855, 0.0000, 1.3313, 0.0000, 1.0000)[::-1])
allpass1filter.set_coefficients_out(
(-0.0000, -1.3313, 0.0000, -0.3855, 0)[::-1])
allpass2filter = DoubleCustomIIRFilter()
allpass2filter.set_input_sampling_rate(sample_rate)
allpass2filter.set_input_port(0, infilter, 0)
allpass2filter.set_coefficients_in(
(0.0947, 0.0000, 0.8335, 0.0000, 1.0000)[::-1])
allpass2filter.set_coefficients_out(
(0.0000, -0.8335, 0.0000, -0.0947)[::-1])
sinusfilter = DoubleCachedSinusGeneratorFilter(100, 1)
sinusfilter.set_input_sampling_rate(sample_rate)
cosinusfilter = DoubleCachedCosinusGeneratorFilter(100, 1)
cosinusfilter.set_input_sampling_rate(sample_rate)
applygainFilter = DoubleApplyGainFilter(2)
applygainFilter.set_input_sampling_rate(sample_rate)
applygainFilter.set_input_port(0, allpass1filter, 0)
applygainFilter.set_input_port(1, sinusfilter, 0)
applygainFilter.set_input_port(2, allpass2filter, 0)
applygainFilter.set_input_port(3, cosinusfilter, 0)
volumeFilter = DoubleVolumeFilter()
volumeFilter.set_input_sampling_rate(sample_rate)
volumeFilter.set_volume(-1)
volumeFilter.set_input_port(0, applygainFilter, 1)
sum1Filter = DoubleSumFilter()
sum1Filter.set_input_sampling_rate(sample_rate)
sum1Filter.set_input_port(0, applygainFilter, 0)
sum1Filter.set_input_port(1, volumeFilter, 0)
sum2Filter = DoubleSumFilter()
sum2Filter.set_input_sampling_rate(sample_rate)
sum2Filter.set_input_port(0, applygainFilter, 0)
sum2Filter.set_input_port(1, applygainFilter, 1)
out1filter = DoubleOutPointerFilter(output1, False)
out1filter.set_input_sampling_rate(sample_rate)
out1filter.set_input_port(0, sum1Filter, 0)
out2filter = DoubleOutPointerFilter(output2, False)
out2filter.set_input_sampling_rate(sample_rate)
out2filter.set_input_port(0, sum2Filter, 0)
pipelinesink = PipelineGlobalSinkFilter()
pipelinesink.set_input_sampling_rate(sample_rate)
pipelinesink.add_filter(out1filter)
pipelinesink.add_filter(out2filter)
pipelinesink.process(input.shape[1])
return output1, output2
def filter(inputl, inputr): import numpy as np outputl = np.zeros(inputl.shape, dtype=np.float64) outputr = np.zeros(inputl.shape, dtype=np.float64) infilterL = DoubleInPointerFilter(inputl, False) infilterL.set_input_sampling_rate(sample_rate) infilterR = DoubleInPointerFilter(inputr, False) infilterR.set_input_sampling_rate(sample_rate) mssplitfilter = DoubleMiddleSideFilter() mssplitfilter.set_input_sampling_rate(sample_rate) mssplitfilter.set_input_port(0, infilterL, 0) mssplitfilter.set_input_port(1, infilterR, 0) adaptgainfilter = DoubleVolumeFilter(2) adaptgainfilter.set_input_sampling_rate(sample_rate) adaptgainfilter.set_input_port(0, mssplitfilter, 0) adaptgainfilter.set_input_port(1, mssplitfilter, 1) adaptgainfilter.set_volume(.5) powerfilter1 = DoublePowerFilter() powerfilter1.set_input_sampling_rate(sample_rate) powerfilter1.set_input_port(0, adaptgainfilter, 0) powerfilter1.set_memory(np.exp(-1/(sample_rate*.1e-3))) attackreleasefilter1 = DoubleAttackReleaseFilter() attackreleasefilter1.set_input_sampling_rate(sample_rate) attackreleasefilter1.set_input_port(0, powerfilter1, 0) attackreleasefilter1.set_attack(np.exp(-1/(sample_rate*1e-3))) attackreleasefilter1.set_release(np.exp(-1/(sample_rate*100e-3))) gainfilter1 = DoubleGainCompressorFilter() gainfilter1.set_input_sampling_rate(sample_rate) gainfilter1.set_input_port(0, attackreleasefilter1, 0) gainfilter1.set_threshold(thresholds) gainfilter1.set_ratio(ratios) gainfilter1.set_softness(1) applygainfilter = DoubleApplyGainFilter(2) applygainfilter.set_input_sampling_rate(sample_rate) applygainfilter.set_input_port(0, gainfilter1, 0) applygainfilter.set_input_port(1, mssplitfilter, 0) powerfilter2 = DoublePowerFilter(1) powerfilter2.set_input_sampling_rate(sample_rate) powerfilter2.set_input_port(0, adaptgainfilter, 1) powerfilter2.set_memory(np.exp(-1/(sample_rate*.1e-3))) attackreleasefilter2 = DoubleAttackReleaseFilter() attackreleasefilter2.set_input_sampling_rate(sample_rate) attackreleasefilter2.set_input_port(0, powerfilter1, 0) attackreleasefilter2.set_attack(np.exp(-1/(sample_rate*1e-3))) attackreleasefilter2.set_release(np.exp(-1/(sample_rate*100e-3))) gainfilter2 = DoubleGainCompressorFilter() gainfilter2.set_input_sampling_rate(sample_rate) gainfilter2.set_input_port(0, attackreleasefilter2, 0) gainfilter2.set_threshold(thresholds) gainfilter2.set_ratio(ratios) gainfilter2.set_softness(1) applygainfilter.set_input_port(2, gainfilter2, 0) applygainfilter.set_input_port(3, mssplitfilter, 1) msmergefilter = DoubleMiddleSideFilter() msmergefilter.set_input_sampling_rate(sample_rate) msmergefilter.set_input_port(0, applygainfilter, 0) msmergefilter.set_input_port(1, applygainfilter, 1) volumefilter = DoubleVolumeFilter(2) volumefilter.set_input_sampling_rate(sample_rate) volumefilter.set_volume(.5) volumefilter.set_input_port(0, msmergefilter, 0) volumefilter.set_input_port(1, msmergefilter, 1) outfilterl = DoubleOutPointerFilter(outputl, False) outfilterl.set_input_sampling_rate(sample_rate) outfilterl.set_input_port(0, volumefilter, 0) outfilterr = DoubleOutPointerFilter(outputr, False) outfilterr.set_input_sampling_rate(sample_rate) outfilterr.set_input_port(0, volumefilter, 1) pipelineend = PipelineGlobalSinkFilter() pipelineend.set_input_sampling_rate(sample_rate) pipelineend.add_filter(outfilterl) pipelineend.add_filter(outfilterr) pipelineend.process(inputl.shape[1]) return outputl, outputr
