Så här använder du komprimerat indataljud

  • Artikel

Referensdokumentation Paket (NuGet) | Ytterligare exempel på GitHub |

Speech SDK och Speech CLI använder GStreamer för att stödja olika typer av indataljudformat. GStreamer dekomprimerar ljudet innan det skickas via kabeln till Speech-tjänsten som rå PCM.

Standardformatet för ljuduppspelning är WAV (16 kHz eller 8 kHz, 16-bitars och mono PCM). Utanför WAV och PCM stöds även följande komprimerade indataformat via GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW i WAV-container
  • MULAW i WAV-container
  • ANY för MP4-container eller okänt medieformat

GStreamer-konfiguration

Speech SDK kan använda GStreamer för att hantera komprimerat ljud. Av licensieringsskäl kompileras inte GStreamer-binärfiler och länkas inte till Speech SDK. Du måste installera vissa beroenden och plugin-program.

GStreamer-binärfiler måste finnas i systemsökvägen så att de kan läsas in av Speech SDK vid körning. Om Speech SDK till exempel hittar libgstreamer-1.0-0.dll eller gstreamer-1.0-0.dll (för den senaste GStreamer) under körning innebär det att GStreamer-binärfilerna finns i systemsökvägen.

Välj en plattform för installationsinstruktioner.

Du måste installera flera beroenden och plugin-program.

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

Mer information finns i Installationsanvisningar för Linux och Linux-distributioner och målarkitekturer som stöds.

Exempel

Om du vill konfigurera Speech SDK för att acceptera komprimerade ljudindata skapar PullAudioInputStream du eller PushAudioInputStream. Skapa sedan en AudioConfig från en instans av din stream-klass som anger komprimeringsformatet för strömmen. Hitta relaterade exempelkodfragment i Om Api för ljudindataström i Speech SDK.

Anta att du har en indataströmsklass som heter pullStream och använder OPUS/OGG. Koden kan se ut så här:

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;

Referensdokumentation Paket (NuGet) | Ytterligare exempel på GitHub |

Speech SDK och Speech CLI använder GStreamer för att stödja olika typer av indataljudformat. GStreamer dekomprimerar ljudet innan det skickas via kabeln till Speech-tjänsten som rå PCM.

Standardformatet för ljuduppspelning är WAV (16 kHz eller 8 kHz, 16-bitars och mono PCM). Utanför WAV och PCM stöds även följande komprimerade indataformat via GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW i WAV-container
  • MULAW i WAV-container
  • ANY för MP4-container eller okänt medieformat

GStreamer-konfiguration

Speech SDK kan använda GStreamer för att hantera komprimerat ljud. Av licensieringsskäl kompileras inte GStreamer-binärfiler och länkas inte till Speech SDK. Du måste installera vissa beroenden och plugin-program.

GStreamer-binärfiler måste finnas i systemsökvägen så att de kan läsas in av Speech SDK vid körning. Om Speech SDK till exempel hittar libgstreamer-1.0-0.dll eller gstreamer-1.0-0.dll (för den senaste GStreamer) under körning innebär det att GStreamer-binärfilerna finns i systemsökvägen.

Välj en plattform för installationsinstruktioner.

Du måste installera flera beroenden och plugin-program.

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

Mer information finns i Installationsanvisningar för Linux och Linux-distributioner och målarkitekturer som stöds.

Exempel

Om du vill konfigurera Speech SDK för att acceptera komprimerade ljudindata skapar PullAudioInputStream du eller PushAudioInputStream. Skapa sedan en AudioConfig från en instans av din stream-klass som anger komprimeringsformatet för strömmen. Hitta relaterad exempelkod i Speech SDK-exempel.

Anta att du har en indataströmsklass som heter pushStream och använder OPUS/OGG. Koden kan se ut så här:

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;

Referensdokumentation Paket (Go) | Ytterligare exempel på GitHub |

Speech SDK och Speech CLI använder GStreamer för att stödja olika typer av indataljudformat. GStreamer dekomprimerar ljudet innan det skickas via kabeln till Speech-tjänsten som rå PCM.

Standardformatet för ljuduppspelning är WAV (16 kHz eller 8 kHz, 16-bitars och mono PCM). Utanför WAV och PCM stöds även följande komprimerade indataformat via GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW i WAV-container
  • MULAW i WAV-container
  • ANY för MP4-container eller okänt medieformat

GStreamer-konfiguration

Speech SDK kan använda GStreamer för att hantera komprimerat ljud. Av licensieringsskäl kompileras inte GStreamer-binärfiler och länkas inte till Speech SDK. Du måste installera vissa beroenden och plugin-program.

Du måste installera flera beroenden och plugin-program.

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

Mer information finns i Installationsanvisningar för Linux och Linux-distributioner och målarkitekturer som stöds.

Exempel

Om du vill konfigurera Speech SDK för att acceptera komprimerade ljudindata skapar du en PullAudioInputStream eller PushAudioInputStream. Skapa sedan en AudioConfig från en instans av din stream-klass som anger komprimeringsformatet för strömmen.

I följande exempel antar vi att ditt användningsfall är att använda PushStream för en komprimerad fil.


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

Referensdokumentation | Ytterligare exempel på GitHub

Speech SDK och Speech CLI använder GStreamer för att stödja olika typer av indataljudformat. GStreamer dekomprimerar ljudet innan det skickas via kabeln till Speech-tjänsten som rå PCM.

Standardformatet för ljuduppspelning är WAV (16 kHz eller 8 kHz, 16-bitars och mono PCM). Utanför WAV och PCM stöds även följande komprimerade indataformat via GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW i WAV-container
  • MULAW i WAV-container
  • ANY för MP4-container eller okänt medieformat

GStreamer-konfiguration

Speech SDK kan använda GStreamer för att hantera komprimerat ljud. Av licensieringsskäl kompileras inte GStreamer-binärfiler och länkas inte till Speech SDK. Du måste installera vissa beroenden och plugin-program.

GStreamer-binärfiler måste finnas i systemsökvägen så att de kan läsas in av Speech SDK vid körning. Om Speech SDK till exempel hittar libgstreamer-1.0-0.dll eller gstreamer-1.0-0.dll (för den senaste GStreamer) under körning innebär det att GStreamer-binärfilerna finns i systemsökvägen.

Välj en plattform för installationsinstruktioner.

Hantering av komprimerat ljud implementeras med hjälp av GStreamer. Av licensieringsskäl kompileras inte GStreamer-binärfiler och länkas inte till Speech SDK. I stället måste du använda de fördefinierade binärfilerna för Android. Information om hur du laddar ned de fördefinierade biblioteken finns i Installera för Android-utveckling.

Objektet libgstreamer_android.so krävs. Kontrollera att alla GStreamer-plugin-program (från den Android.mk filen som följer) är länkade i libgstreamer_android.so. När du använder Speech SDK med GStreamer version 1.18.3 libc++_shared.so måste du också vara närvarande från Android ndk.

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

Ett exempel Android.mk och Application.mk en fil finns här. Följ de här stegen för att skapa det gstreamer delade objektet: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

Du kan skapa libgstreamer_android.so med hjälp av följande kommando på Ubuntu 18.04 eller 20.04. Följande kommandorader har testats för [GStreamer Android version 1.14.4] med 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)

När det delade objektet (libgstreamer_android.so) har skapats placerar du det delade objektet i Android-appen så att Speech SDK kan läsa in det.

Exempel

Om du vill konfigurera Speech SDK för att acceptera komprimerade ljudindata skapar du en PullAudioInputStream eller PushAudioInputStream. Skapa sedan en AudioConfig från en instans av din stream-klass som anger komprimeringsformatet för strömmen. Hitta relaterad exempelkod i Speech SDK-exempel.

Anta att du har en indataströmsklass som heter pullAudio och använder MP3. Koden kan se ut så här:

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

Referensdokumentation Paket (npm) | Ytterligare exempel på GitHub-bibliotekets källkod | |

Speech SDK för JavaScript stöder inte komprimerat ljud.

Standardformatet för ljuduppspelning är WAV (16 kHz eller 8 kHz, 16-bitars och mono PCM). Om du vill mata in en komprimerad ljudfil (till exempel mp3) måste du först konvertera den till en WAV-fil i standardformatet för indata. Om du vill strömma komprimerat ljud måste du först avkoda ljudbuffertarna till standardformatet för indata. Mer information finns i Använda ljudindataströmmen.

Referensdokumentationspaket (ladda ned) | Ytterligare exempel på GitHub |

Speech SDK för Objective-C stöder inte komprimerat ljud.

Standardformatet för ljuduppspelning är WAV (16 kHz eller 8 kHz, 16-bitars och mono PCM). Om du vill mata in en komprimerad ljudfil (till exempel mp3) måste du först konvertera den till en WAV-fil i standardformatet för indata. Om du vill strömma komprimerat ljud måste du först avkoda ljudbuffertarna till standardformatet för indata. Mer information finns i Använda ljudindataströmmen.

Referensdokumentationspaket (ladda ned) | Ytterligare exempel på GitHub |

Speech SDK för Swift stöder inte komprimerat ljud.

Standardformatet för ljuduppspelning är WAV (16 kHz eller 8 kHz, 16-bitars och mono PCM). Om du vill mata in en komprimerad ljudfil (till exempel mp3) måste du först konvertera den till en WAV-fil i standardformatet för indata. Om du vill strömma komprimerat ljud måste du först avkoda ljudbuffertarna till standardformatet för indata. Mer information finns i Använda ljudindataströmmen.

Referensdokumentation Paket (PyPi) | Ytterligare exempel på GitHub |

Speech SDK och Speech CLI använder GStreamer för att stödja olika typer av indataljudformat. GStreamer dekomprimerar ljudet innan det skickas via kabeln till Speech-tjänsten som rå PCM.

Standardformatet för ljuduppspelning är WAV (16 kHz eller 8 kHz, 16-bitars och mono PCM). Utanför WAV och PCM stöds även följande komprimerade indataformat via GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW i WAV-container
  • MULAW i WAV-container
  • ANY för MP4-container eller okänt medieformat

GStreamer-konfiguration

Speech SDK kan använda GStreamer för att hantera komprimerat ljud. Av licensieringsskäl kompileras inte GStreamer-binärfiler och länkas inte till Speech SDK. Du måste installera vissa beroenden och plugin-program.

GStreamer-binärfiler måste finnas i systemsökvägen så att de kan läsas in av Speech SDK vid körning. Om Speech SDK till exempel hittar libgstreamer-1.0-0.dll eller gstreamer-1.0-0.dll (för den senaste GStreamer) under körning innebär det att GStreamer-binärfilerna finns i systemsökvägen.

Välj en plattform för installationsinstruktioner.

Du måste installera flera beroenden och plugin-program.

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

Mer information finns i Installationsanvisningar för Linux och Linux-distributioner och målarkitekturer som stöds.

Exempel

Om du vill konfigurera Speech SDK för att acceptera komprimerade ljudindata skapar PullAudioInputStream du eller PushAudioInputStream. Skapa sedan en AudioConfig från en instans av din stream-klass som anger komprimeringsformatet för strömmen.

Anta att ditt användningsfall är att använda PullStream för en MP3 fil. Koden kan se ut så här:


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)

REST API för tal till text refererar | till REST API för tal till text för kort ljudreferens | Ytterligare exempel på GitHub

Du kan använda REST-API:et för komprimerat ljud, men vi har ännu inte tagit med någon guide här. Välj ett annat programmeringsspråk för att komma igång och lära dig mer om begreppen.

Speech SDK och Speech CLI använder GStreamer för att stödja olika typer av indataljudformat. GStreamer dekomprimerar ljudet innan det skickas via kabeln till Speech-tjänsten som rå PCM.

Standardformatet för ljuduppspelning är WAV (16 kHz eller 8 kHz, 16-bitars och mono PCM). Utanför WAV och PCM stöds även följande komprimerade indataformat via GStreamer:

  • MP3
  • OPUS/OGG
  • FLAC
  • ALAW i WAV-container
  • MULAW i WAV-container
  • ANY för MP4-container eller okänt medieformat

GStreamer-konfiguration

Speech CLI kan använda GStreamer för att hantera komprimerat ljud. Av licensieringsskäl kompileras inte GStreamer-binärfiler och länkas inte till Speech CLI. Du måste installera vissa beroenden och plugin-program.

GStreamer-binärfiler måste finnas i systemsökvägen så att de kan läsas in av Speech CLI vid körning. Om Speech CLI till exempel hittar libgstreamer-1.0-0.dll eller gstreamer-1.0-0.dll (för den senaste GStreamer) under körning innebär det att GStreamer-binärfilerna finns i systemsökvägen.

Välj en plattform för installationsinstruktioner.

Du måste installera flera beroenden och plugin-program.

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

Mer information finns i Installationsanvisningar för Linux och Linux-distributioner och målarkitekturer som stöds.

Exempel

Alternativet --format anger containerformatet för ljudfilen som identifieras. För en mp4-fil anger du formatet enligt any följande kommando:

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

Kör följande kommando för att hämta en lista över ljudformat som stöds:

spx help recognize format

Nästa steg