chrome/browser/resources/chromeos/chromevox/host/interface/abstract_tts.js

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 /**
   6  * @fileoverview Base class for Text-to-Speech engines that actually transform
   7  * text to speech.
   8  *
   9  */
  10
  11 goog.provide('cvox.AbstractTts');
  12
  13 goog.require('cvox.TtsInterface');
  14 goog.require('goog.i18n.MessageFormat');
  15
  16 /**
  17  * Creates a new instance.
  18  * @constructor
  19  * @implements {cvox.TtsInterface}
  20  */
  21 cvox.AbstractTts = function() {
  22   this.ttsProperties = new Object();
  23
  24   /**
  25    * Default value for TTS properties.
  26    * Note that these as well as the subsequent properties might be different
  27    * on different host platforms (like Chrome, Android, etc.).
  28    * @type {{pitch : number,
  29    *         rate: number,
  30    *         volume: number}}
  31    * @protected
  32    */
  33   this.propertyDefault = {
  34     'rate': 0.5,
  35     'pitch': 0.5,
  36     'volume': 0.5
  37   };
  38
  39   /**
  40    * Min value for TTS properties.
  41    * @type {{pitch : number,
  42    *         rate: number,
  43    *         volume: number}}
  44    * @protected
  45    */
  46   this.propertyMin = {
  47     'rate': 0.0,
  48     'pitch': 0.0,
  49     'volume': 0.0
  50   };
  51
  52   /**
  53    * Max value for TTS properties.
  54    * @type {{pitch : number,
  55    *         rate: number,
  56    *         volume: number}}
  57    * @protected
  58    */
  59   this.propertyMax = {
  60     'rate': 1.0,
  61     'pitch': 1.0,
  62     'volume': 1.0
  63   };
  64
  65   /**
  66    * Step value for TTS properties.
  67    * @type {{pitch : number,
  68    *         rate: number,
  69    *         volume: number}}
  70    * @protected
  71    */
  72   this.propertyStep = {
  73     'rate': 0.1,
  74     'pitch': 0.1,
  75     'volume': 0.1
  76   };
  77
  78
  79   /** @private */
  80
  81   if (cvox.AbstractTts.pronunciationDictionaryRegexp_ == undefined) {
  82     // Create an expression that matches all words in the pronunciation
  83     // dictionary on word boundaries, ignoring case.
  84     var words = [];
  85     for (var word in cvox.AbstractTts.PRONUNCIATION_DICTIONARY) {
  86       words.push(word);
  87     }
  88     var expr = '\\b(' + words.join('|') + ')\\b';
  89     cvox.AbstractTts.pronunciationDictionaryRegexp_ = new RegExp(expr, 'ig');
  90   }
  91
  92   if (cvox.AbstractTts.substitutionDictionaryRegexp_ == undefined) {
  93     // Create an expression that matches all words in the substitution
  94     // dictionary.
  95     var symbols = [];
  96     for (var symbol in cvox.AbstractTts.SUBSTITUTION_DICTIONARY) {
  97       symbols.push(symbol);
  98     }
  99     var expr = '(' + symbols.join('|') + ')';
 100     cvox.AbstractTts.substitutionDictionaryRegexp_ = new RegExp(expr, 'ig');
 101   }
 102 };
 103
 104
 105 /**
 106  * Default TTS properties for this TTS engine.
 107  * @type {Object}
 108  * @protected
 109  */
 110 cvox.AbstractTts.prototype.ttsProperties;
 111
 112
 113 /** @override */
 114 cvox.AbstractTts.prototype.speak = function(textString, queueMode, properties) {
 115   return this;
 116 };
 117
 118
 119 /** @override */
 120 cvox.AbstractTts.prototype.isSpeaking = function() {
 121   return false;
 122 };
 123
 124
 125 /** @override */
 126 cvox.AbstractTts.prototype.stop = function() {
 127 };
 128
 129
 130 /** @override */
 131 cvox.AbstractTts.prototype.addCapturingEventListener = function(listener) { };
 132
 133
 134 /** @override */
 135 cvox.AbstractTts.prototype.increaseOrDecreaseProperty =
 136     function(propertyName, increase) {
 137       var min = this.propertyMin[propertyName];
 138       var max = this.propertyMax[propertyName];
 139       var step = this.propertyStep[propertyName];
 140       var current = this.ttsProperties[propertyName];
 141       current = increase ? current + step : current - step;
 142       this.ttsProperties[propertyName] = Math.max(Math.min(current, max), min);
 143     };
 144
 145
 146 /**
 147  * Merges the given properties with the default ones. Always returns a
 148  * new object, so that you can safely modify the result of mergeProperties
 149  * without worrying that you're modifying an object used elsewhere.
 150  * @param {Object=} properties The properties to merge with the current ones.
 151  * @return {Object} The merged properties.
 152  * @protected
 153  */
 154 cvox.AbstractTts.prototype.mergeProperties = function(properties) {
 155   var mergedProperties = new Object();
 156   var p;
 157   if (this.ttsProperties) {
 158     for (p in this.ttsProperties) {
 159       mergedProperties[p] = this.ttsProperties[p];
 160     }
 161   }
 162   if (properties) {
 163     var tts = cvox.AbstractTts;
 164     if (typeof(properties[tts.VOLUME]) == 'number') {
 165       mergedProperties[tts.VOLUME] = properties[tts.VOLUME];
 166     }
 167     if (typeof(properties[tts.PITCH]) == 'number') {
 168       mergedProperties[tts.PITCH] = properties[tts.PITCH];
 169     }
 170     if (typeof(properties[tts.RATE]) == 'number') {
 171       mergedProperties[tts.RATE] = properties[tts.RATE];
 172     }
 173     if (typeof(properties[tts.LANG]) == 'string') {
 174       mergedProperties[tts.LANG] = properties[tts.LANG];
 175     }
 176
 177     var context = this;
 178     var mergeRelativeProperty = function(abs, rel) {
 179       if (typeof(properties[rel]) == 'number' &&
 180           typeof(mergedProperties[abs]) == 'number') {
 181         mergedProperties[abs] += properties[rel];
 182         var min = context.propertyMin[abs];
 183         var max = context.propertyMax[abs];
 184         if (mergedProperties[abs] > max) {
 185           mergedProperties[abs] = max;
 186         } else if (mergedProperties[abs] < min) {
 187           mergedProperties[abs] = min;
 188         }
 189       }
 190     };
 191
 192     mergeRelativeProperty(tts.VOLUME, tts.RELATIVE_VOLUME);
 193     mergeRelativeProperty(tts.PITCH, tts.RELATIVE_PITCH);
 194     mergeRelativeProperty(tts.RATE, tts.RELATIVE_RATE);
 195   }
 196
 197   for (p in properties) {
 198     if (!mergedProperties.hasOwnProperty(p)) {
 199       mergedProperties[p] = properties[p];
 200     }
 201   }
 202
 203   return mergedProperties;
 204 };
 205
 206
 207 /**
 208  * Method to preprocess text to be spoken properly by a speech
 209  * engine.
 210  *
 211  * 1. Replace any single character with a description of that character.
 212  *
 213  * 2. Convert all-caps words to lowercase if they don't look like an
 214  *    acronym / abbreviation.
 215  *
 216  * @param {string} text A text string to be spoken.
 217  * @param {Object= } properties Out parameter populated with how to speak the
 218  *     string.
 219  * @return {string} The text formatted in a way that will sound better by
 220  *     most speech engines.
 221  * @protected
 222  */
 223 cvox.AbstractTts.prototype.preprocess = function(text, properties) {
 224   if (text.length == 1 && text >= 'A' && text <= 'Z') {
 225     for (var prop in cvox.AbstractTts.PERSONALITY_CAPITAL)
 226     properties[prop] = cvox.AbstractTts.PERSONALITY_CAPITAL[prop];
 227   }
 228
 229   // Substitute all symbols in the substitution dictionary. This is pretty
 230   // efficient because we use a single regexp that matches all symbols
 231   // simultaneously.
 232   text = text.replace(
 233       cvox.AbstractTts.substitutionDictionaryRegexp_,
 234       function(symbol) {
 235         return ' ' + cvox.AbstractTts.SUBSTITUTION_DICTIONARY[symbol] + ' ';
 236       });
 237
 238   // Handle single characters that we want to make sure we pronounce.
 239   if (text.length == 1) {
 240     return cvox.AbstractTts.CHARACTER_DICTIONARY[text] ?
 241         (new goog.i18n.MessageFormat(cvox.ChromeVox.msgs.getMsg(
 242                 cvox.AbstractTts.CHARACTER_DICTIONARY[text])))
 243             .format({'COUNT': 1}) :
 244         text.toUpperCase();
 245   }
 246
 247   // Substitute all words in the pronunciation dictionary. This is pretty
 248   // efficient because we use a single regexp that matches all words
 249   // simultaneously, and it calls a function with each match, which we can
 250   // use to look up the replacement in our dictionary.
 251   text = text.replace(
 252       cvox.AbstractTts.pronunciationDictionaryRegexp_,
 253       function(word) {
 254         return cvox.AbstractTts.PRONUNCIATION_DICTIONARY[word.toLowerCase()];
 255       });
 256
 257   // Expand all repeated characters.
 258   text = text.replace(
 259       cvox.AbstractTts.repetitionRegexp_, cvox.AbstractTts.repetitionReplace_);
 260
 261   return text;
 262 };
 263
 264
 265 /** TTS rate property. @type {string} */
 266 cvox.AbstractTts.RATE = 'rate';
 267 /** TTS pitch property. @type {string} */
 268 cvox.AbstractTts.PITCH = 'pitch';
 269 /** TTS volume property. @type {string} */
 270 cvox.AbstractTts.VOLUME = 'volume';
 271 /** TTS language property. @type {string} */
 272 cvox.AbstractTts.LANG = 'lang';
 273
 274 /** TTS relative rate property. @type {string} */
 275 cvox.AbstractTts.RELATIVE_RATE = 'relativeRate';
 276 /** TTS relative pitch property. @type {string} */
 277 cvox.AbstractTts.RELATIVE_PITCH = 'relativePitch';
 278 /** TTS relative volume property. @type {string} */
 279 cvox.AbstractTts.RELATIVE_VOLUME = 'relativeVolume';
 280
 281 /** TTS color property (for the lens display). @type {string} */
 282 cvox.AbstractTts.COLOR = 'color';
 283 /** TTS CSS font-weight property (for the lens display). @type {string} */
 284 cvox.AbstractTts.FONT_WEIGHT = 'fontWeight';
 285
 286 /** TTS punctuation-echo property. @type {string} */
 287 cvox.AbstractTts.PUNCTUATION_ECHO = 'punctuationEcho';
 288
 289 /** TTS pause property. @type {string} */
 290 cvox.AbstractTts.PAUSE = 'pause';
 291
 292 /**
 293  * TTS personality for annotations - text spoken by ChromeVox that
 294  * elaborates on a user interface element but isn't displayed on-screen.
 295  * @type {Object}
 296  */
 297 cvox.AbstractTts.PERSONALITY_ANNOTATION = {
 298   'relativePitch': -0.25,
 299   // TODO:(rshearer) Added this color change for I/O presentation.
 300   'color': 'yellow',
 301   'punctuationEcho': 'none'
 302 };
 303
 304
 305 /**
 306  * TTS personality for announcements - text spoken by ChromeVox that
 307  * isn't tied to any user interface elements.
 308  * @type {Object}
 309  */
 310 cvox.AbstractTts.PERSONALITY_ANNOUNCEMENT = {
 311   'punctuationEcho': 'none'
 312 };
 313
 314 /**
 315  * TTS personality for alerts from the system, such as battery level
 316  * warnings.
 317  * @type {Object}
 318  */
 319 cvox.AbstractTts.PERSONALITY_SYSTEM_ALERT = {
 320   'punctuationEcho': 'none',
 321   'doNotInterrupt': true
 322 };
 323
 324 /**
 325  * TTS personality for an aside - text in parentheses.
 326  * @type {Object}
 327  */
 328 cvox.AbstractTts.PERSONALITY_ASIDE = {
 329   'relativePitch': -0.1,
 330   'color': '#669'
 331 };
 332
 333
 334 /**
 335  * TTS personality for capital letters.
 336  * @type {Object}
 337  */
 338 cvox.AbstractTts.PERSONALITY_CAPITAL = {
 339   'relativePitch': 0.6
 340 };
 341
 342
 343 /**
 344  * TTS personality for deleted text.
 345  * @type {Object}
 346  */
 347 cvox.AbstractTts.PERSONALITY_DELETED = {
 348   'punctuationEcho': 'none',
 349   'relativePitch': -0.6
 350 };
 351
 352
 353 /**
 354  * TTS personality for quoted text.
 355  * @type {Object}
 356  */
 357 cvox.AbstractTts.PERSONALITY_QUOTE = {
 358   'relativePitch': 0.1,
 359   'color': '#b6b',
 360   'fontWeight': 'bold'
 361 };
 362
 363
 364 /**
 365  * TTS personality for strong or bold text.
 366  * @type {Object}
 367  */
 368 cvox.AbstractTts.PERSONALITY_STRONG = {
 369   'relativePitch': 0.1,
 370   'color': '#b66',
 371   'fontWeight': 'bold'
 372 };
 373
 374
 375 /**
 376  * TTS personality for emphasis or italicized text.
 377  * @type {Object}
 378  */
 379 cvox.AbstractTts.PERSONALITY_EMPHASIS = {
 380   'relativeVolume': 0.1,
 381   'relativeRate': -0.1,
 382   'color': '#6bb',
 383   'fontWeight': 'bold'
 384 };
 385
 386
 387 /**
 388  * Flag indicating if the TTS is being debugged.
 389  * @type {boolean}
 390  */
 391 cvox.AbstractTts.DEBUG = true;
 392
 393
 394 /**
 395  * Character dictionary. These symbols are replaced with their human readable
 396  * equivalents. This replacement only occurs for single character utterances.
 397  * @type {Object<string>}
 398  */
 399 cvox.AbstractTts.CHARACTER_DICTIONARY = {
 400   ' ': 'space',
 401   '`': 'backtick',
 402   '~': 'tilde',
 403   '!': 'exclamation',
 404   '@': 'at',
 405   '#': 'pound',
 406   '$': 'dollar',
 407   '%': 'percent',
 408   '^': 'caret',
 409   '&': 'ampersand',
 410   '*': 'asterisk',
 411   '(': 'open_paren',
 412   ')': 'close_paren',
 413   '-': 'dash',
 414   '_': 'underscore',
 415   '=': 'equals',
 416   '+': 'plus',
 417   '[': 'left_bracket',
 418   ']': 'right_bracket',
 419   '{': 'left_brace',
 420   '}': 'right_brace',
 421   '|': 'pipe',
 422   ';': 'semicolon',
 423   ':': 'colon',
 424   ',': 'comma',
 425   '.': 'dot',
 426   '<': 'less_than',
 427   '>': 'greater_than',
 428   '/': 'slash',
 429   '?': 'question_mark',
 430   '"': 'quote',
 431   '\'': 'apostrophe',
 432   '\t': 'tab',
 433   '\r': 'return',
 434   '\n': 'new_line',
 435   '\\': 'backslash'
 436 };
 437
 438
 439 /**
 440  * Pronunciation dictionary. Each key must be lowercase, its replacement
 441  * should be spelled out the way most TTS engines will pronounce it
 442  * correctly. This particular dictionary only handles letters and numbers,
 443  * no symbols.
 444  * @type {Object<string>}
 445  */
 446 cvox.AbstractTts.PRONUNCIATION_DICTIONARY = {
 447   'admob': 'ad-mob',
 448   'adsense': 'ad-sense',
 449   'adwords': 'ad-words',
 450   'angularjs': 'angular j s',
 451   'bcc': 'B C C',
 452   'cc': 'C C',
 453   'chromevox': 'chrome vox',
 454   'cr48': 'C R 48',
 455   'ctrl': 'control',
 456   'doubleclick': 'double-click',
 457   'gmail': 'gee mail',
 458   'gtalk': 'gee talk',
 459   'http': 'H T T P',
 460   'https' : 'H T T P S',
 461   'igoogle': 'eye google',
 462   'pagerank': 'page-rank',
 463   'username': 'user-name',
 464   'www': 'W W W',
 465   'youtube': 'you tube'
 466 };
 467
 468
 469 /**
 470  * Pronunciation dictionary regexp.
 471  * @type {RegExp};
 472  * @private
 473  */
 474 cvox.AbstractTts.pronunciationDictionaryRegexp_;
 475
 476
 477 /**
 478  * Substitution dictionary. These symbols or patterns are ALWAYS substituted
 479  * whenever they occur, so this should be reserved only for unicode characters
 480  * and characters that never have any different meaning in context.
 481  *
 482  * For example, do not include '$' here because $2 should be read as
 483  * "two dollars".
 484  * @type {Object<string>}
 485  */
 486 cvox.AbstractTts.SUBSTITUTION_DICTIONARY = {
 487   '://': 'colon slash slash',
 488   '\u00bc': 'one fourth',
 489   '\u00bd': 'one half',
 490   '\u2190': 'left arrow',
 491   '\u2191': 'up arrow',
 492   '\u2192': 'right arrow',
 493   '\u2193': 'down arrow',
 494   '\u21d0': 'left double arrow',
 495   '\u21d1': 'up double arrow',
 496   '\u21d2': 'right double  arrow',
 497   '\u21d3': 'down double arrow',
 498   '\u21e6': 'left arrow',
 499   '\u21e7': 'up arrow',
 500   '\u21e8': 'right arrow',
 501   '\u21e9': 'down arrow',
 502   '\u2303': 'control',
 503   '\u2318': 'command',
 504   '\u2325': 'option',
 505   '\u25b2': 'up triangle',
 506   '\u25b3': 'up triangle',
 507   '\u25b4': 'up triangle',
 508   '\u25b5': 'up triangle',
 509   '\u25b6': 'right triangle',
 510   '\u25b7': 'right triangle',
 511   '\u25b8': 'right triangle',
 512   '\u25b9': 'right triangle',
 513   '\u25ba': 'right pointer',
 514   '\u25bb': 'right pointer',
 515   '\u25bc': 'down triangle',
 516   '\u25bd': 'down triangle',
 517   '\u25be': 'down triangle',
 518   '\u25bf': 'down triangle',
 519   '\u25c0': 'left triangle',
 520   '\u25c1': 'left triangle',
 521   '\u25c2': 'left triangle',
 522   '\u25c3': 'left triangle',
 523   '\u25c4': 'left pointer',
 524   '\u25c5': 'left pointer',
 525   '\uf8ff': 'apple'
 526 };
 527
 528
 529 /**
 530  * Substitution dictionary regexp.
 531  * @type {RegExp};
 532  * @private
 533  */
 534 cvox.AbstractTts.substitutionDictionaryRegexp_;
 535
 536
 537 /**
 538  * repetition filter regexp.
 539  * @type {RegExp}
 540  * @private
 541  */
 542 cvox.AbstractTts.repetitionRegexp_ =
 543     /([-\/\\|!@#$%^&*\(\)=_+\[\]\{\}.?;'":<>])\1{2,}/g;
 544
 545
 546 /**
 547  * Constructs a description of a repeated character. Use as a param to
 548  * string.replace.
 549  * @param {string} match The matching string.
 550  * @return {string} The description.
 551  * @private
 552  */
 553 cvox.AbstractTts.repetitionReplace_ = function(match) {
 554   var count = match.length;
 555   return ' ' + (new goog.i18n.MessageFormat(cvox.ChromeVox.msgs.getMsg(
 556       cvox.AbstractTts.CHARACTER_DICTIONARY[match[0]])))
 557           .format({'COUNT': count}) + ' ';
 558 };
 559
 560
 561 /**
 562  * @override
 563  */
 564 cvox.AbstractTts.prototype.getDefaultProperty = function(property) {
 565   return this.propertyDefault[property];
 566 };