Esta página se ha traducido con Cloud Translation API.

Usar perfiles de dispositivo para el audio generado

En esta página se describe cómo seleccionar un perfil de dispositivo para el audio creado por Cloud Text-to-Speech.

Puedes optimizar la síntesis de voz que genera Cloud Text-to-Speech para reproducirla en diferentes tipos de hardware. Por ejemplo, si tu aplicación se ejecuta principalmente en dispositivos más pequeños, como wearables, puedes crear una síntesis de voz a partir de la API Cloud Text-to-Speech que esté optimizada específicamente para altavoces más pequeños.

También puedes aplicar varios perfiles de dispositivo al mismo texto de síntesis de voz. La API Cloud Text-to-Speech aplica perfiles de dispositivo al audio en el orden proporcionado en la solicitud al endpoint text:synthesize. No especifiques el mismo perfil más de una vez, ya que puedes obtener resultados no deseados si aplicas el mismo perfil varias veces.

El uso de perfiles de audio es opcional. Si decides usar uno o varios perfiles, Text-to-Speech de Cloud los aplicará a los resultados de voz sintetizada. Si decides no usar un perfil de audio, recibirás los resultados de tu voz sin ninguna modificación posterior a la síntesis.

Para escuchar la diferencia entre el audio generado a partir de diferentes perfiles, compara los dos clips que se muestran a continuación.

Ejemplo 1. Audio generado con el perfil handset-class-device

Ejemplo 2. Audio generado con el perfil telephony-class-application

Nota: Cada perfil de audio se ha optimizado para un dispositivo específico ajustando una serie de efectos de audio. Sin embargo, es posible que la marca y el modelo del dispositivo usado para ajustar el perfil no coincidan exactamente con los dispositivos de reproducción de los usuarios. Puede que tengas que probar con diferentes perfiles para encontrar la mejor salida de sonido para tu aplicación.

Perfiles de audio disponibles

En la siguiente tabla se muestran los IDs y ejemplos de los perfiles de dispositivo disponibles para usar con la API Cloud Text-to-Speech.

ID de perfil de audio	Optimizado para
`wearable-class-device`	Smartwatches y otros wearables, como Apple Watch y relojes Wear OS
`handset-class-device`	Smartphones, como Google Pixel, Samsung Galaxy o Apple iPhone
`headphone-class-device`	Auriculares de botón o auriculares para reproducir audio, como los auriculares Sennheiser
`small-bluetooth-speaker-class-device`	Altavoces domésticos pequeños, como Google Home Mini
`medium-bluetooth-speaker-class-device`	Altavoces domésticos inteligentes, como Google Home
`large-home-entertainment-class-device`	Sistemas de entretenimiento doméstico o smart TVs, como Google Home Max o LG TV
`large-automotive-class-device`	Altavoces del coche
`telephony-class-application`	Sistemas de respuesta de voz interactiva (IVR)

Especificar un perfil de audio que se va a usar

Para especificar un perfil de audio que se va a usar, define el campo effectsProfileId de la solicitud de síntesis de voz.

Protocolo

Para generar un archivo de audio, haz una solicitud POST y proporciona el cuerpo de la solicitud adecuado. A continuación, se muestra un ejemplo de una solicitud POST que utiliza curl. En el ejemplo se usa Google Cloud CLI para obtener un token de acceso para la solicitud. Para obtener instrucciones sobre cómo instalar la CLI de gcloud, consulta Autenticarte en Cloud TTS.

En el siguiente ejemplo se muestra cómo enviar una solicitud al endpoint 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 solicitud se realiza correctamente, la API Cloud Text-to-Speech devuelve el audio sintetizado como datos codificados en base64 incluidos en la salida JSON. El resultado JSON del archivo audio-profiles.txt tiene el siguiente aspecto:

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

Para decodificar los resultados de la API Cloud Text-to-Speech como un archivo de audio MP3, ejecuta el siguiente comando desde el mismo directorio que el archivo 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

Para saber cómo instalar y usar la biblioteca de cliente de Cloud TTS, consulta Bibliotecas de cliente de Cloud TTS. Para obtener más información, consulta la documentación de referencia de la API Go de Cloud TTS.

Para autenticarte en Cloud TTS, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.


import (
	"fmt"
	"io"
	"os"

	"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 = os.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():
    """Synthesizes speech from the input string of text."""
    from google.cloud import texttospeech

    text = "hello"
    output = "output.mp3"
    effects_profile_id = "telephony-class-application"
    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)

Idiomas adicionales

C#: Sigue las instrucciones de configuración de C# en la página de bibliotecas de cliente y, a continuación, consulta la documentación de referencia de Cloud TTS para .NET.

PHP Sigue las instrucciones de configuración de PHP en la página de bibliotecas de cliente y, a continuación, consulta la documentación de referencia de Cloud TTS para PHP.

Ruby: Sigue las instrucciones de configuración de Ruby en la página de bibliotecas de cliente y, a continuación, consulta la documentación de referencia de Cloud TTS para Ruby.

Usar perfiles de dispositivo para el audio generado Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.