import scipy.io.wavfile
files = ( #'../build/openmini/tests/in.dat',
'../build/openmini/tests/out.dat',
# '../build/openmini/tests/expected.dat',
)
view_beginning = 0
view_length = 32768
signals = []
for filename in files:
signal_label = os.path.basename(filename)
print("File '" + signal_label + "': " + str(filename))
signal = ExtractSignal(filename)
metas = utilities.GetMetadata(signal)
print(utilities.PrintMetadata(metas))
pylab.plot(signal[view_beginning:view_beginning + view_length:1],
label=signal_label)
signals.append(signal)
utilities.WriteWav(signal, filename, 96000.0)
# pylab.plot((utilities.Diff(signals[0]))[view_beginning:view_beginning + view_length:1], label = "diff")
# print(numpy.max(utilities.Diff(signals[0])))
# print(utilities.ZeroCrossings(utilities.Diff(signals[0])))
# pylab.plot((signals[1] - signals[0])[view_beginning:view_beginning + view_length:1])
pylab.legend()
pylab.show()
internal_saw_data[idx] = generator_left._sawtooth_gen._current
internal_diff_data[idx] = generator_left._differentiator._last
generator_right = TriangleDPW(sampling_freq)
generator_right.SetPhase(generated_data[length / 2 - 1])
generator_right.SetFrequency(freq)
generator_right.ProcessSample()
for idx in range(length / 2, length):
generated_data[idx] = generator_right.ProcessSample()
internal_saw_data[idx] = generator_right._sawtooth_gen._current
internal_diff_data[idx] = generator_right._differentiator._last
differentiator = Differentiator()
diff_data = numpy.zeros(len(generated_data))
for idx, sample in enumerate(generated_data):
diff_data[idx] = differentiator.ProcessSample(sample)
print(
utilities.PrintMetadata(
utilities.GetMetadata(generated_data - ref_data)))
pylab.plot(generated_data, label="generated")
pylab.plot(internal_saw_data, label="internal_saw")
pylab.plot(internal_diff_data, label="internal_diff")
pylab.plot(diff_data, label="diff")
pylab.legend()
pylab.show()
utilities.WriteWav(generated_data, "triangle_gen", sampling_freq)
ref_data[idx] = generator_ref.ProcessSample()
nopostfilter_data[idx] = generator_nopostfilter.ProcessSample()
low_res_data[idx] = generator_low_res.ProcessSample()
generator_left = BLTriangle(sampling_freq)
generator_left.SetFrequency(freq)
for idx in range(length / 2):
generated_data[idx] = generator_left.ProcessSample()
generator_right = BLTriangle(sampling_freq)
generator_right.SetPhase(generated_data[length / 2 - 1])
generator_right.SetFrequency(freq)
generator_right.ProcessSample()
for idx in range(length / 2, length):
generated_data[idx] = generator_right.ProcessSample()
print(utilities.PrintMetadata(utilities.GetMetadata(ref_data)))
# print(utilities.PrintMetadata(utilities.GetMetadata(ref_data - low_res_data)))
# pylab.plot(generator_ref._table, label = "table")
pylab.plot(ref_data, label="triangle")
# pylab.plot(nopostfilter_data, label = "triangle_nopf")
pylab.plot(generated_data, label="pieces_data")
# pylab.plot(ref_data - low_res_data, label = "diff")
pylab.legend()
pylab.show()
utilities.WriteWav(ref_data, "bl_triangle", sampling_freq)
utilities.WriteWav(generated_data, "bl_triangle_phase", sampling_freq)
# The base lowpass has to be updated with the actual internal values
for idx, _ in enumerate(in_data):
out_data[filter_idx][idx] = filter_instance.ProcessSample(
in_data[idx])
# Check vectorized version
squared_diff = 0.0
idx = 0
while idx < len(in_data) - 4:
current_vector = (in_data[idx], in_data[idx + 1], in_data[idx + 2],
in_data[idx + 3])
current_out = numpy.array(
filter_instance_v.Process4Samples(current_vector))
cmp = numpy.array(out_data[filter_idx][idx:idx + 4])
squared_diff += numpy.sum(current_out * current_out - cmp * cmp)
idx += 4
filter_name = str(type(filter_instance))
pylab.plot(out_data[filter_idx], label="out" + filter_name)
print(filter_name + utilities.PrintMetadata(
utilities.GetMetadata(out_data[filter_idx])))
print("Squared diff: " + str(squared_diff))
print("in_data: " +
utilities.PrintMetadata(utilities.GetMetadata(in_data)))
diff = in_data - out_data[filter_idx]
pylab.plot(diff)
print("diff: " + utilities.PrintMetadata(utilities.GetMetadata(diff)))
pylab.plot(in_data, label="in")
pylab.legend()
pylab.show()
lowpass = Chamberlin()
lowpass.SetParameters(filter_freq, resonance)
lowpassminphase = Chamberlin()
lowpassminphase.SetParameters(filter_freq, resonance)
lowpassoversampled = ChamberlinOverSampled()
lowpassoversampled.SetParameters(filter_freq, resonance)
for idx, _ in enumerate(in_data):
out_data[idx] = lowpass.ProcessSample(in_data[idx])
out_data_minphase[idx] = lowpassminphase.ProcessSampleMinimumPhase(
in_data[idx])
out_data_oversampled[idx] = lowpassoversampled.ProcessSample(
in_data[idx])
print(
utilities.PrintMetadata(
utilities.GetMetadata(out_data - out_data_minphase)))
print(
utilities.PrintMetadata(
utilities.GetMetadata(out_data - out_data_oversampled)))
print(
utilities.PrintMetadata(
utilities.GetMetadata(in_data - out_data_oversampled)))
pylab.plot(in_data, label="in")
pylab.plot(out_data, label="out")
pylab.plot(out_data_minphase, label="out_minphase")
pylab.plot(out_data_oversampled, label="out_oversampled")
pylab.legend()
pylab.show()
while idx < len(in_data) - 1:
in_vec = [
in_data[idx], in_data[idx + 1], in_data[idx + 2], in_data[idx + 3]
]
(out_vec_data[idx], out_vec_data[idx + 1], out_vec_data[idx + 2],
out_vec_data[idx + 3]) = vcf_vec.Process4Samples(in_vec)
idx += 4
# contour_data[idx] = vcf._co ntour
# dry_data[idx] = vcf._dry
# wet_data[idx] = vcf._wet
utilities.WriteWav(out_data, "contour_filter", sampling_freq)
utilities.WriteWav(out_vec_data, "contour_filter_vec", sampling_freq)
print(
utilities.PrintMetadata(utilities.GetMetadata(out_vec_data -
out_data)))
# pylab.plot(in_data[view_beginning:view_beginning + view_length], label="in")
# pylab.plot(out_data[view_beginning:view_beginning + view_length], label="out")
# pylab.plot(out_vec_data[view_beginning:view_beginning + view_length], label="out_vec")
# pylab.plot(out_data[view_beginning:view_beginning + view_length], label="out")
pylab.plot(
(out_vec_data - out_data)[view_beginning:view_beginning + view_length],
label="out_vec")
# pylab.plot(contour_data[view_beginning:view_beginning + view_length], label="contour")
# pylab.plot(dry_data[view_beginning:view_beginning + view_length], label="dry")
# pylab.plot(wet_data[view_beginning:view_beginning + view_length], label="wet")
pylab.legend()
pylab.show()
lowpass_v.SetParameters(filter_freq, 0.0)
idx = 0
while idx < len(in_data):
current_vector = (in_data[idx], in_data[idx + 1], in_data[idx + 2],
in_data[idx + 3])
(out_data_vectorized[idx], out_data_vectorized[idx + 1],
out_data_vectorized[idx + 2],
out_data_vectorized[idx +
3]) = lowpass_v.Process4Samples(current_vector)
(out_data_fixed_vectorized[idx], out_data_fixed_vectorized[idx + 1],
out_data_fixed_vectorized[idx + 2], out_data_fixed_vectorized[idx + 3]
) = moog_fixed_lowpass_v.Process4Samples(current_vector)
idx += 4
print(
utilities.PrintMetadata(
utilities.GetMetadata(out_data - out_data_vectorized)))
print(
utilities.PrintMetadata(
utilities.GetMetadata(out_data - out_fixed_data)))
# Check for the vectorized implementation of the fixed zero low pass
print(
utilities.PrintMetadata(
utilities.GetMetadata(out_data_fixed - out_data_fixed_vectorized)))
# pylab.plot(in_data, label="in")
# pylab.plot(out_data, label="out")
# pylab.plot(out_data_vectorized, label="out_vectorized")
# pylab.plot(out_fixed_data, label="out_fixed")
# pylab.plot(out_data_fixed_vectorized, label="out_vectorized")
# pylab.plot(out_data_fixed, label="out_fixed")