コード例 #1
0
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
コード例 #2
0
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
コード例 #3
0
outfilter_slow = FloatOutPointerFilter(outdata_slow, True)
outfilter_slow.set_input_sampling_rate(sampling_rate)
outfilter_slow.set_input_port(0, slowattackreleasefilter, 0)

outdata_fast = np.zeros((processsize, 1), dtype=np.float32)
outfilter_fast = FloatOutPointerFilter(outdata_fast, True)
outfilter_fast.set_input_sampling_rate(sampling_rate)
outfilter_fast.set_input_port(0, fastattackreleasefilter, 0)

outdata_gain = np.zeros((processsize, 1), dtype=np.float32)
outfilter_gain = FloatOutPointerFilter(outdata_gain, True)
outfilter_gain.set_input_sampling_rate(sampling_rate)
outfilter_gain.set_input_port(0, gainfilter, 0)

pipelineend = PipelineGlobalSinkFilter()
pipelineend.set_input_sampling_rate(sampling_rate)
pipelineend.add_filter(inputfilter)
pipelineend.add_filter(inputhffilter)
pipelineend.add_filter(outfilter)
pipelineend.add_filter(outfilter_power)
pipelineend.add_filter(outfilter_gain)
pipelineend.add_filter(outfilter_slow)
pipelineend.add_filter(outfilter_fast)
pipelineend.process(processsize)

start = 0
stop = processsize

x = np.arange(stop, dtype=np.float32) / sampling_rate

plt.figure()
コード例 #4
0
attackreleasefilter2 = DoubleAttackReleaseHysteresisFilter(1)
attackreleasefilter2.set_input_sampling_rate(sampling_rate)
attackreleasefilter2.set_input_port(0, infilter, 0)
attackreleasefilter2.set_attack(np.exp(-1/(sampling_rate*1e-3)))
attackreleasefilter2.set_release(np.exp(-1/(sampling_rate*10e-3)))
attackreleasefilter2.set_release_hysteresis(.5)
attackreleasefilter2.set_attack_hysteresis(.9)

outdata2 = np.zeros((processsize, 1), dtype=np.float64)
outfilter_hyst = DoubleOutPointerFilter(outdata2, True)
outfilter_hyst.set_input_sampling_rate(sampling_rate)
outfilter_hyst.set_input_port(0, attackreleasefilter2, 0)

pipelineend = PipelineGlobalSinkFilter()
pipelineend.set_input_sampling_rate(sampling_rate)
pipelineend.add_filter(outfilter)
pipelineend.add_filter(outfilter_hyst)
pipelineend.process(processsize)

start = 0
stop = processsize

x = np.arange(stop, dtype=np.float32) / sampling_rate

plt.figure()
plt.suptitle("Attack Release filters")
plt.plot(x[start:], data[start:stop, 0], label="Original")
plt.plot(x[start:], outdata[start:stop, 0], label="AR filter")
plt.plot(x[start:], outdata2[start:stop, 0], label="AR filter with hysteresis (0.9, 0.5)")
コード例 #5
0
def filter(input, blend=0, feedback=0, feedforward=1):
    import numpy as np
    output1 = np.zeros(input.shape, dtype=np.float64)
    output2 = np.zeros(input.shape, dtype=np.float64)

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

    allpass1filter = DoubleCustomIIRFilter()
    allpass1filter.set_input_sampling_rate(sample_rate)
    allpass1filter.set_input_port(0, infilter, 0)
    allpass1filter.set_coefficients_in(
        (0.0000, 0.3855, 0.0000, 1.3313, 0.0000, 1.0000)[::-1])
    allpass1filter.set_coefficients_out(
        (-0.0000, -1.3313, 0.0000, -0.3855, 0)[::-1])

    allpass2filter = DoubleCustomIIRFilter()
    allpass2filter.set_input_sampling_rate(sample_rate)
    allpass2filter.set_input_port(0, infilter, 0)
    allpass2filter.set_coefficients_in(
        (0.0947, 0.0000, 0.8335, 0.0000, 1.0000)[::-1])
    allpass2filter.set_coefficients_out(
        (0.0000, -0.8335, 0.0000, -0.0947)[::-1])

    sinusfilter = DoubleCachedSinusGeneratorFilter(100, 1)
    sinusfilter.set_input_sampling_rate(sample_rate)

    cosinusfilter = DoubleCachedCosinusGeneratorFilter(100, 1)
    cosinusfilter.set_input_sampling_rate(sample_rate)

    applygainFilter = DoubleApplyGainFilter(2)
    applygainFilter.set_input_sampling_rate(sample_rate)
    applygainFilter.set_input_port(0, allpass1filter, 0)
    applygainFilter.set_input_port(1, sinusfilter, 0)
    applygainFilter.set_input_port(2, allpass2filter, 0)
    applygainFilter.set_input_port(3, cosinusfilter, 0)

    volumeFilter = DoubleVolumeFilter()
    volumeFilter.set_input_sampling_rate(sample_rate)
    volumeFilter.set_volume(-1)
    volumeFilter.set_input_port(0, applygainFilter, 1)

    sum1Filter = DoubleSumFilter()
    sum1Filter.set_input_sampling_rate(sample_rate)
    sum1Filter.set_input_port(0, applygainFilter, 0)
    sum1Filter.set_input_port(1, volumeFilter, 0)

    sum2Filter = DoubleSumFilter()
    sum2Filter.set_input_sampling_rate(sample_rate)
    sum2Filter.set_input_port(0, applygainFilter, 0)
    sum2Filter.set_input_port(1, applygainFilter, 1)

    out1filter = DoubleOutPointerFilter(output1, False)
    out1filter.set_input_sampling_rate(sample_rate)
    out1filter.set_input_port(0, sum1Filter, 0)

    out2filter = DoubleOutPointerFilter(output2, False)
    out2filter.set_input_sampling_rate(sample_rate)
    out2filter.set_input_port(0, sum2Filter, 0)

    pipelinesink = PipelineGlobalSinkFilter()
    pipelinesink.set_input_sampling_rate(sample_rate)
    pipelinesink.add_filter(out1filter)
    pipelinesink.add_filter(out2filter)
    pipelinesink.process(input.shape[1])

    return output1, output2
コード例 #6
0
ファイル: 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
コード例 #7
0
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