def play(self, path, loop=False, pos=0.0): """This function takes a path to an audio file. Optionally, you can add a boolean for looping and a starting position. It is ment to make playing files easier.""" if self.file != path: tmp_buffer = libaudioverse.Buffer(self.buffer_player.server) tmp_buffer.load_from_file(path) self.buffer_player.buffer = tmp_buffer self.buffer_player.looping = loop self.buffer_player.position = pos self.buffer_player.connect(0, self.buffer_player.server)
def make_sound_objects(self):
"""Makes sound objects from libaudioverse."""
for key, value in sound_files.iteritems():
path = os.path.join(UNSPOKEN_SOUNDS_PATH, value)
libaudioverse_object = libaudioverse.BufferNode(self.simulation)
buffer = libaudioverse.Buffer(self.simulation)
buffer.load_from_file(path)
libaudioverse_object.buffer = buffer
sounds[key] = libaudioverse_object
def load_sound(self, key):
#our sounds are ogg, so just add .ogg
if key not in self.cache:
b = libaudioverse.Buffer(self.simulation)
b.load_from_file(os.path.join(sound_dir, key+".ogg"))
self.cache[key] = b
b = self.cache[key]
n = libaudioverse.BufferNode(self.simulation)
n.buffer.value =b
return Sound(n)
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)
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):
#a simple command line media player.
import libaudioverse
import os.path
libaudioverse.initialize()
server = libaudioverse.Server()
server.set_output_device()
print("""Command line Media player.
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(server)
buffer = libaudioverse.Buffer(server)
buffer.load_from_file(filepath)
filenode.buffer = buffer
#callback for when the file finishes.
def finished(obj):
print("Finished playing.")
filenode.set_end_callback(finished)
filenode.connect(0, filenode.server)
commands = """Commands:
play
pause
#Schedules 3 copies of the same sound to happen in the future. import libaudioverse import time libaudioverse.initialize() simulation = libaudioverse.Simulation() print "Enter the path to a sound file:" path = raw_input() buffer = libaudioverse.Buffer(simulation) buffer.load_from_file(path) timeline = libaudioverse.BufferTimelineNode(simulation, channels=2) timeline.schedule_buffer(buffer=buffer, time=0.0, pitch_bend=1.0) timeline.schedule_buffer(buffer, time=1.0, pitch_bend=0.5) timeline.schedule_buffer(buffer=buffer, time=2.0, pitch_bend=2.0) timeline.connect_simulation(0) simulation.set_output_device(-1) print "Playing..." time.sleep(30.0) shutdown()
import libaudioverse
import numpy
libaudioverse.initialize()
s = libaudioverse.Simulation()
s.set_output_device(-1)
b = libaudioverse.Buffer(s)
b.load_from_file("footsteps.wav")
n = libaudioverse.BufferNode(s)
n.buffer = b
n.looping = True
householder_matrix = numpy.identity(8, dtype=numpy.float32)
vector = numpy.array([1.0] * 8)
vector.shape = (1, 8)
subtract = 0.25 * vector * vector.transpose()
householder_matrix -= subtract
delays = [
2473.0 / 44100.0,
2767.0 / 44100.0,
3217.0 / 44100.0,
3557.0 / 44100.0,
3907 / 44100.0,
4127.0 / 44100.0,
2143.0 / 44100.0,
1933.0 / 44100.0,
]
class Reverb(object):
def __init__(self, simulation):
