public void AppendTextWithPronunciation(string textToSpeak, string pronunciation) { Helpers.ThrowIfEmptyOrNull(textToSpeak, "textToSpeak"); Helpers.ThrowIfEmptyOrNull(pronunciation, "pronunciation"); ValidateElement(_elementStack.Peek(), SsmlElement.Text); PhonemeConverter.ValidateUpsIds(pronunciation); Element element = new Element(ElementType.Phoneme, textToSpeak); _elements.Add(element); element._attributes = new Collection <AttributeItem>(); element._attributes.Add(new AttributeItem("ph", pronunciation)); }
IToken IElementFactory.CreateToken(IElement parent, string content, string pronunciation, string display, float reqConfidence) { SrgsToken token = new(content); if (!string.IsNullOrEmpty(pronunciation)) { // Check if the pronunciations are ok string sPron = pronunciation; for (int iCurPron = 0, iDeliminator = 0; iCurPron < sPron.Length; iCurPron = iDeliminator + 1) { // Find semi-colon delimiter and replace with null iDeliminator = pronunciation.IndexOfAny(s_pronSeparator, iCurPron); if (iDeliminator == -1) { iDeliminator = sPron.Length; } string sSubPron = sPron.Substring(iCurPron, iDeliminator - iCurPron); // make sure this goes through switch (_grammar.PhoneticAlphabet) { case AlphabetType.Sapi: sSubPron = PhonemeConverter.ConvertPronToId(sSubPron, _grammar.Culture.LCID); break; case AlphabetType.Ipa: PhonemeConverter.ValidateUpsIds(sSubPron); break; case AlphabetType.Ups: sSubPron = PhonemeConverter.UpsConverter.ConvertPronToId(sSubPron); break; } } token.Pronunciation = pronunciation; } if (!string.IsNullOrEmpty(display)) { token.Display = display; } if (reqConfidence >= 0) { throw new NotSupportedException(SR.Get(SRID.ReqConfidenceNotSupported)); } return(token); }
public void AppendTextWithPronunciation(string textToSpeak, string pronunciation) { Helpers.ThrowIfEmptyOrNull(textToSpeak, nameof(textToSpeak)); Helpers.ThrowIfEmptyOrNull(pronunciation, nameof(pronunciation)); // check for well formed document ValidateElement(_elementStack.Peek(), SsmlElement.Text); // validate the pronunciation PhonemeConverter.ValidateUpsIds(pronunciation); Element phoneElement = new(ElementType.Phoneme, textToSpeak); _elements.Add(phoneElement); phoneElement._attributes = new Collection <AttributeItem>(); phoneElement._attributes.Add(new AttributeItem("ph", pronunciation)); }
IToken IElementFactory.CreateToken(IElement parent, string content, string pronunciation, string display, float reqConfidence) { SrgsToken srgsToken = new SrgsToken(content); if (!string.IsNullOrEmpty(pronunciation)) { int num = 0; int num2 = 0; while (num < pronunciation.Length) { num2 = pronunciation.IndexOfAny(_pronSeparator, num); if (num2 == -1) { num2 = pronunciation.Length; } string text = pronunciation.Substring(num, num2 - num); switch (_grammar.PhoneticAlphabet) { case AlphabetType.Sapi: text = PhonemeConverter.ConvertPronToId(text, _grammar.Culture.LCID); break; case AlphabetType.Ipa: PhonemeConverter.ValidateUpsIds(text); break; case AlphabetType.Ups: text = PhonemeConverter.UpsConverter.ConvertPronToId(text); break; } num = num2 + 1; } srgsToken.Pronunciation = pronunciation; } if (!string.IsNullOrEmpty(display)) { srgsToken.Display = display; } if (reqConfidence >= 0f) { throw new NotSupportedException(SR.Get(SRID.ReqConfidenceNotSupported)); } return(srgsToken); }
internal override void Validate(SrgsGrammar grammar) { if (_pronunciation != null || _display != null) { grammar.HasPronunciation = true; } // Validate the pronunciation if any if (_pronunciation != null) { for (int iCurPron = 0, iDeliminator = 0; iCurPron < _pronunciation.Length; iCurPron = iDeliminator + 1) { // Find semi-colon delimiter and replace with null iDeliminator = _pronunciation.IndexOf(';', iCurPron); if (iDeliminator == -1) { iDeliminator = _pronunciation.Length; } string subPronunciation = _pronunciation.Substring(iCurPron, iDeliminator - iCurPron); // Convert the pronunciation, will throw if error switch (grammar.PhoneticAlphabet) { case AlphabetType.Sapi: PhonemeConverter.ConvertPronToId(subPronunciation, grammar.Culture.LCID); break; case AlphabetType.Ups: PhonemeConverter.UpsConverter.ConvertPronToId(subPronunciation); break; case AlphabetType.Ipa: PhonemeConverter.ValidateUpsIds(subPronunciation.ToCharArray()); break; } } } base.Validate(grammar); }
internal override void Validate(SrgsGrammar grammar) { if (_pronunciation != null || _display != null) { grammar.HasPronunciation = true; } if (_pronunciation != null) { int num = 0; int num2 = 0; while (num < _pronunciation.Length) { num2 = _pronunciation.IndexOf(';', num); if (num2 == -1) { num2 = _pronunciation.Length; } string text = _pronunciation.Substring(num, num2 - num); switch (grammar.PhoneticAlphabet) { case AlphabetType.Sapi: PhonemeConverter.ConvertPronToId(text, grammar.Culture.LCID); break; case AlphabetType.Ups: PhonemeConverter.UpsConverter.ConvertPronToId(text); break; case AlphabetType.Ipa: PhonemeConverter.ValidateUpsIds(text.ToCharArray()); break; } num = num2 + 1; } } base.Validate(grammar); }
private void ParseToken(ParseElementCollection parent, string sToken, string pronunciation, string display, float reqConfidence) { int requiredConfidence = parent?._confidence ?? 0; sToken = Backend.NormalizeTokenWhiteSpace(sToken); if (string.IsNullOrEmpty(sToken)) { return; } parent._confidence = 0; if (reqConfidence < 0f || reqConfidence.Equals(0.5f)) { parent._confidence = 0; } else if ((double)reqConfidence < 0.5) { parent._confidence = -1; } else { parent._confidence = 1; } if (pronunciation != null || display != null) { string text = EscapeToken(sToken); string text2 = (display == null) ? text : EscapeToken(display); if (pronunciation != null) { OneOf oneOf = (pronunciation.IndexOf(';') >= 0) ? new OneOf(parent._rule, _backend) : null; int num = 0; int num2 = 0; while (num < pronunciation.Length) { num2 = pronunciation.IndexOf(';', num); if (num2 == -1) { num2 = pronunciation.Length; } string text3 = pronunciation.Substring(num, num2 - num); string text4 = null; switch (_backend.Alphabet) { case AlphabetType.Sapi: text4 = PhonemeConverter.ConvertPronToId(text3, _grammar.Backend.LangId); break; case AlphabetType.Ipa: text4 = text3; PhonemeConverter.ValidateUpsIds(text4); break; case AlphabetType.Ups: text4 = PhonemeConverter.UpsConverter.ConvertPronToId(text3); break; } string sWord = string.Format(CultureInfo.InvariantCulture, "/{0}/{1}/{2};", new object[3] { text2, text, text4 }); if (oneOf != null) { oneOf.AddArc(_backend.WordTransition(sWord, 1f, requiredConfidence)); } else { parent.AddArc(_backend.WordTransition(sWord, 1f, requiredConfidence)); } num = num2 + 1; } ((IElement)oneOf)?.PostParse((IElement)parent); } else { string sWord2 = string.Format(CultureInfo.InvariantCulture, "/{0}/{1};", new object[2] { text2, text }); parent.AddArc(_backend.WordTransition(sWord2, 1f, requiredConfidence)); } } else { parent.AddArc(_backend.WordTransition(sToken, 1f, requiredConfidence)); } }
// Disable parameter validation check /// <summary> /// Add transition representing the normalized token. /// /// White Space Normalization - Trim leading/trailing white spaces. /// Collapse white space sequences to a single ' '. /// Restrictions - Normalized token cannot be empty. /// Normalized token cannot contain double-quote. /// /// If (Parent == Token) And (Parent.SAPIPron.Length > 0) Then /// Escape normalized token. "/" -> "\/", "\" -> "\\" /// Build /D/L/P; form from the escaped token and SAPIPron. /// /// SAPIPron may be a semi-colon delimited list of pronunciations. /// In this case, a transition for each of the pronunciations will be added. /// /// AddTransition(NormalizedToken, Parent.EndState, NewState) /// Parent.EndState = NewState /// </summary> private void ParseToken(ParseElementCollection parent, string sToken, string pronunciation, string display, float reqConfidence) { int requiredConfidence = (parent != null) ? parent._confidence : CfgGrammar.SP_NORMAL_CONFIDENCE; // Performs white space normalization in place sToken = Backend.NormalizeTokenWhiteSpace(sToken); if (string.IsNullOrEmpty(sToken)) { return; } // "sapi:reqconf" Attribute parent._confidence = CfgGrammar.SP_NORMAL_CONFIDENCE; // Default to normal if (reqConfidence < 0 || reqConfidence.Equals(0.5f)) { parent._confidence = CfgGrammar.SP_NORMAL_CONFIDENCE; // Default to normal } else if (reqConfidence < 0.5) { parent._confidence = CfgGrammar.SP_LOW_CONFIDENCE; } else { parent._confidence = CfgGrammar.SP_HIGH_CONFIDENCE; } // If SAPIPron is specified, use /D/L/P; as the transition text, for each of the pronunciations. if (pronunciation != null || display != null) { // Escape normalized token. "/" -> "\/", "\" -> "\\" string sEscapedToken = EscapeToken(sToken); string sDisplayToken = display == null ? sEscapedToken : EscapeToken(display); if (pronunciation != null) { // Garbage transition is optional whereas Wildcard is not. So we need additional epsilon transition. OneOf oneOf = pronunciation.IndexOf(';') >= 0 ? new OneOf(parent._rule, _backend) : null; for (int iCurPron = 0, iDeliminator = 0; iCurPron < pronunciation.Length; iCurPron = iDeliminator + 1) { // Find semi-colon delimiter and replace with null iDeliminator = pronunciation.IndexOf(';', iCurPron); if (iDeliminator == -1) { iDeliminator = pronunciation.Length; } string pron = pronunciation.Substring(iCurPron, iDeliminator - iCurPron); string sSubPron = null; switch (_backend.Alphabet) { case AlphabetType.Sapi: sSubPron = PhonemeConverter.ConvertPronToId(pron, _grammar.Backend.LangId); break; case AlphabetType.Ipa: sSubPron = pron; PhonemeConverter.ValidateUpsIds(sSubPron); break; case AlphabetType.Ups: sSubPron = PhonemeConverter.UpsConverter.ConvertPronToId(pron); break; } // Build /D/L/P; form for this pronunciation. string sDLP = string.Format(CultureInfo.InvariantCulture, "/{0}/{1}/{2};", sDisplayToken, sEscapedToken, sSubPron); // Add /D/L/P; transition to the new state. if (oneOf != null) { oneOf.AddArc(_backend.WordTransition(sDLP, 1.0f, requiredConfidence)); } else { parent.AddArc(_backend.WordTransition(sDLP, 1.0f, requiredConfidence)); } } if (oneOf != null) { ((IOneOf)oneOf).PostParse(parent); } } else { // Build /D/L; form for this pronunciation. string sDLP = string.Format(CultureInfo.InvariantCulture, "/{0}/{1};", sDisplayToken, sEscapedToken); // Add /D/L; transition to the new state. parent.AddArc(_backend.WordTransition(sDLP, 1.0f, requiredConfidence)); } } else { // Add transition to the new state with normalized token. parent.AddArc(_backend.WordTransition(sToken, 1.0f, requiredConfidence)); } }