Python DoubleInPointerFilter Examples

Example #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])

Example #2

File: PyATKTools_Volume_test.py Project: Ravirael/AudioTK

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)

Example #3

File: PyATKTools_Oversampling_test.py Project: Ravirael/AudioTK

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)

Example #4

File: PyATKDelay_universalvariabledelay_test.py Project: whztt07/AudioTK

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

Example #5

File: PyATKTools_Oversampling_test.py Project: mbrucher/AudioTK

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)

Example #6

File: PyATKPreamplifier_follower_transistor_class_A_test.py Project: mbrucher/AudioTK

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

Example #7

File: PyATKDistortion_diode_clipper_test.py Project: mbrucher/AudioTK

def filter_32(input):
  import numpy as np
  output = np.zeros(input.shape, dtype=np.float64)

  infilter = DoubleInPointerFilter(input, False)
  infilter.input_sampling_rate = 48000
  overfilter = DoubleOversampling6points5order_32Filter()
  overfilter.input_sampling_rate = 48000
  overfilter.output_sampling_rate = 48000 * 32
  overfilter.set_input_port(0, infilter, 0)
  overdrivefilter = DoubleDiodeClipperFilter()
  overdrivefilter.input_sampling_rate = 48000 * 32
  overdrivefilter.set_input_port(0, overfilter, 0)
  lowpassfilter = DoubleButterworthLowPassFilter()
  lowpassfilter.input_sampling_rate = 48000 * 32
  lowpassfilter.cut_frequency = 48000
  lowpassfilter.order = 5
  lowpassfilter.set_input_port(0, overdrivefilter, 0)
  decimationfilter = DoubleDecimationFilter(1)
  decimationfilter.input_sampling_rate = 48000 * 32
  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

Example #8

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)

Example #9

File: PyATKDynamic_attackreleasefilter_test.py Project: mbrucher/AudioTK

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

Example #10

File: PyATKTools_Decimation_test.py Project: felipebetancur/AudioTK

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)

Example #11

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

Example #12

File: PyATKTools_Oversampling_test.py Project: whztt07/AudioTK

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)

Example #13

File: PyATKDynamic_attackreleasefilter_test.py Project: whztt07/AudioTK

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

Example #14

File: PyATKDistortion_sd1_overdrive_test.py Project: mbrucher/AudioTK

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 = DoubleSD1OverdriveFilter()
  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

Example #15

File: PyATKDelay_householderfdn_test.py Project: mbrucher/AudioTK

def filter(input, ingain_ch1=0, ingain_ch2=0, ingain_ch3=0, ingain_ch4=0,
    outgain_ch1=0, outgain_ch2=0, outgain_ch3=0, outgain_ch4=0,
    feedback_ch1=0, feedback_ch2=0, feedback_ch3=0, feedback_ch4=0):
  import numpy as np
  output = np.zeros(input.shape, dtype=np.float64)

  infilter = DoubleInPointerFilter(input, False)
  infilter.input_sampling_rate = sample_rate

  delayfilter = DoubleQuadHouseholderFeedbackDelayNetworkFilter(10000)
  delayfilter.input_sampling_rate = sample_rate
  delayfilter.set_input_port(0, infilter, 0)
  delayfilter.set_delay(0, 4800) #50ms
  delayfilter.set_delay(1, 3600) #37.5ms
  delayfilter.set_delay(2, 2400) #25
  delayfilter.set_delay(3, 1200) #12.5ms
  delayfilter.set_ingain(0, ingain_ch1)
  delayfilter.set_ingain(1, ingain_ch2)
  delayfilter.set_ingain(2, ingain_ch3)
  delayfilter.set_ingain(3, ingain_ch4)
  delayfilter.set_outgain(0, outgain_ch1)
  delayfilter.set_outgain(1, outgain_ch2)
  delayfilter.set_outgain(2, outgain_ch3)
  delayfilter.set_outgain(3, outgain_ch4)
  delayfilter.set_feedback(0, feedback_ch1)
  delayfilter.set_feedback(1, feedback_ch2)
  delayfilter.set_feedback(2, feedback_ch3)
  delayfilter.set_feedback(3, feedback_ch4)
  
  outfilter = DoubleOutPointerFilter(output, False)
  outfilter.input_sampling_rate = sample_rate
  outfilter.set_input_port(0, delayfilter, 0)
  outfilter.process(input.shape[1])

  return output

Example #16

File: PyATKEQ_test.py Project: Ravirael/AudioTK

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:])

Example #17

File: PyATKTools_MiddleSide_test.py Project: mbrucher/AudioTK

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.output_sampling_rate = 48000
  msfilter.input_sampling_rate = 48000
  outputfilter.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])

Example #18

File: PyATKDistortion_ts9_overdrive_test.py Project: whztt07/AudioTK

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

Example #19

File: PyATKTools_Buffer_test.py Project: mbrucher/AudioTK

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)

Example #20

File: display_timevaryingEQ.py Project: Ravirael/AudioTK

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

Example #21

File: PyATKDynamic_coloredexpandergain_test.py Project: mbrucher/AudioTK

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.input_sampling_rate = sample_rate
  
  infilter = DoubleInPointerFilter(input, False)
  infilter.input_sampling_rate = sample_rate
  
  gainfilter = DoubleGainMaxColoredExpanderFilter(1)
  gainfilter.input_sampling_rate = sample_rate
  gainfilter.set_input_port(0, in2filter, 0)
  gainfilter.threshold = threshold
  gainfilter.ratio = ratio
  gainfilter.color = color
  gainfilter.softness = softness
  gainfilter.quality = quality
  gainfilter.max_reduction = 10 ** (max_reduction / 20.)
  
  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

Example #22

File: PyATKDelay_chorus_test.py Project: mbrucher/AudioTK

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

Example #23

File: PyATKPreamplifier_leach_tube_filter_test.py Project: whztt07/AudioTK

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

Example #24

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

Example #25

File: PyATKEQ_test.py Project: felipebetancur/AudioTK

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:])

Example #26

File: simple_overdrive.py Project: Ravirael/AudioTK

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

Example #27

File: display_universalvariabledelay.py Project: Ravirael/AudioTK

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

Example #28

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

Example #29

File: PyATKPointer_test.py Project: whztt07/AudioTK

def DoubleInPointerFilter_assign_test():
    import numpy as np
    from ATK.Core import DoubleInPointerFilter
    d = np.ascontiguousarray(np.arange(1000, dtype=np.float64)[None, :])
    filter = DoubleInPointerFilter(d, False)
    filter.set_pointer(d)
    assert filter.nb_output_ports == 1

Example #30

File: PyATKPointer_test.py Project: mbrucher/AudioTK

def DoubleInPointerFilter_assign_fail_test():
  import numpy as np
  from ATK.Core import DoubleInPointerFilter
  d = np.ascontiguousarray(np.arange(1000, dtype=np.float64)[None,:])
  filter = DoubleInPointerFilter(d, False)
  d = np.ascontiguousarray(np.arange(1000, dtype=np.float64).reshape(2,-1))
  filter.set_pointer(d)

Example #31

File: PyATKPointer_test.py Project: mbrucher/AudioTK

def DoubleInPointerFilter_assign_test():
  import numpy as np
  from ATK.Core import DoubleInPointerFilter
  d = np.ascontiguousarray(np.arange(1000, dtype=np.float64)[None,:])
  filter = DoubleInPointerFilter(d, False)
  filter.set_pointer(d)
  assert filter.nb_output_ports == 1

Example #32

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)

Example #33

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])

Example #34

File: PyATKTools_Sum_test.py Project: Ravirael/AudioTK

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])

Example #35

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])

Example #36

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

Example #37

File: PyATKTools_Decimation_test.py Project: Ravirael/AudioTK

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)

Example #38

File: PyATKDynamic_expandergain_test.py Project: mbrucher/AudioTK

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.input_sampling_rate = sample_rate

  infilter = DoubleInPointerFilter(input, False)
  infilter.input_sampling_rate = sample_rate

  gainfilter = DoubleGainExpanderFilter(1)
  gainfilter.input_sampling_rate = sample_rate
  gainfilter.set_input_port(0, in2filter, 0)
  gainfilter.threshold = threshold
  gainfilter.ratio = ratio
  gainfilter.softness = softness

  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

Example #39

File: PyATKPreamplifier_enhanced_tube_filter_test.py Project: mbrucher/AudioTK

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 = DoubleEnhancedKorenTriodeFilter.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

Example #40

File: timevaryingEQ.py Project: felipebetancur/AudioTK

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

Example #41

File: PyATKPointer_test.py Project: whztt07/AudioTK

def DoubleInPointerFilter_assign_fail_test():
    import numpy as np
    from ATK.Core import DoubleInPointerFilter
    d = np.ascontiguousarray(np.arange(1000, dtype=np.float64)[None, :])
    filter = DoubleInPointerFilter(d, False)
    d = np.ascontiguousarray(np.arange(1000, dtype=np.float64).reshape(2, -1))
    filter.set_pointer(d)

Example #42

File: display_chorus.py Project: Ravirael/AudioTK

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

Example #43

File: PyATKPointer_test.py Project: mbrucher/AudioTK

def DoubleInPointerFilter_retrieve_test():
  import numpy as np
  from ATK.Core import DoubleInPointerFilter
  d = np.ascontiguousarray(np.arange(1000, dtype=np.float64)[None,:])
  filter = DoubleInPointerFilter(d, False)
  filter.input_sampling_rate = 48000
  filter.process(1000)
  out = filter.get_output_array(0)
  testing.assert_array_equal(d[0], out)

Example #44

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

Example #45

File: PyATKAdaptive_rls_filter_fir_comparison_test.py Project: mbrucher/AudioTK

  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

Example #46

File: PyATKCore_test.py Project: Ravirael/AudioTK

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)

Example #47

File: PyATKPointer_test.py Project: mbrucher/AudioTK

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)

Example #48

File: PyATKPointer_test.py Project: whztt07/AudioTK

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)

Example #49

    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

Example #50

File: PyATKCore_test.py Project: felipebetancur/AudioTK

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)

Example #51

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

Example #52

File: PyATKEQ_sd1_tone_test.py Project: mbrucher/AudioTK

def tone_filter(input):
  import numpy as np
  output = np.zeros(input.shape, dtype=np.float64)

  infilter = DoubleInPointerFilter(input, False)
  infilter.input_sampling_rate = sampling
  tonefilter = DoubleSD1ToneFilter()
  tonefilter.input_sampling_rate = sampling
  tonefilter.set_input_port(0, infilter, 0)
  tonefilter.tone = 0.5
  outfilter = DoubleOutPointerFilter(output, False)
  outfilter.input_sampling_rate = sampling
  outfilter.set_input_port(0, tonefilter, 0)
  outfilter.process(input.shape[1])
  return output, tonefilter.coefficients_in, tonefilter.coefficients_out

Example #53

File: PyATKEQ_sd1_tone_test.py Project: whztt07/AudioTK

def tone_filter(input):
    import numpy as np
    output = np.zeros(input.shape, dtype=np.float64)

    infilter = DoubleInPointerFilter(input, False)
    infilter.input_sampling_rate = sampling
    tonefilter = DoubleSD1ToneFilter()
    tonefilter.input_sampling_rate = sampling
    tonefilter.set_input_port(0, infilter, 0)
    tonefilter.tone = 0.5
    outfilter = DoubleOutPointerFilter(output, False)
    outfilter.input_sampling_rate = sampling
    outfilter.set_input_port(0, tonefilter, 0)
    outfilter.process(input.shape[1])
    return output, tonefilter.coefficients_in, tonefilter.coefficients_out

Example #54

def filter_high(input):
  import numpy as np
  output = np.zeros(input.shape, dtype=np.float64)
  
  infilter = DoubleInPointerFilter(input, False)
  infilter.input_sampling_rate = 48000
  highpassfilter = DoubleButterworthHighPassFilter()
  highpassfilter.input_sampling_rate = 48000
  highpassfilter.cut_frequency = 1000
  highpassfilter.order = 5
  highpassfilter.set_input_port(0, infilter, 0)
  outfilter = DoubleOutPointerFilter(output, False)
  outfilter.input_sampling_rate = 48000
  outfilter.set_input_port(0, highpassfilter, 0)
  outfilter.process(input.shape[1])
  return output, highpassfilter.coefficients_in, highpassfilter.coefficients_out

Example #55

File: PyATKDistortion_tanhshaper_test.py Project: whztt07/AudioTK

def filter_asym(input):
    import numpy as np
    output = np.zeros(input.shape, dtype=np.float64)

    inputfilter = DoubleInPointerFilter(input, False)
    inputfilter.input_sampling_rate = sample_rate
    shaperfilter = DoubleHalfTanhShaperFilter()
    shaperfilter.input_sampling_rate = sample_rate
    shaperfilter.coefficient = 2
    shaperfilter.set_input_port(0, inputfilter, 0)

    outfilter = DoubleOutPointerFilter(output, False)
    outfilter.input_sampling_rate = sample_rate
    outfilter.set_input_port(0, shaperfilter, 0)
    outfilter.process(input.shape[1])
    return output

Example #56

File: PyATKEQ_bessel_test.py Project: whztt07/AudioTK

def filter_bandstop(input):
  import numpy as np
  output = np.zeros(input.shape, dtype=np.float64)
  
  infilter = DoubleInPointerFilter(input, False)
  infilter.input_sampling_rate = 48000
  bandstopfilter = DoubleBesselBandStopFilter()
  bandstopfilter.input_sampling_rate = 48000
  bandstopfilter.cut_frequencies = (200, 1000)
  bandstopfilter.order = 5
  bandstopfilter.set_input_port(0, infilter, 0)
  outfilter = DoubleOutPointerFilter(output, False)
  outfilter.input_sampling_rate = 48000
  outfilter.set_input_port(0, bandstopfilter, 0)
  outfilter.process(input.shape[1])
  return output, bandstopfilter.coefficients_in, bandstopfilter.coefficients_out

Example #57

def PipelineGlobalSinkFilter_usage_test():
  import numpy as np
  from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter, PipelineGlobalSinkFilter
  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.output_sampling_rate = 48000
  outputfilter.input_sampling_rate = 48000
  sink = PipelineGlobalSinkFilter()
  sink.add_filter(outputfilter)
  sink.input_sampling_rate = 48000
  sink.process(1000)
  assert_equal(input, output)

Example #58

File: PyATKEQ_bessel_test.py Project: whztt07/AudioTK

def filter_low(input):
  import numpy as np
  output = np.zeros(input.shape, dtype=np.float64)

  infilter = DoubleInPointerFilter(input, False)
  infilter.input_sampling_rate = 48000
  lowpassfilter = DoubleBesselLowPassFilter()
  lowpassfilter.input_sampling_rate = 48000
  lowpassfilter.cut_frequency = 1000
  lowpassfilter.order = 5
  lowpassfilter.set_input_port(0, infilter, 0)
  outfilter = DoubleOutPointerFilter(output, False)
  outfilter.input_sampling_rate = 48000
  outfilter.set_input_port(0, lowpassfilter, 0)
  outfilter.process(input.shape[1])
  return output, lowpassfilter.coefficients_in, lowpassfilter.coefficients_out