Utiliser une entrée audio compressée par codec avec le SDK SpeechUse codec compressed audio input with the Speech SDK

L’API Compressed Audio Input Stream du SDK du service Speech permet de diffuser en streaming du contenu audio compressé vers le service Speech à l’aide d’un PullStream ou d’un PushStream.The Speech service SDK Compressed Audio Input Stream API provides a way to stream compressed audio to the Speech service using either a PullStream or PushStream.

PlateformePlatform LanguagesLanguages Version de GStreamer prise en chargeSupported GStreamer version
Windows (sauf UWP)Windows (excluding UWP) C++, C#, Java, PythonC++, C#, Java, Python 1.18.31.18.3
LinuxLinux C++, C#, Java, PythonC++, C#, Java, Python architectures cibles et distributions Linux prises en chargesupported Linux distributions and target architectures
AndroidAndroid JavaJava 1.18.31.18.3

Version du SDK Speech requise pour l’entrée audio compresséeSpeech SDK version required for compressed audio input

  • Le Kit de développement logiciel (SDK) Speech version 1.10.0 ou ultérieure est requis pour RHEL 8 et CentOS 8.Speech SDK version 1.10.0 or later is required for RHEL 8 and CentOS 8
  • Le Kit de développement logiciel (SDK) Speech version 1.11.0 ou ultérieure est requis pour Windows.Speech SDK version 1.11.0 or later is required for for Windows.
  • Le Kit de développement logiciel (SDK) Speech version 1.16.0 ou ultérieure pour la version la plus récente de GStreamer sur Windows et Android.Speech SDK version 1.16.0 or later for latest gstreamer on Windows and Android.

Le format de streaming audio par défaut est WAV (16 kHz ou 8 kHz, 16 bits et PCM Mono).The default audio streaming format is WAV (16 kHz or 8 kHz, 16-bit, and mono PCM). En plus de WAV/PCM, les formats d’entrées compressées listés ci-dessous sont également pris en charge à l’aide de GStreamer.Outside of WAV / PCM, the compressed input formats listed below are also supported using GStreamer.

  • MP3MP3
  • OPUS/OGGOPUS/OGG
  • FLACFLAC
  • ALAW dans un conteneur wavALAW in wav container
  • MULAW dans un conteneur wavMULAW in wav container
  • ANY (pour le scénario où le format du média n’est pas connu)ANY (For the scenario where the media format is not known)

GStreamer requis pour gérer l’audio compresséGStreamer required to handle compressed audio

La gestion d'un contenu audio compressé est implémentée à l’aide de GStreamer.Handling compressed audio is implemented using GStreamer. Pour une raison liée à la gestion des licences, les fichiers binaires GStreamer ne sont pas compilés et liés avec le Kit de développement logiciel (SDK) Speech.For licensing reasons GStreamer binaries are not compiled and linked with the Speech SDK. Les développeurs doivent installer plusieurs dépendances et plug-ins. Voir Installation sur Windows ou Installation sur Linux.Developers need to install several dependencies and plugins, see Installing on Windows or Installing on Linux. Les fichiers binaires GStreamer doivent se trouver sous le chemin d’accès système afin que le Kit de développement logiciel (SDK) Speech puisse les charger lors de l’exécution du runtime.GStreamer binaries need to be in the system path, so that the Speech SDK can load the binaries during runtime. Par exemple, sur Windows, si le Kit de développement logiciel (SDK) Speech est en mesure de trouver libgstreamer-1.0-0.dll ou gstreamer-1.0-0.dll (pour la version la plus récente de GStreamer) lors de l’exécution, cela signifie que les fichiers binaires GStreamer se trouvent sous le chemin d’accès système.For example, on Windows, if the Speech SDK is able to find libgstreamer-1.0-0.dll or gstreamer-1.0-0.dll (for latest gstreamer) during runtime, it means the gstreamer binaries are in the system path.

La gestion d'un contenu audio compressé est implémentée à l’aide de GStreamer.Handling compressed audio is implemented using GStreamer. Pour une raison liée à la gestion des licences, les fichiers binaires GStreamer ne sont pas compilés et liés avec le Kit de développement logiciel (SDK) Speech.For licensing reasons GStreamer binaries are not compiled and linked with the Speech SDK. Les développeurs doivent installer plusieurs dépendances et plug-ins.Developers need to install several dependencies and plugins.

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

La gestion d'un contenu audio compressé est implémentée à l’aide de GStreamer.Handling compressed audio is implemented using GStreamer. Pour une raison liée à la gestion des licences, les fichiers binaires GStreamer ne sont pas compilés et liés avec le Kit de développement logiciel (SDK) Speech.For licensing reasons GStreamer binaries are not compiled and linked with the Speech SDK. À la place, vous devez utiliser les fichiers binaires prédéfinis pour Android.Instead, you'll need to use the prebuilt binaries for Android. Pour télécharger les bibliothèques prédéfinies, voir Installation pour le développement Android.To download the prebuilt libraries, see installing for Android development.

libgstreamer_android.so est obligatoire.libgstreamer_android.so is required. Assurez-vous que tous les plug-ins GStreamer (à partir du fichier Android.mk ci-dessous) sont liés dans libgstreamer_android.so.Make sure that all the GStreamer plugins (from Android.mk file below) are linked in libgstreamer_android.so. Lorsque vous utilisez le dernier Kit de développement logiciel (SDK) Speech (1.16.0 et versions ultérieures) avec GStreamer version 1.18.3, libc++_shared.so doit également être présent à partir d’Android NDK.When using the latest speech SDK (1.16.0 and above) with gstreamer version 1.18.3, libc++_shared.so is also required to be present from android ndk.

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

Vous trouverez ci-dessous des exemples de fichiers Android.mk et Application.mk.An example Android.mk and Application.mk file are provided below. Pour créer l’objet partagé gstreamer, procédez comme suit :libgstreamer_android.so.Follow these steps to create the gstreamer shared object: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 16.04 ou 18.04.You can build libgstreamer_android.so using the following command on Ubuntu 16.04 or 18.04. Les lignes de commande suivantes ont été testées seulement pour GSstreamer Android version 1.14.4 avec Android NDK b16b.The following command lines have only been tested for GStreamer Android version 1.14.4 with Android NDK b16b.

# Assuming wget and unzip 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/data/pkg/android/1.14.4/gstreamer-1.0-android-universal-1.14.4.tar.bz2
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 créé, le développeur doit le placer dans l’application Android afin que le SDK Speech puisse le charger.Once the shared object (libgstreamer_android.so) is built application developer needs to place the shared object in the Android app, so that it can be loaded by speech SDK.

La gestion d'un contenu audio compressé est implémentée à l’aide de GStreamer.Handling compressed audio is implemented using GStreamer. Pour une raison liée à la gestion des licences, les fichiers binaires GStreamer ne sont pas compilés et liés avec le Kit de développement logiciel (SDK) Speech.For licensing reasons GStreamer binaries are not compiled and linked with the Speech SDK. Les développeurs doivent installer plusieurs dépendances et plug-ins. Voir Installation sur Windows ou Installation sur Linux.Developers need to install several dependencies and plugins, see Installing on Windows or Installing on Linux. Les fichiers binaires GStreamer doivent se trouver sous le chemin d’accès système afin que le Kit de développement logiciel (SDK) Speech puisse les charger lors de l’exécution du runtime.GStreamer binaries need to be in the system path, so that the Speech SDK can load the binaries during runtime. Par exemple, sur Windows, si le Kit de développement logiciel (SDK) Speech est en mesure de trouver libgstreamer-1.0-0.dll lors de l’exécution, cela signifie que les fichiers binaires GStreamer se trouvent sous le chemin d’accès système.For example, on Windows, if the Speech SDK is able to find libgstreamer-1.0-0.dll during runtime, it means the gstreamer binaries are in the system path.

Exemple de code utilisant une entrée audio compressé par codecExample code using codec compressed audio input

Pour configurer le SDK Speech afin d’accepter l’entrée audio compressée, créez PullAudioInputStream ou PushAudioInputStream.To configure Speech SDK to accept compressed audio input, create PullAudioInputStream or PushAudioInputStream. Ensuite, créez un AudioConfig à partir d’une instance de votre classe de flux en spécifiant le format de compression du flux.Then, create an AudioConfig from an instance of your stream class, specifying the compression format of the stream.

Supposons que vous disposez d’une classe de flux d’entrée appelée pushStream et que vous utilisez OPUS/OGG.Let's assume that you have an input stream class called pushStream and are using OPUS/OGG. Voici à quoi peut ressembler votre code :Your code may look like this:

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 audioFormat =
    AudioStreamFormat.GetCompressedFormat(
        AudioStreamContainerFormat.OGG_OPUS);
var audioConfig =
    AudioConfig.FromStreamInput(
        pushStream,
        audioFormat);

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

var text = result.Text;

Pour configurer le SDK Speech afin d’accepter l’entrée audio compressée, créez PullAudioInputStream ou PushAudioInputStream.To configure Speech SDK to accept compressed audio input, create PullAudioInputStream or PushAudioInputStream. Ensuite, créez un AudioConfig à partir d’une instance de votre classe de flux en spécifiant le format de compression du flux.Then, create an AudioConfig from an instance of your stream class, specifying the compression format of the stream.

Supposons que vous disposez d’une classe de flux d’entrée appelée pushStream et que vous utilisez OPUS/OGG.Let's assume that you have an input stream class called pushStream and are using OPUS/OGG. Voici à quoi peut ressembler votre code :Your code may look like this:

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

// ... omitted for brevity

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

auto audioFormat =
    AudioStreamFormat::GetCompressedFormat(
        AudioStreamContainerFormat::OGG_OPUS
    );
auto audioConfig =
    AudioConfig::FromStreamInput(
        pushStream,
        audioFormat
    );

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

auto text = result->Text;

Pour configurer le SDK Speech afin d’accepter l’entrée audio compressée, créez PullAudioInputStream ou PushAudioInputStream.To configure Speech SDK to accept compressed audio input, create a PullAudioInputStream or PushAudioInputStream. Ensuite, créez un AudioConfig à partir d’une instance de votre classe de flux en spécifiant le format de compression du flux.Then, create an AudioConfig from an instance of your stream class, specifying the compression format of the stream.

Supposons que vous disposez d’une classe de flux d’entrée appelée pullStream et que vous utilisez OPUS/OGG.Let's assume that you have an input stream class called pullStream and are using OPUS/OGG. Voici à quoi peut ressembler votre code :Your code may look like this:

import com.microsoft.cognitiveservices.speech.audio.AudioConfig;
import com.microsoft.cognitiveservices.speech.audio.AudioInputStream;
import com.microsoft.cognitiveservices.speech.audio.AudioStreamFormat;
import com.microsoft.cognitiveservices.speech.audio.PullAudioInputStream;
import com.microsoft.cognitiveservices.speech.internal.AudioStreamContainerFormat;

// ... omitted for brevity

SpeechConfig speechConfig =
    SpeechConfig.fromSubscription(
        "YourSubscriptionKey",
        "YourServiceRegion");

// Create an audio config specifying the compressed
// audio format and the instance of your input stream class.
AudioStreamFormat audioFormat = 
    AudioStreamFormat.getCompressedFormat(
        AudioStreamContainerFormat.OGG_OPUS);
AudioConfig audioConfig =
    AudioConfig.fromStreamInput(
        pullStream,
        audioFormat);

SpeechRecognizer recognizer = new SpeechRecognizer(speechConfig, audioConfig);
SpeechRecognitionResult result = recognizer.recognizeOnceAsync().get();

String text = result.getText();

Pour configurer le SDK Speech afin d’accepter l’entrée audio compressée, créez PullAudioInputStream ou PushAudioInputStream.To configure Speech SDK to accept compressed audio input, create PullAudioInputStream or PushAudioInputStream. Ensuite, créez un AudioConfig à partir d’une instance de votre classe de flux en spécifiant le format de compression du flux.Then, create an AudioConfig from an instance of your stream class, specifying the compression format of the stream.

Supposons que votre cas d’usage consiste à utiliser PullStream pour un fichier MP3.Let's assume that your use case is to use PullStream for an MP3 file. Voici à quoi peut ressembler votre code :Your code may look like this:


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()
    # </SpeechContinuousRecognitionWithFile>

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)

Étapes suivantesNext steps