def test_sms_initAnalysis(self):
"sms_initAnalysis"
create_test_audio_file()
if(sms_openSF(TEST_AUDIO_FILE, self.snd_header)):
raise NameError("error opening sound file: " + sms_errorString())
self.assert_(sms_initAnalysis(self.analysis_params, self.snd_header) == 0)
delete_test_audio_file()
def test_sms_allocFrameH(self):
"sms_allocFrameH"
create_test_audio_file()
if(sms_openSF(TEST_AUDIO_FILE, self.snd_header)):
raise NameError("error opening sound file: " + sms_errorString())
self.assert_(sms_allocFrameH(self.sms_header, self.data) == 0)
delete_test_audio_file()
def test_sms_allocFrameH(self):
"sms_allocFrameH"
create_test_audio_file()
if (sms_openSF(TEST_AUDIO_FILE, self.snd_header)):
raise NameError("error opening sound file: " + sms_errorString())
self.assert_(sms_allocFrameH(self.sms_header, self.data) == 0)
delete_test_audio_file()
def test_sms_initAnalysis(self):
"sms_initAnalysis"
create_test_audio_file()
if (sms_openSF(TEST_AUDIO_FILE, self.snd_header)):
raise NameError("error opening sound file: " + sms_errorString())
self.assert_(
sms_initAnalysis(self.analysis_params, self.snd_header) == 0)
delete_test_audio_file()
def analyze(audio_file, frame_rate=300, window_size=1001, window_type=pysms.SMS_WIN_HAMMING,
num_stoc_coeffs=128, default_fundamental=100, highest_freq=12000,
env_type=0, env_order=0):
pysms.sms_init()
analysis_params = pysms.SMS_AnalParams()
pysms.sms_initAnalParams(analysis_params)
analysis_params.fDefaultFundamental = default_fundamental
analysis_params.fHighestFreq = highest_freq
analysis_params.specEnvParams.iType = env_type
analysis_params.specEnvParams.iOrder = env_order
analysis_params.iFrameRate = frame_rate
analysis_params.nStochasticCoeff = num_stoc_coeffs
# Try to open the input file
snd_header = pysms.SMS_SndHeader()
if(pysms.sms_openSF(audio_file, snd_header)):
raise NameError("error opening sound file: " + pysms.sms_errorString())
# initialize memory for analysis
if pysms.sms_initAnalysis(analysis_params, snd_header) != 0:
raise Exception("Error allocating memory for analysis_params")
# copy data into the sms header
sms_header = pysms.SMS_Header()
pysms.sms_fillHeader(sms_header, analysis_params, "analysis.py")
analysis_frames = []
num_samples = snd_header.nSamples
num_frames = 0
sample_offset = 0
size_new_data = 0
do_analysis = True
# Analysis loop
while do_analysis:
sample_offset += size_new_data
if((sample_offset + analysis_params.sizeNextRead) < num_samples):
size_new_data = analysis_params.sizeNextRead
else:
size_new_data = num_samples - sample_offset
frame = np.zeros(size_new_data, dtype=np.float32)
if pysms.sms_getSound(snd_header, frame, sample_offset, analysis_params):
raise NameError("error opening sound file: " + pysms.sms_errorString())
data = pysms.SMS_Data()
pysms.sms_allocFrameH(sms_header, data)
status = pysms.sms_analyze(frame, data, analysis_params)
if status == 1:
analysis_frames.append(data)
num_frames += 1
elif status == -1:
do_analysis = False
sms_header.nFrames = num_frames
# free memory and return
pysms.sms_freeAnalysis(analysis_params)
pysms.sms_closeSF()
pysms.sms_free()
return analysis_frames, sms_header, snd_header
def sms_size_next_read():
pysms.sms_init()
snd_header = pysms.SMS_SndHeader()
# Try to open the input file to fill snd_header
if(pysms.sms_openSF(audio_path, snd_header)):
raise NameError(
"error opening sound file: " + pysms.sms_errorString()
)
analysis_params = _pysms_analysis_params(sampling_rate)
analysis_params.iMaxDelayFrames = num_frames + 1
if pysms.sms_initAnalysis(analysis_params, snd_header) != 0:
raise Exception("Error allocating memory for analysis_params")
analysis_params.nFrames = num_frames
sms_header = pysms.SMS_Header()
pysms.sms_fillHeader(sms_header, analysis_params, "pysms")
sample_offset = 0
pysms_size_new_data = 0
current_frame = 0
next_read_sizes = []
while current_frame < num_frames:
next_read_sizes.append(analysis_params.sizeNextRead)
sample_offset += pysms_size_new_data
pysms_size_new_data = analysis_params.sizeNextRead
# convert frame to floats for libsms
frame = audio[sample_offset:sample_offset + pysms_size_new_data]
frame = np.array(frame, dtype=np.float32)
if len(frame) < pysms_size_new_data:
frame = np.hstack((
frame, np.zeros(pysms_size_new_data - len(frame),
dtype=np.float32)
))
analysis_data = pysms.SMS_Data()
pysms.sms_allocFrameH(sms_header, analysis_data)
status = pysms.sms_analyze(frame, analysis_data, analysis_params)
# as the no. of frames of delay is > num_frames, sms_analyze should
# never get around to performing partial tracking, and so the
# return value should be 0
assert status == 0
pysms.sms_freeFrame(analysis_data)
current_frame += 1
pysms.sms_freeAnalysis(analysis_params)
pysms.sms_closeSF()
pysms.sms_free()
return next_read_sizes
def test_sms_getSound(self):
"sms_getSound"
create_test_audio_file()
self.assert_(sms_openSF(TEST_AUDIO_FILE, self.snd_header) == 0)
frame_size = 512
frame = zeros(frame_size).astype('float32')
self.assert_(sms_getSound(self.snd_header, frame, 0) == 0)
# test that values read in are the same as those written (allowing for some rounding errors)
class SampleMismatch(Exception): pass
for sample_number in range(frame_size):
if abs((test_audio[sample_number] / 32768.0) - frame[sample_number] > 0.000001):
raise SampleMismatch
delete_test_audio_file()
def test_sms_getSound(self):
"sms_getSound"
create_test_audio_file()
self.assert_(sms_openSF(TEST_AUDIO_FILE, self.snd_header) == 0)
frame_size = 512
frame = zeros(frame_size).astype('float32')
self.assert_(sms_getSound(self.snd_header, frame, 0) == 0)
# test that values read in are the same as those written (allowing for some rounding errors)
class SampleMismatch(Exception):
pass
for sample_number in range(frame_size):
if abs((test_audio[sample_number] / 32768.0) -
frame[sample_number] > 0.000001):
raise SampleMismatch
delete_test_audio_file()
def test_sms_openSF_file_exists(self):
"sms_openSF returns True when trying to open an existing file"
create_test_audio_file()
self.assert_(sms_openSF(TEST_AUDIO_FILE, self.snd_header) == 0)
delete_test_audio_file()
def test_sms_openSF_file_exists(self):
"sms_openSF returns True when trying to open an existing file"
create_test_audio_file()
self.assert_(sms_openSF(TEST_AUDIO_FILE, self.snd_header) == 0)
delete_test_audio_file()
def sms_residual_synthesis():
pysms.sms_init()
snd_header = pysms.SMS_SndHeader()
if(pysms.sms_openSF(audio_path, snd_header)):
raise NameError(pysms.sms_errorString())
analysis_params = _pysms_analysis_params(sampling_rate)
analysis_params.nStochasticCoeff = 128
analysis_params.iStochasticType = pysms.SMS_STOC_APPROX
if pysms.sms_initAnalysis(analysis_params, snd_header) != 0:
raise Exception("Error allocating memory for analysis_params")
analysis_params.iSizeSound = num_samples
analysis_params.nFrames = num_frames
sms_header = pysms.SMS_Header()
pysms.sms_fillHeader(sms_header, analysis_params, "pysms")
sample_offset = 0
size_new_data = 0
current_frame = 0
analysis_frames = []
do_analysis = True
while do_analysis and (current_frame < num_frames):
sample_offset += size_new_data
size_new_data = analysis_params.sizeNextRead
frame_audio = audio[sample_offset:sample_offset + size_new_data]
frame_audio = np.array(frame_audio, dtype=np.float32)
if len(frame_audio) < size_new_data:
frame_audio = np.hstack((
frame_audio, np.zeros(size_new_data - len(frame_audio),
dtype=np.float32)
))
analysis_data = pysms.SMS_Data()
pysms.sms_allocFrameH(sms_header, analysis_data)
status = pysms.sms_analyze(frame_audio, analysis_data,
analysis_params)
analysis_frames.append(analysis_data)
current_frame += 1
if status == -1:
do_analysis = False
sms_header.nFrames = len(analysis_frames)
synth_params = _pysms_synthesis_params(sampling_rate)
synth_params.iStochasticType = pysms.SMS_STOC_APPROX
synth_params.iSynthesisType = pysms.SMS_STYPE_STOC
pysms.sms_initSynth(sms_header, synth_params)
synth_frame = np.zeros(synth_params.sizeHop, dtype=np.float32)
synth_audio = np.array([], dtype=np.float32)
for i in range(len(analysis_frames)):
pysms.sms_synthesize(analysis_frames[i], synth_frame, synth_params)
synth_audio = np.hstack((synth_audio, synth_frame))
synth_audio = np.asarray(synth_audio * 32768, np.int16)
for frame in analysis_frames:
pysms.sms_freeFrame(frame)
pysms.sms_freeAnalysis(analysis_params)
pysms.sms_closeSF()
pysms.sms_freeSynth(synth_params)
pysms.sms_free()
return synth_audio
def sms_harmonic_synthesis(det_synth_type):
pysms.sms_init()
snd_header = pysms.SMS_SndHeader()
if(pysms.sms_openSF(audio_path, snd_header)):
raise NameError(pysms.sms_errorString())
analysis_params = _pysms_analysis_params(sampling_rate)
if pysms.sms_initAnalysis(analysis_params, snd_header) != 0:
raise Exception("Error allocating memory for analysis_params")
analysis_params.iSizeSound = num_samples
analysis_params.nFrames = num_frames
sms_header = pysms.SMS_Header()
pysms.sms_fillHeader(sms_header, analysis_params, "pysms")
sample_offset = 0
size_new_data = 0
current_frame = 0
analysis_frames = []
do_analysis = True
while do_analysis and (current_frame < num_frames):
sample_offset += size_new_data
size_new_data = analysis_params.sizeNextRead
frame_audio = audio[sample_offset:sample_offset + size_new_data]
frame_audio = np.array(frame_audio, dtype=np.float32)
if len(frame_audio) < size_new_data:
frame_audio = np.hstack((
frame_audio, np.zeros(size_new_data - len(frame_audio),
dtype=np.float32)
))
analysis_data = pysms.SMS_Data()
pysms.sms_allocFrameH(sms_header, analysis_data)
status = pysms.sms_analyze(frame_audio, analysis_data,
analysis_params)
analysis_frames.append(analysis_data)
current_frame += 1
if status == -1:
do_analysis = False
synth_params = _pysms_synthesis_params(sampling_rate)
if det_synth_type == 'ifft':
synth_params.iDetSynthType = pysms.SMS_DET_IFFT
elif det_synth_type == 'sin':
synth_params.iDetSynthType = pysms.SMS_DET_SIN
else:
raise Exception("Invalid deterministic synthesis type")
pysms.sms_initSynth(sms_header, synth_params)
synth_frame = np.zeros(synth_params.sizeHop, dtype=np.float32)
synth_audio = np.array([], dtype=np.float32)
for i in range(len(analysis_frames)):
pysms.sms_synthesize(analysis_frames[i], synth_frame, synth_params)
synth_audio = np.hstack((synth_audio, synth_frame))
synth_audio = np.asarray(synth_audio * 32768, np.int16)
for frame in analysis_frames:
pysms.sms_freeFrame(frame)
pysms.sms_freeAnalysis(analysis_params)
pysms.sms_closeSF()
pysms.sms_freeSynth(synth_params)
pysms.sms_free()
return synth_audio
def sms_partial_tracking():
pysms.sms_init()
snd_header = pysms.SMS_SndHeader()
if(pysms.sms_openSF(audio_path, snd_header)):
raise NameError(pysms.sms_errorString())
analysis_params = _pysms_analysis_params(sampling_rate)
if pysms.sms_initAnalysis(analysis_params, snd_header) != 0:
raise Exception("Error allocating memory for analysis_params")
analysis_params.iSizeSound = num_samples
analysis_params.nFrames = num_frames
sms_header = pysms.SMS_Header()
pysms.sms_fillHeader(sms_header, analysis_params, "pysms")
sample_offset = 0
size_new_data = 0
current_frame = 0
sms_frames = []
do_analysis = True
while do_analysis and (current_frame < num_frames):
sample_offset += size_new_data
size_new_data = analysis_params.sizeNextRead
frame_audio = audio[sample_offset:sample_offset + size_new_data]
frame_audio = np.array(frame_audio, dtype=np.float32)
if len(frame_audio) < size_new_data:
frame_audio = np.hstack((
frame_audio, np.zeros(size_new_data - len(frame_audio),
dtype=np.float32)
))
analysis_data = pysms.SMS_Data()
pysms.sms_allocFrameH(sms_header, analysis_data)
num_partials = analysis_data.nTracks
status = pysms.sms_analyze(frame_audio, analysis_data,
analysis_params)
sms_freqs = np.zeros(num_partials, dtype=np.float32)
sms_amps = np.zeros(num_partials, dtype=np.float32)
sms_phases = np.zeros(num_partials, dtype=np.float32)
frame = {'status': status}
frame['partials'] = []
if status == 1:
analysis_data.getSinFreq(sms_freqs)
analysis_data.getSinAmp(sms_amps)
analysis_data.getSinPhase(sms_phases)
current_frame += 1
if status == -1:
do_analysis = False
for i in range(num_partials):
frame['partials'].append({
'n': i,
'amplitude': float(sms_amps[i]),
'frequency': float(sms_freqs[i]),
'phase': float(sms_phases[i])
})
sms_frames.append(frame)
pysms.sms_freeFrame(analysis_data)
pysms.sms_freeAnalysis(analysis_params)
pysms.sms_closeSF()
pysms.sms_free()
return sms_frames
