Come usare l'audio di input compresso

  • Articolo

Pacchetto della documentazione di riferimento | (NuGet) | 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 il runtime, significa che i file binari GStreamer si trovano nel percorso di sistema.

Scegliere una piattaforma per le istruzioni di installazione.

È 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 per accettare l'input audio compresso, creare PullAudioInputStream o PushAudioInputStream. Creare quindi un oggetto da un'istanza AudioConfig 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.

Si supponga 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;

Pacchetto della documentazione di riferimento | (NuGet) | 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 il runtime, significa che i file binari GStreamer si trovano nel percorso di sistema.

Scegliere una piattaforma per le istruzioni di installazione.

È 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 per accettare l'input audio compresso, creare PullAudioInputStream o PushAudioInputStream. Creare quindi un oggetto da un'istanza AudioConfig 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 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;

Pacchetto della documentazione di riferimento | (Go) | 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.

È 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 per accettare l'input audio compresso, creare un PullAudioInputStream oggetto o PushAudioInputStream. Creare quindi un oggetto da un'istanza AudioConfig della classe di flusso che specifica il formato di compressione del flusso.

Nell'esempio seguente si presuppone che il caso d'uso sia quello di usare 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 su 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 il runtime, significa che i file binari GStreamer si trovano nel percorso di sistema.

Scegliere una piattaforma per le istruzioni di installazione.

La gestione dell'audio compresso viene implementata tramite GStreamer. Per motivi di licenza, i file binari GStreamer non vengono compilati e collegati con Speech SDK. È invece necessario usare i file binari predefiniti per Android. Per scaricare le librerie predefinite, vedere Installazione per lo sviluppo android.

L'oggetto libgstreamer_android.so è obbligatorio. Assicurarsi che tutti i plug-in GStreamer (dal file Android.mk che segue) siano collegati in libgstreamer_android.so. Quando si usa Speech SDK con GStreamer versione 1.18.3, libc++_shared.so è necessario anche essere presenti da Android ndk.

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

Di seguito è riportato un esempio Android.mk e Application.mk un file. Seguire questa procedura per creare l'oggetto gstreamer condiviso: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

È possibile compilare libgstreamer_android.so usando il comando seguente in Ubuntu 18.04 o 20.04. Le righe di comando seguenti sono state testate per [GStreamer Android versione 1.14.4] con 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)

Dopo aver compilato l'oggetto condiviso (libgstreamer_android.so), posizionare l'oggetto condiviso nell'app Android in modo che Speech SDK possa caricarlo.

Esempio

Per configurare Speech SDK per accettare l'input audio compresso, creare un PullAudioInputStream oggetto o PushAudioInputStream. Creare quindi un oggetto da un'istanza AudioConfig 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 che usi 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);

Pacchetto della documentazione di riferimento | (npm) | Esempi aggiuntivi nel codice sorgente della libreria GitHub |

Speech SDK per JavaScript 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 (ad esempio mp3), devi prima convertirlo in un file WAV nel formato di input predefinito. Per trasmettere l'audio compresso, devi prima decodificare i buffer audio nel formato di input predefinito. Per altre informazioni, vedere Come usare il flusso di input audio.

Pacchetto della documentazione di riferimento | (download) | Esempi aggiuntivi 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 (ad esempio mp3), devi prima convertirlo in un file WAV nel formato di input predefinito. Per trasmettere l'audio compresso, devi prima decodificare i buffer audio nel formato di input predefinito. Per altre informazioni, vedere Come usare il flusso di input audio.

Pacchetto della documentazione di riferimento | (download) | Esempi aggiuntivi 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 (ad esempio mp3), devi prima convertirlo in un file WAV nel formato di input predefinito. Per trasmettere l'audio compresso, devi prima decodificare i buffer audio nel formato di input predefinito. Per altre informazioni, vedere Come usare il flusso di input audio.

Pacchetto della documentazione di riferimento | (PyPi) | 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 il runtime, significa che i file binari GStreamer si trovano nel percorso di sistema.

Scegliere una piattaforma per le istruzioni di installazione.

È 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 per accettare l'input audio compresso, creare PullAudioInputStream o PushAudioInputStream. Creare quindi un oggetto da un'istanza AudioConfig della classe di flusso che specifica il formato di compressione del flusso.

Si supponga che il caso d'uso sia quello di usare PullStream per un MP3 file. 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 Riconoscimento vocale in testo per brevi riferimenti | audio Esempi aggiuntivi in GitHub

È possibile usare l'API REST per l'audio compresso, ma non è ancora stata inclusa una guida qui. Selezionare un altro linguaggio di programmazione per iniziare e apprendere i 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 in modo che 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 il runtime, significa che i file binari GStreamer si trovano nel percorso di sistema.

Scegliere una piattaforma per le istruzioni di installazione.

È 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

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

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

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

spx help recognize format

Passaggi successivi