Synthesizer gRPC API

The Synthesizer gRPC API contains methods for requesting speech synthesis from TTSaaS, using standard and enhanced voices.

If you wish to use Microsoft neural voices, use Neural TTSaaS instead. Consult the Neural TTSaaS documentation: Synthesizer gRPC API for Neural TTSaaS.

Tip:

Try out this API using a Sample synthesis client.

Proto file structure

The Synthesizer API is defined in the synthesizer.proto file.

└── nuance
    ├── rpc (RPC message files)
    └── tts
        ├── storage
        │   └── v1beta1
        │       └── storage.proto
        └── v1
            └── synthesizer.proto

The proto file defines a Synthesizer service with three RPC methods: GetVoices, Synthesize, and UnarySynthesize.

  Proto file fields for GetVoices  

  Proto file fields for Synthesize and UnarySynthesize  

Synthesizer

The Synthesizer service offers three methods related to voice synthesis.

Streamed vs. unary response

TTSaaS offers two types of synthesis response: a streamed response in SynthesisResponse and a non-streamed response in UnarySynthesisResponse.

The request is the same in both cases: SynthesisRequest specifies a voice, the input text to synthesize, and optional parameters. The response can be either:

• SynthesisResponse: Returns one status message followed by multiple streamed audio buffers, each including the markers or other events specified in the request. Each audio buffer contains the latest synthesized audio.

• UnarySynthesisResponse: Returns one status message and one audio buffer, containing all the markers and events specified in the request. The underlying TTSaaS engine caps the audio response size.

  See Run client for unary response to run the sample Python client with a unary response, activated by a command line flag.

One request, two possible responses (from proto file):

service Synthesizer {
    rpc Synthesize(SynthesisRequest) returns (stream SynthesisResponse) {} 
    rpc UnarySynthesize(SynthesisRequest) returns (UnarySynthesisResponse {}
. . .
message SynthesisRequest { 
    Voice voice = 1;  
    AudioParameters audio_params = 2; 
    Input input = 3;   
    EventParameters event_params = 4;  
    map<string, string> client_data = 5; 
}

message SynthesisResponse {
    oneof response {
        Status status = 1;
        Events events = 2;
        bytes audio = 3;
    }
}

message UnarySynthesisResponse {
    Status status = 1;
    Events events = 2;
    bytes audio = 3;
}

GetVoicesRequest

Input message for Synthesizer: GetVoices, to query voices available to the client.

The GetVoicesRequest message includes:

GetVoicesRequest
  voice (Voice)
    name
    model
    language
    age_group (EnumAgeGroup)
    gender (EnumGender)
    sample_rate_hz
    language_tlw

For example:

# This retrieves all American English voices
GetVoicesRequest (
    voice = Voice (language = "en-us")
)

# This returns one named voice
GetVoicesRequest (
    voice = Voice (name = "Evan")
)

# This returns all female American English voices
GetVoicesRequest (
    voice = Voice (
        gender = EnumGender.FEMALE,
        language = "en-us"
    )
)

Voice

Input or output message for voices:

• In GetVoicesRequest, it filters the list of available voices.
• In GetVoicesResponse, it returns the list of available voices.
• In SynthesisRequest, it specifies the voice to use for the synthesis operation.

These fields are supported in all cases:

These Voice fields are used only in GetVoicesRequest and GetVoicesResponse. They are ignored in SynthesisRequest.

The Voice message includes different fields depending on the context:

GetVoicesRequest
  voice (Voice)
    name
    model
    language
    age_group (EnumAgeGroup)
    gender (EnumGender)
    sample_rate_hz
    language_tlw
 
GetVoicesResponse
  voice (Voice)
    name
    model
    language
    age_group (EnumAgeGroup)
    gender (EnumGender)
    sample_rate_hz
    language_tlw
    restricted
    version
    foreign_languages
 
SynthesisRequest
  voice (Voice)
    name
    model

EnumAgeGroup

Input field for GetVoicesRequest or output field for GetVoicesResponse, specifying whether the voice uses its adult or child version, if available. Included in Voice.

EnumGender

Input field for GetVoicesRequest or output field for GetVoicesResponse, specifying gender for voices that support multiple genders. Included in Voice.

2023-09-26 15:51:16,151 (139911033857856) INFO  Iteration #1
2023-09-26 15:51:16,154 (139911033857856) DEBUG Creating secure gRPC channel
2023-09-26 15:51:16,161 (139911033857856) INFO  Running file [flow.py]
2023-09-26 15:51:16,161 (139911033857856) DEBUG [voice {
  language: "en-us"
}
]
2023-09-26 15:51:16,161 (139911033857856) INFO  Sending GetVoices request
2023-09-26 15:51:16,367 (139911033857856) INFO  voices {
  name: "Allison"
  model: "standard"
  language: "en-US"
  gender: FEMALE
  sample_rate_hz: 22050
  language_tlw: "enu"
  version: "2.0.0"
}
voices {
  name: "Ava-Ml"
  model: "enhanced"
  language: "en-US"
  gender: FEMALE
  sample_rate_hz: 22050
  language_tlw: "enu"
  version: "3.0.1"
  foreign_languages: "es-MX"
}
voices {
  name: "Chloe"
  model: "standard"
  language: "en-US"
  gender: FEMALE
  sample_rate_hz: 22050
  language_tlw: "enu"
  version: "5.2.3.15315"
}
voices {
  name: "Chloe"
  model: "standard"
  language: "en-US"
  gender: FEMALE
  sample_rate_hz: 8000
  language_tlw: "enu"
  version: "5.2.3.15315"
}
voices {
  name: "Erica"
  model: "standard"
  language: "en-US"
  gender: FEMALE
  sample_rate_hz: 22050
  language_tlw: "enu"
  restricted: true
  version: "1.0.2"
}
voices {
  name: "Erica"
  model: "standard"
  language: "en-US"
  gender: FEMALE
  sample_rate_hz: 8000
  language_tlw: "enu"
  restricted: true
  version: "1.0.2"
}
voices {
  name: "Evan"
  model: "enhanced"
  language: "en-US"
  gender: MALE
  sample_rate_hz: 22050
  language_tlw: "enu"
  version: "1.1.1"
}
voices {
  name: "Evelyn"
  model: "standard"
  language: "en-US"
  gender: FEMALE
  sample_rate_hz: 22050
  language_tlw: "enu"
  version: "5.2.3.15114"
}
voices {
  name: "Evelyn"
  model: "standard"
  language: "en-US"
  gender: FEMALE
  sample_rate_hz: 8000
  language_tlw: "enu"
  version: "5.2.3.15114"
}
voices {
  name: "Nathan"
  model: "enhanced"
  language: "en-US"
  gender: MALE
  sample_rate_hz: 22050
  language_tlw: "enu"
  version: "4.1.1"
}
voices {
  name: "Nolan"
  model: "standard"
  language: "en-US"
  gender: MALE
  sample_rate_hz: 22050
  language_tlw: "enu"
  version: "5.2.3.15315"
}
voices {
  name: "Nolan"
  model: "standard"
  language: "en-US"
  gender: MALE
  sample_rate_hz: 8000
  language_tlw: "enu"
  version: "5.2.3.15315"
}
voices {
  name: "Samantha"
  model: "standard"
  language: "en-US"
  gender: FEMALE
  sample_rate_hz: 22050
  language_tlw: "enu"
  version: "2.0.0"
}
voices {
  name: "Susan"
  model: "standard"
  language: "en-US"
  gender: FEMALE
  sample_rate_hz: 22050
  language_tlw: "enu"
  version: "2.0.0"
}
voices {
  name: "Tom"
  model: "standard"
  language: "en-US"
  gender: MALE
  sample_rate_hz: 22050
  language_tlw: "enu"
  version: "3.2.1"
}
voices {
  name: "Zoe-Ml"
  model: "enhanced"
  language: "en-US"
  gender: FEMALE
  sample_rate_hz: 22050
  language_tlw: "enu"
  version: "2.0.0"
  foreign_languages: "es-MX"
  foreign_languages: "fr-CA"
}

2023-09-26 15:51:16,368 (139911033857856) INFO  Done running file [flow.py]
2023-09-26 15:51:16,369 (139911033857856) INFO  Iteration #1 complete
2023-09-26 15:51:16,369 (139911033857856) INFO  Done

SynthesisRequest

Input message for Synthesizer: Synthesize. Specifies input text, audio parameters, and events to subscribe to, in exchange for synthesized audio. See Defaults for default values for optional fields.

The SynthesisRequest message includes:

SynthesisRequest
  voice (Voice)
    name
    model
  audio_params (AudioParameters)
    audio_format (AudioFormat)
    volume_percentage
    speaking_rate_factor
    audio_chunk_duration_ms
    target_audio_length
    disable_early_emission
  input (Input)
    text (Text)
    ssml (SSML)
    tokenized_sequence (TokenizedSequence)
    resources (SynthesisResource)
    lid_params (LanguageIdentificationParameters)
    download_params (DownloadParameters)
  event_params (EventParameters)
    send_sentence_marker_events
    send_word_marker_events
    send_phoneme_marker_events
    send_bookmark_marker_events
    send_paragraph_marker_events
    send_visemes
    send_log_events
    suppress_input
  client_data
  user_id

This synthesis request includes most fields:

SynthesisRequest(
    voice = Voice(
        name = "Evan",
        model = "enhanced"
    ),
    audio_params = AudioParameters(
        audio_format = AudioFormat(
            pcm = PCM(sample_rate_hz = 22050)
        ),
        volume_percentage = 80,       # Default value
        speaking_rate_factor = 1.0    # Default value
    ),
    input = Input(
        text = Text(
           text = "Your coffee will be ready in 5 minutes")
    ),
    event_params = EventParameters(
        send_log_events = True,
        suppress_input = True
    ),
    client_data = {'company':'Aardvark Coffee','user':'Leslie'},
    user_id = "leslie.somebody@aardvark.com"
)

This minimal synthesis request uses all defaults:

SynthesisRequest(
    voice = Voice(
        name = "Evan",
        model = "enhanced"
    ),
    input = Input(
        text = Text(
           text = "Your coffee will be ready in 5 minutes")
    )
)

AudioParameters

Input message for audio-related parameters during synthesis, including encoding, volume, and audio length. Included in SynthesisRequest.

The AudioParameters message includes:

SynthesisRequest
  voice (Voice)
  audio_params (AudioParameters)
    audio_format (AudioFormat)
      pcm (PCM)
      alaw (Alaw)
      ulaw (Ulaw)
      ogg_opus (OggOpus)
      opus (Opus)
    volume_percentage
    speaking_rate_factor
    audio_chunk_duration_ms
    target_audio_length
    disable_early_emission

AudioFormat

Input message for audio encoding of synthesized text. Included in AudioParameters.

The AudioFormat message includes:

SynthesisRequest
  voice (Voice)
  audio_params (AudioParameters)
    audio_format (AudioFormat)
      pcm (PCM)
        sample_rate_hz
      alaw (Alaw)
      ulaw (Ulaw)
      ogg_opus (OggOpus)
        sample_rate_hz
        bit_rate_bps
        max_frame_ duration_ms
        complexity
        vbr (EnumVariableBitrate)
      opus (Opus)
        sample_rate_hz
        bit_rate_bps
        max_frame_ duration_ms
        complexity
        vbr (EnumVariableBitrate)

The PCM audio format is shown in this example, with alternatives in commented lines:

SynthesisRequest(
    voice = Voice(
        name = "Evan",
        model = "enhanced"
    ),
    audio_params = AudioParameters(
        audio_format = AudioFormat(
            pcm = PCM(sample_rate_hz = 22050)
#           alaw = ALaw()
#           ulaw = ULaw()
#           ogg_opus = OggOpus(sample_rate_hz = 16000)
#           opus = Opus(sample_rate_hz = 8000, bit_rate_bps = 30000)
        )
    )

PCM

Input message defining PCM sample rate. Included in AudioFormat.

ALaw

Input message defining A-law audio format. Included in AudioFormat. G.711 audio formats are set to 8kHz.

ULaw

Input message defining Mu-law audio format. Included in AudioFormat. G.711 audio formats are set to 8kHz.

OggOpus

Input message defining Ogg Opus output rate. Included in AudioFormat.

Opus

Input message defining Opus output rate. Included in AudioFormat.

EnumVariableBitrate

Settings for variable bitrate. Included in OggOpus and Opus. Turned on by default.

Input

Input message containing text to synthesize and synthesis parameters, including tuning data, etc. Included in SynthesisRequest. The type of input may be plain text, SSML, or a sequence of plain text and Nuance control codes. See Input to synthesize for more examples.

The Input message includes:

SynthesisRequest
  voice (Voice)
  input (Input)
    text (Text)
      text
      uri
    ssml (SSML)
      text
      uri
      ssml_validation_mode (EnumSSMLValidationMode)
    tokenized_sequence (TokenizedSequence)
      tokens (Token)
      uri

Text

Input message for synthesizing plain text. The encoding must be UTF-8. Included in Input.

This example shows plain text input:

SynthesisRequest(
   voice = Voice(
       name = "Evan",
       model = "enhanced"
    ),
    input = Input(
        text = Text(
           text = "Your coffee will be ready in 5 minutes")
    ),
)

SSML

Input message for synthesizing SSML input. See SSML input for a list of supported elements and examples.

Input message for synthesizing SSML input.

This input contains SSML:

SynthesisRequest(
   voice = Voice(
       name = "Evan",
       model = "enhanced"
    ),
    input = Input(
        ssml = SSML(
            text = '<?xml version="1.0"?><speak  xmlns="http://www.w3.org/2001/10/synthesis"
xml:lang="en-US" version="1.0">This is the normal volume of my voice.
<prosody volume="10">I can speak rather quietly, </prosody>
<prosody volume="90">But also very loudly.</prosody></speak>',
            ssml_validation_mode = WARN
        )
    )
)

The xml tag and the speak attributes may be omitted:

SynthesisRequest(
   voice = Voice(
       name = "Evan",
       model = "enhanced"
    ),
    input = Input(
        ssml = SSML(
            text = '<speak>This is the normal volume of my voice.
<prosody volume="10">I can speak rather quietly,</prosody>
<prosody volume="90">But also very loudly.</prosody></speak>',
            ssml_validation_mode = WARN
        )
    )
)

EnumSSMLValidationMode

SSML validation mode when using SSML input. Included in SSML. Strict by default but can be relaxed.

TokenizedSequence

Input message for synthesizing a sequence of plain text and Nuance control codes. Included in Input. See Tokenized sequence for a list of supported codes and examples.

The TokenizedSequence message includes:

SynthesisRequest
  voice (Voice)
  input (Input)
    tokenized_sequence (TokenizedSequence)
      tokens (Token)
        text
        control_code (ControlCode)
          key
          value

This input is a sequence of tokens: text and control codes:

SynthesisRequest(
   voice = Voice(
       name = "Evan",
       model = "enhanced"
    ),
    input = Input(
        tokenized_sequence = TokenizedSequence(
            tokens = [
                Token(control_code = ControlCode(
                    key = "vol",
                    value = "10")),
                 Token(text = "I can speak rather quietly,"),
                 Token(control_code = ControlCode(
                     key = "vol",
                     value = "90")),
                 Token(text = "but also very loudly.")
             ]
        )
    )
)

Token

The unit when using TokenizedSequence for input. Each token can be either plain text or a Nuance control code.

ControlCode

Nuance control code that specifies how text should be spoken, similar to SSML. Included in Token.

SynthesisResource

SynthesisRequest (
    voice = Voice (name = "Evan", model = "enhanced"),
    input = Input (
        text = Text (text = "Your coffee will be ready in 5 minutes"),
        resources =  [
            SynthesisResource (
                type = USER_DICTIONARY,
                body = open("/path/to/user_dictionary.dcb", 'rb').read()
            )
        ]
    )
)

SynthesisRequest (
    voice = Voice (name = "Evan", model = "enhanced"),
    input = Input (
        text = Text (text = "Your coffee will be ready in 5 minutes"),
        resources =  [
            SynthesisResource (
                type = USER_DICTIONARY,
                uri = "urn:nuance-mix:tag:tuning:lang/coffee_app/coffee_dict/en-us/mix.tts"
            )
        ]
    )
)

SynthesisRequest (
    voice = Voice (name = "Evan", model = "enhanced"),
    input = Input (
        text = Text (text = "Your coffee will be ready in 5 minutes"),
        resources =  [
            SynthesisResource (
                type = ACTIVEPROMPT_DB,
                uri = "urn:nuance-mix:tag:tuning:voice/coffee_app/coffee_prompts/Evan/mix.tts"
            )
        ]
    )
)

SynthesisRequest (
    voice = Voice (name = "Evan", model = "enhanced"),
    input = Input (
        text = Text (text = "Your coffee will be ready in 5 minutes"),
        resources =  [
            SynthesisResource (
                type = TEXT_USER_RULESET,
                uri = "urn:nuance-mix:tag:tuning:lang/coffee_app/coffee_rules/en-us/mix.tts"
            )
        ]
    )
)

uri: "urn:nuance-mix:tag:tuning:lang/coffee_app/coffee_dict/en-us/mix.tts?type=userdict"

User dictionary:
urn:nuance-mix:tag:tuning:lang/coffee_app/coffee_dict/en-us/mix.tts

Text ruleset:
urn:nuance-mix:tag:tuning:lang/coffee_app/coffee_rules/en-us/mix.tts

ActivePrompt database:
urn:nuance-mix:tag:tuning:voice/coffee_app/coffee_prompts/Evan/mix.tts

Audio file:
urn:nuance-mix:tag:tuning:audio/coffee_app/thanks/mix.tts

LanguageIdentificationParameters

Input message controlling the language identifier. Included in Input. The language identifier runs on input blocks labeled with control code lang unknown or the SSML attribute xml:lang="unknown".

By default, the language identifier matches languages to all installed voices. The languages field limits the permissible languages, and also sets the order of precedence (first to last) when they have equal confidence scores.

The LanguageIdentificationParameters message includes:

SynthesisRequest
  voice (Voice)
  input (Input)
    lid_params (LanguageIdentificationParameters)
      disable
      languages
      always_use_highest_confidence

This Input message includes LID parameters to limit the choice of languages to French Canadian (frc) or American English (enu):

SynthesisRequest(
    voice = Voice(
        name = "Evan",
        model = "enhanced"
    ),
    input = Input(
       tokenized_sequence = TokenizedSequence(
            tokens = [
                Token(text = "The name of the song is. "),
                Token(control_code = ControlCode(
                    key = "lang",
                    value = "unknown")),
                Token(text = "Au clair de la lune."),
                Token(control_code = ControlCode(
                    key = "lang",
                    value = "normal")),
                Token(text = "It's a folk song meaning, in the light of the moon.")
            ]
        ),
        lid_params = LanguageIdentificationParameters(
            languages = (["frc", "enu"])
        )
    )
)

DownloadParameters

Input message containing parameters for remote file download, whether for input text (Input.uri) or a SynthesisResource (SynthesisResource.uri). Included in Input.

The DownloadParameters message includes:

SynthesisRequest
  voice (Voice)
  input (Input)
    download_params (DownloadParameters)
      headers
      request_timeout_ms
      refuse_cookies

EventParameters

Input message that defines event subscription parameters. Included in SynthesisRequest. Events that are requested are sent throughout the SynthesisResponse stream, when generated. Marker events can send events as certain parts of the synthesized audio are reached, for example, at the end of a word, sentence, or user-defined bookmark.

Log events are produced throughout a synthesis request for events such as a voice loaded by the server or an audio chunk being ready to send.

The EventParameters message includes:

SynthesisRequest
  voice (Voice)
  input (Input)
  event_params (EventParameters)
    send_sentence_marker_events
    send_word_marker_events
    send_phoneme_marker_events
    send_bookmark_marker_events
    send_paragraph_marker_events
    send_visemes
    send_log_events
    suppress_input

Event parameters in SynthesisRequest:

SynthesisRequest(
    voice = Voice(
        name = "Evan",
        model = "enhanced"
    ),
    input = Input(
        text = Text(
           text = "Your coffee will be ready in 5 minutes.")
    ),
    event_params = EventParameters(
        send_sentence_marker_events = True,
        send_paragraph_marker_events = True,
        send_log_events = True,
        suppress_input = True
    )
)

SynthesisResponse

The Synthesizer Synthesize method returns a stream of SynthesisResponse messages. (See UnarySynthesisResponse for a non-streamed response.) Each response contains one of:

• A status response, indicating completion or failure of the request. This is received only once and signifies the end of a Synthesize call.
• A list of events the client has requested. This can be received many times.
• An audio buffer. This may be received many times.

The SynthesisResponse message includes:

SynthesisResponse
  status (Status)
    code
    message
    details
  events (Events)
    event (Event)
      name
      values
  audio

Response to synthesis request:

try:
    if args.output_audio_file:
        audio_file = open(args.output_audio_file, "wb")
    for response in stream_in:
        if response.HasField("audio"):
            print("Received audio: %d bytes" % len(response.audio))
            if(audio_file):
                audio_file.write(response.audio)
        elif response.HasField("events"):
            print("Received events")
            print(text_format.MessageToString(response.events))
        else:
            if response.status.code == 200:
                print("Received status response: SUCCESS")
            else:
                print("Received status response: FAILED")
                print("Code: {}, Message: {}".format(response.status.code, response.status.message))
                print('Error: {}'.format(response.status.details))
except Exception as e:
    print(e)
if audio_file:
    print("Saved audio to {}".format(args.output_audio_file))
    audio_file.close()

These results synthesize a simple text string using the Evan voice, and include a user dictionary:

2023-09-26 15:45:42,436 (139898668111680) INFO  Iteration #1
2023-09-26 15:45:42,439 (139898668111680) DEBUG Creating secure gRPC channel
2023-09-26 15:45:42,444 (139898668111680) INFO  Running file [flow.py]
2023-09-26 15:45:42,444 (139898668111680) DEBUG [voice {
  name: "Evan"
  model: "enhanced"
}
audio_params {
  audio_format {
    pcm {
      sample_rate_hz: 22050
    }
  }
  volume_percentage: 80
  speaking_rate_factor: 1.0
  audio_chunk_duration_ms: 2000
}
input {
  text {
    text: "This is a test. A very simple test."
  }
  resources {
    uri: "urn:nuance-mix:tag:tuning:lang/coffee_app/coffee_dict/en-us/mix.tts"
  }
}
user_id: "MyApplicationUser"
]
2023-09-26 15:45:42,444 (139898668111680) INFO  Sending Synthesis request
2023-09-26 15:45:42,631 (139898668111680) INFO  Received audio: 57484 bytes
2023-09-26 15:45:42,655 (139898668111680) INFO  Received audio: 70432 bytes
2023-09-26 15:45:42,657 (139898668111680) INFO  Received status response: SUCCESS
2023-09-26 15:45:42,657 (139898668111680) INFO  Wrote audio to flow.py_i1_s1.wav
2023-09-26 15:45:42,657 (139898668111680) INFO  Done running file [flow.py]
2023-09-26 15:45:42,660 (139898668111680) INFO  Iteration #1 complete
2023-09-26 15:45:42,660 (139898668111680) INFO  Done

Status

Output message containing a status response, indicating completion or failure of a Synthesize call. Included in SynthesisResponse and UnarySynthesisResponse.

Events

Output message defining a container for a list of events. This container is needed because oneof does not allow repeated parameters. Included in SynthesisResponse and UnarySynthesisResponse.

Events are returned when send_log_events is True in the request’s EventParameters.

For a description of the NVOC events in the results, see TTS payload: callsummary.

2023-08-09 13:00:56,401 (140323311499072) INFO  Iteration #1
2023-08-09 13:00:56,403 (140323311499072) DEBUG Creating secure gRPC channel
2023-08-09 13:00:56,408 (140323311499072) INFO  Running file [mix-flow.py]
2023-08-09 13:00:56,408 (140323311499072) DEBUG [voice {
  name: "Evan"
}
, voice {
  name: "Evan"
  model: "enhanced"
}
audio_params {
  audio_format {
    pcm {
      sample_rate_hz: 22050
    }
  }
  volume_percentage: 80
  speaking_rate_factor: 1.0
  audio_chunk_duration_ms: 2000
}
input {
  text {
    text: "This is a test. A very simple test."
  }
}
event_params {
  send_log_events: true
}
user_id: "my-user-id"
]
2023-08-09 13:00:56,408 (140323311499072) INFO  Sending GetVoices request
2023-08-09 13:00:56,644 (140323311499072) INFO  voices {
  name: "Evan"
  model: "enhanced"
  language: "en-US"
  gender: MALE
  sample_rate_hz: 22050
  language_tlw: "enu"
  version: "1.1.1"
}

2023-08-09 13:00:56,644 (140323311499072) INFO  Sending Synthesis request
2023-08-09 13:00:56,768 (140323311499072) INFO  Received events
2023-08-09 13:00:56,769 (140323311499072) INFO  events {
  name: "NVOCliss"
  values {
    key: "LFEAT"
    value: "tts,unthrottled"
  }
  values {
    key: "LMAX"
    value: "5000"
  }
  values {
    key: "LUSED"
    value: "1"
  }
  values {
    key: "OMAX"
    value: "5000"
  }
  values {
    key: "TTSAASTIME"
    value: "2023-08-09T17:00:24.892Z"
  }
  values {
    key: "TTSTIME"
    value: "2023/08/09 17:00:24.892 UTC"
  }
}

2023-08-09 13:00:56,769 (140323311499072) INFO  Received events
2023-08-09 13:00:56,770 (140323311499072) INFO  events {
  name: "NVOCsyst"
  values {
    key: "APNM"
    value: "MyApp"
  }
  values {
    key: "CODEC"
    value: "linear_16"
  }
  values {
    key: "FREQ"
    value: "22050"
  }
  values {
    key: "LANG"
    value: "American English"
  }
  values {
    key: "LVER"
    value: "17.7.000000"
  }
  values {
    key: "PVER"
    value: "7.4.0"
  }
  values {
    key: "TTSAASTIME"
    value: "2023-08-09T17:00:24.892Z"
  }
  values {
    key: "TTSAASVER"
    value: "1.0.0"
  }
  values {
    key: "TTSTIME"
    value: "2023/08/09 17:00:24.892 UTC"
  }
  values {
    key: "VMDL"
    value: "xpremium-high"
  }
  values {
    key: "VOIC"
    value: "Evan"
  }
  values {
    key: "VOPVER"
    value: "1.1.1"
  }
  values {
    key: "VVER"
    value: "1.1.0"
  }
}

2023-08-09 13:00:56,770 (140323311499072) INFO  Received events
2023-08-09 13:00:56,770 (140323311499072) INFO  events {
  name: "NVOCadon"
  values {
    key: "ADDON_NAME"
    value: "/usr/local/Nuance/Vocalizer_for_Cloud/voices/nuance/drug-names_sysdict_enu_cfg4_v6.5.000000.sdc"
  }
  values {
    key: "TTSAASTIME"
    value: "2023-08-09T17:00:24.895Z"
  }
  values {
    key: "TTSTIME"
    value: "2023/08/09 17:00:24.895 UTC"
  }
}

2023-08-09 13:00:56,826 (140323311499072) INFO  Received events
2023-08-09 13:00:56,827 (140323311499072) INFO  events {
  name: "NVOCaudf"
  values {
    key: "FREQ"
    value: "22"
  }
  values {
    key: "SAMP"
    value: "28742"
  }
  values {
    key: "TTSAASTIME"
    value: "2023-08-09T17:00:24.952Z"
  }
  values {
    key: "TTSTIME"
    value: "2023/08/09 17:00:24.952 UTC"
  }
}

2023-08-09 13:00:56,879 (140323311499072) INFO  Received audio: 57484 bytes
2023-08-09 13:00:56,880 (140323311499072) INFO  Received events
2023-08-09 13:00:56,881 (140323311499072) INFO  events {
  name: "NVOCadon"
  values {
    key: "ADDON_NAME"
    value: "/usr/local/Nuance/Vocalizer_for_Cloud/voices/nuance/drug-names_sysdict_enu_cfg4_v6.5.000000.sdc"
  }
  values {
    key: "TTSAASTIME"
    value: "2023-08-09T17:00:24.954Z"
  }
  values {
    key: "TTSTIME"
    value: "2023/08/09 17:00:24.954 UTC"
  }
}

2023-08-09 13:00:56,881 (140323311499072) INFO  Received events
2023-08-09 13:00:56,881 (140323311499072) INFO  events {
  name: "NVOCadon"
  values {
    key: "ADDON_NAME"
    value: "/usr/local/Nuance/Vocalizer_for_Cloud/voices/nuance/drug-names_sysdict_enu_cfg4_v6.5.000000.sdc"
  }
  values {
    key: "TTSAASTIME"
    value: "2023-08-09T17:00:24.954Z"
  }
  values {
    key: "TTSTIME"
    value: "2023/08/09 17:00:24.954 UTC"
  }
}

2023-08-09 13:00:56,941 (140323311499072) INFO  Received events
2023-08-09 13:00:56,942 (140323311499072) INFO  events {
  name: "NVOCaudn"
  values {
    key: "FREQ"
    value: "22"
  }
  values {
    key: "SAMP"
    value: "35216"
  }
  values {
    key: "TTSAASTIME"
    value: "2023-08-09T17:00:25.064Z"
  }
  values {
    key: "TTSTIME"
    value: "2023/08/09 17:00:25.064 UTC"
  }
}

2023-08-09 13:00:56,968 (140323311499072) INFO  Received audio: 70432 bytes
2023-08-09 13:00:56,969 (140323311499072) INFO  Received events
2023-08-09 13:00:56,969 (140323311499072) INFO  events {
  name: "NVOCcntv"
  values {
    key: "CHARS"
    value: "28"
  }
  values {
    key: "TTSAASTIME"
    value: "2023-08-09T17:00:25.065Z"
  }
  values {
    key: "TTSTIME"
    value: "2023/08/09 17:00:25.065 UTC"
  }
  values {
    key: "VOICE_VOP"
    value: "Evan_xpremium-high"
  }
}

2023-08-09 13:00:56,970 (140323311499072) INFO  Received events
2023-08-09 13:00:56,970 (140323311499072) INFO  events {
  name: "NVOCcntg"
  values {
    key: "CHARS"
    value: "28"
  }
  values {
    key: "TTSAASTIME"
    value: "2023-08-09T17:00:25.065Z"
  }
  values {
    key: "TTSTIME"
    value: "2023/08/09 17:00:25.065 UTC"
  }
}

2023-08-09 13:00:56,970 (140323311499072) INFO  Received events
2023-08-09 13:00:56,970 (140323311499072) INFO  events {
  name: "NVOCinpt"
  values {
    key: "MIME"
    value: "text/plain;charset=utf-8"
  }
  values {
    key: "TEXT"
    value: "This is a test. A very simple test."
  }
  values {
    key: "TTSAASTIME"
    value: "2023-08-09T17:00:25.065Z"
  }
  values {
    key: "TTSTIME"
    value: "2023/08/09 17:00:25.065 UTC"
  }
  values {
    key: "TXSZ"
    value: "35"
  }
}

2023-08-09 13:00:56,971 (140323311499072) INFO  Received events
2023-08-09 13:00:56,971 (140323311499072) INFO  events {
  name: "NVOCsynd"
  values {
    key: "DURS"
    value: "2900"
  }
  values {
    key: "INPT"
    value: "35"
  }
  values {
    key: "RSTT"
    value: "ok"
  }
  values {
    key: "TTSAASTIME"
    value: "2023-08-09T17:00:25.065Z"
  }
  values {
    key: "TTSTIME"
    value: "2023/08/09 17:00:25.065 UTC"
  }
}

2023-08-09 13:00:56,971 (140323311499072) INFO  Received events
2023-08-09 13:00:56,972 (140323311499072) INFO  events {
  name: "NVOClise"
  values {
    key: "LFEAT"
    value: "tts,unthrottled"
  }
  values {
    key: "LMAX"
    value: "5000"
  }
  values {
    key: "LUSED"
    value: "1"
  }
  values {
    key: "OMAX"
    value: "5000"
  }
  values {
    key: "TTSAASTIME"
    value: "2023-08-09T17:00:25.065Z"
  }
  values {
    key: "TTSTIME"
    value: "2023/08/09 17:00:25.065 UTC"
  }
}

2023-08-09 13:00:56,972 (140323311499072) INFO  Received status response: SUCCESS
2023-08-09 13:00:56,973 (140323311499072) INFO  Wrote audio to mix-flow.py_i1_s1.wav
2023-08-09 13:00:56,973 (140323311499072) INFO  Done running file [mix-flow.py]
2023-08-09 13:00:56,973 (140323311499072) INFO  Iteration #1 complete
2023-08-09 13:00:56,973 (140323311499072) INFO  Done

Event

Output message defining an event message. Included in Events. See EventParameters for details.

UnarySynthesisResponse

The Synthesizer UnarySynthesize RPC call returns a single UnarySynthesisResponse message. It is similar to SynthesisResponse but includes all the information at once instead of a streaming response. The response contains:

• A status response, indicating completion or failure of the request.
• A list of events the client has requested.
• The complete audio buffer of the synthesized text.

The UnarySynthesisResponse message includes:

UnarySynthesisResponse
  status (Status)
    code
    message
    details
  events (Events)
    event (Event)
      name
      values
  audio

Scalar value types