def test_06(self):
"Buffer operators with different lengths"
sine = ns.Sine(100)
b1 = ns.Buffer(100)
b1 = sine.drawLine(1.0, 2.0, 2.0)
b2 = ns.Buffer(100)
b2 = sine.drawLine(2.0, 3.0, 3.0)
result = b1 * b2
self.assertEqual(b1.getLength(), result.getLength())
for x in result:
self.assertAlmostEqual(6.0, x, self.GAMMA)
result = b2 * b1
self.assertEqual(b2.getLength(), result.getLength())
for i in xrange(b1.getLength()):
self.assertAlmostEqual(6.0, result[i], self.GAMMA)
for i in xrange(b1.getLength(), result.getLength()):
self.assertAlmostEqual(3.0, result[i], self.GAMMA)
def test_10(self):
"AudioStream operators with different lengths ..."
sine = ns.Sine(100)
a1 = ns.AudioStream(100, 2)
a1 << sine.drawLine(1.0, 2.0, 2.0)
a2 = ns.AudioStream(100, 2)
a2 << sine.drawLine(2.0, 3.0, 3.0)
result = a1 * a2
self.assertNotEqual(a2[0].getLength(), result[0].getLength())
for x in result[0]:
self.assertAlmostEqual(6.0, x, self.GAMMA)
result = a2 * a1
self.assertEqual(a2[0].getLength(), result[0].getLength())
for i in xrange(a1[0].getLength()):
self.assertAlmostEqual(6.0, result[0][i])
for i in xrange(a1[0].getLength(), result[0].getLength()):
self.assertAlmostEqual(3.0, result[0][i], self.GAMMA)
def test_11(self):
"AudioStream slices ..."
print "\n"
sine = ns.Sine(100)
a1 = ns.AudioStream(100, 3)
a1 << sine.drawLine(1.0, 1.0, 1.0)
a1[0] += 1.0
a1[2] += 1.0
for b in a1[0]:
self.assertAlmostEqual(2.0, b, self.GAMMA)
for b in a1[1]:
self.assertAlmostEqual(1.0, b, self.GAMMA)
for b in a1[2]:
self.assertAlmostEqual(2.0, b, self.GAMMA)
selection = a1.select(0, 2) # selects channels 0,1
selection -= 1.0
for b in a1[0]:
self.assertAlmostEqual(1.0, b, self.GAMMA)
for b in a1[1]:
self.assertAlmostEqual(0.0, b, self.GAMMA)
for b in a1[2]:
self.assertAlmostEqual(2.0, b, self.GAMMA)
def test_3(self):
"Test 3"
SR = 44100
T = 0.01
N = int(round(T * SR, 1))
pb = ns.AudioPlaybackRt(SR, 1, 10, T)
info = pb.get_debug_info()
self.assertEqual(10, info.pool_size)
self.assertEqual(N, info.samples_per_buffer)
self.assertEqual(0, info.rd_ptr)
self.assertEqual(0, info.wr_ptr)
self.assertEqual(0, info.wr_index)
self.assertEqual(0, info.n_ready)
self.assertEqual(False, info.is_streaming)
gen = ns.Sine(SR)
dur = 1 * T
buf = gen.silence(dur)
pb.play(buf)
time.sleep(dur)
def test_06(self):
"::operator+,-,*,/ ..."
a1 = ns.AudioStream(100, 1)
a2 = ns.AudioStream(100, 1)
for i in xrange(10):
a1 << i + 1
a2 << i + 1
self.assertEqual(1 + a1 * 2, 2 * a2 + 1)
self.assertEqual(1 - a1 / 2, -1 * a2 / 2 + 1)
t1 = 2.0 / a1
t2 = 4.0 * (0.5 / a2)
for i in xrange(t1[0].getLength()):
self.assertAlmostEqual(t1[0][i], t2[0][i], self.GAMMA)
a1 = -1.0 * a2
a2 += a1
for buf in a2:
for x in buf:
self.assertAlmostEqual(x, 0.0, self.GAMMA)
def test_2(self):
"Test 2"
fn_gold_in = fn("gold/Wavefile_out1.wav")
fn_gold_out = fn("gold/Wavefile_out2.wav")
fn_data = fn("test_wavefile2.wav")
data = ns.AudioStream(fn_gold_in)
ns.Wavefile.setDefaultSampleSize(24)
data >> fn_data
data = ns.AudioStream(fn_data)
#~ # Create gold file
#~ data >> fn_gold_out
gold = ns.AudioStream(fn_gold_out)
diff = data - gold
abs_diff = diff.getAbs()
if abs_diff.getMax() > self.GAMMA:
abs_diff.plot("Absolute diff (data - gold)")
ns.Plotter.show()
raise ValueError("Broken!")
def remake_oscillator(self, widget):
self._need_redraw_lock.acquire()
if widget.type == OscType.SINE:
self._oscillators[widget._id] = Nsound.Sine(self._sample_rate)
elif widget.type == OscType.SAWTOOTH:
self._oscillators[widget._id] = Nsound.Sawtooth(
self._sample_rate, widget.harmonics)
elif widget.type == OscType.SQUARE:
self._oscillators[widget._id] = Nsound.Square(
self._sample_rate, widget.harmonics)
elif widget.type == OscType.PULSE:
self._oscillators[widget._id] = Nsound.Pulse(
self._sample_rate, widget.pulse_width)
if widget.sync:
self._oscillators[0].addSlaveSync(self._oscillators[widget._id])
self._need_redraw = True
self._need_redraw_lock.release()
def play_sound():
buff = ns.Buffer()
i = 0
for x in inc_freq:
if (x):
buff = buff + ns.Sine(sr).generate(1,
(freq[i] +
(scale_val / 100.0) * freq[i]))
i += 1
while (True in inc_freq):
buff >> ns.AudioPlayback(sr, 2, 32)
def test_04(self):
"Buffer::reverse()"
b = ns.Buffer()
b << 1.1 << 2.2 << 3.3 << 4.4
b.reverse()
gold = ns.Buffer()
gold << 4.4 << 3.3 << 2.2 << 1.1
for i in xrange(b.getLength()):
self.assertAlmostEqual(gold[i], b[i], self.GAMMA)
def test_02(self):
"Buffer copy constructor"
b1 = ns.Buffer()
b1 << 1.1 << 2.2 << 3.3 << 4.4
b2 = ns.Buffer(b1)
try:
self.assertEqual(b1, b2)
self.assertEqual(b2, b1)
except:
self._plot_diff(b1, b2, "b1", "b2")
raise
b3 = ns.Buffer(b2)
b4 = ns.Buffer(b3)
b4 << b1
b3 << b1
try:
self.assertEqual(b3, b4)
self.assertEqual(b4, b3)
except:
self._plot_diff(b3, b4, "b1", "b2")
raise
size = b4.getLength()
for i in xrange(size):
try:
self.assertAlmostEqual(b4[i], b3[i], self.GAMMA)
except:
self._plot_diff(b3, b4, "b3", "b4")
raise
self.assertEqual(1 + b4 * 2, 2 * b3 + 1)
self.assertEqual(1 - b4 / 2, -1 * b3 / 2 + 1)
self.assertEqual(2.0 / b4, 4.0 * (0.5 / b3))
b3 = -1.0 * b4
b4 += b3
for i in xrange(b4.getLength()):
self.assertAlmostEqual(b4[i], 0.0, self.GAMMA)
def test_08(self):
"Buffer advanced slicing"
b1 = ns.Buffer([1, 2, 3, 4, 5])
b2 = b1[1:]
self.assertEqual(b2, ns.Buffer([2, 3, 4, 5]))
b2 = b1[:1]
self.assertEqual(b2, ns.Buffer([1.0]))
b2 = b1[1:2]
self.assertEqual(b2, ns.Buffer([2.0]))
b2 = b1[2:1]
self.assertEqual(b2, ns.Buffer([]))
b2 = b1[-1:]
self.assertEqual(b2, ns.Buffer([5.0]))
b2 = b1[-1:-2]
self.assertEqual(b2, ns.Buffer([]))
b2 = b1[-2:-1]
self.assertEqual(b2, ns.Buffer([4]))
def test_02(self):
"AudioStream copy constructor"
a1 = ns.AudioStream(100, 1)
a1 << 1.1 << 2.2 << 3.3 << 4.4
a2 = ns.AudioStream(a1)
try:
self.assertEqual(a1, a2)
self.assertEqual(a2, a1)
except:
self._plot_diff(a1[0], a2[0], "a1", "a2")
raise
def test_13(self):
"AudioStream buffer assignment and transpose"
b = ns.Buffer()
b << 1 << 2 << 3 << 4
a = ns.AudioStream(1, 2)
a[0] = b
a[1] = b.getReverse()
self.assertEqual(2, a.getNChannels())
self.assertEqual(4, a.getLength())
self.assertAlmostEqual(a[0], ns.Buffer([1,2,3,4]), self.GAMMA)
self.assertAlmostEqual(a[1], ns.Buffer([4,3,2,1]), self.GAMMA)
a.transpose()
self.assertEqual(4, a.getNChannels())
self.assertEqual(2, a.getLength())
self.assertAlmostEqual(a[0], ns.Buffer([1,4]), self.GAMMA)
self.assertAlmostEqual(a[1], ns.Buffer([2,3]), self.GAMMA)
self.assertAlmostEqual(a[2], ns.Buffer([3,2]), self.GAMMA)
self.assertAlmostEqual(a[3], ns.Buffer([4,1]), self.GAMMA)
def test_03(self):
"FilterMedian stuff"
fm = ns.FilterMedian(4)
b1 = ns.Buffer([6, 4, 2, 1, 7, 3, 5, 9, 4, 6, 2])
data = fm.filter(b1)
gold = [6, 6, 6, 4, 4, 3, 3, 5, 5, 5, 5]
# convert to int for comparison conviences
data = [int(x) for x in data]
self.assertEqual(gold, data)
def test_01(self):
"FilterMedian stuff"
fm = ns.FilterMedian(3)
b1 = ns.Buffer([1, 2, 3, 4, 5, 6, 7])
data = fm.filter(b1)
gold = [1, 1, 2, 3, 4, 5, 6]
# convert to int for comparison conviences
data = [int(x) for x in data]
self.assertEqual(gold, data)
def test_09(self):
"AudioStream::substream() ..."
a1 = ns.AudioStream(100, 2)
chunk = 100
for i in range(chunk * 2 + 1):
a1 << i
test_size = 99 / 100.0
substream = a1.substream(0, test_size)
self.assertAlmostEqual(test_size, substream.getDuration(), self.GAMMA/2)
test_size = 1.0
substream = a1.substream(0, test_size)
self.assertAlmostEqual(test_size, substream.getDuration(), self.GAMMA)
test_size = a1.getDuration() + 1.0
substream = a1.substream(0, test_size)
self.assertAlmostEqual(a1.getDuration(), substream.getDuration(), self.GAMMA)
test_size = (chunk + 10) / 100.0
for i in xrange(10):
substream = a1.substream(i/100.0, test_size)
self.assertAlmostEqual(test_size, substream.getDuration())
substream = a1.substream(0, 0.10)
for i in xrange(10):
self.assertAlmostEqual(i, substream[0][i], self.GAMMA)
substream = a1.substream(0.031, 0.031)
for i in xrange(3):
self.assertAlmostEqual(i + 3, substream[0][i])
substream = a1.substream(3.1/100.0)
self.assertEqual(a1[0].getLength() - 3, substream[0].getLength())
substream = a1.substream(0)
self.assertEqual(a1[0].getLength(), substream[0].getLength())
for i in xrange(10):
self.assertAlmostEqual(i, substream[0][i], self.GAMMA)
substream = a1.substream(5.1/100.0,5.1/100.0)
self.assertEqual(5, substream[0].getLength())
def test_10(self):
"Buffer::circular_iterator forward"
b1 = ns.Buffer([1, 2, 3])
c = b1.cbegin()
b2 = ns.Buffer()
for i in xrange(10):
b2 << float(c)
c += 1
gold = [1, 2, 3, 1, 2, 3, 1, 2, 3, 1]
np.testing.assert_almost_equal(gold, b2)
def test_12(self):
"AudioStream pickling"
gold = [1.1, 2.2, 3.3, 4.4, 5.5]
as1 = ns.AudioStream(2, 2)
as1 << gold
fn = 'audio_stream.pkl'
with open(fn, 'w') as fd:
pickle.dump(as1, fd)
with open(fn, 'r') as fd:
obj = pickle.load(fd)
self.assertEqual(2, int(obj.getSampleRate()))
self.assertEqual(2, obj.getNChannels())
for i in xrange(2):
data = obj[i].toList()
np.testing.assert_almost_equal(gold, data)
if os.path.isfile(fn):
os.remove(fn)
def test_10(self):
"Buffer::circular_iterator backward"
b1 = ns.Buffer([1,2,3])
c = b1.cbegin()
b2 = ns.Buffer()
for i in range(10):
c -= 1
b2 << float(c)
gold = [3,2,1,3,2,1,3,2,1,3]
np.testing.assert_almost_equal(gold, b2)
def open_reference(self, widget, filename=None):
if filename == None:
dialog = gtk.FileChooserDialog(
"Open Reference .wav file",
action=gtk.FILE_CHOOSER_ACTION_OPEN,
buttons=(gtk.STOCK_OPEN, gtk.RESPONSE_OK, gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL))
if self._last_path != None:
dialog.set_current_folder(self._last_path)
file_filter = gtk.FileFilter()
file_filter.set_name("Wavefiles")
file_filter.add_pattern("*.wav")
dialog.add_filter(file_filter)
response = dialog.run()
if response != gtk.RESPONSE_OK:
dialog.destroy()
return
filename = dialog.get_filename()
dirname = os.path.dirname(filename)
dialog.destroy()
self._last_path = dirname
# Load the wavefile
try:
a = Nsound.AudioStream(filename)
except:
raise RuntimeError("Could not read wavefile '%s'" % filename)
a.normalize()
ref_sr = a.getSampleRate()
self._duration = a.getDuration()
# Set the global self._sample_rate
if self._sample_rate != ref_sr:
self._sample_rate = ref_sr
for widget in self._osc_widgets:
self.remake_oscillator(widget)
for widget in self._filter_widgets:
self.remake_filter(widget)
# Save the reference Nsound.Buffer object
self._need_redraw_lock.acquire()
self._reference_wave = a[0]
self._need_redraw = True
self._need_redraw_lock.release()
def test_04(self):
"AudioStream::operator<<(const AudioStream &) ..."
a1 = ns.AudioStream(100, 1)
for i in xrange(10):
a1 << i
a2 = ns.AudioStream(a1)
a3 = ns.AudioStream(a2)
a2 << a1
a3 << a1
try:
self.assertEqual(a2, a3)
except:
self._plot_diff(a2[0], a3[0], "a2", "a3")
raise
def test_05(self):
"AudioStream::operator[](uint32) ..."
a1 = ns.AudioStream(100, 1)
a2 = ns.AudioStream(100, 1)
for i in xrange(10):
a1 << i
a2 << i
size = a1[0].getLength()
try:
for i in xrange(size):
self.assertAlmostEqual(a1[0][i], a2[0][i], self.GAMMA)
except:
self._plot_diff(a1[0], a2[0], "a1", "a2")
raise
def test_1(self):
"Test 1"
fn_gold = fn("gold/Wavefile_out1.wav")
fn_data = fn("test_wavefile1.wav")
sr = 100
n_channels = 3
ns.Wavefile.setDefaultSampleSize(48)
sin = ns.Sine(sr)
data = ns.AudioStream(sr, n_channels)
data << sin.generate(1.0, 13.0)
data[1] *= 0.666666666666666
data[2] *= 0.333333333333333
# Write data to disk, read it back in.
data >> fn_data
#~ # Create gold file
#~ data >> fn_gold
data = ns.AudioStream(fn_data)
gold = ns.AudioStream(fn_gold)
diff = data - gold
abs_diff = diff.getAbs()
if abs_diff.getMax() > self.GAMMA:
abs_diff.plot("Absolute diff (data - gold)")
ns.Plotter.show()
raise ValueError("Broken!")
def test_03(self):
"AudioStream::operator<<(Buffer)"
a1 = ns.AudioStream(100, 1)
b1 = ns.Buffer()
for i in xrange(10):
a1 << i
b1 << i
a2 = ns.AudioStream(a1)
a3 = ns.AudioStream(a2)
a2 << b1
a3 << b1
try:
self.assertEqual(a2, a3)
except:
self._plot_diff(a2[0], a3[0], "a2", "a3")
raise
def test_2(self):
"Test 2"
SR = 44100
T = 0.01
N = int(round(T * SR, 1))
pb = ns.AudioPlaybackRt(SR, 1, 10, T)
info = pb.get_debug_info()
self.assertEqual(10, info.pool_size)
self.assertEqual(N, info.samples_per_buffer)
self.assertEqual(0, info.rd_ptr)
self.assertEqual(0, info.wr_ptr)
self.assertEqual(0, info.wr_index)
self.assertEqual(0, info.n_ready)
self.assertEqual(False, info.is_streaming)
# Play some samples
for i in xrange( 10 * N):
pb.play(0)
# Note: not sleepping, trying to capture n_ready from 10 to 0
info = pb.get_debug_info()
self.assertEqual(False, info.is_streaming)
self.assertEqual(10, info.n_ready)
x = set()
for i in xrange(1 << 10):
pb.play(0)
info = pb.get_debug_info()
if info.is_streaming: break
self.assertEqual(True, info.is_streaming)
while info.n_ready != 0:
self.assertEqual(True, info.is_streaming)
info = pb.get_debug_info()
x.add(info.n_ready)
gold = set(range(11))
# print "gold = ", gold
# print "x = ", x
self.assertEqual(gold, x)
def play(self, duration, frequency):
samplerate = self.samplerate
if not frequency:
return Nsound.Buffer.zeros(int(samplerate * duration))
out = Nsound.AudioStream(samplerate, 1) # mono
cycles = int(samplerate / frequency)
ring = collections.deque(Nsound.Buffer.rand(cycles).toList())
for i in xrange(int(samplerate * duration)):
out << ring[0]
avg = 0.996 * 0.5 * (ring[0] + ring[1])
ring.append(avg)
ring.popleft()
return 0.25 * out
def remake_filter(self, widget):
self._need_redraw_lock.acquire()
if widget.ir_type == IRType.IIR:
if widget.filter_type == FilterType.LOW_PASS:
f = Nsound.FilterLowPassIIR(self._sample_rate, widget.order,
widget.fc_low, widget.ripple)
elif widget.filter_type == FilterType.HIGH_PASS:
f = Nsound.FilterHighPassIIR(self._sample_rate, widget.order,
widget.fc_high, widget.ripple)
elif widget.filter_type == FilterType.BAND_PASS:
f = Nsound.FilterBandPassIIR(self._sample_rate, widget.order,
widget.fc_low, widget.fc_high,
widget.ripple)
elif widget.filter_type == FilterType.BAND_REJECT:
f = Nsound.FilterBandRejectIIR(self._sample_rate, widget.order,
widget.fc_low, widget.fc_high,
widget.ripple)
elif widget.ir_type == IRType.FIR:
if widget.filter_type == FilterType.LOW_PASS:
f = Nsound.FilterLowPassFIR(self._sample_rate, widget.order,
widget.fc_low)
elif widget.filter_type == FilterType.HIGH_PASS:
f = Nsound.FilterHighPassFIR(self._sample_rate, widget.order,
widget.fc_high)
elif widget.filter_type == FilterType.BAND_PASS:
f = Nsound.FilterBandPassFIR(self._sample_rate, widget.order,
widget.fc_low, widget.fc_high)
elif widget.filter_type == FilterType.BAND_REJECT:
f = Nsound.FilterBandRejectFIR(self._sample_rate, widget.order,
widget.fc_low, widget.fc_high)
self._filters[widget._id] = f
self._need_redraw = True
self._need_redraw_lock.release()
def test_08(self):
"AudioStream::reverse() ..."
a1 = ns.AudioStream(100, 2)
for f in xrange(100):
a1 << f
a1.reverse()
for buf in a1:
index = 0;
for f in xrange(99, -1, -1):
self.assertAlmostEqual(float(f), buf[index], self.GAMMA)
index += 1
def test_01(self):
"AudioStream::operator<<(float64)"
a1 = ns.AudioStream(100, 2)
i = 0.0
while i < 100.0:
a1 << i
i += 1.1
for buf in a1:
i = 0.0
for x in buf:
self.assertAlmostEqual(x, i, self.GAMMA)
i += 1.1
def test_01(self):
"Basic buffer stuff"
ns.Wavefile.setDefaultSampleSize(48)
b1 = ns.Buffer(29)
i = 0.0
while i < 100.0:
b1 << i
i += 1.1
i = 0.0
for x in b1:
self.assertAlmostEqual(x, i, self.GAMMA)
i += 1.1
