def __init__(self,
width,
height,
lowFreq=500,
highFreq=5000,
sweepDelay=0.5,
sweepDuration=4,
sweepCount=4,
reverseBrightness=False):
self.width = width
self.height = height
self.baseFreq = lowFreq
self.octiveCount = math.log(highFreq / lowFreq, 2)
self.sweepDelay = sweepDelay
self.sweepDuration = sweepDuration
self.sweepCount = sweepCount
self.reverseBrightness = reverseBrightness
self.lavSim = libaudioverse.Simulation()
self.lavPanner = libaudioverse.MultipannerNode(self.lavSim, "default")
self.lavPanner.strategy = libaudioverse.PanningStrategies.hrtf
self.lavPanner.should_crossfade = False
self.lavPanner.connect_simulation(0)
self.lavWaves = []
for x in xrange(self.height):
lavPanner = libaudioverse.AmplitudePannerNode(self.lavSim)
lavPanner.should_crossfade = False
lavPanner.connect_simulation(0)
lavWave = libaudioverse.SineNode(self.lavSim)
lavWave.mul = 0
lavWave.frequency.value = self.baseFreq * (
(2**self.octiveCount)**(x / self.height))
lavWave.connect(0, lavPanner, 0)
lavWave.connect(0, self.lavPanner, 0)
self.lavWaves.append((lavWave, lavPanner))
self.lavSim.set_output_device(-1)
def __init__(self, width, height, lowFreq=90, highFreq=4000):
self.width = width
self.height = height
self.lowFreq = lowFreq
self.highFreq = highFreq
self.lavSim = libaudioverse.Simulation()
self.lavWave = libaudioverse.AdditiveSawNode(self.lavSim)
self.lavWave.mul = 0
self.lavWave.frequency.value = lowFreq
self.lavWave.connect_simulation(0)
self.lavWave2 = libaudioverse.SineNode(self.lavSim)
self.lavWave2.mul = 0
self.lavWave2.frequency.value = lowFreq * (highFreq / lowFreq)
self.lavWave2.connect_simulation(0)
self.lavNoise = libaudioverse.NoiseNode(self.lavSim)
self.lavNoise.mul.value = 0
self.lavNoise.noise_type.value = libaudioverse.NoiseTypes.brown
self.lavNoise.connect_simulation(0)
self.lavSim.set_output_device(-1)
def __init__(self, *args, **kwargs):
super(GlobalPlugin, self).__init__(*args, **kwargs)
addonGui.initialize()
config.conf.spec["unspoken"] = {"sayAll": "boolean(default=False)"}
self.simulation = libaudioverse.Simulation(block_size=1024)
self.make_sound_objects()
self.hrtf_panner = libaudioverse.HrtfNode(self.simulation, "default")
self.hrtf_panner.should_crossfade = False
self.hrtf_panner.connect_simulation(0)
# Hook to keep NVDA from announcing roles.
self._NVDA_getSpeechTextForProperties = speech.getSpeechTextForProperties
speech.getSpeechTextForProperties = self._hook_getSpeechTextForProperties
self._previous_mouse_object = None
self._last_played_object = None
self._last_played_time = 0
#these are in degrees.
self._display_width = 180.0
self._display_height_min = -40.0
self._display_height_magnitude = 50.0
#the mixer feeds us through NVDA.
self.mixer = mixer.Mixer(self.simulation, 1)
import libaudioverse
import os.path
import time
time_per_demo = 5.0
libaudioverse.initialize()
sim = libaudioverse.Simulation()
sim.set_output_device()
print("""Biquad demo.
Please enter the path to a file in a format supported by Libsndfile: typically wave or ogg."""
)
filepath = input()
filepath = os.path.abspath(filepath)
filenode = libaudioverse.BufferNode(sim)
buffer = libaudioverse.Buffer(sim)
buffer.load_from_file(filepath)
filenode.buffer = buffer
bq = libaudioverse.BiquadNode(sim, 2)
filenode.connect(0, bq, 0)
bq.connect_simulation(0)
print("Sweeping lowpass from 0.0 hz to 10000 hz over", time_per_demo,
"seconds:")
resolution = 10
for i in range(10000 // resolution):
bq.frequency.value = i * resolution
time.sleep(time_per_demo / (10000 / resolution))
print("Sweeping Highpass from 0 to 10000 over", time_per_demo, "seconds:")
bq.filter_type.value = libaudioverse.BiquadTypes.highpass
for i in range(10000 // resolution):
import libaudioverse
import math
import time
import random
libaudioverse.initialize()
simulation = libaudioverse.Simulation(block_size=128)
def make_fm(carrier, ratio, index):
carrier_node = libaudioverse.SineNode(simulation)
modulator_node = libaudioverse.SineNode(simulation)
modulator_frequency = ratio * carrier
modulator_amplitude = index * modulator_frequency
carrier_node.frequency.value = carrier
modulator_node.frequency.value = modulator_frequency
modulator_node.mul.value = modulator_amplitude
modulator_node.connect_property(0, carrier_node.frequency)
return carrier_node
fm1 = make_fm(carrier=50, ratio=0.5, index=50)
fm2 = make_fm(carrier=90, ratio=1.03, index=15)
#A bit of noise makes the HRTF much more obvious.
noise = libaudioverse.NoiseNode(simulation)
noise.noise_type.value = libaudioverse.NoiseTypes.pink
fm1.mul.value = 0.1
fm2.mul.value = 0.1