Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://developer.chrome.com/docs/extensions/reference/api/ttsEngine below:

chrome.ttsEngine | API | Chrome for Developers

Stay organized with collections Save and categorize content based on your preferences.

Use the chrome.ttsEngine API to implement a text-to-speech(TTS) engine using an extension. If your extension registers using this API, it will receive events containing an utterance to be spoken and other parameters when any extension or Chrome App uses the tts API to generate speech. Your extension can then use any available web technology to synthesize and output the speech, and send events back to the calling function to report the status.

ttsEngine

An extension can register itself as a speech engine. By doing so, it can intercept some or all calls to functions such as tts.speak() and tts.stop() and provide an alternate implementation. Extensions are free to use any available web technology to provide speech, including streaming audio from a server, HTML5 audio. An extension could even do something different with the utterances, like display closed captions in a popup or send them as log messages to a remote server.

To implement a TTS engine, an extension must declare the "ttsEngine" permission and then declare all voices it provides in the extension manifest, like this:

{
  "name": "My TTS Engine",
  "version": "1.0",
  "permissions": ["ttsEngine"],
  "tts_engine": {
    "voices": [
      {
        "voice_name": "Alice",
        "lang": "en-US",
        "event_types": ["start", "marker", "end"]
      },
      {
        "voice_name": "Pat",
        "lang": "en-US",
        "event_types": ["end"]
      }
    ]
  },
  "background": {
    "page": "background.html",
    "persistent": false
  }
}

An extension can specify any number of voices.

The voice_name parameter is required. The name should be descriptive enough that it identifies the name of the voice and the engine used. In the unlikely event that two extensions register voices with the same name, a client can specify the ID of the extension that should do the synthesis.

The lang parameter is optional, but highly recommended. Almost always, a voice can synthesize speech in just a single language. When an engine supports more than one language, it can easily register a separate voice for each language. Under rare circumstances where a single voice can handle more than one language, it's easiest to just list two separate voices and handle them using the same logic internally. However, if you want to create a voice that will handle utterances in any language, leave out the lang parameter from your extension's manifest.

Finally, the event_types parameter is required if the engine can send events to update the client on the progress of speech synthesis. At a minimum, supporting the 'end' event type to indicate when speech is finished is highly recommended, otherwise Chrome cannot schedule queued utterances.

Once loaded, an extension can replace the list of declared voices by calling chrome.ttsEngine.updateVoices. (Note that the parameters used in the programatic call to updateVoices are in camel case: e.g., voiceName, unlike the manifest file which uses voice_name.)

The possible event types that you can send correspond to the event types that the speak() method receives:

• 'start': The engine has started speaking the utterance.
• 'word': A word boundary was reached. Use event.charIndex to determine the current speech position.
• 'sentence': A sentence boundary was reached. Use event.charIndex to determine the current speech position.
• 'marker': An SSML marker was reached. Use event.charIndex to determine the current speech position.
• 'end': The engine has finished speaking the utterance.
• 'error': An engine-specific error occurred and this utterance cannot be spoken. Pass more information in event.errorMessage.

The 'interrupted' and 'cancelled' events are not sent by the speech engine; they are generated automatically by Chrome.

Text-to-speech clients can get the voice information from your extension's manifest by calling tts.getVoices, assuming you've registered speech event listeners as described below.

To generate speech at the request of clients, your extension must register listeners for both onSpeak and onStop, like this:

const speakListener = (utterance, options, sendTtsEvent) => {
  sendTtsEvent({type: 'start', charIndex: 0})

  // (start speaking)

  sendTtsEvent({type: 'end', charIndex: utterance.length})
};

const stopListener = () => {
  // (stop all speech)
};

chrome.ttsEngine.onSpeak.addListener(speakListener);
chrome.ttsEngine.onStop.addListener(stopListener);

The decision of whether or not to send a given speech request to an extension is based solely on whether the extension supports the given voice parameters in its manifest and has registered listeners for onSpeak and onStop. In other words, there's no way for an extension to receive a speech request and dynamically decide whether to handle it.

Parameters containing an audio buffer and associated data.

• The audio buffer from the text-to-speech engine. It should have length exactly audioStreamOptions.bufferSize and encoded as mono, at audioStreamOptions.sampleRate, and as linear pcm, 32-bit signed float i.e. the Float32Array type in javascript.

• charIndex

  number optional

  The character index associated with this audio buffer.

• isLastBuffer

  boolean optional

  True if this audio buffer is the last for the text being spoken.

Contains the audio stream format expected to be produced by an engine.

• The number of samples within an audio buffer.

• The sample rate expected in an audio buffer.

The install status of a voice.

"notInstalled"

Install status of a language.

• Detail about installation failures. Optionally populated if the language failed to install.

• Installation status.

• Language string in the form of language code-region code, where the region may be omitted. Examples are en, en-AU, zh-CH.

Options for uninstalling a given language.

• uninstallImmediately

  boolean

  True if the TTS client wants the language to be immediately uninstalled. The engine may choose whether or when to uninstall the language, based on this parameter and the requestor information. If false, it may use other criteria, such as recent usage, to determine when to uninstall.

Options specified to the tts.speak() method.

• Deprecated since Chrome 92

  Gender is deprecated and will be ignored.

  Gender of voice for synthesized speech.

• The language to be used for synthesis, in the form language-region. Examples: 'en', 'en-US', 'en-GB', 'zh-CN'.

• Speaking pitch between 0 and 2 inclusive, with 0 being lowest and 2 being highest. 1.0 corresponds to this voice's default pitch.

• Speaking rate relative to the default rate for this voice. 1.0 is the default rate, normally around 180 to 220 words per minute. 2.0 is twice as fast, and 0.5 is half as fast. This value is guaranteed to be between 0.1 and 10.0, inclusive. When a voice does not support this full range of rates, don't return an error. Instead, clip the rate to the range the voice supports.

• voiceName

  string optional

  The name of the voice to use for synthesis.

• Speaking volume between 0 and 1 inclusive, with 0 being lowest and 1 being highest, with a default of 1.0.

Identifier for the client requesting status.

• Client making a language management request. For an extension, this is the unique extension ID. For Chrome features, this is the human-readable name of the feature.

• Type of requestor.

Type of requestor.

"chromefeature"

Chrome 54+ Deprecated since Chrome 70

Gender is deprecated and will be ignored.

chrome.ttsEngine.updateLanguage(
  status: LanguageStatus,
): void

Called by an engine when a language install is attempted, and when a language is uninstalled. Also called in response to a status request from a client. When a voice is installed or uninstalled, the engine should also call ttsEngine.updateVoices to register the voice.

• The install status of the language.

chrome.ttsEngine.updateVoices(
  voices: TtsVoice[],
): void

Called by an engine to update its list of voices. This list overrides any voices declared in this extension's manifest.

• Array of tts.TtsVoice objects representing the available voices for speech synthesis.

chrome.ttsEngine.onInstallLanguageRequest.addListener(
  callback: function,
)

Fired when a TTS client requests to install a new language. The engine should attempt to download and install the language, and call ttsEngine.updateLanguage with the result. On success, the engine should also call ttsEngine.updateVoices to register the newly available voices.

• The callback parameter looks like:

  (requestor: TtsClient, lang: string) => void

chrome.ttsEngine.onLanguageStatusRequest.addListener(
  callback: function,
)

Fired when a TTS client requests the install status of a language.

• The callback parameter looks like:

  (requestor: TtsClient, lang: string) => void

chrome.ttsEngine.onPause.addListener(
  callback: function,
)

Optional: if an engine supports the pause event, it should pause the current utterance being spoken, if any, until it receives a resume event or stop event. Note that a stop event should also clear the paused state.

• The callback parameter looks like:

  () => void

chrome.ttsEngine.onResume.addListener(
  callback: function,
)

Optional: if an engine supports the pause event, it should also support the resume event, to continue speaking the current utterance, if any. Note that a stop event should also clear the paused state.

• The callback parameter looks like:

  () => void

chrome.ttsEngine.onSpeak.addListener(
  callback: function,
)

Called when the user makes a call to tts.speak() and one of the voices from this extension's manifest is the first to match the options object.

• The callback parameter looks like:

  (utterance: string, options: SpeakOptions, sendTtsEvent: function) => void

  • The sendTtsEvent parameter looks like:

    (event: tts.TtsEvent) => void

    • The event from the text-to-speech engine indicating the status of this utterance.

chrome.ttsEngine.onSpeakWithAudioStream.addListener(
  callback: function,
)

Called when the user makes a call to tts.speak() and one of the voices from this extension's manifest is the first to match the options object. Differs from ttsEngine.onSpeak in that Chrome provides audio playback services and handles dispatching tts events.

• The callback parameter looks like:

  (utterance: string, options: SpeakOptions, audioStreamOptions: AudioStreamOptions, sendTtsAudio: function, sendError: function) => void

  • The sendTtsAudio parameter looks like:

    (audioBufferParams: AudioBuffer) => void

    • Parameters containing an audio buffer and associated data.

  • The sendError parameter looks like:

    (errorMessage?: string) => void

    • errorMessage

      string optional

      A string describing the error.

chrome.ttsEngine.onStop.addListener(
  callback: function,
)

Fired when a call is made to tts.stop and this extension may be in the middle of speaking. If an extension receives a call to onStop and speech is already stopped, it should do nothing (not raise an error). If speech is in the paused state, this should cancel the paused state.

• The callback parameter looks like:

  () => void

chrome.ttsEngine.onUninstallLanguageRequest.addListener(
  callback: function,
)

Fired when a TTS client indicates a language is no longer needed.

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates.

Last updated 2025-08-11 UTC.

[[["Easy to understand","easyToUnderstand","thumb-up"],["Solved my problem","solvedMyProblem","thumb-up"],["Other","otherUp","thumb-up"]],[["Missing the information I need","missingTheInformationINeed","thumb-down"],["Too complicated / too many steps","tooComplicatedTooManySteps","thumb-down"],["Out of date","outOfDate","thumb-down"],["Samples / code issue","samplesCodeIssue","thumb-down"],["Other","otherDown","thumb-down"]],["Last updated 2025-08-11 UTC."],[],[]]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4