Python DoubleInPointerFilter.set_output_sampling_rate Exemples

Exemple #1

Fichier : PyATKTools_MiddleSide_test.py Projet : Ravirael/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.set_output_sampling_rate(48000)
  msfilter.set_input_sampling_rate(48000)
  outputfilter.set_input_sampling_rate(48000)

  msfilter.set_input_port(0, inputfilter, 0)
  msfilter.set_input_port(1, inputfilter, 1)
  outputfilter.set_input_port(0, msfilter, 0)
  outputfilter.set_input_port(1, msfilter, 1)

  outputfilter.process(1000)

  assert_almost_equal(input[0], output[0])
  assert_almost_equal(0, output[1])

Exemple #2

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

Exemple #3

Fichier : display_universalvariabledelay.py Projet : 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

Exemple #4

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

Exemple #5

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)

Exemple #6

Fichier : PyATKEQ_test.py Projet : 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:])

Exemple #7

Fichier : PyATKTools_Decimation_test.py Projet : 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)

Exemple #8

Fichier : PyATKTools_Sum_test.py Projet : 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])

Exemple #9

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

Exemple #10

Fichier : PyATKEQ_test.py Projet : 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:])

Exemple #11

Fichier : PyATKTools_Volume_test.py Projet : felipebetancur/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)

Exemple #12

Fichier : PyATKTools_Decimation_test.py Projet : 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)

Exemple #13

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

Exemple #14

Fichier : PyATKTools_Oversampling_test.py Projet : 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)

Exemple #15

Fichier : PyATKTools_Volume_test.py Projet : 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)

Exemple #16

Fichier : PyATKCore_test.py Projet : 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)

Exemple #17

Fichier : PyATKCore_test.py Projet : 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)

Exemple #18

import numpy as np
import matplotlib.pyplot as plt

from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter, PipelineGlobalSinkFilter

from ATK.Dynamic import DoubleAttackReleaseFilter, DoubleAttackReleaseHysteresisFilter

processsize = 3000
sampling_rate = 44100

data = np.sin(np.arange(processsize) * np.pi * 40 / sampling_rate).reshape(
    -1, 1)
data = data**2
infilter = DoubleInPointerFilter(data, True)
infilter.set_output_sampling_rate(sampling_rate)

attackreleasefilter = DoubleAttackReleaseFilter(1)
attackreleasefilter.set_input_sampling_rate(sampling_rate)
attackreleasefilter.set_input_port(0, infilter, 0)
attackreleasefilter.set_attack(np.exp(-1 / (sampling_rate * 1e-3)))
attackreleasefilter.set_release(np.exp(-1 / (sampling_rate * 10e-3)))

outdata = np.zeros((processsize, 1), dtype=np.float64)
outfilter = DoubleOutPointerFilter(outdata, True)
outfilter.set_input_sampling_rate(sampling_rate)
outfilter.set_input_port(0, attackreleasefilter, 0)

attackreleasefilter2 = DoubleAttackReleaseHysteresisFilter(1)
attackreleasefilter2.set_input_sampling_rate(sampling_rate)
attackreleasefilter2.set_input_port(0, infilter, 0)

Exemple #19

Fichier : display_attackreleasefilter.py Projet : Ravirael/AudioTK

#!/usr/bin/env python

import numpy as np
import matplotlib.pyplot as plt

from ATK.Core import DoubleInPointerFilter, DoubleOutPointerFilter, PipelineGlobalSinkFilter

from ATK.Dynamic import DoubleAttackReleaseFilter, DoubleAttackReleaseHysteresisFilter

processsize = 3000
sampling_rate = 44100

data = np.sin(np.arange(processsize) * np.pi * 40 / sampling_rate).reshape(-1, 1)
data = data ** 2
infilter = DoubleInPointerFilter(data, True)
infilter.set_output_sampling_rate(sampling_rate)

attackreleasefilter = DoubleAttackReleaseFilter(1)
attackreleasefilter.set_input_sampling_rate(sampling_rate)
attackreleasefilter.set_input_port(0, infilter, 0)
attackreleasefilter.set_attack(np.exp(-1/(sampling_rate*1e-3)))
attackreleasefilter.set_release(np.exp(-1/(sampling_rate*10e-3)))

outdata = np.zeros((processsize, 1), dtype=np.float64)
outfilter = DoubleOutPointerFilter(outdata, True)
outfilter.set_input_sampling_rate(sampling_rate)
outfilter.set_input_port(0, attackreleasefilter, 0)

attackreleasefilter2 = DoubleAttackReleaseHysteresisFilter(1)
attackreleasefilter2.set_input_sampling_rate(sampling_rate)
attackreleasefilter2.set_input_port(0, infilter, 0)