Uso del audio de entrada comprimido

Referencia de la API REST de voz a texto | Referencia de la API REST de voz a texto para audio corto | Muestras adicionales en GitHub

Disponibilidad

Puede usar la API REST para audio comprimido, pero aún no hemos incluido una guía aquí. Seleccione otro lenguaje de programación para empezar a trabajar y obtener información sobre los conceptos.

Documentación de referencia | Package (PyPi) | Ejemplos adicionales en GitHub

El SDK de Voz y la CLI de Voz usan GStreamer para admitir diferentes tipos de formatos de audio de entrada. GStreamer descomprime el audio antes de enviarlo a través de la conexión al servicio de voz como PCM sin procesar.

El formato de streaming de audio predeterminado es WAV (16 kHz o 8 kHz, 16 bits y PCM mono). Fuera de WAV y PCM, los siguientes formatos de entrada comprimidos también se admiten a través de GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW en el contenedor WAV
  • MULAW en el contenedor WAV
  • ANY para el contenedor MP4 o formato multimedia desconocido

Configuración de GStreamer

El SDK de Voz puede usar GStreamer para controlar el audio comprimido. Por motivos de licencia, los archivos binarios de GStreamer no se compilan ni se vinculan con el SDK de Voz. Debe instalar algunas dependencias y complementos.

Los archivos binarios de GStreamer deben estar en la ruta de acceso del sistema para que el SDK de Voz pueda cargarlos en tiempo de ejecución. Por ejemplo, en Windows, si el SDK de Voz encuentra libgstreamer-1.0-0.dll o gstreamer-1.0-0.dll (para la versión más reciente de GStreamer) durante el tiempo de ejecución, significa que los archivos binarios de GStreamer están en la ruta del sistema.

Elija una plataforma para obtener instrucciones de instalación.

Debe instalar varias dependencias y complementos.

sudo apt install libgstreamer1.0-0 \
gstreamer1.0-plugins-base \
gstreamer1.0-plugins-good \
gstreamer1.0-plugins-bad \
gstreamer1.0-plugins-ugly

Para obtener más información, consulte Instrucciones de instalación de Linux y distribuciones de Linux admitidas y arquitecturas de destino.

Ejemplo

Para configurar el SDK de Voz para aceptar la entrada de audio comprimida, cree PullAudioInputStream o PushAudioInputStream. A continuación, cree un AudioConfig a partir de una instancia de su clase de flujo que especifique el formato de compresión del flujo.

Supongamos que el caso de uso es usar PullStream para un archivo MP3. El código podría tener este aspecto:


import azure.cognitiveservices.speech as speechsdk

class BinaryFileReaderCallback(speechsdk.audio.PullAudioInputStreamCallback):
    def __init__(self, filename: str):
        super().__init__()
        self._file_h = open(filename, "rb")

    def read(self, buffer: memoryview) -> int:
        print('trying to read {} frames'.format(buffer.nbytes))
        try:
            size = buffer.nbytes
            frames = self._file_h.read(size)

            buffer[:len(frames)] = frames
            print('read {} frames'.format(len(frames)))

            return len(frames)
        except Exception as ex:
            print('Exception in `read`: {}'.format(ex))
            raise

    def close(self) -> None:
        print('closing file')
        try:
            self._file_h.close()
        except Exception as ex:
            print('Exception in `close`: {}'.format(ex))
            raise

def compressed_stream_helper(compressed_format,
        mp3_file_path,
        default_speech_auth):
    callback = BinaryFileReaderCallback(mp3_file_path)
    stream = speechsdk.audio.PullAudioInputStream(stream_format=compressed_format, pull_stream_callback=callback)

    speech_config = speechsdk.SpeechConfig(**default_speech_auth)
    audio_config = speechsdk.audio.AudioConfig(stream=stream)

    speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)

    done = False

    def stop_cb(evt):
        """callback that signals to stop continuous recognition upon receiving an event `evt`"""
        print('CLOSING on {}'.format(evt))
        nonlocal done
        done = True

    # Connect callbacks to the events fired by the speech recognizer
    speech_recognizer.recognizing.connect(lambda evt: print('RECOGNIZING: {}'.format(evt)))
    speech_recognizer.recognized.connect(lambda evt: print('RECOGNIZED: {}'.format(evt)))
    speech_recognizer.session_started.connect(lambda evt: print('SESSION STARTED: {}'.format(evt)))
    speech_recognizer.session_stopped.connect(lambda evt: print('SESSION STOPPED {}'.format(evt)))
    speech_recognizer.canceled.connect(lambda evt: print('CANCELED {}'.format(evt)))
    # stop continuous recognition on either session stopped or canceled events
    speech_recognizer.session_stopped.connect(stop_cb)
    speech_recognizer.canceled.connect(stop_cb)

    # Start continuous speech recognition
    speech_recognizer.start_continuous_recognition()
    while not done:
        time.sleep(.5)

    speech_recognizer.stop_continuous_recognition()

def pull_audio_input_stream_compressed_mp3(mp3_file_path: str,
        default_speech_auth):
    # Create a compressed format
    compressed_format = speechsdk.audio.AudioStreamFormat(compressed_stream_format=speechsdk.AudioStreamContainerFormat.MP3)
    compressed_stream_helper(compressed_format, mp3_file_path, default_speech_auth)

Documentación de referencia | Paquete (NuGet) | Muestras adicionales en GitHub

El SDK de Voz y la CLI de Voz usan GStreamer para admitir diferentes tipos de formatos de audio de entrada. GStreamer descomprime el audio antes de enviarlo a través de la conexión al servicio de voz como PCM sin procesar.

El formato de streaming de audio predeterminado es WAV (16 kHz o 8 kHz, 16 bits y PCM mono). Fuera de WAV y PCM, los siguientes formatos de entrada comprimidos también se admiten a través de GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW en el contenedor WAV
  • MULAW en el contenedor WAV
  • ANY para el contenedor MP4 o formato multimedia desconocido

Configuración de GStreamer

El SDK de Voz puede usar GStreamer para controlar el audio comprimido. Por motivos de licencia, los archivos binarios de GStreamer no se compilan ni se vinculan con el SDK de Voz. Debe instalar algunas dependencias y complementos.

Los archivos binarios de GStreamer deben estar en la ruta de acceso del sistema para que el SDK de Voz pueda cargarlos en tiempo de ejecución. Por ejemplo, en Windows, si el SDK de Voz encuentra libgstreamer-1.0-0.dll o gstreamer-1.0-0.dll (para la versión más reciente de GStreamer) durante el tiempo de ejecución, significa que los archivos binarios de GStreamer están en la ruta del sistema.

Elija una plataforma para obtener instrucciones de instalación.

Debe instalar varias dependencias y complementos.

sudo apt install libgstreamer1.0-0 \
gstreamer1.0-plugins-base \
gstreamer1.0-plugins-good \
gstreamer1.0-plugins-bad \
gstreamer1.0-plugins-ugly

Para obtener más información, consulte Instrucciones de instalación de Linux y distribuciones de Linux admitidas y arquitecturas de destino.

Ejemplo

Para configurar el SDK de Voz para aceptar la entrada de audio comprimida, cree PullAudioInputStream o PushAudioInputStream. A continuación, cree un AudioConfig a partir de una instancia de su clase de flujo que especifique el formato de compresión del flujo. Busque fragmentos de código de ejemplo relacionados en Acerca de la API de flujo de entrada de audio del SDK de Voz.

Supongamos que tiene una clase de flujo de entrada denominada pullStream y usa OPUS/OGG. El código podría tener este aspecto:

using Microsoft.CognitiveServices.Speech;
using Microsoft.CognitiveServices.Speech.Audio;

// ... omitted for brevity

var speechConfig =
    SpeechConfig.FromSubscription(
        "YourSpeechResoureKey",
        "YourServiceRegion");

// Create an audio config specifying the compressed
// audio format and the instance of your input stream class.
var pullStream = AudioInputStream.CreatePullStream(
    AudioStreamFormat.GetCompressedFormat(AudioStreamContainerFormat.OGG_OPUS));
var audioConfig = AudioConfig.FromStreamInput(pullStream);

using var recognizer = new SpeechRecognizer(speechConfig, audioConfig);
var result = await recognizer.RecognizeOnceAsync();

var text = result.Text;

Documentación de referencia | Paquete (npm) | Muestras adicionales en GitHub | Código fuente de la biblioteca

El SDK de Voz para JavaScript no admite audio comprimido.

El formato de streaming de audio predeterminado es WAV (16 kHz o 8 kHz, 16 bits y PCM mono). Para introducir un archivo de audio comprimido (como mp3), primero debe convertirlo a un archivo WAV en el formato de entrada predeterminado. Para transmitir audio comprimido, primero debe descodificar los búferes de audio en el formato de entrada predeterminado. Para obtener más información, consulte Uso de la secuencia de entrada de audio.

Documentación de referencia | Ejemplos adicionales en GitHub

El SDK de Voz y la CLI de Voz usan GStreamer para admitir diferentes tipos de formatos de audio de entrada. GStreamer descomprime el audio antes de enviarlo a través de la conexión al servicio de voz como PCM sin procesar.

El formato de streaming de audio predeterminado es WAV (16 kHz o 8 kHz, 16 bits y PCM mono). Fuera de WAV y PCM, los siguientes formatos de entrada comprimidos también se admiten a través de GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW en el contenedor WAV
  • MULAW en el contenedor WAV
  • ANY para el contenedor MP4 o formato multimedia desconocido

Configuración de GStreamer

El SDK de Voz puede usar GStreamer para controlar el audio comprimido. Por motivos de licencia, los archivos binarios de GStreamer no se compilan ni se vinculan con el SDK de Voz. Debe instalar algunas dependencias y complementos.

Los archivos binarios de GStreamer deben estar en la ruta de acceso del sistema para que el SDK de Voz pueda cargarlos en tiempo de ejecución. Por ejemplo, en Windows, si el SDK de Voz encuentra libgstreamer-1.0-0.dll o gstreamer-1.0-0.dll (para la versión más reciente de GStreamer) durante el tiempo de ejecución, significa que los archivos binarios de GStreamer están en la ruta del sistema.

Elija una plataforma para obtener instrucciones de instalación.

El control del audio comprimido se implementa mediante GStreamer. Por motivos de licencia, los archivos binarios de GStreamer no se compilan ni se vinculan con el SDK de Voz. En su lugar, debe usar los archivos binarios creados previamente para Android. Para descargar las bibliotecas precompiladas, consulte Instalación para el desarrollo de Android.

El libgstreamer_android.so objeto es obligatorio. Asegúrese de que todos los complementos de GStreamer (del archivo Android.mk siguiente) estén vinculados en libgstreamer_android.so. Al usar el SDK de Voz con GStreamer versión 1.18.3, libc++_shared.so también es necesario que esté presente desde Android NDK.

GSTREAMER_PLUGINS := coreelements app audioconvert mpg123 \
    audioresample audioparsers ogg opusparse \
    opus wavparse alaw mulaw flac

Aquí se proporcionan un ejemplo Android.mk y un archivo Application.mk. Siga estos pasos para crear el gstreamer objeto compartido:libgstreamer_android.so.

# Android.mk
LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE    := dummy
LOCAL_SHARED_LIBRARIES := gstreamer_android
include $(BUILD_SHARED_LIBRARY)

ifndef GSTREAMER_ROOT_ANDROID
$(error GSTREAMER_ROOT_ANDROID is not defined!)
endif

ifndef APP_BUILD_SCRIPT
$(error APP_BUILD_SCRIPT is not defined!)
endif

ifndef TARGET_ARCH_ABI
$(error TARGET_ARCH_ABI is not defined!)
endif

ifeq ($(TARGET_ARCH_ABI),armeabi)
GSTREAMER_ROOT        := $(GSTREAMER_ROOT_ANDROID)/arm
else ifeq ($(TARGET_ARCH_ABI),armeabi-v7a)
GSTREAMER_ROOT        := $(GSTREAMER_ROOT_ANDROID)/armv7
else ifeq ($(TARGET_ARCH_ABI),arm64-v8a)
GSTREAMER_ROOT        := $(GSTREAMER_ROOT_ANDROID)/arm64
else ifeq ($(TARGET_ARCH_ABI),x86)
GSTREAMER_ROOT        := $(GSTREAMER_ROOT_ANDROID)/x86
else ifeq ($(TARGET_ARCH_ABI),x86_64)
GSTREAMER_ROOT        := $(GSTREAMER_ROOT_ANDROID)/x86_64
else
$(error Target arch ABI not supported: $(TARGET_ARCH_ABI))
endif

GSTREAMER_NDK_BUILD_PATH  := $(GSTREAMER_ROOT)/share/gst-android/ndk-build/
include $(GSTREAMER_NDK_BUILD_PATH)/plugins.mk
GSTREAMER_PLUGINS         :=  $(GSTREAMER_PLUGINS_CORE) \ 
                              $(GSTREAMER_PLUGINS_CODECS) \ 
                              $(GSTREAMER_PLUGINS_PLAYBACK) \
                              $(GSTREAMER_PLUGINS_CODECS_GPL) \
                              $(GSTREAMER_PLUGINS_CODECS_RESTRICTED)
GSTREAMER_EXTRA_LIBS      := -liconv -lgstbase-1.0 -lGLESv2 -lEGL
include $(GSTREAMER_NDK_BUILD_PATH)/gstreamer-1.0.mk

# Application.mk
APP_STL = c++_shared
APP_PLATFORM = android-21
APP_BUILD_SCRIPT = Android.mk

Puede compilar libgstreamer_android.so mediante el siguiente comando en Ubuntu 18.04 o 20.04. Se han probado las siguientes líneas de comandos para [GStreamer Android versión 1.14.4] con Android NDK b16b.

# Assuming wget and unzip are already installed on the system
mkdir buildLibGstreamer
cd buildLibGstreamer
wget https://dl.google.com/android/repository/android-ndk-r16b-linux-x86_64.zip
unzip -q -o android-ndk-r16b-linux-x86_64.zip
export PATH=$PATH:$(pwd)/android-ndk-r16b
export NDK_PROJECT_PATH=$(pwd)/android-ndk-r16b
wget https://gstreamer.freedesktop.org/download/
mkdir gstreamer_android
tar -xjf gstreamer-1.0-android-universal-1.14.4.tar.bz2 -C $(pwd)/gstreamer_android/
export GSTREAMER_ROOT_ANDROID=$(pwd)/gstreamer_android

mkdir gstreamer
# Copy the Application.mk and Android.mk from the documentation above and put it inside $(pwd)/gstreamer

# Enable only one of the following at one time to create the shared object for the targeted ABI
echo "building for armeabi-v7a. libgstreamer_android.so will be placed in $(pwd)/armeabi-v7a"
ndk-build -C $(pwd)/gstreamer "NDK_APPLICATION_MK=Application.mk" APP_ABI=armeabi-v7a NDK_LIBS_OUT=$(pwd)

#echo "building for arm64-v8a. libgstreamer_android.so will be placed in $(pwd)/arm64-v8a"
#ndk-build -C $(pwd)/gstreamer "NDK_APPLICATION_MK=Application.mk" APP_ABI=arm64-v8a NDK_LIBS_OUT=$(pwd)

#echo "building for x86_64. libgstreamer_android.so will be placed in $(pwd)/x86_64"
#ndk-build -C $(pwd)/gstreamer "NDK_APPLICATION_MK=Application.mk" APP_ABI=x86_64 NDK_LIBS_OUT=$(pwd)

#echo "building for x86. libgstreamer_android.so will be placed in $(pwd)/x86"
#ndk-build -C $(pwd)/gstreamer "NDK_APPLICATION_MK=Application.mk" APP_ABI=x86 NDK_LIBS_OUT=$(pwd)

Una vez compilado el objeto compartido (libgstreamer_android.so), coloque el objeto compartido en la aplicación Android para que el SDK de Voz pueda cargarlo.

Ejemplo

Para configurar el SDK de Voz para aceptar la entrada de audio comprimida, cree un PullAudioInputStream o un PushAudioInputStream. A continuación, cree una AudioConfig a partir de una instancia de su clase de flujo de datos que especifique el formato de compresión del flujo de datos. Busque código de ejemplo relacionado en Speech SDK samples.

Supongamos que tiene una clase de flujo de entrada denominada pullAudio y que usa MP3. El código podría tener este aspecto:

String filePath = "whatstheweatherlike.mp3";
PullAudioInputStream pullAudio = AudioInputStream.createPullStream(new BinaryAudioStreamReader(filePath),
    AudioStreamFormat.getCompressedFormat(AudioStreamContainerFormat.MP3));
AudioConfig audioConfig = AudioConfig.fromStreamInput(pullAudio);

Documentación de referencia | Paquete (NuGet) | Muestras adicionales en GitHub

El SDK de Voz y la CLI de Voz usan GStreamer para admitir diferentes tipos de formatos de audio de entrada. GStreamer descomprime el audio antes de enviarlo a través de la conexión al servicio de voz como PCM sin procesar.

El formato de streaming de audio predeterminado es WAV (16 kHz o 8 kHz, 16 bits y PCM mono). Fuera de WAV y PCM, los siguientes formatos de entrada comprimidos también se admiten a través de GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW en el contenedor WAV
  • MULAW en el contenedor WAV
  • ANY para el contenedor MP4 o formato multimedia desconocido

Configuración de GStreamer

El SDK de Voz puede usar GStreamer para controlar el audio comprimido. Por motivos de licencia, los archivos binarios de GStreamer no se compilan ni se vinculan con el SDK de Voz. Debe instalar algunas dependencias y complementos.

Los archivos binarios de GStreamer deben estar en la ruta de acceso del sistema para que el SDK de Voz pueda cargarlos en tiempo de ejecución. Por ejemplo, en Windows, si el SDK de Voz encuentra libgstreamer-1.0-0.dll o gstreamer-1.0-0.dll (para la versión más reciente de GStreamer) durante el tiempo de ejecución, significa que los archivos binarios de GStreamer están en la ruta del sistema.

Elija una plataforma para obtener instrucciones de instalación.

Debe instalar varias dependencias y complementos.

sudo apt install libgstreamer1.0-0 \
gstreamer1.0-plugins-base \
gstreamer1.0-plugins-good \
gstreamer1.0-plugins-bad \
gstreamer1.0-plugins-ugly

Para obtener más información, consulte Instrucciones de instalación de Linux y distribuciones de Linux admitidas y arquitecturas de destino.

Ejemplo

Para configurar el SDK de Voz para aceptar la entrada de audio comprimida, cree PullAudioInputStream o PushAudioInputStream. A continuación, cree un AudioConfig a partir de una instancia de su clase de flujo que especifica el formato de compresión del flujo. Busque código de ejemplo relacionado en Speech SDK samples.

Supongamos que tiene una clase de flujo de entrada denominada pushStream y usa OPUS/OGG. El código podría tener este aspecto:

using namespace Microsoft::CognitiveServices::Speech;
using namespace Microsoft::CognitiveServices::Speech::Audio;

// ... omitted for brevity

 auto config =
    SpeechConfig::FromSubscription(
        "YourSpeechResoureKey",
        "YourServiceRegion"
    );

// Create an audio config specifying the compressed
// audio format and the instance of your input stream class.
auto pullStream = AudioInputStream::CreatePullStream(
    AudioStreamFormat::GetCompressedFormat(AudioStreamContainerFormat::OGG_OPUS));
auto audioConfig = AudioConfig::FromStreamInput(pullStream);

auto recognizer = SpeechRecognizer::FromConfig(config, audioConfig);
auto result = recognizer->RecognizeOnceAsync().get();

auto text = result->Text;

Documentación de referencia | Paquete (Go) | Muestras adicionales en GitHub

El SDK de Voz y la CLI de Voz usan GStreamer para admitir diferentes tipos de formatos de audio de entrada. GStreamer descomprime el audio antes de enviarlo a través de la conexión al servicio de voz como PCM sin procesar.

El formato de streaming de audio predeterminado es WAV (16 kHz o 8 kHz, 16 bits y PCM mono). Fuera de WAV y PCM, los siguientes formatos de entrada comprimidos también se admiten a través de GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW en el contenedor WAV
  • MULAW en el contenedor WAV
  • CUALQUIERA para contenedores MP4 o formatos multimedia desconocidos

Configuración de GStreamer

El SDK de Voz puede usar GStreamer para controlar el audio comprimido. Por motivos de licencia, los archivos binarios de GStreamer no se compilan ni se vinculan con el SDK de Voz. Debe instalar algunas dependencias y complementos.

Debe instalar varias dependencias y complementos.

sudo apt install libgstreamer1.0-0 \
gstreamer1.0-plugins-base \
gstreamer1.0-plugins-good \
gstreamer1.0-plugins-bad \
gstreamer1.0-plugins-ugly

Para obtener más información, consulte Instrucciones de instalación de Linux y distribuciones de Linux admitidas y arquitecturas de destino.

Ejemplo

Para configurar el SDK de Voz para aceptar la entrada de audio comprimida, cree un PullAudioInputStream o un PushAudioInputStream. A continuación, cree un AudioConfig a partir de una instancia de su clase de flujo que especifique el formato de compresión del flujo.

En el ejemplo siguiente, supongamos que el caso de uso es usar PushStream para un archivo comprimido.


package recognizer

import (
  "fmt"
  "time"
    "strings"

  "github.com/Microsoft/cognitive-services-speech-sdk-go/audio"
  "github.com/Microsoft/cognitive-services-speech-sdk-go/speech"
  "github.com/Microsoft/cognitive-services-speech-sdk-go/samples/helpers"
)

func RecognizeOnceFromCompressedFile(subscription string, region string, file string) {
  var containerFormat audio.AudioStreamContainerFormat
  if strings.Contains(file, ".mulaw") {
    containerFormat = audio.MULAW
  } else if strings.Contains(file, ".alaw") {
    containerFormat = audio.ALAW
  } else if strings.Contains(file, ".mp3") {
    containerFormat = audio.MP3
  } else if strings.Contains(file, ".flac") {
    containerFormat = audio.FLAC
  } else if strings.Contains(file, ".opus") {
    containerFormat = audio.OGGOPUS
  } else {
    containerFormat = audio.ANY
  }
  format, err := audio.GetCompressedFormat(containerFormat)
  if err != nil {
    fmt.Println("Got an error: ", err)
    return
  }
  defer format.Close()
  stream, err := audio.CreatePushAudioInputStreamFromFormat(format)
  if err != nil {
    fmt.Println("Got an error: ", err)
    return
  }
  defer stream.Close()
  audioConfig, err := audio.NewAudioConfigFromStreamInput(stream)
  if err != nil {
    fmt.Println("Got an error: ", err)
    return
  }
  defer audioConfig.Close()
  config, err := speech.NewSpeechConfigFromSubscription(subscription, region)
  if err != nil {
    fmt.Println("Got an error: ", err)
    return
  }
  defer config.Close()
  speechRecognizer, err := speech.NewSpeechRecognizerFromConfig(config, audioConfig)
  if err != nil {
    fmt.Println("Got an error: ", err)
    return
  }
  defer speechRecognizer.Close()
  speechRecognizer.SessionStarted(func(event speech.SessionEventArgs) {
    defer event.Close()
    fmt.Println("Session Started (ID=", event.SessionID, ")")
  })
  speechRecognizer.SessionStopped(func(event speech.SessionEventArgs) {
    defer event.Close()
    fmt.Println("Session Stopped (ID=", event.SessionID, ")")
  })
  helpers.PumpFileIntoStream(file, stream)
  task := speechRecognizer.RecognizeOnceAsync()
  var outcome speech.SpeechRecognitionOutcome
  select {
  case outcome = <-task:
  case <-time.After(40 * time.Second):
    fmt.Println("Timed out")
    return
  }
  defer outcome.Close()
  if outcome.Error != nil {
    fmt.Println("Got an error: ", outcome.Error)
  }
  fmt.Println("Got a recognition!")
  fmt.Println(outcome.Result.Text)
}

Documentación de referencia | Paquete (descargar) | Muestras adicionales en GitHub

El SDK de Voz para Objective-C no admite audio comprimido.

El formato de streaming de audio predeterminado es WAV (16 kHz o 8 kHz, 16 bits y PCM mono). Para introducir un archivo de audio comprimido (como mp3), primero debe convertirlo a un archivo WAV en el formato de entrada predeterminado. Para transmitir audio comprimido, primero debe descodificar los búferes de audio en el formato de entrada predeterminado. Para obtener más información, consulte Uso de la secuencia de entrada de audio.

El SDK de Voz y la CLI de Voz usan GStreamer para admitir diferentes tipos de formatos de audio de entrada. GStreamer descomprime el audio antes de enviarlo a través de la conexión al servicio de voz como PCM sin procesar.

El formato de streaming de audio predeterminado es WAV (16 kHz o 8 kHz, 16 bits y PCM mono). Fuera de WAV y PCM, los siguientes formatos de entrada comprimidos también se admiten a través de GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW en el contenedor WAV
  • MULAW en el contenedor WAV
  • ANY para el contenedor MP4 o formato multimedia no reconocido

Configuración de GStreamer

La CLI de Voz puede usar GStreamer para controlar el audio comprimido. Por motivos de licencia, los archivos binarios de GStreamer no se compilan ni se vinculan con la CLI de Voz. Debe instalar algunas dependencias y complementos.

Los archivos binarios de GStreamer deben estar en la ruta de acceso del sistema para que la CLI de Voz pueda cargarlos en tiempo de ejecución. Por ejemplo, en Windows, si la CLI de Voz encuentra libgstreamer-1.0-0.dll o gstreamer-1.0-0.dll (para la versión más reciente de GStreamer) durante el tiempo de ejecución, significa que los archivos binarios de GStreamer están en la ruta del sistema.

Elija una plataforma para obtener instrucciones de instalación.

Debe instalar varias dependencias y complementos.

sudo apt install libgstreamer1.0-0 \
gstreamer1.0-plugins-base \
gstreamer1.0-plugins-good \
gstreamer1.0-plugins-bad \
gstreamer1.0-plugins-ugly

Para obtener más información, consulte Instrucciones de instalación de Linux y distribuciones de Linux admitidas y arquitecturas de destino.

Ejemplo

La --format opción especifica el formato de contenedor para el archivo de audio que se reconoce. Para un archivo mp4, establezca el formato any en como se muestra en el siguiente comando:

spx recognize --file YourAudioFile.mp4 --format any

Para obtener una lista de formatos de audio admitidos, ejecute el siguiente comando:

spx help recognize format

Documentación de referencia | Paquete (descargar) | Muestras adicionales en GitHub

El SDK de Voz para Swift no admite audio comprimido.

El formato de streaming de audio predeterminado es WAV (16 kHz o 8 kHz, 16 bits y PCM mono). Para introducir un archivo de audio comprimido (como mp3), primero debe convertirlo a un archivo WAV en el formato de entrada predeterminado. Para transmitir audio comprimido, primero debe descodificar los búferes de audio en el formato de entrada predeterminado. Para obtener más información, consulte Uso de la secuencia de entrada de audio.

Pasos siguientes

  • Last updated on