A codec tömörített hangbemenetének használata a Speech SDK-valUse codec compressed audio input with the Speech SDK

A Speech Service SDK tömörített hangbemeneti stream API lehetővé teszi a tömörített hang továbbítását a beszédfelismerési szolgáltatásba vagy a vagy a használatával PullStream 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.

PlatformPlatform NyelvekLanguages Támogatott GStreamer-verzióSupported GStreamer version
Windows (UWP nélkül)Windows (excluding UWP) C++, C#, Java, PythonC++, C#, Java, Python 1.18.31.18.3
LinuxLinux C++, C#, Java, PythonC++, C#, Java, Python támogatott Linux-disztribúciók és-megcélzott architektúráksupported Linux distributions and target architectures
AndroidAndroid JavaJava 1.18.31.18.3

A tömörített hangbemenethez szükséges Speech SDK-verzióSpeech SDK version required for compressed audio input

  • A Speech SDK 1.10.0 vagy újabb verziójára van szükség a RHEL 8 és a CentOS 8 esetébenSpeech SDK version 1.10.0 or later is required for RHEL 8 and CentOS 8
  • A Windows rendszerhez a Speech SDK 1.11.0 vagy újabb verziója szükséges.Speech SDK version 1.11.0 or later is required for for Windows.
  • A Windows és az Android rendszerhez készült legújabb GStreamer a Speech SDK 1.16.0 vagy újabb verziója.Speech SDK version 1.16.0 or later for latest gstreamer on Windows and Android.

Az alapértelmezett hang-adatfolyam formátuma a WAV (16 kHz vagy 8 kHz, 16 bites és monó PCM).The default audio streaming format is WAV (16 kHz or 8 kHz, 16-bit, and mono PCM). A WAV/PCM-en kívül az alább felsorolt tömörített bemeneti formátumok is támogatottak a GStreamer használatával.Outside of WAV / PCM, the compressed input formats listed below are also supported using GStreamer.

  • MP3MP3
  • OPUS/OGGOPUS/OGG
  • FLACFLAC
  • ATÖRVÉNY a WAV-tárolóbanALAW in wav container
  • MULAW a WAV-tárolóbanMULAW in wav container
  • BÁRMELY (a forgatókönyv esetében, ahol a média formátuma nem ismert)ANY (For the scenario where the media format is not known)

A tömörített hang kezeléséhez szükséges GStreamerGStreamer required to handle compressed audio

A tömörített hang kezelésére a GStreamerhasználatával kerül sor.Handling compressed audio is implemented using GStreamer. Licencelési okokból a GStreamer bináris fájlok nincsenek lefordítva és csatolva a Speech SDK-hoz.For licensing reasons GStreamer binaries are not compiled and linked with the Speech SDK. A fejlesztőknek több függőséget és beépülő modult kell telepíteniük, lásd: telepítés Windows rendszeren vagy Linux rendszeren való telepítés.Developers need to install several dependencies and plugins, see Installing on Windows or Installing on Linux. A GStreamer bináris fájljainak a rendszer elérési útjában kell lenniük, így a beszédfelismerési SDK a futásidejű környezetekben is betöltheti a bináris fájlokat.GStreamer binaries need to be in the system path, so that the Speech SDK can load the binaries during runtime. Windows rendszeren például, ha a Speech SDK képes megtalálni libgstreamer-1.0-0.dll vagy gstreamer-1.0-0.dll (a legújabb GStreamer) a futtatókörnyezet során, az azt jelenti, hogy a GStreamer bináris fájljai a rendszer elérési útjában vannak.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.

A tömörített hang kezelésére a GStreamerhasználatával kerül sor.Handling compressed audio is implemented using GStreamer. Licencelési okokból a GStreamer bináris fájlok nincsenek lefordítva és csatolva a Speech SDK-hoz.For licensing reasons GStreamer binaries are not compiled and linked with the Speech SDK. A fejlesztőknek több függőséget és beépülő modult kell telepíteniük.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

A tömörített hang kezelésére a GStreamerhasználatával kerül sor.Handling compressed audio is implemented using GStreamer. Licencelési okokból a GStreamer bináris fájlok nincsenek lefordítva és csatolva a Speech SDK-hoz.For licensing reasons GStreamer binaries are not compiled and linked with the Speech SDK. Ehelyett az Androidhoz készült előre elkészített bináris fájlokat kell használnia.Instead, you'll need to use the prebuilt binaries for Android. Az előre elkészített kódtárak letöltéséhez lásd: telepítés Android-fejlesztéshez.To download the prebuilt libraries, see installing for Android development.

A libgstreamer_android.so használata kötelező.libgstreamer_android.so is required. Győződjön meg arról, hogy az összes GStreamer beépülő modul (az alábbi Android.mk-fájlból) össze van kapcsolva libgstreamer_android.so .Make sure that all the GStreamer plugins (from Android.mk file below) are linked in libgstreamer_android.so. Ha a legújabb Speech SDK-t (1.16.0 és újabb verziót) használja a GStreamer-verzió 1.18.3, libc++_shared.so az Android-NDK is be kell jelentkeznie.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

Alább látható egy példa Android.mk és egy Application.mk fájl.An example Android.mk and Application.mk file are provided below. A megosztott objektum létrehozásához kövesse az alábbi lépéseket gstreamer : 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

libgstreamer_android.soAz Ubuntu 16,04-es vagy a 18,04-es verziójában a következő paranccsal hozhat létre.You can build libgstreamer_android.so using the following command on Ubuntu 16.04 or 18.04. A következő parancssorok csak a GStreamer Android-verzió 1.14.4 lettek tesztelve 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)

Miután a megosztott objektum () létrehozta az libgstreamer_android.so alkalmazás fejlesztőjét, el kell helyeznie a megosztott objektumot az Android-alkalmazásban, hogy a SPEECH SDK tudja betölteni.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.

A tömörített hang kezelésére a GStreamerhasználatával kerül sor.Handling compressed audio is implemented using GStreamer. Licencelési okokból a GStreamer bináris fájlok nincsenek lefordítva és csatolva a Speech SDK-hoz.For licensing reasons GStreamer binaries are not compiled and linked with the Speech SDK. A fejlesztőknek több függőséget és beépülő modult kell telepíteniük, lásd: telepítés Windows rendszeren vagy Linux rendszeren való telepítés.Developers need to install several dependencies and plugins, see Installing on Windows or Installing on Linux. A GStreamer bináris fájljainak a rendszer elérési útjában kell lenniük, így a beszédfelismerési SDK a futásidejű környezetekben is betöltheti a bináris fájlokat.GStreamer binaries need to be in the system path, so that the Speech SDK can load the binaries during runtime. Windows rendszeren például, ha a Speech SDK képes megtalálni a libgstreamer-1.0-0.dll futtatókörnyezetet, az azt jelenti, hogy a GStreamer bináris fájlok a rendszer elérési útjában vannak.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.

Kód tömörített hangbemenetet használó programkódExample code using codec compressed audio input

A Speech SDK konfigurálása a tömörített hangbemenetek fogadására, létrehozás PullAudioInputStream vagy PushAudioInputStream .To configure Speech SDK to accept compressed audio input, create PullAudioInputStream or PushAudioInputStream. Ezután hozzon létre egy AudioConfig példányt a stream osztály egy példányáról, és adja meg az adatfolyam tömörítési formátumát.Then, create an AudioConfig from an instance of your stream class, specifying the compression format of the stream.

Tegyük fel, hogy rendelkezik egy nevű bemeneti stream-osztállyal pushStream , és az Opus/OGG-t használja.Let's assume that you have an input stream class called pushStream and are using OPUS/OGG. A kód így néz ki: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;

A Speech SDK konfigurálása a tömörített hangbemenetek fogadására, létrehozás PullAudioInputStream vagy PushAudioInputStream .To configure Speech SDK to accept compressed audio input, create PullAudioInputStream or PushAudioInputStream. Ezután hozzon létre egy AudioConfig példányt a stream osztály egy példányáról, és adja meg az adatfolyam tömörítési formátumát.Then, create an AudioConfig from an instance of your stream class, specifying the compression format of the stream.

Tegyük fel, hogy rendelkezik egy nevű bemeneti stream-osztállyal pushStream , és az Opus/OGG-t használja.Let's assume that you have an input stream class called pushStream and are using OPUS/OGG. A kód így néz ki: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;

A Speech SDK a tömörített hangbemenetek fogadására való konfigurálásához hozzon létre egy PullAudioInputStream vagy PushAudioInputStream .To configure Speech SDK to accept compressed audio input, create a PullAudioInputStream or PushAudioInputStream. Ezután hozzon létre egy AudioConfig példányt a stream osztály egy példányáról, és adja meg az adatfolyam tömörítési formátumát.Then, create an AudioConfig from an instance of your stream class, specifying the compression format of the stream.

Tegyük fel, hogy rendelkezik egy nevű bemeneti stream-osztállyal pullStream , és az Opus/OGG-t használja.Let's assume that you have an input stream class called pullStream and are using OPUS/OGG. A kód így néz ki: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();

A Speech SDK konfigurálása a tömörített hangbemenetek fogadására, létrehozás PullAudioInputStream vagy PushAudioInputStream .To configure Speech SDK to accept compressed audio input, create PullAudioInputStream or PushAudioInputStream. Ezután hozzon létre egy AudioConfig példányt a stream osztály egy példányáról, és adja meg az adatfolyam tömörítési formátumát.Then, create an AudioConfig from an instance of your stream class, specifying the compression format of the stream.

Tegyük fel, hogy a használati eset PullStream egy MP3 fájlhoz való használata.Let's assume that your use case is to use PullStream for an MP3 file. A kód így néz ki: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)

Következő lépésekNext steps