Share via

Jak używać skompresowanego dźwięku wejściowego

  • Artykuł

Dokumentacja referencyjna | Package (NuGet) | Dodatkowe przykłady w usłudze GitHub

Zestaw SPEECH SDK i interfejs wiersza polecenia usługi Mowa używają usługi GStreamer do obsługi różnych rodzajów formatów audio wejściowych. GStreamer dekompresuje dźwięk przed wysłaniem go przez przewody do usługi Mowa jako nieprzetworzone PCM.

Domyślny format przesyłania strumieniowego audio to WAV (16 kHz lub 8 kHz, 16-bitowy i mono PCM). Poza programem WAV i PCM następujące skompresowane formaty wejściowe są również obsługiwane za pośrednictwem usługi GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • Usługa ALAW w kontenerze WAV
  • MULAW w kontenerze WAV
  • DOWOLNY dla kontenera MP4 lub nieznanego formatu nośnika

Konfiguracja usługi GStreamer

Zestaw SPEECH SDK może używać usługi GStreamer do obsługi skompresowanego dźwięku. Ze względów licencjonowania pliki binarne usługi GStreamer nie są kompilowane i połączone z zestawem Speech SDK. Musisz zainstalować pewne zależności i wtyczki.

Pliki binarne usługi GStreamer muszą znajdować się w ścieżce systemowej, aby można je było załadować za pomocą zestawu SDK usługi Mowa w czasie wykonywania. Na przykład w systemie Windows, jeśli zestaw SPEECH SDK znajdzie libgstreamer-1.0-0.dll lub gstreamer-1.0-0.dll (dla najnowszej GStreamer) podczas wykonywania, oznacza to, że pliki binarne GStreamer znajdują się w ścieżce systemowej.

Wybierz platformę, aby uzyskać instrukcje instalacji.

Należy zainstalować kilka zależności i wtyczek.

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

Aby uzyskać więcej informacji, zobacz Instrukcje instalacji systemu Linux i obsługiwane dystrybucje systemu Linux i architektury docelowe.

Przykład

Aby skonfigurować zestaw SPEECH SDK do akceptowania skompresowanych danych wejściowych audio, utwórz PullAudioInputStream lub PushAudioInputStream. Następnie utwórz element AudioConfig na podstawie wystąpienia klasy strumienia, który określa format kompresji strumienia. Znajdź powiązane fragmenty kodu przykładowego w temacie About the Speech SDK audio input stream API (Informacje o interfejsie API strumienia danych wejściowych audio zestawu SDK usługi Mowa).

Załóżmy, że masz klasę strumienia wejściowego o nazwie pullStream i używasz funkcji OPUS/OGG. Kod może wyglądać następująco:

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;

Dokumentacja referencyjna | Package (NuGet) | Dodatkowe przykłady w usłudze GitHub

Zestaw SPEECH SDK i interfejs wiersza polecenia usługi Mowa używają usługi GStreamer do obsługi różnych rodzajów formatów audio wejściowych. GStreamer dekompresuje dźwięk przed wysłaniem go przez przewody do usługi Mowa jako nieprzetworzone PCM.

Domyślny format przesyłania strumieniowego audio to WAV (16 kHz lub 8 kHz, 16-bitowy i mono PCM). Poza programem WAV i PCM następujące skompresowane formaty wejściowe są również obsługiwane za pośrednictwem usługi GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • Usługa ALAW w kontenerze WAV
  • MULAW w kontenerze WAV
  • DOWOLNY dla kontenera MP4 lub nieznanego formatu nośnika

Konfiguracja usługi GStreamer

Zestaw SPEECH SDK może używać usługi GStreamer do obsługi skompresowanego dźwięku. Ze względów licencjonowania pliki binarne usługi GStreamer nie są kompilowane i połączone z zestawem Speech SDK. Musisz zainstalować pewne zależności i wtyczki.

Pliki binarne usługi GStreamer muszą znajdować się w ścieżce systemowej, aby można je było załadować za pomocą zestawu SDK usługi Mowa w czasie wykonywania. Na przykład w systemie Windows, jeśli zestaw SPEECH SDK znajdzie libgstreamer-1.0-0.dll lub gstreamer-1.0-0.dll (dla najnowszej GStreamer) podczas wykonywania, oznacza to, że pliki binarne GStreamer znajdują się w ścieżce systemowej.

Wybierz platformę, aby uzyskać instrukcje instalacji.

Należy zainstalować kilka zależności i wtyczek.

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

Aby uzyskać więcej informacji, zobacz Instrukcje instalacji systemu Linux i obsługiwane dystrybucje systemu Linux i architektury docelowe.

Przykład

Aby skonfigurować zestaw SPEECH SDK do akceptowania skompresowanych danych wejściowych audio, utwórz PullAudioInputStream lub PushAudioInputStream. Następnie utwórz element AudioConfig na podstawie wystąpienia klasy strumienia, który określa format kompresji strumienia. Znajdź powiązany przykładowy kod w przykładach zestawu Speech SDK.

Załóżmy, że masz klasę strumienia wejściowego o nazwie pushStream i używasz funkcji OPUS/OGG. Kod może wyglądać następująco:

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;

Dokumentacja referencyjna Package (Go)Additional Samples on GitHub (Dodatkowe przykłady w witrynie GitHub) | |

Zestaw SPEECH SDK i interfejs wiersza polecenia usługi Mowa używają usługi GStreamer do obsługi różnych rodzajów formatów audio wejściowych. GStreamer dekompresuje dźwięk przed wysłaniem go przez przewody do usługi Mowa jako nieprzetworzone PCM.

Domyślny format przesyłania strumieniowego audio to WAV (16 kHz lub 8 kHz, 16-bitowy i mono PCM). Poza programem WAV i PCM następujące skompresowane formaty wejściowe są również obsługiwane za pośrednictwem usługi GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • Usługa ALAW w kontenerze WAV
  • MULAW w kontenerze WAV
  • DOWOLNY dla kontenera MP4 lub nieznanego formatu nośnika

Konfiguracja usługi GStreamer

Zestaw SPEECH SDK może używać usługi GStreamer do obsługi skompresowanego dźwięku. Ze względów licencjonowania pliki binarne usługi GStreamer nie są kompilowane i połączone z zestawem Speech SDK. Musisz zainstalować pewne zależności i wtyczki.

Należy zainstalować kilka zależności i wtyczek.

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

Aby uzyskać więcej informacji, zobacz Instrukcje instalacji systemu Linux i obsługiwane dystrybucje systemu Linux i architektury docelowe.

Przykład

Aby skonfigurować zestaw SPEECH SDK do akceptowania skompresowanych danych wejściowych audio, utwórz element PullAudioInputStream lub PushAudioInputStream. Następnie utwórz element AudioConfig na podstawie wystąpienia klasy strumienia, który określa format kompresji strumienia.

W poniższym przykładzie załóżmy, że przypadek użycia jest używany PushStream dla skompresowanego pliku.


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

| Dokumentacja referencyjna — dodatkowe przykłady w usłudze GitHub

Zestaw SPEECH SDK i interfejs wiersza polecenia usługi Mowa używają usługi GStreamer do obsługi różnych rodzajów formatów audio wejściowych. GStreamer dekompresuje dźwięk przed wysłaniem go przez przewody do usługi Mowa jako nieprzetworzone PCM.

Domyślny format przesyłania strumieniowego audio to WAV (16 kHz lub 8 kHz, 16-bitowy i mono PCM). Poza programem WAV i PCM następujące skompresowane formaty wejściowe są również obsługiwane za pośrednictwem usługi GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • Usługa ALAW w kontenerze WAV
  • MULAW w kontenerze WAV
  • DOWOLNY dla kontenera MP4 lub nieznanego formatu nośnika

Konfiguracja usługi GStreamer

Zestaw SPEECH SDK może używać usługi GStreamer do obsługi skompresowanego dźwięku. Ze względów licencjonowania pliki binarne usługi GStreamer nie są kompilowane i połączone z zestawem Speech SDK. Musisz zainstalować pewne zależności i wtyczki.

Pliki binarne usługi GStreamer muszą znajdować się w ścieżce systemowej, aby można je było załadować za pomocą zestawu SDK usługi Mowa w czasie wykonywania. Na przykład w systemie Windows, jeśli zestaw SPEECH SDK znajdzie libgstreamer-1.0-0.dll lub gstreamer-1.0-0.dll (dla najnowszej GStreamer) podczas wykonywania, oznacza to, że pliki binarne GStreamer znajdują się w ścieżce systemowej.

Wybierz platformę, aby uzyskać instrukcje instalacji.

Obsługa skompresowanego dźwięku jest implementowana przy użyciu GStreamer. Ze względów licencjonowania pliki binarne usługi GStreamer nie są kompilowane i połączone z zestawem Speech SDK. Zamiast tego należy użyć wstępnie utworzonych plików binarnych dla systemu Android. Aby pobrać wstępnie utworzone biblioteki, zobacz Instalowanie aplikacji dla systemu Android.

Obiekt libgstreamer_android.so jest wymagany. Upewnij się, że wszystkie wtyczki GStreamer (z poniższego pliku Android.mk) są połączone w pliku libgstreamer_android.so. W przypadku korzystania z zestawu Speech SDK z usługą GStreamer w wersji 1.18.3 libc++_shared.so wymagane jest również, aby był obecny z poziomu zestawu Android ndk.

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

W tym miejscu podano przykład Android.mk i Application.mk plik. Wykonaj następujące kroki, aby utworzyć gstreamer obiekt udostępniony: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

Możesz skompilować libgstreamer_android.so przy użyciu następującego polecenia w systemie Ubuntu 18.04 lub 20.04. Następujące wiersze polecenia zostały przetestowane pod kątem [GStreamer Android w wersji 1.14.4] z systemem 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)

Po skompilowanych obiektach udostępnionych (libgstreamer_android.so) umieść obiekt udostępniony w aplikacji systemu Android, aby zestaw SPEECH SDK mógł go załadować.

Przykład

Aby skonfigurować zestaw SPEECH SDK do akceptowania skompresowanych danych wejściowych audio, utwórz element PullAudioInputStream lub PushAudioInputStream. Następnie utwórz element AudioConfig na podstawie wystąpienia klasy strumienia, który określa format kompresji strumienia. Znajdź powiązany przykładowy kod w przykładach zestawu Speech SDK.

Załóżmy, że masz klasę strumienia wejściowego o nazwie pullAudio i używasz mp3. Kod może wyglądać następująco:

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

Dokumentacja referencyjna | Package (npm)Additional Samples on GitHub Library source code (Dodatkowe przykłady w kodzie źródłowym biblioteki GitHub) | |

Zestaw SPEECH SDK dla języka JavaScript nie obsługuje skompresowanego dźwięku.

Domyślny format przesyłania strumieniowego audio to WAV (16 kHz lub 8 kHz, 16-bitowy i mono PCM). Aby wprowadzić skompresowany plik audio (na przykład mp3), należy najpierw przekonwertować go na plik WAV w domyślnym formacie wejściowym. Aby przesyłać strumieniowo skompresowany dźwięk, należy najpierw zdekodować bufory audio do domyślnego formatu wejściowego. Aby uzyskać więcej informacji, zobacz How to use the audio input stream (Jak używać strumienia wejściowego audio).

Dokumentacja referencyjna Pakietu (Pobierz) | Dodatkowe przykłady w usłudze GitHub |

Zestaw SPEECH SDK dla języka Objective-C nie obsługuje skompresowanego dźwięku.

Domyślny format przesyłania strumieniowego audio to WAV (16 kHz lub 8 kHz, 16-bitowy i mono PCM). Aby wprowadzić skompresowany plik audio (na przykład mp3), należy najpierw przekonwertować go na plik WAV w domyślnym formacie wejściowym. Aby przesyłać strumieniowo skompresowany dźwięk, należy najpierw zdekodować bufory audio do domyślnego formatu wejściowego. Aby uzyskać więcej informacji, zobacz How to use the audio input stream (Jak używać strumienia wejściowego audio).

Dokumentacja referencyjna Pakietu (Pobierz) | Dodatkowe przykłady w usłudze GitHub |

Zestaw SPEECH SDK dla języka Swift nie obsługuje skompresowanego dźwięku.

Domyślny format przesyłania strumieniowego audio to WAV (16 kHz lub 8 kHz, 16-bitowy i mono PCM). Aby wprowadzić skompresowany plik audio (na przykład mp3), należy najpierw przekonwertować go na plik WAV w domyślnym formacie wejściowym. Aby przesyłać strumieniowo skompresowany dźwięk, należy najpierw zdekodować bufory audio do domyślnego formatu wejściowego. Aby uzyskać więcej informacji, zobacz How to use the audio input stream (Jak używać strumienia wejściowego audio).

Dokumentacja referencyjna | Package (PyPi) | Dodatkowe przykłady w witrynie GitHub

Zestaw SPEECH SDK i interfejs wiersza polecenia usługi Mowa używają usługi GStreamer do obsługi różnych rodzajów formatów audio wejściowych. GStreamer dekompresuje dźwięk przed wysłaniem go przez przewody do usługi Mowa jako nieprzetworzone PCM.

Domyślny format przesyłania strumieniowego audio to WAV (16 kHz lub 8 kHz, 16-bitowy i mono PCM). Poza programem WAV i PCM następujące skompresowane formaty wejściowe są również obsługiwane za pośrednictwem usługi GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • Usługa ALAW w kontenerze WAV
  • MULAW w kontenerze WAV
  • DOWOLNY dla kontenera MP4 lub nieznanego formatu nośnika

Konfiguracja usługi GStreamer

Zestaw SPEECH SDK może używać usługi GStreamer do obsługi skompresowanego dźwięku. Ze względów licencjonowania pliki binarne usługi GStreamer nie są kompilowane i połączone z zestawem Speech SDK. Musisz zainstalować pewne zależności i wtyczki.

Pliki binarne usługi GStreamer muszą znajdować się w ścieżce systemowej, aby można je było załadować za pomocą zestawu SDK usługi Mowa w czasie wykonywania. Na przykład w systemie Windows, jeśli zestaw SPEECH SDK znajdzie libgstreamer-1.0-0.dll lub gstreamer-1.0-0.dll (dla najnowszej GStreamer) podczas wykonywania, oznacza to, że pliki binarne GStreamer znajdują się w ścieżce systemowej.

Wybierz platformę, aby uzyskać instrukcje instalacji.

Należy zainstalować kilka zależności i wtyczek.

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

Aby uzyskać więcej informacji, zobacz Instrukcje instalacji systemu Linux i obsługiwane dystrybucje systemu Linux i architektury docelowe.

Przykład

Aby skonfigurować zestaw SPEECH SDK do akceptowania skompresowanych danych wejściowych audio, utwórz PullAudioInputStream lub PushAudioInputStream. Następnie utwórz element AudioConfig na podstawie wystąpienia klasy strumienia, który określa format kompresji strumienia.

Załóżmy, że twój przypadek użycia jest używany PullStream dla MP3 pliku. Kod może wyglądać następująco:


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)

Interfejs API REST zamiany mowy na tekst — dokumentacja | interfejsu API REST zamiany mowy na tekst w celu uzyskania krótkiej dokumentacji | audio — dodatkowe przykłady w usłudze GitHub

Możesz użyć interfejsu API REST do skompresowanego dźwięku, ale nie dołączyliśmy jeszcze tutaj przewodnika. Wybierz inny język programowania, aby rozpocząć pracę i dowiedzieć się więcej o pojęciach.

Zestaw SPEECH SDK i interfejs wiersza polecenia usługi Mowa używają usługi GStreamer do obsługi różnych rodzajów formatów audio wejściowych. GStreamer dekompresuje dźwięk przed wysłaniem go przez przewody do usługi Mowa jako nieprzetworzone PCM.

Domyślny format przesyłania strumieniowego audio to WAV (16 kHz lub 8 kHz, 16-bitowy i mono PCM). Poza programem WAV i PCM następujące skompresowane formaty wejściowe są również obsługiwane za pośrednictwem usługi GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • Usługa ALAW w kontenerze WAV
  • MULAW w kontenerze WAV
  • DOWOLNY dla kontenera MP4 lub nieznanego formatu nośnika

Konfiguracja usługi GStreamer

Interfejs wiersza polecenia usługi Mowa może używać usługi GStreamer do obsługi skompresowanego dźwięku. Ze względów licencjonowania pliki binarne usługi GStreamer nie są kompilowane i połączone z interfejsem wiersza polecenia usługi Mowa. Musisz zainstalować pewne zależności i wtyczki.

Pliki binarne usługi GStreamer muszą znajdować się w ścieżce systemowej, aby można je było załadować za pomocą interfejsu wiersza polecenia usługi Mowa w czasie wykonywania. Na przykład w systemie Windows, jeśli interfejs wiersza polecenia rozpoznawania mowy znajdzie libgstreamer-1.0-0.dll lub gstreamer-1.0-0.dll (dla najnowszej GStreamer) podczas wykonywania, oznacza to, że pliki binarne GStreamer znajdują się w ścieżce systemowej.

Wybierz platformę, aby uzyskać instrukcje instalacji.

Należy zainstalować kilka zależności i wtyczek.

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

Aby uzyskać więcej informacji, zobacz Instrukcje instalacji systemu Linux i obsługiwane dystrybucje systemu Linux i architektury docelowe.

Przykład

Opcja --format określa format kontenera dla rozpoznawanego pliku audio. W przypadku pliku mp4 ustaw format na any , jak pokazano w poniższym poleceniu:

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

Aby uzyskać listę obsługiwanych formatów audio, uruchom następujące polecenie:

spx help recognize format

Następne kroki