def waveform(sound):
startTime = request.args.get('startTime', '0')
endTime = request.args.get('endTime', '0')
if float(startTime) > float(endTime):
endTime = startTime
script = praat._scripts_dir + 'drawWave'
params = [sound, startTime, endTime, praat._sounds_dir, praat._images_dir]
ts = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S_")
if "wav" not in sound:
image = praat._images_dir + ts + str(sound.replace("mp3", "png"))
else:
image = praat._images_dir + ts + str(sound.replace("wav", "png"))
# Add image name to params list
params.append(image)
# If image does not exist, run script
#if not os.path.isfile(image):
praat.runScript(script, params)
utils.resizeImage(image, (1280, 640))
#utils.cropImage(image)
# Image should be available now, generated or cached
with open(image) as fp:
resp = app.make_response(fp.read())
utils.rm_rf(image)
resp.content_type = "image/png"
return resp
def drawSound(sound, startTime, endTime):
# Get URL parameters
showSpectrogram = '0' if request.args.get("spectrogram") is None else '1'
showPitch = '0' if request.args.get("pitch") is None else '1'
showIntensity = '0' if request.args.get("intensity") is None else '1'
showFormants = '0' if request.args.get("formants") is None else '1'
showPulses = '0' if request.args.get("pulses") is None else '1'
# Script file
script = praat._scripts_dir + "drawSpectrogram"
# Parameters to the script
params = [
sound, startTime, endTime, showSpectrogram, showPitch, showIntensity,
showFormants, showPulses, praat._sounds_dir, praat._images_dir
]
# Image name will be a combination of relevant params joined by a period.
image = praat._images_dir + ".".join(params[:-2]) + ".png"
# Add image name to params list
params.append(image)
# If image does not exist, run script
if not os.path.isfile(image):
praat.runScript(script, params)
utils.resizeImage(image)
# Image should be available now, generated or cached
resp = app.make_response(open(image).read())
resp.content_type = "image/png"
return resp
def drawElan(sound, startTime, endTime):
#if(endTime<0)
#resp = drawSound1(sound)
showPitch = '0'
# Script file
script = praat._scripts_dir + "drawWaveform"
# Parameters to the script
params = [
sound, startTime, endTime, showPitch, praat._sounds_dir,
praat._images_dir
]
# Image name will be a combination of relevant params joined by a period.
if "wav" not in sound:
image = praat._images_dir + str(sound.replace("mp3", "png"))
else:
image = praat._images_dir + str(sound.replace("wav", "png"))
# Add image name to params list
params.append(image)
# If image does not exist, run script
if not os.path.isfile(image):
praat.runScript(script, params)
utils.resizeImage(image)
# Image should be available now, generated or cached
resp = app.make_response(open(image).read())
resp.content_type = "image/png"
return resp
def spectrumFrequencyBounds(sound):
# Script file
script = praat._scripts_dir + "spectrumFreqBounds";
# Run script and get output
output = praat.runScript(script, [sound, praat._sounds_dir])
# Split output into an array
res = output.split()
# Create JSON object to return
bounds = {
"low": float(res[0]),
"high": float(res[2])
}
return jsonify(bounds)
def intensityBounds(sound):
# Patht to script
script = praat._scripts_dir + "intensityBounds"
# Run script
output = praat.runScript(script, [sound, praat._sounds_dir])
# Split output into an array
res = output.split()
# Create JSON object to return
bounds = {
"min": float(res[0]),
"max": float(res[2]),
"mean": float(res[4])
}
return jsonify(bounds)
def getBounds(sound):
script = praat._scripts_dir + "getBounds";
output = praat.runScript(script, [sound, praat._sounds_dir])
res = output.split() # Split output into an array
# Get last modified time of the sound file
# Should think about either changing the service name,
# or obtaining last modified time using a different service
lastModifiedTime = time.ctime(os.path.getctime(os.path.join(praat._sounds_dir, sound)))
# Create JSON object to return
bounds = {
"start": float(res[0]),
"end": float(res[2]),
"min": float(res[4]),
"max": float(res[6]),
"lastModified": lastModifiedTime
};
return jsonify(bounds);
def formantValueAtTime(sound, formantNumber, time):
script = praat._scripts_dir + "formantValueAtTime"
return praat.runScript(script,
[sound, formantNumber, time, praat._sounds_dir])
def intensityValueAtTime(sound, time):
script = praat._scripts_dir + "intensityValueAtTime"
return praat.runScript(script, [sound, time, praat._sounds_dir])
def getEnergy(sound):
script = praat._scripts_dir + "getEnergy"
return praat.runScript(script, [sound, praat._sounds_dir])
def generic_audio_ops(user, group, method, audio=None, params=None):
if group is None:
return "Group does not exist"
storage_svc = get_storage_service(praat.app.config)
if method == 'GET':
#g_info = group.details()
#return jsonify(g_info['details']['audios'])
audios = []
for audio in group.audios:
info = audio.summary()
if utils.is_true(params.get('show_versions')):
info['versions'] = storage_svc.show_versions(audio.id)
audios.append(info)
resp = {"status": "success", "audios": audios}
print resp
return jsonify(resp)
if not audio or not audio.filename:
# If no audio file, stop
status = "No audio file"
audioName = ""
elif not utils.isSound(audio.filename):
# Stop if uploaded file is not a audio
status = "Unknown file type"
audioName = audio.filename
else:
audioName = audio.filename
data = audio.read()
key_seed = group.id + audioName
key = utils.generate_id(group.id + audioName)
attrs = {
'created_by': user.email,
}
audioObj = praat.Audio.query.get(key)
retval = storage_svc.put(key, data, attrs)
# save waveform
temp_dir = '/tmp/waveform' + key + retval['version'] + '/'
waveform_name = key + retval['version'] + '.png'
utils.mkdir_p(temp_dir)
with open(temp_dir + audioName, 'w') as fp:
fp.write(data)
script = praat._scripts_dir + 'drawWaveV2'
params = [temp_dir + audioName, temp_dir + waveform_name]
praat.runScript(script, params)
with open(temp_dir + waveform_name, 'r') as fp:
data = fp.read()
attrs = {'name': audioName}
attrs.update(retval)
storage_svc.put(waveform_name, data, attrs)
utils.rm_rf(temp_dir)
if audioObj is None:
print 'Creating new audio file'
audioObj = praat.Audio(audioName, user, group, key_seed)
praat.db_session.add(audioObj)
praat.db_session.commit()
else:
print audioObj.summary()
audioObj.updated_at = datetime.datetime.utcnow()
praat.db_session.commit()
print 'Updating existing audio file'
status = "Success"
result = {
"status": status,
"audio": audioName
}
#return jsonify(result)
return redirect('/?context=workspace')
def pointProcessGetNumPoints(sound):
script = praat._scripts_dir + "pointProcessGetNumPoints";
return praat.runScript(script, [sound, praat._sounds_dir])
def pointProcessGetNumPeriods(sound, start, end):
script = praat._scripts_dir + "pointProcessGetNumPeriods";
return praat.runScript(script, [sound, start, end, praat._sounds_dir])
def pointProcessGetJitter(sound, start, end):
script = praat._scripts_dir + "pointProcessGetJitter";
return praat.runScript(script, [sound, start, end, praat._sounds_dir])
def intensityMean(sound, start, end):
script = praat._scripts_dir + "intensityMean"
return praat.runScript(script, [sound, start, end, praat._sounds_dir])
def harmonicityValueAtTime(sound, time):
script = praat._scripts_dir + "harmonicityGetValueAtTime"
return praat.runScript(script, [sound, time, praat._sounds_dir])
def formantCountAtFrame(sound, frame):
script = praat._scripts_dir + "formantCount"
return praat.runScript(script, [sound, frame, praat._sounds_dir])
def countVoicedFrames(sound):
script = praat._scripts_dir + "countVoicedFrames"
return praat.runScript(script, [sound, praat._sounds_dir])
def pitchValueInFrame(sound, frame):
script = praat._scripts_dir + "pitchValueInFrame"
return praat.runScript(script, [sound, frame, praat._sounds_dir])
def pitchValueAtTime(sound, time):
script = praat._scripts_dir + "pitchValueAtTime"
return praat.runScript(script, [sound, time, praat._sounds_dir])
def harmonicityGetMin(sound, start, end):
script = praat._scripts_dir + "harmonicityGetMin"
return praat.runScript(script, [sound, start, end, praat._sounds_dir])
def formantFrameCount(sound):
script = praat._scripts_dir + "formantFrameCount"
return praat.runScript(script, [sound, praat._sounds_dir])
