Essayez les modèles Gemini 1.5, les derniers modèles multimodaux de Vertex AI, et découvrez ce que vous pouvez créer avec une fenêtre de contexte pouvant comprendre jusqu'à deux millions de jetons. Essayez les modèles Gemini 1.5, les derniers modèles multimodaux de Vertex AI, et découvrez ce que vous pouvez créer avec une fenêtre de contexte pouvant comprendre jusqu'à deux millions de jetons.

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'en utiliser un ou plusieurs, Text-to-Speech applique les profils à vos résultats de 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
`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. L'exemple récupère un jeton d'accès pour la requête à l'aide de la Google Cloud CLI. Pour obtenir des instructions sur l'installation de la gcloud CLI, consultez S'authentifier auprès de Text-to-Speech.

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

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour Text-to-Speech, consultez la page Bibliothèques clientes Text-to-Speech. Pour en savoir plus, consultez la documentation de référence de l'API Text-to-Speech en langage Go.

Pour vous authentifier auprès de Text-to-Speech, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.


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

	"context"

	texttospeech "cloud.google.com/go/texttospeech/apiv1"
	"cloud.google.com/go/texttospeech/apiv1/texttospeechpb"
)

// 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: %w", err)
	}
	defer client.Close()

	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: %w", 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

Pour savoir comment installer et utiliser la bibliothèque cliente Text-to-Speech, consultez la page Bibliothèques clientes Text-to-Speech. Pour en savoir plus, consultez la documentation de référence de l'API Text-to-Speech en langage 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)

Langues supplémentaires

C# : Veuillez suivre les Instructions de configuration de C# sur la page des bibliothèques clientes, puis consultez la page Documentation de référence sur Text-to-Speech pour .NET.

PHP : Veuillez suivre les Instructions de configuration de PHP sur la page des bibliothèques clientes, puis consultez la page Documentation de référence sur Text-to-Speech pour PHP.

Ruby : Veuillez suivre les Instructions de configuration de Ruby sur la page des bibliothèques clientes, puis consultez la page Documentation de référence sur Text-to-Speech pour Ruby.