marytts.modules.KlattDurationModeller Maven / Gradle / Ivy
The newest version!
/**
* Copyright 2002 DFKI GmbH.
* All Rights Reserved. Use is subject to license terms.
*
* This file is part of MARY TTS.
*
* MARY TTS is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 3 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see end attribute. (This value is then comparable to the
* end feature in FreeTTS, but we use milliseconds, they use seconds.)
*/
private void calculateAccumulatedDurations(Element sentence) {
TreeWalker tw = ((DocumentTraversal) sentence.getOwnerDocument()).createTreeWalker(sentence, NodeFilter.SHOW_ELEMENT,
new NameNodeFilter(new String[] { MaryXML.PHONE, MaryXML.BOUNDARY }), false);
float totalDurationInSeconds = 0f;
Element element;
while ((element = (Element) tw.nextNode()) != null) {
if (element.getTagName().equals(MaryXML.PHONE)) {
// A segment
int d = 0;
try {
d = Integer.parseInt(element.getAttribute("d"));
} catch (NumberFormatException e) {
logger.warn("Unexpected duration value `" + element.getAttribute("d") + "'");
}
float durationInSeconds = 0.001f * d;
totalDurationInSeconds += durationInSeconds;
element.setAttribute("end", String.format(Locale.US, "%.3f", totalDurationInSeconds));
} else {
// A boundary
int d = 0;
try {
d = Integer.parseInt(element.getAttribute("duration"));
} catch (NumberFormatException e) {
logger.warn("Unexpected duration value `" + element.getAttribute("duration") + "'");
}
float durationInSeconds = 0.001f * d;
totalDurationInSeconds += durationInSeconds;
}
}
}
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
// //////////////////////////// Helpers ///////////////////////////////
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
private int getPropertyAsInteger(String prop) {
int value = 100;
try {
value = Integer.parseInt(klattRuleParams.getProperty(prop));
} catch (NumberFormatException e) {
logger.warn("Cannot read property " + prop + " in klattrule parameter file. Using default.");
}
return value;
}
private Element getToken(Element segmentOrSyllable) {
return (Element) MaryDomUtils.getAncestor(segmentOrSyllable, MaryXML.TOKEN);
}
private Element getSyllable(Element segment) {
return (Element) MaryDomUtils.getAncestor(segment, MaryXML.SYLLABLE);
}
private int getStress(Element syllable) {
// Klatt's usage of 1ary and 2ary stress (Klatt, 1979):
// primary lexical stress is reserved for vowels in open-class content
// words, only one 1ary stress per word;
// 2ary lexical stress is used in some content words, in compounds,
// in the strongest syllable of polysyllabic function words, and for
// pronouns (excluding personal pronouns).
// Approximately adapt our input to Klatt's input:
// * accented prosodic words (have a tobi accent) can stay as they are
// * for each unaccented prosodic word (no tobi accent)
// - if it is monosyllabic and not a pronoun, remove any stress sign
// - if it is polysyllabic, remove 2ary stress,
// and reduce 1ary to 2ary.
int stress = 0;
if (syllable.hasAttribute("stress")) {
String helper = syllable.getAttribute("stress");
if (helper.equals("1"))
stress = 1;
else if (helper.equals("2"))
stress = 2;
}
if (stress != 0) {
// it is worth thinking about stress reduction
Element token = getToken(syllable);
// stress reduction:
if (!hasAccent(token)) {
// unaccented word
if (isPolysyllabic(token)) {
// polysyllabic:
// reduce 1ary to 2ary, 2ary to no stress:
if (stress == 1)
stress = 2;
else if (stress == 2)
stress = 0;
} else {
// monosyllabic:
if (!isPronoun(token)) {
// not a pronoun
// remove any stress:
stress = 0;
}
}
}
}
return stress;
}
/**
* Find the segment preceding this segment within the same phrase.
*
* @return that segment, or null if there is no such segment.
*/
private static Element getPreviousSegment(Element segment) {
Element phrase = (Element) MaryDomUtils.getAncestor(segment, MaryXML.PHRASE);
return MaryDomUtils.getPreviousOfItsKindIn(segment, phrase);
}
/**
* Find the segment following this segment within the same phrase.
*
* @return that segment, or null if there is no such segment.
*/
private static Element getNextSegment(Element segment) {
Element phrase = (Element) MaryDomUtils.getAncestor(segment, MaryXML.PHRASE);
return MaryDomUtils.getNextOfItsKindIn(segment, phrase);
}
/**
* Find the syllable preceding this syllable within the same phrase.
*
* @return that syllable, or null if there is no such syllable.
*/
private static Element getPreviousSyllable(Element syllable) {
Element phrase = (Element) MaryDomUtils.getAncestor(syllable, MaryXML.PHRASE);
return MaryDomUtils.getPreviousOfItsKindIn(syllable, phrase);
}
/**
* Find the syllable following this syllable within the same phrase.
*
* @return that syllable, or null if there is no such syllable.
*/
private static Element getNextSyllable(Element syllable) {
if (syllable == null)
return null;
Element phrase = (Element) MaryDomUtils.getAncestor(syllable, MaryXML.PHRASE);
return MaryDomUtils.getNextOfItsKindIn(syllable, phrase);
}
private int getMinDuration(Element segment) {
int minDuration = klattDurationParams.getMinDuration(segment.getAttribute("p"));
// additional reduction for unstressed segments:
// (this comes from klatt's original rule no. 7)
if (getStress(getSyllable(segment)) == 0) {
// For unstressed segments,
// increase stretchability by reducing minimum duration:
return (minDuration * getPropertyAsInteger("rule7.mindur")) / 100;
} else { // default
return minDuration;
}
}
private int getInhDuration(Element segment) {
return klattDurationParams.getInhDuration(segment.getAttribute("p"));
}
private boolean isPronoun(Element token) {
String pos = token.getAttribute("pos");
return pos.equals("PDS") || pos.equals("PDAT") || pos.equals("PIS") || pos.equals("PIAT") || pos.equals("PIDAT")
|| pos.equals("PPER") || pos.equals("PPOSS") || pos.equals("PPOSAT") || pos.equals("PRELS")
|| pos.equals("PRELAT") || pos.equals("PRF") || pos.equals("PWS") || pos.equals("PWAT") || pos.equals("PWAV");
}
private boolean isPolysyllabic(Element token) {
return token.getElementsByTagName(MaryXML.SYLLABLE).getLength() > 1;
}
private boolean hasAccent(Element token) {
String accent = token.getAttribute("accent");
return !accent.equals("");
}
/**
* Search for boundary and syllable elements following the given syllable. If the next matching element found is a boundary
* with breakindex minBreakindex or larger, return true; otherwise, return false. If there is no next node,
* return true.
*/
private boolean isLastBeforeBoundary(Element syllable, int minBreakindex) {
Document doc = syllable.getOwnerDocument();
Element sentence = (Element) MaryDomUtils.getAncestor(syllable, MaryXML.SENTENCE);
TreeWalker tw = ((DocumentTraversal) doc).createTreeWalker(sentence, NodeFilter.SHOW_ELEMENT, new NameNodeFilter(
new String[] { MaryXML.SYLLABLE, MaryXML.BOUNDARY }), false);
tw.setCurrentNode(syllable);
Element next = (Element) tw.nextNode();
if (next == null) {
// no matching node after syllable --
// we must be in a final position.
return true;
}
if (next.getNodeName().equals(MaryXML.BOUNDARY)) {
if (getBreakindex(next) >= minBreakindex)
return true;
}
// This syllable is either followed by another syllable or
// by a boundary with breakindex < minBreakindex
return false;
}
private boolean isMajIPFinal(Element syllable) {
// If this syllable is followed by a boundary with breakindex
// 4 or above, return true.
return isLastBeforeBoundary(syllable, 4);
}
private boolean isMinipFinal(Element syllable) {
// If this syllable is followed by a boundary with breakindex
// 3 or above, return true.
return isLastBeforeBoundary(syllable, 3);
}
private boolean isWordFinal(Element syllable) {
Element e = syllable;
while (e != null) {
e = MaryDomUtils.getNextSiblingElement(e);
if (e != null && e.getNodeName().equals(MaryXML.SYLLABLE))
return false;
}
return true;
}
private boolean isWordMedial(Element syllable) {
return !(isWordFinal(syllable) || isWordInitial(syllable));
}
private boolean isWordInitial(Element syllable) {
Element e = syllable;
while (e != null) {
e = MaryDomUtils.getPreviousSiblingElement(e);
if (e != null && e.getNodeName().equals(MaryXML.SYLLABLE))
return false;
}
return true;
}
private boolean isInOnset(Element segment) {
Allophone ph = allophoneSet.getAllophone(segment.getAttribute("p"));
if (ph.isSyllabic()) {
return false;
}
// OK, segment is not syllabic. See if it is followed by a syllabic
// segment:
for (Element e = MaryDomUtils.getNextSiblingElement(segment); e != null; e = MaryDomUtils.getNextSiblingElement(e)) {
ph = allophoneSet.getAllophone(e.getAttribute("p"));
assert ph != null;
if (ph.isSyllabic()) {
return true;
}
}
return false;
}
private boolean isInNucleus(Element segment) {
Allophone ph = allophoneSet.getAllophone(segment.getAttribute("p"));
assert ph != null;
return ph.isSyllabic();
}
private boolean isInCoda(Element segment) {
Allophone ph = allophoneSet.getAllophone(segment.getAttribute("p"));
if (ph.isSyllabic()) {
return false;
}
// OK, segment is not syllabic. See if it is preceded by a syllabic
// segment:
for (Element e = MaryDomUtils.getPreviousSiblingElement(segment); e != null; e = MaryDomUtils
.getPreviousSiblingElement(e)) {
ph = allophoneSet.getAllophone(e.getAttribute("p"));
if (ph.isSyllabic()) {
return true;
}
}
return false;
}
private boolean isConsonant(Element segment) {
return !isVowel(segment);
}
private boolean isVowel(Element segment) {
Allophone ph = allophoneSet.getAllophone(segment.getAttribute("p"));
return ph.isVowel();
}
private boolean isLiquid(Element segment) {
Allophone ph = allophoneSet.getAllophone(segment.getAttribute("p"));
return ph.isLiquid();
}
private boolean isGlide(Element segment) {
Allophone ph = allophoneSet.getAllophone(segment.getAttribute("p"));
return ph.isGlide();
}
private boolean isNasal(Element segment) {
Allophone ph = allophoneSet.getAllophone(segment.getAttribute("p"));
return ph.isNasal();
}
private boolean isFricative(Element segment) {
Allophone ph = allophoneSet.getAllophone(segment.getAttribute("p"));
return ph.isFricative();
}
private int getBreakindex(Element boundary) {
int breakindex = 0;
try {
breakindex = Integer.parseInt(boundary.getAttribute("breakindex"));
} catch (NumberFormatException e) {
logger.warn("Unexpected breakindex value `" + boundary.getAttribute("breakindex") + "'");
}
return breakindex;
}
/**
* Tell whether the string contains a positive or negative percentage delta, i.e., a percentage number with an obligatory + or
* - sign.
*/
private boolean isPercentageDelta(String string) {
String s = string.trim();
if (s.length() < 3)
return false;
return s.substring(s.length() - 1).equals("%") && isNumberDelta(s.substring(0, s.length() - 1));
}
/**
* For a string containing a percentage delta as judged by isPercentageDelta(), return the numerical value,
* rounded to an integer.
*
* @return the numeric part of the percentage, rounded to an integer, or 0 if the string is not a valid percentage delta.
*/
private int getPercentageDelta(String string) {
String s = string.trim();
if (!isPercentageDelta(s))
return 0;
return getNumberDelta(s.substring(0, s.length() - 1));
}
/**
* Tell whether the string contains a positive or negative semitones delta, i.e., a semitones number with an obligatory + or -
* sign, such as "+3.2st" or "-13.2st".
*/
private boolean isSemitonesDelta(String string) {
String s = string.trim();
if (s.length() < 4)
return false;
return s.substring(s.length() - 2).equals("st") && isNumberDelta(s.substring(0, s.length() - 2));
}
/**
* For a string containing a semitones delta as judged by isSemitonesDelta(), return the numerical value, as a
* double.
*
* @return the numeric part of the semitones delta, or 0 if the string is not a valid semitones delta.
*/
private double getSemitonesDelta(String string) {
String s = string.trim();
if (!isSemitonesDelta(s))
return 0;
String num = s.substring(0, s.length() - 2);
double value = 0;
try {
value = Double.parseDouble(num);
} catch (NumberFormatException e) {
logger.warn("Unexpected number value `" + num + "'");
}
return value;
}
/**
* Tell whether the string contains a positive or negative number delta, i.e., a number with an obligatory + or - sign.
*/
private boolean isNumberDelta(String string) {
String s = string.trim();
if (s.length() < 2)
return false;
return (s.charAt(0) == '+' || s.charAt(0) == '-') && isUnsignedNumber(s.substring(1));
}
/**
* For a string containing a number delta as judged by isNumberDelta(), return the numerical value, rounded to an
* integer.
*
* @return the numeric value, rounded to an integer, or 0 if the string is not a valid number delta.
*/
private int getNumberDelta(String string) {
String s = string.trim();
if (!isNumberDelta(s))
return 0;
double value = 0;
try {
value = Double.parseDouble(s);
} catch (NumberFormatException e) {
logger.warn("Unexpected number value `" + s + "'");
}
return (int) Math.round(value);
}
/**
* Tell whether the string contains an unsigned semitones expression, such as "12st" or "5.4st".
*/
private boolean isUnsignedSemitones(String string) {
String s = string.trim();
if (s.length() < 3)
return false;
return s.substring(s.length() - 2).equals("st") && isUnsignedNumber(s.substring(0, s.length() - 2));
}
/**
* For a string containing an unsigned semitones expression as judged by isUnsignedSemitones(), return the
* numerical value as a double.
*
* @return the numeric part of the semitones expression, or 0 if the string is not a valid unsigned semitones expression.
*/
private double getUnsignedSemitones(String string) {
String s = string.trim();
if (!isUnsignedSemitones(s))
return 0;
String num = s.substring(0, s.length() - 2);
double value = 0;
try {
value = Double.parseDouble(num);
} catch (NumberFormatException e) {
logger.warn("Unexpected number value `" + num + "'");
}
return value;
}
/**
* Tell whether the string contains an unsigned number.
*/
private boolean isUnsignedNumber(String string) {
String s = string.trim();
if (s.length() < 1)
return false;
if (s.charAt(0) != '+' && s.charAt(0) != '-') {
double value = 0;
try {
value = Double.parseDouble(s);
} catch (NumberFormatException e) {
return false;
}
return true;
}
return false;
}
/**
* For a string containing an unsigned number as judged by isUnsignedNumber(), return the numerical value,
* rounded to an integer.
*
* @return the numeric value, rounded to an integer, or 0 if the string is not a valid unsigned number.
*/
private int getUnsignedNumber(String string) {
String s = string.trim();
if (!isUnsignedNumber(s))
return 0;
double value = 0;
try {
value = Double.parseDouble(s);
} catch (NumberFormatException e) {
logger.warn("Unexpected number value `" + s + "'");
}
return (int) Math.round(value);
}
/**
* Tell whether the string contains a number.
*/
private boolean isNumber(String string) {
String s = string.trim();
if (s.length() < 1)
return false;
double value = 0;
try {
value = Double.parseDouble(s);
} catch (NumberFormatException e) {
return false;
}
return true;
}
/**
* For a string containing a number as judged by isNumber(), return the numerical value, rounded to an integer.
*
* @return the numeric value, rounded to an integer, or 0 if the string is not a valid number.
*/
private int getNumber(String string) {
String s = string.trim();
if (!isNumber(s))
return 0;
double value = 0;
try {
value = Double.parseDouble(s);
} catch (NumberFormatException e) {
logger.warn("Unexpected number value `" + s + "'");
}
return (int) Math.round(value);
}
/**
* For a given token, find the stressed syllable. If no syllable has primary stress, return the first syllable with secondary
* stress. If none has secondary stress, return the first syllable in the token. If there is no syllable in the token or the
* element given in the argument is not a token element, return null.
*/
private Element getStressedSyllable(Element token) {
if (token == null || !token.getTagName().equals(MaryXML.TOKEN))
return null;
Element syl = MaryDomUtils.getFirstElementByTagName(token, MaryXML.SYLLABLE);
while (syl != null && !syl.getAttribute("stress").equals("1")) {
syl = MaryDomUtils.getNextSiblingElementByTagName(syl, MaryXML.SYLLABLE);
}
if (syl != null) {
return syl;
}
// If we get here, there is no stressed syllable. As a fallback, use
// the first syllable with secondary stress, or the first syllable if
// none has secondary stress.
Element first = MaryDomUtils.getFirstElementByTagName(token, MaryXML.SYLLABLE);
Element secondary = first;
while (secondary != null && !secondary.getAttribute("stress").equals("2")) {
secondary = MaryDomUtils.getNextSiblingElementByTagName(secondary, MaryXML.SYLLABLE);
}
if (secondary != null) {
return secondary;
}
return first;
}
/**
* For a syllable, return the first child segment which is a nucleus segment. Return null if there is no such
* segment.
*/
private Element getNucleus(Element syllable) {
if (syllable == null || !syllable.getTagName().equals(MaryXML.SYLLABLE))
return null;
Element seg = MaryDomUtils.getFirstElementByTagName(syllable, MaryXML.PHONE);
while (seg != null && !isInNucleus(seg)) {
seg = MaryDomUtils.getNextSiblingElementByTagName(seg, MaryXML.PHONE);
}
return seg;
}
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
// ///////////////////////// Helper Classes ///////////////////////////
// ////////////////////////////////////////////////////////////////////
// ////////////////////////////////////////////////////////////////////
static class ProsodicSettings {
// Relative settings: 100 = 100% = no change
int rate;
int accentProminence;
int accentSlope;
int numberOfPauses;
int pauseDuration;
int vowelDuration;
int plosiveDuration;
int fricativeDuration;
int nasalDuration;
int liquidDuration;
int glideDuration;
int volume;
ProsodicSettings() {
this.rate = 100;
this.accentProminence = 100;
this.accentSlope = 100;
this.numberOfPauses = 100;
this.pauseDuration = 100;
this.vowelDuration = 100;
this.plosiveDuration = 100;
this.fricativeDuration = 100;
this.nasalDuration = 100;
this.liquidDuration = 100;
this.glideDuration = 100;
this.volume = 50;
}
ProsodicSettings(int rate, int accentProminence, int accentSlope, int numberOfPauses, int pauseDuration,
int vowelDuration, int plosiveDuration, int fricativeDuration, int nasalDuration, int liquidDuration,
int glideDuration, int volume) {
this.rate = rate;
this.accentProminence = accentProminence;
this.accentSlope = accentSlope;
this.numberOfPauses = numberOfPauses;
this.pauseDuration = pauseDuration;
this.vowelDuration = vowelDuration;
this.plosiveDuration = plosiveDuration;
this.fricativeDuration = fricativeDuration;
this.nasalDuration = nasalDuration;
this.liquidDuration = liquidDuration;
this.glideDuration = glideDuration;
this.volume = volume;
}
int rate() {
return rate;
}
int accentProminence() {
return accentProminence;
}
int accentSlope() {
return accentSlope;
}
int numberOfPauses() {
return numberOfPauses;
}
int pauseDuration() {
return pauseDuration;
}
int vowelDuration() {
return vowelDuration;
}
int plosiveDuration() {
return plosiveDuration;
}
int fricativeDuration() {
return fricativeDuration;
}
int nasalDuration() {
return nasalDuration;
}
int liquidDuration() {
return liquidDuration;
}
int glideDuration() {
return glideDuration;
}
int volume() {
return volume;
}
void setRate(int value) {
rate = value;
}
void setAccentProminence(int value) {
accentProminence = value;
}
void setAccentSlope(int value) {
accentSlope = value;
}
void setNumberOfPauses(int value) {
numberOfPauses = value;
}
void setPauseDuration(int value) {
pauseDuration = value;
}
void setVowelDuration(int value) {
vowelDuration = value;
}
void setPlosiveDuration(int value) {
plosiveDuration = value;
}
void setFricativeDuration(int value) {
fricativeDuration = value;
}
void setNasalDuration(int value) {
nasalDuration = value;
}
void setLiquidDuration(int value) {
liquidDuration = value;
}
void setGlideDuration(int value) {
glideDuration = value;
}
void setVolume(int value) {
volume = value;
}
}
public static class KlattDurationParams {
private Map inh = new HashMap();
private Map min = new HashMap();
public KlattDurationParams(String filename) throws SAXException, IOException, ParserConfigurationException {
// parse the xml file:
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(false);
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(new File(filename));
// In document, ignore everything that is not a segment element:
NodeList segElements = document.getElementsByTagName("segment");
for (int i = 0; i < segElements.getLength(); i++) {
Element seg = (Element) segElements.item(i);
String name = seg.getAttribute("s");
int inherentDuration = Integer.parseInt(seg.getAttribute("inh"));
int minimalDuration = Integer.parseInt(seg.getAttribute("min"));
inh.put(name, inherentDuration);
min.put(name, minimalDuration);
}
}
public int getInhDuration(String ph) {
return inh.get(ph);
}
public int getMinDuration(String ph) {
return min.get(ph);
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy