Jak používat komprimovaný vstupní zvuk

  • Článek

Referenční dokumentace | Package (NuGet) | Další ukázky na GitHubu

Sada Speech SDK a Speech CLI používají GStreamer k podpoře různých typů vstupních zvukových formátů. GStreamer dekomprimuje zvuk před odesláním přes drát do služby Speech jako nezpracovaný PCM.

Výchozí formát streamování zvuku je WAV (16 kHz nebo 8 kHz, 16bitový a mono PCM). Mimo WAV a PCM jsou prostřednictvím GStreameru podporovány také následující komprimované vstupní formáty:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW v kontejneru WAV
  • MULAW v kontejneru WAV
  • ANY pro kontejner MP4 nebo neznámý formát média

Konfigurace GStreameru

Sada Speech SDK může ke zpracování komprimovaného zvuku použít GStreamer . Z důvodů licencování nejsou binární soubory GStreamer kompilované a propojené se sadou Speech SDK. Je potřeba nainstalovat některé závislosti a moduly plug-in.

Binární soubory GStreamer musí být v systémové cestě, aby je mohl za běhu načíst sada Speech SDK. Pokud například sada Speech SDK najde libgstreamer-1.0-0.dll nebo gstreamer-1.0-0.dll (pro nejnovější GStreamer) během běhu, znamená to, že binární soubory GStreameru jsou v systémové cestě.

Zvolte platformu pro pokyny k instalaci.

Musíte nainstalovat několik závislostí a modulů plug-in.

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

Další informace najdete v pokynech k instalaci Linuxu a podporovaných distribucí Linuxu a cílových architekturách.

Příklad

Pokud chcete sadu Speech SDK nakonfigurovat tak, aby přijímala komprimovaný zvukový vstup, vytvořte PullAudioInputStream nebo PushAudioInputStream. Pak vytvořte AudioConfig z instance třídy streamu, která určuje formát komprese datového proudu. Vyhledejte související ukázkové fragmenty kódu v rozhraní API zvukového vstupu sady Speech SDK.

Předpokládejme, že máte volanou pullStream vstupní třídu streamu a používáte OPUS/OGG. Váš kód může vypadat takto:

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;

Referenční dokumentace | Package (NuGet) | Další ukázky na GitHubu

Sada Speech SDK a Speech CLI používají GStreamer k podpoře různých typů vstupních zvukových formátů. GStreamer dekomprimuje zvuk před odesláním přes drát do služby Speech jako nezpracovaný PCM.

Výchozí formát streamování zvuku je WAV (16 kHz nebo 8 kHz, 16bitový a mono PCM). Mimo WAV a PCM jsou prostřednictvím GStreameru podporovány také následující komprimované vstupní formáty:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW v kontejneru WAV
  • MULAW v kontejneru WAV
  • ANY pro kontejner MP4 nebo neznámý formát média

Konfigurace GStreameru

Sada Speech SDK může ke zpracování komprimovaného zvuku použít GStreamer . Z důvodů licencování nejsou binární soubory GStreamer kompilované a propojené se sadou Speech SDK. Je potřeba nainstalovat některé závislosti a moduly plug-in.

Binární soubory GStreamer musí být v systémové cestě, aby je mohl za běhu načíst sada Speech SDK. Pokud například sada Speech SDK najde libgstreamer-1.0-0.dll nebo gstreamer-1.0-0.dll (pro nejnovější GStreamer) během běhu, znamená to, že binární soubory GStreameru jsou v systémové cestě.

Zvolte platformu pro pokyny k instalaci.

Musíte nainstalovat několik závislostí a modulů plug-in.

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

Další informace najdete v pokynech k instalaci Linuxu a podporovaných distribucí Linuxu a cílových architekturách.

Příklad

Pokud chcete sadu Speech SDK nakonfigurovat tak, aby přijímala komprimovaný zvukový vstup, vytvořte PullAudioInputStream nebo PushAudioInputStream. Pak vytvořte AudioConfig z instance třídy streamu, která určuje formát komprese datového proudu. Vyhledání souvisejícího ukázkového kódu v ukázkách sady Speech SDK

Předpokládejme, že máte volanou pushStream vstupní třídu streamu a používáte OPUS/OGG. Váš kód může vypadat takto:

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;

Referenční dokumentace | Package (Go) | Další ukázky na GitHubu

Sada Speech SDK a Speech CLI používají GStreamer k podpoře různých typů vstupních zvukových formátů. GStreamer dekomprimuje zvuk před odesláním přes drát do služby Speech jako nezpracovaný PCM.

Výchozí formát streamování zvuku je WAV (16 kHz nebo 8 kHz, 16bitový a mono PCM). Mimo WAV a PCM jsou prostřednictvím GStreameru podporovány také následující komprimované vstupní formáty:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW v kontejneru WAV
  • MULAW v kontejneru WAV
  • ANY pro kontejner MP4 nebo neznámý formát média

Konfigurace GStreameru

Sada Speech SDK může ke zpracování komprimovaného zvuku použít GStreamer . Z důvodů licencování nejsou binární soubory GStreamer kompilované a propojené se sadou Speech SDK. Je potřeba nainstalovat některé závislosti a moduly plug-in.

Musíte nainstalovat několik závislostí a modulů plug-in.

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

Další informace najdete v pokynech k instalaci Linuxu a podporovaných distribucí Linuxu a cílových architekturách.

Příklad

Pokud chcete sadu Speech SDK nakonfigurovat tak, aby přijímala komprimovaný zvukový vstup, vytvořte PullAudioInputStream nebo PushAudioInputStream. Pak vytvořte AudioConfig z instance třídy streamu, která určuje formát komprese datového proudu.

V následujícím příkladu předpokládejme, že váš případ použití se používá PushStream pro komprimovaný soubor.


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

Referenční dokumentace | Další ukázky na GitHubu

Sada Speech SDK a Speech CLI používají GStreamer k podpoře různých typů vstupních zvukových formátů. GStreamer dekomprimuje zvuk před odesláním přes drát do služby Speech jako nezpracovaný PCM.

Výchozí formát streamování zvuku je WAV (16 kHz nebo 8 kHz, 16bitový a mono PCM). Mimo WAV a PCM jsou prostřednictvím GStreameru podporovány také následující komprimované vstupní formáty:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW v kontejneru WAV
  • MULAW v kontejneru WAV
  • ANY pro kontejner MP4 nebo neznámý formát média

Konfigurace GStreameru

Sada Speech SDK může ke zpracování komprimovaného zvuku použít GStreamer . Z důvodů licencování nejsou binární soubory GStreamer kompilované a propojené se sadou Speech SDK. Je potřeba nainstalovat některé závislosti a moduly plug-in.

Binární soubory GStreamer musí být v systémové cestě, aby je mohl za běhu načíst sada Speech SDK. Pokud například sada Speech SDK najde libgstreamer-1.0-0.dll nebo gstreamer-1.0-0.dll (pro nejnovější GStreamer) během běhu, znamená to, že binární soubory GStreameru jsou v systémové cestě.

Zvolte platformu pro pokyny k instalaci.

Zpracování komprimovaného zvuku se implementuje pomocí GStreameru. Z důvodů licencování nejsou binární soubory GStreamer kompilované a propojené se sadou Speech SDK. Místo toho musíte použít předem připravené binární soubory pro Android. Pokud si chcete stáhnout předem připravené knihovny, přečtěte si téma Instalace pro vývoj pro Android.

Objekt libgstreamer_android.so je povinný. Ujistěte se, že jsou všechny moduly plug-in GStreamer (z následujícího souboru Android.mk) propojeny v libgstreamer_android.so. Pokud používáte sadu Speech SDK s GStreamer verze 1.18.3, je také nutné, libc++_shared.so aby byla přítomna z android ndk.

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

Tady najdete příklad Android.mk a Application.mk soubor. Chcete-li vytvořit gstreamer sdílený objekt, postupujte takto: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

Sestavení můžete libgstreamer_android.so provést pomocí následujícího příkazu na Ubuntu 18.04 nebo 20.04. Následující příkazové řádky byly testovány pro [GStreamer Android verze 1.14.4] s Androidem 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)

Po sestavení sdíleného objektu (libgstreamer_android.so) umístěte sdílený objekt do aplikace pro Android, aby ji sada Speech SDK mohl načíst.

Příklad

Pokud chcete sadu Speech SDK nakonfigurovat tak, aby přijímala komprimovaný zvukový vstup, vytvořte PullAudioInputStream nebo PushAudioInputStream. Pak vytvořte AudioConfig z instance třídy streamu, která určuje formát komprese datového proudu. Vyhledání souvisejícího ukázkového kódu v ukázkách sady Speech SDK

Předpokládejme, že máte volanou pullAudio třídu vstupního streamu a používáte MP3. Váš kód může vypadat takto:

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

Referenční dokumentace | Balíček (npm) | Další ukázky ve zdrojovém kódu knihovny GitHub |

Sada Speech SDK pro JavaScript nepodporuje komprimovaný zvuk.

Výchozí formát streamování zvuku je WAV (16 kHz nebo 8 kHz, 16bitový a mono PCM). Pokud chcete zadat komprimovaný zvukový soubor (například mp3), musíte ho nejprve převést na soubor WAV ve výchozím formátu vstupu. Pokud chcete streamovat komprimovaný zvuk, musíte nejdřív dekódovat zvukové vyrovnávací paměti do výchozího vstupního formátu. Další informace naleznete v tématu Použití zvukového vstupního datového proudu.

Referenční dokumentace | Balíček (stáhnout) | Další ukázky na GitHubu

Sada Speech SDK pro Objective-C nepodporuje komprimovaný zvuk.

Výchozí formát streamování zvuku je WAV (16 kHz nebo 8 kHz, 16bitový a mono PCM). Pokud chcete zadat komprimovaný zvukový soubor (například mp3), musíte ho nejprve převést na soubor WAV ve výchozím formátu vstupu. Pokud chcete streamovat komprimovaný zvuk, musíte nejdřív dekódovat zvukové vyrovnávací paměti do výchozího vstupního formátu. Další informace naleznete v tématu Použití zvukového vstupního datového proudu.

Referenční dokumentace | Balíček (stáhnout) | Další ukázky na GitHubu

Sada Speech SDK pro Swift nepodporuje komprimovaný zvuk.

Výchozí formát streamování zvuku je WAV (16 kHz nebo 8 kHz, 16bitový a mono PCM). Pokud chcete zadat komprimovaný zvukový soubor (například mp3), musíte ho nejprve převést na soubor WAV ve výchozím formátu vstupu. Pokud chcete streamovat komprimovaný zvuk, musíte nejdřív dekódovat zvukové vyrovnávací paměti do výchozího vstupního formátu. Další informace naleznete v tématu Použití zvukového vstupního datového proudu.

Referenční dokumentace | Package (PyPi) | Další ukázky na GitHubu

Sada Speech SDK a Speech CLI používají GStreamer k podpoře různých typů vstupních zvukových formátů. GStreamer dekomprimuje zvuk před odesláním přes drát do služby Speech jako nezpracovaný PCM.

Výchozí formát streamování zvuku je WAV (16 kHz nebo 8 kHz, 16bitový a mono PCM). Mimo WAV a PCM jsou prostřednictvím GStreameru podporovány také následující komprimované vstupní formáty:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW v kontejneru WAV
  • MULAW v kontejneru WAV
  • ANY pro kontejner MP4 nebo neznámý formát média

Konfigurace GStreameru

Sada Speech SDK může ke zpracování komprimovaného zvuku použít GStreamer . Z důvodů licencování nejsou binární soubory GStreamer kompilované a propojené se sadou Speech SDK. Je potřeba nainstalovat některé závislosti a moduly plug-in.

Binární soubory GStreamer musí být v systémové cestě, aby je mohl za běhu načíst sada Speech SDK. Pokud například sada Speech SDK najde libgstreamer-1.0-0.dll nebo gstreamer-1.0-0.dll (pro nejnovější GStreamer) během běhu, znamená to, že binární soubory GStreameru jsou v systémové cestě.

Zvolte platformu pro pokyny k instalaci.

Musíte nainstalovat několik závislostí a modulů plug-in.

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

Další informace najdete v pokynech k instalaci Linuxu a podporovaných distribucí Linuxu a cílových architekturách.

Příklad

Pokud chcete sadu Speech SDK nakonfigurovat tak, aby přijímala komprimovaný zvukový vstup, vytvořte PullAudioInputStream nebo PushAudioInputStream. Pak vytvořte AudioConfig z instance třídy streamu, která určuje formát komprese datového proudu.

Předpokládejme, že se váš případ použití používá PullStream pro MP3 soubor. Váš kód může vypadat takto:


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)

Speech to text REST API reference | Speech to text REST API for short audio reference | Additional samples on GitHub

K komprimovanému zvuku můžete použít rozhraní REST API, ale zatím jsme tu průvodce nezahrnuli. Začněte výběrem jiného programovacího jazyka a seznamte se s koncepty.

Sada Speech SDK a Speech CLI používají GStreamer k podpoře různých typů vstupních zvukových formátů. GStreamer dekomprimuje zvuk před odesláním přes drát do služby Speech jako nezpracovaný PCM.

Výchozí formát streamování zvuku je WAV (16 kHz nebo 8 kHz, 16bitový a mono PCM). Mimo WAV a PCM jsou prostřednictvím GStreameru podporovány také následující komprimované vstupní formáty:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW v kontejneru WAV
  • MULAW v kontejneru WAV
  • ANY pro kontejner MP4 nebo neznámý formát média

Konfigurace GStreameru

Rozhraní příkazového řádku služby Speech může ke zpracování komprimovaného zvuku použít GStreamer . Z důvodů licencování nejsou binární soubory GStreamer kompilovány a propojeny s rozhraním příkazového řádku služby Speech. Je potřeba nainstalovat některé závislosti a moduly plug-in.

Binární soubory GStreamer musí být v systémové cestě, aby je bylo možné načíst pomocí rozhraní příkazového řádku služby Speech za běhu. Pokud například rozhraní příkazového řádku služby Speech najde libgstreamer-1.0-0.dll nebo gstreamer-1.0-0.dll (pro nejnovější GStreamer) během běhu, znamená to, že binární soubory GStreameru jsou v systémové cestě.

Zvolte platformu pro pokyny k instalaci.

Musíte nainstalovat několik závislostí a modulů plug-in.

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

Další informace najdete v pokynech k instalaci Linuxu a podporovaných distribucí Linuxu a cílových architekturách.

Příklad

Možnost --format určuje formát kontejneru pro rozpoznaný zvukový soubor. U souboru mp4 nastavte formát tak, jak any je znázorněno v následujícím příkazu:

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

Pokud chcete získat seznam podporovaných formátů zvuku, spusťte následující příkaz:

spx help recognize format

Další kroky