Come usare l'input audio compresso

Documentazione di riferimento | Pacchetto (NuGet) | Ulteriori esempi in GitHub

Speech SDK e l'interfaccia della riga di comando di Voce usano GStreamer per supportare diversi tipi di formati audio di input. GStreamer decomprime l'audio prima che venga inviato in rete al servizio Voce come PCM non elaborato.

Il formato di streaming audio predefinito è WAV (16 kHz o 8 kHz, 16 bit e PCM mono). All'esterno di WAV e PCM, sono supportati anche i formati di input compressi seguenti tramite GStreamer:

• MP3
• OPUS/OGG
• FLAC
• ALAW nel contenitore WAV
• MULAW nel contenitore WAV
• ANY per il contenitore MP4 o il formato multimediale sconosciuto

Configurazione di GStreamer

Speech SDK può usare GStreamer per gestire l'audio compresso. Per motivi di licenza, i file binari GStreamer non vengono compilati e collegati con Speech SDK. È necessario installare alcune dipendenze e plug-in.

I file binari GStreamer devono trovarsi nel percorso di sistema in modo che possano essere caricati da Speech SDK in fase di esecuzione. Ad esempio, in Windows, se Speech SDK trova libgstreamer-1.0-0.dll o gstreamer-1.0-0.dll (per la versione più recente di GStreamer) durante l’esecuzione, significa che i file binari GStreamer si trovano nel percorso di sistema.

Scegliere una piattaforma per le istruzioni di installazione.

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

Esempio

Per configurare Speech SDK affinché accetti l'input audio compresso, creare PullAudioInputStream o PushAudioInputStream. Creare quindi un AudioConfig partendo da un'istanza della classe di flusso che specifica il formato di compressione del flusso. Trovare frammenti di codice di esempio correlati in Informazioni sull'API flusso di input audio di Speech SDK.

Supponiamo di avere una classe di flusso di input denominata pullStream e di usare OPUS/OGG. Il codice potrebbe essere simile al seguente:

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;

Documentazione di riferimento | Pacchetto (NuGet) | Ulteriori esempi in GitHub

Speech SDK e l'interfaccia della riga di comando di Voce usano GStreamer per supportare diversi tipi di formati audio di input. GStreamer decomprime l'audio prima che venga inviato in rete al servizio Voce come PCM non elaborato.

Il formato di streaming audio predefinito è WAV (16 kHz o 8 kHz, 16 bit e PCM mono). All'esterno di WAV e PCM, sono supportati anche i formati di input compressi seguenti tramite GStreamer:

• MP3
• OPUS/OGG
• FLAC
• ALAW nel contenitore WAV
• MULAW nel contenitore WAV
• ANY per il contenitore MP4 o il formato multimediale sconosciuto

Configurazione di GStreamer

Speech SDK può usare GStreamer per gestire l'audio compresso. Per motivi di licenza, i file binari GStreamer non vengono compilati e collegati con Speech SDK. È necessario installare alcune dipendenze e plug-in.

I file binari GStreamer devono trovarsi nel percorso di sistema in modo che possano essere caricati da Speech SDK in fase di esecuzione. Ad esempio, in Windows, se Speech SDK trova libgstreamer-1.0-0.dll o gstreamer-1.0-0.dll (per la versione più recente di GStreamer) durante l’esecuzione, significa che i file binari GStreamer si trovano nel percorso di sistema.

Scegliere una piattaforma per le istruzioni di installazione.

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

Esempio

Per configurare Speech SDK affinché accetti l'input audio compresso, creare PullAudioInputStream o PushAudioInputStream. Creare quindi un AudioConfig partendo da un'istanza della classe di flusso che specifica il formato di compressione del flusso. Trovare il codice di esempio correlato negli esempi di Speech SDK.

Supponiamo di avere una classe di flusso di input denominata pushStream e di usare OPUS/OGG. Il codice potrebbe essere simile al seguente:

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;

Documentazione di riferimento | Pacchetto (Go) | Ulteriori esempi in GitHub

Speech SDK e l'interfaccia della riga di comando di Voce usano GStreamer per supportare diversi tipi di formati audio di input. GStreamer decomprime l'audio prima che venga inviato in rete al servizio Voce come PCM non elaborato.

Il formato di streaming audio predefinito è WAV (16 kHz o 8 kHz, 16 bit e PCM mono). All'esterno di WAV e PCM, sono supportati anche i formati di input compressi seguenti tramite GStreamer:

• MP3
• OPUS/OGG
• FLAC
• ALAW nel contenitore WAV
• MULAW nel contenitore WAV
• ANY per il contenitore MP4 o il formato multimediale sconosciuto

Configurazione di GStreamer

Speech SDK può usare GStreamer per gestire l'audio compresso. Per motivi di licenza, i file binari GStreamer non vengono compilati e collegati con Speech SDK. È necessario installare alcune dipendenze e plug-in.

È necessario installare diverse dipendenze e plug-in.

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

Per altre informazioni, vedere Istruzioni per l'installazione di Linux e distribuzioni Linux supportate e architetture di destinazione.

Esempio

Per configurare Speech SDK affinché accetti l'input audio compresso, creare un PullAudioInputStream o PushAudioInputStream. Creare quindi un AudioConfig partendo da un'istanza della classe di flusso che specifica il formato di compressione del flusso.

Nell'esempio seguente si presuppone che il caso d'uso sia utilizzare PushStream per un file compresso.

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

documentazione di riferimento | Esempi aggiuntivi in GitHub

Speech SDK e l'interfaccia della riga di comando di Voce usano GStreamer per supportare diversi tipi di formati audio di input. GStreamer decomprime l'audio prima che venga inviato in rete al servizio Voce come PCM non elaborato.

Il formato di streaming audio predefinito è WAV (16 kHz o 8 kHz, 16 bit e PCM mono). All'esterno di WAV e PCM, sono supportati anche i formati di input compressi seguenti tramite GStreamer:

• MP3
• OPUS/OGG
• FLAC
• ALAW nel contenitore WAV
• MULAW nel contenitore WAV
• ANY per il contenitore MP4 o il formato multimediale sconosciuto

Configurazione di GStreamer

Speech SDK può usare GStreamer per gestire l'audio compresso. Per motivi di licenza, i file binari GStreamer non vengono compilati e collegati con Speech SDK. È necessario installare alcune dipendenze e plug-in.

I file binari GStreamer devono trovarsi nel percorso di sistema in modo che possano essere caricati da Speech SDK in fase di esecuzione. Ad esempio, in Windows, se Speech SDK trova libgstreamer-1.0-0.dll o gstreamer-1.0-0.dll (per la versione più recente di GStreamer) durante l’esecuzione, significa che i file binari GStreamer si trovano nel percorso di sistema.

Scegliere una piattaforma per le istruzioni di installazione.

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

# 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

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

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

Esempio

Per configurare Speech SDK affinché accetti l'input audio compresso, creare un PullAudioInputStream o PushAudioInputStream. Creare quindi un AudioConfig partendo da un'istanza della classe di flusso che specifica il formato di compressione del flusso. Trovare il codice di esempio correlato negli esempi di Speech SDK.

Si supponga di avere una classe di flusso di input denominata pullAudio e di utilizzare MP3. Il codice potrebbe essere simile al seguente:

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

Documentazione di riferimento | Pacchetto (npm) | Ulteriori esempi in GitHub | Codice sorgente della libreria

Speech SDK per JavaScript non supporta audio compresso.

Il formato di streaming audio predefinito è WAV (16 kHz o 8 kHz, 16 bit e PCM mono). Per immettere un file audio compresso (come un mp3), occorre prima convertirlo in un file WAV nel formato di input predefinito. Per trasmettere l'audio compresso, occorre prima decodificare i buffer audio nel formato di input predefinito. Per altre informazioni, vedere Come usare il flussodi input audio.

Documentazione di riferimento | Pacchetto (download) | Ulteriori esempi in GitHub

Speech SDK per Objective-C non supporta l'audio compresso.

Il formato di streaming audio predefinito è WAV (16 kHz o 8 kHz, 16 bit e PCM mono). Per immettere un file audio compresso (come un mp3), occorre prima convertirlo in un file WAV nel formato di input predefinito. Per trasmettere l'audio compresso, occorre prima decodificare i buffer audio nel formato di input predefinito. Per altre informazioni, vedere Come usare il flussodi input audio.

Documentazione di riferimento | Pacchetto (download) | Ulteriori esempi in GitHub

Speech SDK per Swift non supporta l'audio compresso.

Il formato di streaming audio predefinito è WAV (16 kHz o 8 kHz, 16 bit e PCM mono). Per immettere un file audio compresso (come un mp3), occorre prima convertirlo in un file WAV nel formato di input predefinito. Per trasmettere l'audio compresso, occorre prima decodificare i buffer audio nel formato di input predefinito. Per altre informazioni, vedere Come usare il flussodi input audio.

Documentazione di riferimento | Pacchetto (PyPi) | Ulteriori esempi in GitHub

Speech SDK e l'interfaccia della riga di comando di Voce usano GStreamer per supportare diversi tipi di formati audio di input. GStreamer decomprime l'audio prima che venga inviato in rete al servizio Voce come PCM non elaborato.

Il formato di streaming audio predefinito è WAV (16 kHz o 8 kHz, 16 bit e PCM mono). All'esterno di WAV e PCM, sono supportati anche i formati di input compressi seguenti tramite GStreamer:

• MP3
• OPUS/OGG
• FLAC
• ALAW nel contenitore WAV
• MULAW nel contenitore WAV
• ANY per il contenitore MP4 o il formato multimediale sconosciuto

Configurazione di GStreamer

Speech SDK può usare GStreamer per gestire l'audio compresso. Per motivi di licenza, i file binari GStreamer non vengono compilati e collegati con Speech SDK. È necessario installare alcune dipendenze e plug-in.

I file binari GStreamer devono trovarsi nel percorso di sistema in modo che possano essere caricati da Speech SDK in fase di esecuzione. Ad esempio, in Windows, se Speech SDK trova libgstreamer-1.0-0.dll o gstreamer-1.0-0.dll (per la versione più recente di GStreamer) durante l’esecuzione, significa che i file binari GStreamer si trovano nel percorso di sistema.

Scegliere una piattaforma per le istruzioni di installazione.

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

Esempio

Per configurare Speech SDK affinché accetti l'input audio compresso, creare PullAudioInputStream o PushAudioInputStream. Creare quindi un AudioConfig partendo da un'istanza della classe di flusso che specifica il formato di compressione del flusso.

Si supponga che il caso d'uso sia utilizzare PullStream per un file MP3. Il codice potrebbe essere simile al seguente:

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)

Informazioni di riferimento sull'API REST di riconoscimento vocale | Informazioni di riferimento sull'API REST di riconoscimento vocale per audio brevi | Ulteriori esempi in GitHub

È possibile usare l'API REST per audio compresso, ma non è ancora disponibile una guida. Selezionare un altro linguaggio di programmazione per iniziare e ottenere informazioni sui concetti.

Speech SDK e l'interfaccia della riga di comando di Voce usano GStreamer per supportare diversi tipi di formati audio di input. GStreamer decomprime l'audio prima che venga inviato in rete al servizio Voce come PCM non elaborato.

Il formato di streaming audio predefinito è WAV (16 kHz o 8 kHz, 16 bit e PCM mono). All'esterno di WAV e PCM, sono supportati anche i formati di input compressi seguenti tramite GStreamer:

• MP3
• OPUS/OGG
• FLAC
• ALAW nel contenitore WAV
• MULAW nel contenitore WAV
• ANY per il contenitore MP4 o il formato multimediale sconosciuto

Configurazione di GStreamer

L'interfaccia della riga di comando di Voce può usare GStreamer per gestire l'audio compresso. Per motivi di licenza, i file binari GStreamer non vengono compilati e collegati all'interfaccia della riga di comando di Voce. È necessario installare alcune dipendenze e plug-in.

I file binari GStreamer devono trovarsi nel percorso di sistema affinché possano essere caricati dall'interfaccia della riga di comando di Voce in fase di esecuzione. Ad esempio, in Windows, se l'interfaccia della riga di comando di Voce trova libgstreamer-1.0-0.dll o gstreamer-1.0-0.dll (per la versione più recente di GStreamer) durante l’esecuzione, significa che i file binari GStreamer si trovano nel percorso di sistema.

Scegliere una piattaforma per le istruzioni di installazione.

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

Esempio

L'opzione --format specifica il formato del contenitore per il riconoscimento del file audio. Per un file mp4, impostare il formato su any come illustrato nel comando seguente:

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

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

Per ottenere un elenco dei formati audio supportati, eseguire il comando seguente:

spx help recognize format

spx help recognize format