Cette page a été traduite par l'API Cloud Translation.
Switch to English

Utiliser des profils d'appareil pour les contenus audio générés

Cette page explique comment sélectionner un profil d'appareil pour les contenus audio créés par Text-to-Speech.

Vous pouvez optimiser la voix synthétique produite par Text-to-Speech en fonction du matériel sur lequel elle sera lue. Par exemple, si votre application s'exécute principalement sur des types d'appareils plus petits et connectés, vous pouvez créer une synthèse vocale à partir de l'API Text-to-Speech optimisée spécifiquement pour les haut-parleurs plus petits.

Vous pouvez également appliquer plusieurs profils d'appareil à la même voix synthétique. L'API Text-to-Speech applique les profils d'appareils aux contenus audio dans l'ordre indiqué dans la requête envoyée au point de terminaison text:synthesize. Évitez de spécifier le même profil plusieurs fois, car cela peut entraîner des résultats indésirables.

L'utilisation de profils audio est facultative. Si vous choisissez d'utiliser un ou plusieurs de ces derniers, Text-to-Speech applique le ou les profils aux résultats de la synthèse vocale post-traitée. Si vous choisissez de ne pas utiliser de profil audio, vous recevrez vos résultats vocaux sans aucune modification post-synthèse.

Pour entendre la différence entre des contenus audio générés à partir de profils différents, comparez les deux extraits ci-dessous.


Exemple 1. Contenu audio généré avec le profil handset-class-device


Exemple 2. Contenu audio généré avec le profil telephony-class-application

Remarque : Chaque profil audio a été optimisé pour un appareil spécifique en ajustant une plage d'effets audio. Toutefois, la marque et le modèle de l'appareil utilisé pour ajuster le profil peuvent ne pas correspondre exactement aux appareils de lecture des utilisateurs. Vous devrez éventuellement essayer différents profils pour trouver la meilleure sortie audio pour votre application.

Profils audio disponibles

Le tableau suivant fournit les ID et des exemples de profils d'appareil pouvant être utilisés par l'API Text-to-Speech.

ID de profil audio Optimisé pour les types d'appareils suivants
wearable-class-device Montres connectées et autres appareils connectés, par exemple : Apple Watch ou montre Wear OS
handset-class-device Smartphones, par exemple : Google Pixel, Samsung Galaxy et iPhone Apple
headphone-class-device Écouteurs ou casques de lecture audio, par exemple : casques Sennheiser
small-bluetooth-speaker-class-device Petites enceintes domestiques, par exemple : Google Home Mini
medium-bluetooth-speaker-class-device Enceintes pour maison connectée, par exemple : Google Home
large-home-entertainment-class-device Systèmes de divertissement à domicile ou Smart TV, par exemple : Google Home Max ou téléviseur LG
large-automotive-class-device Enceintes de voiture
telephony-class-application Systèmes de réponse vocale interactive (IVR, Interactive Voice Response)

Spécifier un profil audio à utiliser

Pour spécifier un profil audio à utiliser, définissez le champ effectsProfileId pour la requête de synthèse vocale.

Protocole

Pour générer un fichier audio, envoyez une requête POST et indiquez le corps de requête approprié. Voici un exemple de requête POST utilisant curl. Cet exemple se sert du jeton d'accès associé à un compte de service configuré pour le projet à l'aide du SDK Cloud de Google Cloud Platform. Pour obtenir des instructions sur l'installation du SDK Cloud, la configuration d'un projet avec un compte de service et l'obtention d'un jeton d'accès, consultez la page Démarrage rapide.

L'exemple suivant montre comment envoyer une requête au point de terminaison text:synthesize.

curl \
  -H "Authorization: Bearer "$(gcloud auth print-access-token) \
  -H "Content-Type: application/json; charset=utf-8" \
  --data "{
    'input':{
      'text':'This is a sentence that helps test how audio profiles can change the way Cloud Text-to-Speech sounds.'
    },
    'voice':{
      'languageCode':'en-us',
    },
    'audioConfig':{
      'audioEncoding':'LINEAR16',
      'effectsProfileId': ['telephony-class-application']
    }
  }" "https://texttospeech.googleapis.com/v1beta1/text:synthesize" > audio-profile.txt

Si la requête aboutit, l'API Text-to-Speech renvoie l'audio synthétisé sous forme de données encodées en base64 dans la sortie JSON. La sortie JSON dans le fichier audio-profiles.txt se présente comme suit :

{
  "audioContent": "//NExAASCCIIAAhEAGAAEMW4kAYPnwwIKw/BBTpwTvB+IAxIfghUfW.."
}

Pour décoder les résultats de l'API Cloud Text-to-Speech sous forme de fichier audio MP3, exécutez la commande suivante à partir du même répertoire que le fichier audio-profiles.txt.

sed 's|audioContent| |' < audio-profile.txt > tmp-output.txt && \
tr -d '\n ":{}' < tmp-output.txt > tmp-output-2.txt && \
base64 tmp-output-2.txt --decode > audio-profile.wav && \
rm tmp-output*.txt

C#

/// <summary>
/// Creates an audio file from the text input, applying the specifed
/// device profile to the output.
/// </summary>
/// <param name="text">Text to synthesize into audio</param>
/// <param name="outputFile">Name of audio output file</param>
/// <param name="effectProfileId">Audio effect profile to apply</param>
/// <remarks>
/// Output file saved in project folder.
/// </remarks>
public static int SynthesizeTextWithAudioProfile(string text,
                                                 string outputFile,
                                                 string effectProfileId)
{
    var client = TextToSpeechClient.Create();
    var response = client.SynthesizeSpeech(new SynthesizeSpeechRequest
    {
        Input = new SynthesisInput
        {
            Text = text
        },
        // Note: voices can also be specified by name
        // Names of voices can be retrieved with client.ListVoices().
        Voice = new VoiceSelectionParams
        {
            LanguageCode = "en-US",
            SsmlGender = SsmlVoiceGender.Female
        },
        AudioConfig = new AudioConfig
        {
            AudioEncoding = AudioEncoding.Mp3,
            // Note: you can pass in multiple audio effects profiles.
            // They are applied in the same order as provided.
            EffectsProfileId = { effectProfileId }
        }
    });

    // The response's AudioContent is binary.
    using (Stream output = File.Create(outputFile))
    {
        response.AudioContent.WriteTo(output);
    }

    return 0;
}

Go


import (
	"fmt"
	"io"
	"io/ioutil"

	"context"

	texttospeech "cloud.google.com/go/texttospeech/apiv1"
	texttospeechpb "google.golang.org/genproto/googleapis/cloud/texttospeech/v1"
)

// audioProfile generates audio from text using a custom synthesizer like a telephone call.
func audioProfile(w io.Writer, text string, outputFile string) error {
	// text := "hello"
	// outputFile := "out.mp3"

	ctx := context.Background()

	client, err := texttospeech.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %v", err)
	}

	req := &texttospeechpb.SynthesizeSpeechRequest{
		Input: &texttospeechpb.SynthesisInput{
			InputSource: &texttospeechpb.SynthesisInput_Text{Text: text},
		},
		Voice: &texttospeechpb.VoiceSelectionParams{LanguageCode: "en-US"},
		AudioConfig: &texttospeechpb.AudioConfig{
			AudioEncoding:    texttospeechpb.AudioEncoding_MP3,
			EffectsProfileId: []string{"telephony-class-application"},
		},
	}

	resp, err := client.SynthesizeSpeech(ctx, req)
	if err != nil {
		return fmt.Errorf("SynthesizeSpeech: %v", err)
	}

	if err = ioutil.WriteFile(outputFile, resp.AudioContent, 0644); err != nil {
		return err
	}

	fmt.Fprintf(w, "Audio content written to file: %v\n", outputFile)

	return nil
}

Java

/**
 * Demonstrates using the Text to Speech client with audio profiles to synthesize text or ssml
 *
 * @param text the raw text to be synthesized. (e.g., "Hello there!")
 * @param effectsProfile audio profile to be used for synthesis. (e.g.,
 *     "telephony-class-application")
 * @throws Exception on TextToSpeechClient Errors.
 */
public static void synthesizeTextWithAudioProfile(String text, String effectsProfile)
    throws Exception {
  // Instantiates a client
  try (TextToSpeechClient textToSpeechClient = TextToSpeechClient.create()) {
    // Set the text input to be synthesized
    SynthesisInput input = SynthesisInput.newBuilder().setText(text).build();

    // Build the voice request
    VoiceSelectionParams voice =
        VoiceSelectionParams.newBuilder()
            .setLanguageCode("en-US") // languageCode = "en_us"
            .setSsmlGender(SsmlVoiceGender.FEMALE) // ssmlVoiceGender = SsmlVoiceGender.FEMALE
            .build();

    // Select the type of audio file you want returned and the audio profile
    AudioConfig audioConfig =
        AudioConfig.newBuilder()
            .setAudioEncoding(AudioEncoding.MP3) // MP3 audio.
            .addEffectsProfileId(effectsProfile) // audio profile
            .build();

    // Perform the text-to-speech request
    SynthesizeSpeechResponse response =
        textToSpeechClient.synthesizeSpeech(input, voice, audioConfig);

    // Get the audio contents from the response
    ByteString audioContents = response.getAudioContent();

    // Write the response to the output file.
    try (OutputStream out = new FileOutputStream("output.mp3")) {
      out.write(audioContents.toByteArray());
      System.out.println("Audio content written to file \"output.mp3\"");
    }
  }
}

Node.js


/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const text = 'Text you want to vocalize';
// const outputFile = 'YOUR_OUTPUT_FILE_LOCAtION;
// const languageCode = 'LANGUAGE_CODE_FOR_OUTPUT';
// const ssmlGender = 'SSML_GENDER_OF_SPEAKER';

// Imports the Google Cloud client library
const speech = require('@google-cloud/text-to-speech');
const fs = require('fs');
const util = require('util');

// Creates a client
const client = new speech.TextToSpeechClient();

async function synthesizeWithEffectsProfile() {
  // Add one or more effects profiles to array.
  // Refer to documentation for more details:
  // https://cloud.google.com/text-to-speech/docs/audio-profiles
  const effectsProfileId = ['telephony-class-application'];

  const request = {
    input: {text: text},
    voice: {languageCode: languageCode, ssmlGender: ssmlGender},
    audioConfig: {audioEncoding: 'MP3', effectsProfileId: effectsProfileId},
  };

  const [response] = await client.synthesizeSpeech(request);
  const writeFile = util.promisify(fs.writeFile);
  await writeFile(outputFile, response.audioContent, 'binary');
  console.log(`Audio content written to file: ${outputFile}`);
}

Python

def synthesize_text_with_audio_profile(text, output, effects_profile_id):
    """Synthesizes speech from the input string of text."""
    from google.cloud import texttospeech

    client = texttospeech.TextToSpeechClient()

    input_text = texttospeech.SynthesisInput(text=text)

    # Note: the voice can also be specified by name.
    # Names of voices can be retrieved with client.list_voices().
    voice = texttospeech.VoiceSelectionParams(language_code="en-US")

    # Note: you can pass in multiple effects_profile_id. They will be applied
    # in the same order they are provided.
    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3,
        effects_profile_id=[effects_profile_id],
    )

    response = client.synthesize_speech(
        input=input_text, voice=voice, audio_config=audio_config
    )

    # The response's audio_content is binary.
    with open(output, "wb") as out:
        out.write(response.audio_content)
        print('Audio content written to file "%s"' % output)