Gecomprimeerde invoeraudio gebruiken

  • Artikel

Referentiedocumentatiepakket (NuGet) | Aanvullende voorbeelden op GitHub |

De Speech SDK en Speech CLI gebruiken GStreamer om verschillende soorten invoeraudioindelingen te ondersteunen. GStreamer decomprimeert de audio voordat deze via de kabel naar de Speech-service wordt verzonden als onbewerkte PCM.

De standaardindeling voor audiostreaming is WAV (16 kHz of 8 kHz, 16-bits en mono PCM). Buiten WAV en PCM worden de volgende gecomprimeerde invoerindelingen ook ondersteund via GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW in WAV-container
  • MULAW in WAV-container
  • ANY voor MP4-container of onbekende media-indeling

GStreamer-configuratie

De Speech SDK kan GStreamer gebruiken voor het verwerken van gecomprimeerde audio. Om licentieredenen worden binaire GStreamer-bestanden niet gecompileerd en gekoppeld aan de Speech SDK. U moet enkele afhankelijkheden en invoegtoepassingen installeren.

Binaire GStreamer-bestanden moeten zich in het systeempad bevinden, zodat ze tijdens runtime kunnen worden geladen door de Speech SDK. Als de Speech SDK bijvoorbeeld tijdens runtime zoekt libgstreamer-1.0-0.dll of gstreamer-1.0-0.dll (voor de meest recente GStreamer) in Windows, betekent dit dat de binaire GStreamer-bestanden zich in het systeempad bevinden.

Kies een platform voor installatie-instructies.

U moet verschillende afhankelijkheden en invoegtoepassingen installeren.

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

Zie installatie-instructies voor Linux en ondersteunde Linux-distributies en doelarchitecturen voor meer informatie.

Opmerking

Als u de Speech SDK wilt configureren voor het accepteren van gecomprimeerde audio-invoer, maakt PullAudioInputStream u of PushAudioInputStream. Maak vervolgens een AudioConfig exemplaar van uw streamklasse dat de compressie-indeling van de stream aangeeft. Zoek gerelateerde voorbeeldcodefragmenten in About the Speech SDK audio input stream API.

Stel dat u een invoerstroomklasse hebt die wordt aangeroepen pullStream en dat u OPUS/MSP gebruikt. Uw code ziet er mogelijk als volgt uit:

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;

Referentiedocumentatiepakket (NuGet) | Aanvullende voorbeelden op GitHub |

De Speech SDK en Speech CLI gebruiken GStreamer om verschillende soorten invoeraudioindelingen te ondersteunen. GStreamer decomprimeert de audio voordat deze via de kabel naar de Speech-service wordt verzonden als onbewerkte PCM.

De standaardindeling voor audiostreaming is WAV (16 kHz of 8 kHz, 16-bits en mono PCM). Buiten WAV en PCM worden de volgende gecomprimeerde invoerindelingen ook ondersteund via GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW in WAV-container
  • MULAW in WAV-container
  • ANY voor MP4-container of onbekende media-indeling

GStreamer-configuratie

De Speech SDK kan GStreamer gebruiken voor het verwerken van gecomprimeerde audio. Om licentieredenen worden binaire GStreamer-bestanden niet gecompileerd en gekoppeld aan de Speech SDK. U moet enkele afhankelijkheden en invoegtoepassingen installeren.

Binaire GStreamer-bestanden moeten zich in het systeempad bevinden, zodat ze tijdens runtime kunnen worden geladen door de Speech SDK. Als de Speech SDK bijvoorbeeld tijdens runtime zoekt libgstreamer-1.0-0.dll of gstreamer-1.0-0.dll (voor de meest recente GStreamer) in Windows, betekent dit dat de binaire GStreamer-bestanden zich in het systeempad bevinden.

Kies een platform voor installatie-instructies.

U moet verschillende afhankelijkheden en invoegtoepassingen installeren.

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

Zie installatie-instructies voor Linux en ondersteunde Linux-distributies en doelarchitecturen voor meer informatie.

Opmerking

Als u de Speech SDK wilt configureren voor het accepteren van gecomprimeerde audio-invoer, maakt PullAudioInputStream u of PushAudioInputStream. Maak vervolgens een AudioConfig exemplaar van uw streamklasse dat de compressie-indeling van de stream aangeeft. Zoek gerelateerde voorbeeldcode in Speech SDK-voorbeelden.

Stel dat u een invoerstroomklasse hebt die wordt aangeroepen pushStream en dat u OPUS/MSP gebruikt. Uw code ziet er mogelijk als volgt uit:

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;

Referentiedocumentatiepakket (Go) | Aanvullende voorbeelden op GitHub |

De Speech SDK en Speech CLI gebruiken GStreamer om verschillende soorten invoeraudioindelingen te ondersteunen. GStreamer decomprimeert de audio voordat deze via de kabel naar de Speech-service wordt verzonden als onbewerkte PCM.

De standaardindeling voor audiostreaming is WAV (16 kHz of 8 kHz, 16-bits en mono PCM). Buiten WAV en PCM worden de volgende gecomprimeerde invoerindelingen ook ondersteund via GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW in WAV-container
  • MULAW in WAV-container
  • ANY voor MP4-container of onbekende media-indeling

GStreamer-configuratie

De Speech SDK kan GStreamer gebruiken voor het verwerken van gecomprimeerde audio. Om licentieredenen worden binaire GStreamer-bestanden niet gecompileerd en gekoppeld aan de Speech SDK. U moet enkele afhankelijkheden en invoegtoepassingen installeren.

U moet verschillende afhankelijkheden en invoegtoepassingen installeren.

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

Zie installatie-instructies voor Linux en ondersteunde Linux-distributies en doelarchitecturen voor meer informatie.

Opmerking

Als u de Speech SDK wilt configureren voor het accepteren van gecomprimeerde audio-invoer, maakt u een PullAudioInputStream of PushAudioInputStream. Maak vervolgens een AudioConfig exemplaar van uw streamklasse dat de compressie-indeling van de stream aangeeft.

In het volgende voorbeeld gaan we ervan uit dat uw use-case moet worden gebruikt PushStream voor een gecomprimeerd bestand.


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

Referentiedocumentatie | Aanvullende voorbeelden op GitHub

De Speech SDK en Speech CLI gebruiken GStreamer om verschillende soorten invoeraudioindelingen te ondersteunen. GStreamer decomprimeert de audio voordat deze via de kabel naar de Speech-service wordt verzonden als onbewerkte PCM.

De standaardindeling voor audiostreaming is WAV (16 kHz of 8 kHz, 16-bits en mono PCM). Buiten WAV en PCM worden de volgende gecomprimeerde invoerindelingen ook ondersteund via GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW in WAV-container
  • MULAW in WAV-container
  • ANY voor MP4-container of onbekende media-indeling

GStreamer-configuratie

De Speech SDK kan GStreamer gebruiken voor het verwerken van gecomprimeerde audio. Om licentieredenen worden binaire GStreamer-bestanden niet gecompileerd en gekoppeld aan de Speech SDK. U moet enkele afhankelijkheden en invoegtoepassingen installeren.

Binaire GStreamer-bestanden moeten zich in het systeempad bevinden, zodat ze tijdens runtime kunnen worden geladen door de Speech SDK. Als de Speech SDK bijvoorbeeld tijdens runtime zoekt libgstreamer-1.0-0.dll of gstreamer-1.0-0.dll (voor de meest recente GStreamer) in Windows, betekent dit dat de binaire GStreamer-bestanden zich in het systeempad bevinden.

Kies een platform voor installatie-instructies.

Het verwerken van gecomprimeerde audio wordt geïmplementeerd met behulp van GStreamer. Om licentieredenen worden binaire GStreamer-bestanden niet gecompileerd en gekoppeld aan de Speech SDK. In plaats daarvan moet u de vooraf gemaakte binaire bestanden voor Android gebruiken. Zie Installeren voor Android-ontwikkeling om de vooraf gemaakte bibliotheken te downloaden.

Het libgstreamer_android.so object is vereist. Zorg ervoor dat alle GStreamer-invoegtoepassingen (uit het volgende Android.mk-bestand) zijn gekoppeld.libgstreamer_android.so Wanneer u de Speech SDK gebruikt met GStreamer versie 1.18.3, libc++_shared.so moet u ook aanwezig zijn vanuit Android ndk.

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

Hier ziet u een voorbeeld Android.mk en Application.mk bestand. Volg deze stappen om het gstreamer gedeelde object te maken: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

U kunt bouwen libgstreamer_android.so met behulp van de volgende opdracht op Ubuntu 18.04 of 20.04. De volgende opdrachtregels zijn getest op [GStreamer Android versie 1.14.4] met 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)

Nadat het gedeelde object (libgstreamer_android.so) is gemaakt, plaatst u het gedeelde object in de Android-app, zodat de Speech SDK het kan laden.

Opmerking

Als u de Speech SDK wilt configureren voor het accepteren van gecomprimeerde audio-invoer, maakt u een PullAudioInputStream of PushAudioInputStream. Maak vervolgens een AudioConfig exemplaar van uw streamklasse dat de compressie-indeling van de stream aangeeft. Zoek gerelateerde voorbeeldcode in Speech SDK-voorbeelden.

Stel dat u een invoerstroomklasse hebt die wordt aangeroepen pullAudio en mp3 gebruikt. Uw code ziet er mogelijk als volgt uit:

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

Referentiedocumentatiepakket (npm) | Aanvullende voorbeelden op GitHub | Library-broncode |

De Speech SDK voor JavaScript biedt geen ondersteuning voor gecomprimeerde audio.

De standaardindeling voor audiostreaming is WAV (16 kHz of 8 kHz, 16-bits en mono PCM). Als u een gecomprimeerd audiobestand (zoals mp3) wilt invoeren, moet u het eerst converteren naar een WAV-bestand in de standaardinvoerindeling. Als u gecomprimeerde audio wilt streamen, moet u eerst de audiobuffers decoderen naar de standaardinvoerindeling. Zie De audio-invoerstroom gebruiken voor meer informatie.

Referentiedocumentatiepakket (downloaden) | Aanvullende voorbeelden op GitHub |

De Speech SDK voor Objective-C biedt geen ondersteuning voor gecomprimeerde audio.

De standaardindeling voor audiostreaming is WAV (16 kHz of 8 kHz, 16-bits en mono PCM). Als u een gecomprimeerd audiobestand (zoals mp3) wilt invoeren, moet u het eerst converteren naar een WAV-bestand in de standaardinvoerindeling. Als u gecomprimeerde audio wilt streamen, moet u eerst de audiobuffers decoderen naar de standaardinvoerindeling. Zie De audio-invoerstroom gebruiken voor meer informatie.

Referentiedocumentatiepakket (downloaden) | Aanvullende voorbeelden op GitHub |

De Speech SDK voor Swift biedt geen ondersteuning voor gecomprimeerde audio.

De standaardindeling voor audiostreaming is WAV (16 kHz of 8 kHz, 16-bits en mono PCM). Als u een gecomprimeerd audiobestand (zoals mp3) wilt invoeren, moet u het eerst converteren naar een WAV-bestand in de standaardinvoerindeling. Als u gecomprimeerde audio wilt streamen, moet u eerst de audiobuffers decoderen naar de standaardinvoerindeling. Zie De audio-invoerstroom gebruiken voor meer informatie.

Referentiedocumentatiepakket (PyPi) | Aanvullende voorbeelden op GitHub |

De Speech SDK en Speech CLI gebruiken GStreamer om verschillende soorten invoeraudioindelingen te ondersteunen. GStreamer decomprimeert de audio voordat deze via de kabel naar de Speech-service wordt verzonden als onbewerkte PCM.

De standaardindeling voor audiostreaming is WAV (16 kHz of 8 kHz, 16-bits en mono PCM). Buiten WAV en PCM worden de volgende gecomprimeerde invoerindelingen ook ondersteund via GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW in WAV-container
  • MULAW in WAV-container
  • ANY voor MP4-container of onbekende media-indeling

GStreamer-configuratie

De Speech SDK kan GStreamer gebruiken voor het verwerken van gecomprimeerde audio. Om licentieredenen worden binaire GStreamer-bestanden niet gecompileerd en gekoppeld aan de Speech SDK. U moet enkele afhankelijkheden en invoegtoepassingen installeren.

Binaire GStreamer-bestanden moeten zich in het systeempad bevinden, zodat ze tijdens runtime kunnen worden geladen door de Speech SDK. Als de Speech SDK bijvoorbeeld tijdens runtime zoekt libgstreamer-1.0-0.dll of gstreamer-1.0-0.dll (voor de meest recente GStreamer) in Windows, betekent dit dat de binaire GStreamer-bestanden zich in het systeempad bevinden.

Kies een platform voor installatie-instructies.

U moet verschillende afhankelijkheden en invoegtoepassingen installeren.

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

Zie installatie-instructies voor Linux en ondersteunde Linux-distributies en doelarchitecturen voor meer informatie.

Opmerking

Als u de Speech SDK wilt configureren voor het accepteren van gecomprimeerde audio-invoer, maakt PullAudioInputStream u of PushAudioInputStream. Maak vervolgens een AudioConfig exemplaar van uw streamklasse dat de compressie-indeling van de stream aangeeft.

Stel dat uw use-case moet worden gebruikt PullStream voor een MP3 bestand. Uw code ziet er mogelijk als volgt uit:


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)

Spraak-naar-tekst-REST API-verwijzing Speech naar text REST API voor korte audioverwijzing | Aanvullende voorbeelden op GitHub |

U kunt de REST API gebruiken voor gecomprimeerde audio, maar we hebben hier nog geen handleiding opgenomen. Selecteer een andere programmeertaal om aan de slag te gaan en meer te weten te komen over de concepten.

De Speech SDK en Speech CLI gebruiken GStreamer om verschillende soorten invoeraudioindelingen te ondersteunen. GStreamer decomprimeert de audio voordat deze via de kabel naar de Speech-service wordt verzonden als onbewerkte PCM.

De standaardindeling voor audiostreaming is WAV (16 kHz of 8 kHz, 16-bits en mono PCM). Buiten WAV en PCM worden de volgende gecomprimeerde invoerindelingen ook ondersteund via GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW in WAV-container
  • MULAW in WAV-container
  • ANY voor MP4-container of onbekende media-indeling

GStreamer-configuratie

De Speech CLI kan GStreamer gebruiken om gecomprimeerde audio af te handelen. Om licentieredenen worden binaire GStreamer-bestanden niet gecompileerd en gekoppeld aan de Speech CLI. U moet enkele afhankelijkheden en invoegtoepassingen installeren.

Binaire GStreamer-bestanden moeten zich in het systeempad bevinden, zodat ze tijdens runtime door de Speech CLI kunnen worden geladen. Als in Windows bijvoorbeeld de Speech CLI tijdens runtime vindt libgstreamer-1.0-0.dll of gstreamer-1.0-0.dll (voor de meest recente GStreamer), betekent dit dat de binaire GStreamer-bestanden zich in het systeempad bevinden.

Kies een platform voor installatie-instructies.

U moet verschillende afhankelijkheden en invoegtoepassingen installeren.

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

Zie installatie-instructies voor Linux en ondersteunde Linux-distributies en doelarchitecturen voor meer informatie.

Opmerking

Met de --format optie geeft u de containerindeling op voor het audiobestand dat wordt herkend. Voor een mp4-bestand stelt u de indeling any in op zoals wordt weergegeven in de volgende opdracht:

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

Voer de volgende opdracht uit om een lijst met ondersteunde audio-indelingen op te halen:

spx help recognize format

Volgende stappen