def DoubleConvertFilter2_new_test(): import numpy as np from ATK.Core import DoubleComplexToRealFilter, PipelineGlobalSinkFilter from ATK.Core import ComplexDoubleInPointerFilter, DoubleOutPointerFilter from numpy.testing import assert_equal input = np.ascontiguousarray(np.arange(1000, dtype=np.complex128)) output = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)) output2 = np.ascontiguousarray(np.zeros(1000, dtype=np.float64)) inputfilter = ComplexDoubleInPointerFilter(input) convertFilter = DoubleComplexToRealFilter() outputfilter = DoubleOutPointerFilter(output) output2filter = DoubleOutPointerFilter(output2) convertFilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, convertFilter, 0) output2filter.set_input_port(0, convertFilter, 1) inputfilter.output_sampling_rate = 48000 convertFilter.input_sampling_rate = 48000 outputfilter.input_sampling_rate = 48000 output2filter.input_sampling_rate = 48000 sink = PipelineGlobalSinkFilter() sink.add_filter(outputfilter) sink.add_filter(output2filter) sink.input_sampling_rate = 48000 sink.process(1000) assert_equal(input, output) assert_equal(0, output2)
def process(input_l, input_r): # Populate the outputs output_l = np.zeros(size, dtype=np.float64) output_r = np.zeros(size, dtype=np.float64) # Create the inputs of the pipeline from the numpy arrays infilter_l = DoubleInPointerFilter(input_l, False) infilter_l.input_sampling_rate = sample_rate infilter_r = DoubleInPointerFilter(input_r, False) infilter_r.input_sampling_rate = sample_rate # Create the intermediate buffer and connect it to the inputs buffer = DoubleBufferFilter(2) buffer.input_sampling_rate = sample_rate buffer.set_input_port(0, infilter_l, 0) buffer.set_input_port(1, infilter_r, 0) # Create the outputs and connect them to the buffer outfilter_l = DoubleOutPointerFilter(output_l, False) outfilter_l.input_sampling_rate = sample_rate outfilter_l.set_input_port(0, buffer, 1) outfilter_r = DoubleOutPointerFilter(output_r, False) outfilter_r.input_sampling_rate = sample_rate outfilter_r.set_input_port(0, buffer, 0) # Create the sink of the pipeline sink = PipelineGlobalSinkFilter() sink.input_sampling_rate = sample_rate sink.add_filter(outfilter_l) sink.add_filter(outfilter_r) # Process the pipeline sink.process(size) return (output_l, output_r)
def filter(input): infilter = DoubleInPointerFilter(input) infilter.output_sampling_rate = sampling_rate attackreleasefilter = DoubleAttackReleaseFilter(1) attackreleasefilter.input_sampling_rate = sampling_rate attackreleasefilter.set_input_port(0, infilter, 0) attackreleasefilter.attack = np.exp(-1 / (sampling_rate * 1e-3)) attackreleasefilter.release = np.exp(-1 / (sampling_rate * 10e-3)) outdata = np.zeros(processsize, dtype=np.float64) outfilter = DoubleOutPointerFilter(outdata) outfilter.input_sampling_rate = sampling_rate outfilter.set_input_port(0, attackreleasefilter, 0) attackreleasefilter2 = DoubleAttackReleaseHysteresisFilter(1) attackreleasefilter2.input_sampling_rate = sampling_rate attackreleasefilter2.set_input_port(0, infilter, 0) attackreleasefilter2.attack = np.exp(-1 / (sampling_rate * 1e-3)) attackreleasefilter2.release = np.exp(-1 / (sampling_rate * 10e-3)) attackreleasefilter2.release_hysteresis = .5 attackreleasefilter2.attack_hysteresis = .9 outdata2 = np.zeros(processsize, dtype=np.float64) outfilter_hyst = DoubleOutPointerFilter(outdata2) outfilter_hyst.input_sampling_rate = sampling_rate outfilter_hyst.set_input_port(0, attackreleasefilter2, 0) pipelineend = PipelineGlobalSinkFilter() pipelineend.input_sampling_rate = sampling_rate pipelineend.add_filter(outfilter) pipelineend.add_filter(outfilter_hyst) pipelineend.process(processsize) return outdata, outdata2
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.input_sampling_rate = sample_rate infilterR = DoubleInPointerFilter(inputr, False) infilterR.input_sampling_rate = sample_rate delayfilter = DoubleDualMultipleUniversalFixedDelayLineFilter(5000) delayfilter.input_sampling_rate = sample_rate delayfilter.set_input_port(0, infilterL, 0) delayfilter.set_input_port(1, infilterR, 0) delayfilter.set_delay(0, 4800) #50ms delayfilter.set_delay(1, 3600) #37.5ms delayfilter.set_blend(0, blend_ch1) delayfilter.set_blend(1, blend_ch2) delayfilter.set_feedback(0, 0, feedback_ch1_ch1) delayfilter.set_feedback(0, 1, feedback_ch1_ch2) delayfilter.set_feedback(1, 0, feedback_ch2_ch1) delayfilter.set_feedback(1, 1, feedback_ch2_ch2) delayfilter.set_feedforward(0, 0, feedforward_ch1_ch1) delayfilter.set_feedforward(0, 1, feedforward_ch1_ch2) delayfilter.set_feedforward(1, 0, feedforward_ch2_ch1) delayfilter.set_feedforward(1, 1, feedforward_ch2_ch2) outfilterl = DoubleOutPointerFilter(outputl, False) outfilterl.input_sampling_rate = sample_rate outfilterl.set_input_port(0, delayfilter, 0) outfilterr = DoubleOutPointerFilter(outputr, False) outfilterr.input_sampling_rate = sample_rate outfilterr.set_input_port(0, delayfilter, 1) pipelineend = PipelineGlobalSinkFilter() pipelineend.input_sampling_rate = sample_rate pipelineend.add_filter(outfilterl) pipelineend.add_filter(outfilterr) pipelineend.process(inputl.shape[1]) return outputl, outputr
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 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 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_4(input): import numpy as np output = np.zeros(input.shape, dtype=np.float64) inputfilter = DoubleInPointerFilter(input, False) inputfilter.input_sampling_rate = sample_rate overfilter = DoubleOversampling6points5order_4Filter() overfilter.input_sampling_rate = sample_rate overfilter.output_sampling_rate = sample_rate * 4 overfilter.set_input_port(0, inputfilter, 0) overdrivefilter = DoubleTS9OverdriveFilter() overdrivefilter.input_sampling_rate = sample_rate * 4 overdrivefilter.set_input_port(0, overfilter, 0) overdrivefilter.drive = 0.9 lowpassfilter = DoubleButterworthLowPassFilter() lowpassfilter.input_sampling_rate = sample_rate * 4 lowpassfilter.cut_frequency = sample_rate lowpassfilter.order = 5 lowpassfilter.set_input_port(0, overdrivefilter, 0) decimationfilter = DoubleDecimationFilter(1) decimationfilter.input_sampling_rate = sample_rate * 4 decimationfilter.output_sampling_rate = sample_rate decimationfilter.set_input_port(0, lowpassfilter, 0) outfilter = DoubleOutPointerFilter(output, False) outfilter.input_sampling_rate = sample_rate outfilter.set_input_port(0, decimationfilter, 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 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(noise, input, blend=0, feedback=0, feedforward=1): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.input_sampling_rate = sample_rate noisefilter = DoubleInPointerFilter(noise, False) noisefilter.input_sampling_rate = sample_rate lownoisefilter = DoubleSecondOrderLowPassFilter() lownoisefilter.input_sampling_rate = sample_rate lownoisefilter.cut_frequency = 5 lownoisefilter.set_input_port(0, noisefilter, 0) delayfilter = DoubleUniversalVariableDelayLineFilter(5000) delayfilter.input_sampling_rate = sample_rate delayfilter.set_input_port(0, infilter, 0) delayfilter.set_input_port(1, lownoisefilter, 0) delayfilter.blend = blend delayfilter.feedback = feedback delayfilter.feedforward = feedforward outfilter = DoubleOutPointerFilter(output, False) outfilter.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.output_sampling_rate = sample_rate generator = DoubleSinusGeneratorFilter() generator.output_sampling_rate = sample_rate generator.frequency = 1 generator.volume = 1e-3*sample_rate generator.offset = 1.5e-3*sample_rate delayfilter = DoubleUniversalVariableDelayLineFilter(5000) delayfilter.input_sampling_rate = sample_rate delayfilter.set_input_port(0, infilter, 0) delayfilter.set_input_port(1, generator, 0) delayfilter.blend = blend delayfilter.feedback = feedback delayfilter.feedforward = feedforward outfilter = DoubleOutPointerFilter(output, False) outfilter.input_sampling_rate = sample_rate outfilter.set_input_port(0, delayfilter, 0) outfilter.process(input.shape[1]) return output
def max_filter(input, ratio=4, threshold=1, softness=1, max_reduction=0.1): import numpy as np output = np.zeros(input.shape, dtype=np.float64) input2 = input**2 in2filter = DoubleInPointerFilter(input2, False) in2filter.input_sampling_rate = sample_rate infilter = DoubleInPointerFilter(input, False) infilter.input_sampling_rate = sample_rate gainfilter = DoubleGainMaxCompressorFilter(1) gainfilter.input_sampling_rate = sample_rate gainfilter.set_input_port(0, in2filter, 0) gainfilter.threshold = threshold gainfilter.ratio = ratio gainfilter.softness = softness gainfilter.max_reduction = max_reduction applygainfilter = DoubleApplyGainFilter(1) applygainfilter.input_sampling_rate = sample_rate applygainfilter.set_input_port(0, gainfilter, 0) applygainfilter.set_input_port(1, infilter, 0) outfilter = DoubleOutPointerFilter(output, False) outfilter.input_sampling_rate = sample_rate outfilter.set_input_port(0, applygainfilter, 0) outfilter.process(input.shape[1]) return output
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.output_sampling_rate = 48000 volumefilter.input_sampling_rate = 48000 volumefilter.volume = .5 outputfilter.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 Oversampling_32_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from ATK.Tools import DoubleOversampling6points5order_32Filter from numpy.testing import assert_almost_equal ref = np.sin( np.arange(32000, dtype=np.float64)[None, :] * 1000 * 2 * np.pi / (2 * 768000)) input = np.ascontiguousarray(ref[:, ::32]) output = np.ascontiguousarray(np.zeros(32000, dtype=np.float64)[None, :]) inputfilter = DoubleInPointerFilter(input, False) oversamplingfilter = DoubleOversampling6points5order_32Filter() outputfilter = DoubleOutPointerFilter(output, False) inputfilter.output_sampling_rate = 48000 oversamplingfilter.input_sampling_rate = 48000 oversamplingfilter.output_sampling_rate = 32 * 48000 outputfilter.input_sampling_rate = 32 * 48000 oversamplingfilter.set_input_port(0, inputfilter, 0) outputfilter.set_input_port(0, oversamplingfilter, 0) outputfilter.process(32000) assert_almost_equal(ref[:, 904:-96], output[:, 1000:], decimal=1)
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 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 DoubleOutPointerFilter_assign_test(): import numpy as np from ATK.Core import DoubleOutPointerFilter d = np.ascontiguousarray(np.arange(1000, dtype=np.float64)[None, :]) filter = DoubleOutPointerFilter(d, False) filter.set_pointer(d) assert filter.nb_input_ports == 1
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 DoubleOutPointerFilter_assign_fail_test(): import numpy as np from ATK.Core import DoubleOutPointerFilter d = np.ascontiguousarray(np.arange(1000, dtype=np.float64)[None, :]) filter = DoubleOutPointerFilter(d, False) d = np.ascontiguousarray(np.arange(1000, dtype=np.float64).reshape(2, -1)) filter.set_pointer(d)
def filter_4(input): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.input_sampling_rate = 48000 overfilter = DoubleOversampling6points5order_4Filter() overfilter.input_sampling_rate = 48000 overfilter.output_sampling_rate = 48000 * 4 overfilter.set_input_port(0, infilter, 0) overdrivefilter = DoubleLeachTriodeFilter.build_standard_filter() overdrivefilter.input_sampling_rate = 48000 * 4 overdrivefilter.set_input_port(0, overfilter, 0) lowpassfilter = DoubleButterworthLowPassFilter() lowpassfilter.input_sampling_rate = 48000 * 4 lowpassfilter.cut_frequency = 48000 lowpassfilter.order = 5 lowpassfilter.set_input_port(0, overdrivefilter, 0) decimationfilter = DoubleDecimationFilter(1) decimationfilter.input_sampling_rate = 48000 * 4 decimationfilter.output_sampling_rate = 48000 decimationfilter.set_input_port(0, lowpassfilter, 0) outfilter = DoubleOutPointerFilter(output, False) outfilter.input_sampling_rate = 48000 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_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(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 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 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 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 DoublePointerFilter2_new_test(): import numpy as np from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter from numpy.testing import assert_equal input = np.arange(1000, dtype=np.float64) output = np.zeros(1000, dtype=np.float64) inputfilter = DoubleInPointerFilter(input) outputfilter = DoubleOutPointerFilter(output) outputfilter.set_input_port(0, inputfilter, 0) inputfilter.output_sampling_rate = 48000 outputfilter.input_sampling_rate = 48000 outputfilter.process(1000) assert_equal(input, output)
def process(self, input): import numpy as np output = np.zeros(input.shape, dtype=np.float64) infilter = DoubleInPointerFilter(input, False) infilter.input_sampling_rate = fs self.filter.set_input_port(0, infilter, 0) outfilter = DoubleOutPointerFilter(output, False) outfilter.input_sampling_rate = fs outfilter.set_input_port(0, self.filter, 0) outfilter.process(input.shape[1]) return output