Partager via

Utilisation de l’audio d’entrée compressée

  • Article

Documentation de référence | Package (NuGet) | Exemples supplémentaires sur GitHub

Le kit de développement logiciel (SDK, Software Development Kit) Speech et l’interface de ligne de commande Speech utilisent GStreamer pour prendre en charge différents types de formats audio d’entrée. GStreamer décompresse l’audio avant de l’envoyer sur le réseau au service Speech sous forme de PCM brut.

Le format de streaming audio par défaut est WAV (16 kHz ou 8 kHz, 16 bits et PCM Mono). En dehors de WAV et PCM, les formats d’entrée compressés suivants sont également pris en charge par GStreamer :

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW dans un conteneur WAV
  • MULAW dans un conteneur WAV
  • ANY pour le conteneur MP4 ou le format multimédia inconnu

Configuration de GStreamer

Le SDK Speech peut utiliser GStreamer pour gérer l’audio compressé. Pour des raisons liées à la gestion des licences, les fichiers binaires GStreamer ne sont pas compilés et liés au SDK Speech. Vous devez installer plusieurs dépendances et plug-ins.

Les fichiers binaires GStreamer doivent se trouver dans le chemin du système afin qu’ils puissent être chargés par SDK Speech au moment de l’exécution. Par exemple, sur Windows, si le SDK Speech trouve libgstreamer-1.0-0.dll ou gstreamer-1.0-0.dll (pour la version la plus récente de GStreamer) pendant l’exécution, cela signifie que les fichiers binaires GStreamer se trouvent dans le chemin système.

Choisissez une plateforme pour obtenir des instructions d’installation.

Vous devez installer plusieurs dépendances et plug-ins.

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

Pour plus d’informations, consultez les instructions d’installation de Linuxet les distributions Linux prises en charge et les architectures cibles.

Exemple

Pour configurer le SDK Speech afin d’accepter l’entrée audio compressée, créez PullAudioInputStream ou PushAudioInputStream. Ensuite, créez un AudioConfig à partir d’une instance de votre classe de flux qui spécifie le format de compression du flux. Recherchez des exemples d’extraits de code connexes dans À propos de l’API de flux d’entrée audio du Kit de développement logiciel (SDK) Speech.

Supposons que vous disposez d’une classe de flux d’entrée appelée pullStream et que vous utilisez OPUS/OGG. Votre code peut se présenter comme suit :

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

// ... omitted for brevity

var speechConfig =
    SpeechConfig.FromSubscription(
        "YourSubscriptionKey",
        "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;

Documentation de référence | Package (NuGet) | Exemples supplémentaires sur GitHub

Le kit de développement logiciel (SDK, Software Development Kit) Speech et l’interface de ligne de commande Speech utilisent GStreamer pour prendre en charge différents types de formats audio d’entrée. GStreamer décompresse l’audio avant de l’envoyer sur le réseau au service Speech sous forme de PCM brut.

Le format de streaming audio par défaut est WAV (16 kHz ou 8 kHz, 16 bits et PCM Mono). En dehors de WAV et PCM, les formats d’entrée compressés suivants sont également pris en charge par GStreamer :

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW dans un conteneur WAV
  • MULAW dans un conteneur WAV
  • ANY pour le conteneur MP4 ou le format multimédia inconnu

Configuration de GStreamer

Le SDK Speech peut utiliser GStreamer pour gérer l’audio compressé. Pour des raisons liées à la gestion des licences, les fichiers binaires GStreamer ne sont pas compilés et liés au SDK Speech. Vous devez installer plusieurs dépendances et plug-ins.

Les fichiers binaires GStreamer doivent se trouver dans le chemin du système afin qu’ils puissent être chargés par SDK Speech au moment de l’exécution. Par exemple, sur Windows, si le SDK Speech trouve libgstreamer-1.0-0.dll ou gstreamer-1.0-0.dll (pour la version la plus récente de GStreamer) pendant l’exécution, cela signifie que les fichiers binaires GStreamer se trouvent dans le chemin système.

Choisissez une plateforme pour obtenir des instructions d’installation.

Vous devez installer plusieurs dépendances et plug-ins.

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

Pour plus d’informations, consultez les instructions d’installation de Linuxet les distributions Linux prises en charge et les architectures cibles.

Exemple

Pour configurer le SDK Speech afin d’accepter l’entrée audio compressée, créez PullAudioInputStream ou PushAudioInputStream. Ensuite, créez un AudioConfig à partir d’une instance de votre classe de flux qui spécifie le format de compression du flux. Recherchez un exemple de code connexe dans Exemple de kits SDK Speech.

Supposons que vous disposez d’une classe de flux d’entrée appelée pushStream et que vous utilisez OPUS/OGG. Votre code peut se présenter comme suit :

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

// ... omitted for brevity

 auto config =
    SpeechConfig::FromSubscription(
        "YourSubscriptionKey",
        "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;

Documentation de référence | Package (Go) | Exemples supplémentaires sur GitHub

Le kit de développement logiciel (SDK, Software Development Kit) Speech et l’interface de ligne de commande Speech utilisent GStreamer pour prendre en charge différents types de formats audio d’entrée. GStreamer décompresse l’audio avant de l’envoyer sur le réseau au service Speech sous forme de PCM brut.

Le format de streaming audio par défaut est WAV (16 kHz ou 8 kHz, 16 bits et PCM Mono). En dehors de WAV et PCM, les formats d’entrée compressés suivants sont également pris en charge par GStreamer :

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW dans un conteneur WAV
  • MULAW dans un conteneur WAV
  • ANY pour le conteneur MP4 ou le format multimédia inconnu

Configuration de GStreamer

Le SDK Speech peut utiliser GStreamer pour gérer l’audio compressé. Pour des raisons liées à la gestion des licences, les fichiers binaires GStreamer ne sont pas compilés et liés au SDK Speech. Vous devez installer plusieurs dépendances et plug-ins.

Vous devez installer plusieurs dépendances et plug-ins.

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

Pour plus d’informations, consultez les instructions d’installation de Linuxet les distributions Linux prises en charge et les architectures cibles.

Exemple

Pour configurer le SDK Speech afin d’accepter l’entrée audio compressée, créez PullAudioInputStream ou PushAudioInputStream. Ensuite, créez un AudioConfig à partir d’une instance de votre classe de flux qui spécifie le format de compression du flux.

Dans l’exemple suivant, supposons que votre cas d’utilisation consiste à utiliser PushStream pour un fichier compressé.


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)
}

Documentation de référence | Exemples supplémentaires sur GitHub

Le kit de développement logiciel (SDK, Software Development Kit) Speech et l’interface de ligne de commande Speech utilisent GStreamer pour prendre en charge différents types de formats audio d’entrée. GStreamer décompresse l’audio avant de l’envoyer sur le réseau au service Speech sous forme de PCM brut.

Le format de streaming audio par défaut est WAV (16 kHz ou 8 kHz, 16 bits et PCM Mono). En dehors de WAV et PCM, les formats d’entrée compressés suivants sont également pris en charge par GStreamer :

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW dans un conteneur WAV
  • MULAW dans un conteneur WAV
  • ANY pour le conteneur MP4 ou le format multimédia inconnu

Configuration de GStreamer

Le SDK Speech peut utiliser GStreamer pour gérer l’audio compressé. Pour des raisons liées à la gestion des licences, les fichiers binaires GStreamer ne sont pas compilés et liés au SDK Speech. Vous devez installer plusieurs dépendances et plug-ins.

Les fichiers binaires GStreamer doivent se trouver dans le chemin du système afin qu’ils puissent être chargés par SDK Speech au moment de l’exécution. Par exemple, sur Windows, si le SDK Speech trouve libgstreamer-1.0-0.dll ou gstreamer-1.0-0.dll (pour la version la plus récente de GStreamer) pendant l’exécution, cela signifie que les fichiers binaires GStreamer se trouvent dans le chemin système.

Choisissez une plateforme pour obtenir des instructions d’installation.

La gestion d’un contenu audio compressé est implémentée à l’aide de GStreamer. Pour des raisons liées à la gestion des licences, les fichiers binaires GStreamer ne sont pas compilés et liés au SDK Speech. À la place, vous devez utiliser les fichiers binaires prédéfinis pour Android. Pour télécharger les bibliothèques prédéfinies, consultez Installation pour le développement Android.

L’objet libgstreamer_android.so est obligatoire. Assurez-vous que tous les plug-ins GStreamer (figurant dans le fichier Android.mk qui suit) sont liés dans libgstreamer_android.so. Quand vous utilisez le SDK Speech avec la version 1.18.3 de GStreamer, Android NDK exige également la présence de libc++_shared.so.

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

Vous trouverez ici un exemple de fichiers Android.mk et Application.mk. Pour créer l’objet partagé gstreamer, procédez comme suit :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

Vous pouvez générer libgstreamer_android.so à l’aide de la commande suivante sur Ubuntu 18.04 ou 20.04. Les lignes de commande suivantes ont été testées seulement pour la [version 1.14.4 de GStreamer Android] avec 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)

Une fois l’objet partagé (libgstreamer_android.so) généré, placez-le dans l’application Android afin que le SDK Speech puisse le charger.

Exemple

Pour configurer le SDK Speech afin d’accepter l’entrée audio compressée, créez PullAudioInputStream ou PushAudioInputStream. Ensuite, créez un AudioConfig à partir d’une instance de votre classe de flux qui spécifie le format de compression du flux. Recherchez un exemple de code connexe dans Exemple de kits SDK Speech.

Supposez que vous disposez d’une classe de flux d’entrée appelée pullAudio et que vous utilisez MP3. Votre code peut se présenter comme suit :

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

Documentation de référence | Package (npm) | Exemples supplémentaires sur GitHub | Code source de la bibliothèque

Le SDK Speech pour JavaScript ne prend pas en charge l’audio compressé.

Le format de streaming audio par défaut est WAV (16 kHz ou 8 kHz, 16 bits et PCM Mono). Pour entrer un fichier audio compressé (par exemple, mp3), vous devez d’abord le convertir en fichier WAV au format d’entrée par défaut. Pour diffuser en continu l’audio compressé, vous devez d’abord décoder les mémoires tampons audio au format d’entrée par défaut. Pour plus d’informations, consultez Comment utiliser le flux d’entrée audio.

Documentation de référence | Package (téléchargement) | Exemples supplémentaires sur GitHub

Le SDK Speech pour Objective-C ne prend pas en charge l’audio compressé.

Le format de streaming audio par défaut est WAV (16 kHz ou 8 kHz, 16 bits et PCM Mono). Pour entrer un fichier audio compressé (par exemple, mp3), vous devez d’abord le convertir en fichier WAV au format d’entrée par défaut. Pour diffuser en continu l’audio compressé, vous devez d’abord décoder les mémoires tampons audio au format d’entrée par défaut. Pour plus d’informations, consultez Comment utiliser le flux d’entrée audio.

Documentation de référence | Package (téléchargement) | Exemples supplémentaires sur GitHub

Le SDK Speech pour Swift ne prend pas en charge l’audio compressé.

Le format de streaming audio par défaut est WAV (16 kHz ou 8 kHz, 16 bits et PCM Mono). Pour entrer un fichier audio compressé (par exemple, mp3), vous devez d’abord le convertir en fichier WAV au format d’entrée par défaut. Pour diffuser en continu l’audio compressé, vous devez d’abord décoder les mémoires tampons audio au format d’entrée par défaut. Pour plus d’informations, consultez Comment utiliser le flux d’entrée audio.

Documentation de référence | Package (PyPi) | Exemples supplémentaires sur GitHub

Le kit de développement logiciel (SDK, Software Development Kit) Speech et l’interface de ligne de commande Speech utilisent GStreamer pour prendre en charge différents types de formats audio d’entrée. GStreamer décompresse l’audio avant de l’envoyer sur le réseau au service Speech sous forme de PCM brut.

Le format de streaming audio par défaut est WAV (16 kHz ou 8 kHz, 16 bits et PCM Mono). En dehors de WAV et PCM, les formats d’entrée compressés suivants sont également pris en charge par GStreamer :

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW dans un conteneur WAV
  • MULAW dans un conteneur WAV
  • ANY pour le conteneur MP4 ou le format multimédia inconnu

Configuration de GStreamer

Le SDK Speech peut utiliser GStreamer pour gérer l’audio compressé. Pour des raisons liées à la gestion des licences, les fichiers binaires GStreamer ne sont pas compilés et liés au SDK Speech. Vous devez installer plusieurs dépendances et plug-ins.

Les fichiers binaires GStreamer doivent se trouver dans le chemin du système afin qu’ils puissent être chargés par SDK Speech au moment de l’exécution. Par exemple, sur Windows, si le SDK Speech trouve libgstreamer-1.0-0.dll ou gstreamer-1.0-0.dll (pour la version la plus récente de GStreamer) pendant l’exécution, cela signifie que les fichiers binaires GStreamer se trouvent dans le chemin système.

Choisissez une plateforme pour obtenir des instructions d’installation.

Vous devez installer plusieurs dépendances et plug-ins.

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

Pour plus d’informations, consultez les instructions d’installation de Linuxet les distributions Linux prises en charge et les architectures cibles.

Exemple

Pour configurer le SDK Speech afin d’accepter l’entrée audio compressée, créez PullAudioInputStream ou PushAudioInputStream. Ensuite, créez un AudioConfig à partir d’une instance de votre classe de flux qui spécifie le format de compression du flux.

Supposons que votre cas d’usage consiste à utiliser PullStream pour un fichier MP3. Votre code peut se présenter comme suit :


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)

Informations de référence sur l’API REST Reconnaissance vocale | Informations de référence sur l’API REST Reconnaissance vocale pour l’audio court | Exemples supplémentaires sur GitHub

Vous pouvez utiliser l’API REST pour l’audio compressé, mais nous n’avons pas encore inclus de guide ici. Sélectionnez un autre langage de programmation pour commencer et découvrir les concepts.

Le kit de développement logiciel (SDK, Software Development Kit) Speech et l’interface de ligne de commande Speech utilisent GStreamer pour prendre en charge différents types de formats audio d’entrée. GStreamer décompresse l’audio avant de l’envoyer sur le réseau au service Speech sous forme de PCM brut.

Le format de streaming audio par défaut est WAV (16 kHz ou 8 kHz, 16 bits et PCM Mono). En dehors de WAV et PCM, les formats d’entrée compressés suivants sont également pris en charge par GStreamer :

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW dans un conteneur WAV
  • MULAW dans un conteneur WAV
  • ANY pour le conteneur MP4 ou le format multimédia inconnu

Configuration de GStreamer

Le CLI Speech peut utiliser GStreamer pour gérer l’audio compressé. Pour des raisons liées à la gestion des licences, les fichiers binaires GStreamer ne sont pas compilés et liés au CLI Speech. Vous devez installer plusieurs dépendances et plug-ins.

Les fichiers binaires GStreamer doivent se trouver dans le chemin du système afin qu’ils puissent être chargés par le CLI Speech au moment de l’exécution. Par exemple, sur Windows, si le CLI Speech trouve libgstreamer-1.0-0.dll ou gstreamer-1.0-0.dll (pour la version la plus récente de GStreamer) pendant l’exécution, cela signifie que les fichiers binaires GStreamer se trouvent dans le chemin système.

Choisissez une plateforme pour obtenir des instructions d’installation.

Vous devez installer plusieurs dépendances et plug-ins.

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

Pour plus d’informations, consultez les instructions d’installation de Linuxet les distributions Linux prises en charge et les architectures cibles.

Exemple

L’option --format spécifie le format conteneur du fichier audio reconnu. Pour un fichier mp4, définissez le format any comme indiqué dans la commande suivante :

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

Pour obtenir la liste des formats audio pris en charge, exécutez la commande suivante :

spx help recognize format

Étapes suivantes