def __init__(self, pos, listener):
"""For the position, this class is expecting a vector. A vector will work as intended, at any rate."""
super().__init__(listener.server)
self.position = pos
self.source = libaudioverse.SourceNode(listener.server,
listener.environment)
self.source.position = tuple(pos)
def load_sound(self, key): self.source = libaudioverse.SourceNode(self.server, self.world) if key not in self.cache: b = libaudioverse.Buffer(self.server) if self.pdata=="": b.load_from_file(os.path.join(sound_dir, key)) else: b.decode_from_array(self.pdata[key]) self.cache[key] = b b = self.cache[key] n = libaudioverse.BufferNode(self.server) n.buffer.value =b return Sound(n,self.source)
def __init__(self, server, world, fileRoute, position, callback=None):
self.server = server
self.world = world
self.source = libaudioverse.SourceNode(server, world)
self.buffer = libaudioverse.BufferNode(server)
b = libaudioverse.Buffer(server)
b.load_from_file(fileRoute)
self.ruta = fileRoute
self.buffer.buffer = b
self.buffer.state = libaudioverse.NodeStates.paused
self.source.position = position
self.respuesta = callback
self.buffer.set_end_callback(self._lanzarRespuesta)
self.duracion = buffer_get_duration(b)
#demonstrates how to use the 3d simulation.
import libaudioverse
import collections
libaudioverse.initialize()
sim = libaudioverse.Simulation()
sim.set_output_device(-1)
world = libaudioverse.EnvironmentNode(sim, "default")
source = libaudioverse.SourceNode(sim, world)
print "Enter a path to a sound file."
filepath = raw_input()
n = libaudioverse.BufferNode(sim)
b = libaudioverse.Buffer(sim)
b.load_from_file(filepath)
n.buffer = b
n.connect(0, source, 0)
n.looping.value = True
world.connect_simulation(0)
print """Enter python expressions that evaluate to 3-tuples (x, y, z).
Positive x is to your right, positive y is above you, and positive z is behind you.
Enter quit to quit."""
while True:
command = raw_input()
if command == 'quit':
break
vect = eval(command)
if not isinstance(vect, collections.Sized) or len(vect) != 3:
print "Must evaluate to a 3-tuple. Try again"
rm.mul.set(time=28.0, value=1.0)
rm.mul.linear_ramp_to_value(time=30.0, value=0.0)
#This is the 3D infrastructure.
world = libaudioverse.EnvironmentNode(simulation, "default")
world.orientation.value = (0, 1, 0, 0, 0, 1)
#Turn on HRTF.
world.default_panning_strategy.value = libaudioverse.PanningStrategies.hrtf
world.output_channels.value = 2
#Set a default for the distance model.
world.default_max_distance.value = 20
#Get a source.
source = libaudioverse.SourceNode(simulation, environment=world)
rm.connect(0, source, 0)
world.connect_simulation(0)
square_side_length = 15
square_phase_length = 5.0
def block_callback(simulation, time):
phase = (time // square_phase_length) % 4
percent = (time % square_phase_length) / square_phase_length
if phase == 0:
source.position.value = (-square_side_length / 2 +
square_side_length * percent,
def __init__(self,
f,
duration,
min_x,
max_x,
min_y,
max_y,
x_ticks=None,
y_ticks=None,
zero_ticks=False,
hrtf=False,
axis_ticks=False):
"""Parameters:
f: A callable. Given a value for x, return a value for y.
duration: The total duration of the graph. We reach max_x at duration seconds, then stop.
min_x, max_x: The range of the X axis.
min_y, max_y: The range of the y axis.
x_ticks: If set to a value besides None, tick for every time we cross a multiple of the value.
y_ticks: x_ticks, but for y.
zero_ticks: tick when y crosses zero.
hrtf: If True, use HRTF panning.
axis_ticks: If True, tick for crossing x=0 or y=0.
x_ticks and y_ticks exist to allow representing graph lines through audio.
The visual equivalent of these values is the setting which allows one to specify the size of grid squares.
As this class graphs, it will produce distinct ticks as the value of f crosses multiples of x_ticks or y_ticks."""
# This is around 3 milliseconds. We can probably increase the resolution further.
self.server = libaudioverse.Server(block_size=block_size,
sample_rate=sr)
self.main_tone = libaudioverse.AdditiveTriangleNode(self.server)
self.main_tone.frequency = main_start_frequency
self.main_tone.mul = main_volume
# This helps HRTF a little.
self.main_noise = libaudioverse.NoiseNode(self.server)
self.main_noise.mul = 0.005
self.undefined_noise = libaudioverse.NoiseNode(self.server)
self.undefined_noise.mul = 0
self.undefined_noise.noise_type = libaudioverse.NoiseTypes.pink
self.panner = libaudioverse.MultipannerNode(self.server, "default")
self.environment = libaudioverse.EnvironmentNode(
self.server, "default")
self.source = libaudioverse.SourceNode(self.server, self.environment)
self.main_tone.connect(0, self.panner, 0)
self.main_tone.connect(0, self.source, 0)
if hrtf:
self.main_noise.connect(0, self.source, 0)
self.undefined_noise.connect(0, self.source, 0)
self.environment.connect(0, self.server)
self.environment.panning_strategy = libaudioverse.PanningStrategies.hrtf
self.environment.position = (0, 0, hrtf_listener_offset)
else:
self.undefined_noise.connect(0, self.panner, 0)
self.panner.connect(0, self.server)
# These are for the small ticks. We don't necessarily use them, but we get them going anyway so that we can if we want.
self.x_ticker = libaudioverse.AdditiveSquareNode(self.server)
self.y_ticker = libaudioverse.AdditiveSawNode(self.server)
self.zero_ticker = libaudioverse.AdditiveSawNode(self.server)
self.x_ticker.mul = 0
self.y_ticker.mul = 0
self.zero_ticker.mul = 0
self.x_ticker.frequency = 115
self.x_ticker.connect(0, self.panner, 0)
self.y_ticker.connect(0, self.panner, 0)
self.zero_ticker.connect(0, self.panner, 0)
self.x_ticker.connect(0, self.source, 0)
self.y_ticker.connect(0, self.source, 0)
self.zero_ticker.connect(0, self.source, 0)
self.prev_x = min_x
self.prev_y = min_y + (max_y - min_y) / 2
try:
tmp = f(min_x)
if isinstance(tmp, float):
self.prev_y = tmp
except:
pass
if self.prev_y < 0: self.prev_y_sign = -1
elif self.prev_y == 0: self.prev_y_sign = 0
else: self.prev_y_sign = 1
self.server.set_block_callback(self.model_update)
# We start not faded out.
self.faded_out = False
# Copy everything.
self.f = f
self.duration = duration
self.min_x = min_x
self.min_y = min_y
self.max_x = max_x
self.max_y = max_y
self.hrtf = hrtf
self.x_ticks = x_ticks
self.y_ticks = y_ticks
self.zero_ticks = zero_ticks
self.axis_ticks = axis_ticks
self.finished = False
rm.mul.set(time=28.0, value=1.0)
rm.mul.linear_ramp_to_value(time=30.0, value=0.0)
# This is the 3D infrastructure.
world = libaudioverse.EnvironmentNode(server, "default")
world.orientation.value = (0, 1, 0, 0, 0, 1)
# Turn on HRTF.
world.panning_strategy.value = libaudioverse.PanningStrategies.hrtf
world.output_channels.value = 2
# Set a default for the distance model.
world.max_distance.value = 20
# Get a source.
source = libaudioverse.SourceNode(server, environment=world)
rm.connect(0, source, 0)
world.connect(0, server)
square_side_length = 15
square_phase_length = 5.0
def block_callback(server, time):
phase = (time//square_phase_length) % 4
percent = (time % square_phase_length) / square_phase_length
if phase == 0:
source.position.value = (
-square_side_length / 2 + square_side_length * percent,
#demonstrates how to use the 3d simulation.
import libaudioverse
import collections
libaudioverse.initialize()
server = libaudioverse.Server()
server.set_output_device()
world = libaudioverse.EnvironmentNode(server, "default")
world.panning_strategy = libaudioverse.PanningStrategies.hrtf
source = libaudioverse.SourceNode(server, world)
print("Enter a path to a sound file.")
filepath = input()
n = libaudioverse.BufferNode(server)
b = libaudioverse.Buffer(server)
b.load_from_file(filepath)
n.buffer = b
n.connect(0, source, 0)
n.looping = True
world.connect(0, world.server)
print("""Enter python expressions that evaluate to 3-tuples (x, y, z).
Positive x is to your right, positive y is above you, and positive z is behind you.
Enter quit to quit.""")
while True:
command = input()
if command == 'quit':
break
