Python DoubleInPointerFilter.set_input_sampling_rate 예제들

예제 #1

파일: timevaryingEQ.py 프로젝트: 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

예제 #2

파일: display_chorus.py 프로젝트: 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

예제 #3

파일: simple_overdrive.py 프로젝트: 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

예제 #4

파일: display_expandergain.py 프로젝트: icewwn/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.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

예제 #5

파일: universalvariabledelay.py 프로젝트: 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)

  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

예제 #6

파일: display_timevaryingEQ.py 프로젝트: 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

예제 #7

파일: display_coloredexpandergain.py 프로젝트: Ravirael/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.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

예제 #8

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

예제 #9

파일: PyATKPreamplifier_follower_transistor_class_A_test.py 프로젝트: 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

예제 #10

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)

    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

예제 #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

예제 #12

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

예제 #13

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

예제 #14

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

예제 #15

파일: stereouniversaldelay.py 프로젝트: felipebetancur/AudioTK

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

예제 #16

파일: sweep_sd1_overdrive.py 프로젝트: Ravirael/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(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

예제 #17

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

예제 #18

파일: sd1_tone.py 프로젝트: Ravirael/AudioTK

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

예제 #19

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

예제 #20

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

예제 #21

파일: butterworth.py 프로젝트: Ravirael/AudioTK

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

예제 #22

파일: butterworth.py 프로젝트: Ravirael/AudioTK

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

예제 #23

파일: display_stereouniversaldelay.py 프로젝트: Ravirael/AudioTK

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

예제 #24

파일: chebyshev2.py 프로젝트: felipebetancur/AudioTK

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

예제 #25

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

예제 #26

파일: chebyshev2.py 프로젝트: Ravirael/AudioTK

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

예제 #27

파일: display_universaldelay.py 프로젝트: 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)

  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

예제 #28

파일: display_universaldelay.py 프로젝트: 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)

    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

예제 #29

파일: display_coloredexpandergain.py 프로젝트: felipebetancur/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.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

예제 #30

파일: tremolo.py 프로젝트: felipebetancur/AudioTK

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

예제 #31

파일: tremolo.py 프로젝트: Ravirael/AudioTK

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

예제 #32

파일: display_limiter.py 프로젝트: felipebetancur/AudioTK

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

예제 #33

파일: stereo_phaser.py 프로젝트: felipebetancur/AudioTK

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

예제 #34

파일: stereo_phaser.py 프로젝트: Ravirael/AudioTK

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

예제 #35

파일: display_middlesidecompressor.py 프로젝트: Ravirael/AudioTK

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