Udostępnij za pośrednictwem

Szybki start: przesyłanie strumieniowe audio po stronie serwera

  • Artykuł

Ważne

Funkcje opisane w tym artykule są obecnie dostępne w publicznej wersji zapoznawczej. Ta wersja zapoznawcza jest udostępniana bez umowy dotyczącej poziomu usług i nie zalecamy korzystania z niej w przypadku obciążeń produkcyjnych. Niektóre funkcje mogą być nieobsługiwane lub ograniczone. Aby uzyskać więcej informacji, zobacz Uzupełniające warunki korzystania z wersji zapoznawczych platformy Microsoft Azure.

Rozpoczynanie pracy ze strumieniami audio za pośrednictwem interfejsu API przesyłania strumieniowego audio usług Azure Communication Services. W tym przewodniku Szybki start założono, że znasz już interfejsy API usługi Call Automation w celu utworzenia zautomatyzowanego rozwiązania do routingu wywołań.

Funkcje opisane w tym przewodniku Szybki start są obecnie dostępne w publicznej wersji zapoznawczej.

Wymagania wstępne

Konfigurowanie serwera websocket

Usługi Azure Communication Services wymagają, aby aplikacja serwera skonfigurowała serwer WebSocket w celu strumieniowego przesyłania dźwięku w czasie rzeczywistym. WebSocket to ustandaryzowany protokół, który zapewnia kanał komunikacji pełnodupleksowej za pośrednictwem jednego połączenia TCP. Opcjonalnie możesz użyć usług platformy Azure WebApps, które umożliwiają tworzenie aplikacji w celu odbierania strumieni audio za pośrednictwem połączenia websocket. Postępuj zgodnie z tym przewodnikiem Szybki start.

Ustanawianie połączenia

Ustanów połączenie i podaj szczegóły przesyłania strumieniowego

MediaStreamingOptions mediaStreamingOptions = new MediaStreamingOptions( 
    new Uri("<WEBSOCKET URL>"), 
    MediaStreamingContent.Audio, 
    MediaStreamingAudioChannel.Mixed, 
    MediaStreamingTransport.Websocket, 
    false); 

 var createCallOptions = new CreateCallOptions(callInvite, callbackUri) 
 { 
     CallIntelligenceOptions = new CallIntelligenceOptions() { CognitiveServicesEndpoint = new Uri(cognitiveServiceEndpoint) }, 
     MediaStreamingOptions = mediaStreamingOptions, 
 }; 

 CreateCallResult createCallResult = await callAutomationClient.CreateCallAsync(createCallOptions);

Uruchamianie przesyłania strumieniowego audio

Jak uruchomić przesyłanie strumieniowe audio:

StartMediaStreamingOptions options = new StartMediaStreamingOptions() 
    { 
        OperationCallbackUri = new Uri(callbackUriHost), 
        OperationContext = "startMediaStreamingContext" 
    };
    await callMedia.StartMediaStreamingAsync(options);

Gdy usługi Azure Communication Services odbierają adres URL serwera WebSocket, tworzy z nim połączenie. Po pomyślnym nawiązaniu połączenia z serwerem WebSocket i uruchomieniu przesyłania strumieniowego usługi Azure Communication Services usługa będzie wysyłać za pośrednictwem pierwszego pakietu danych zawierającego metadane dotyczące przychodzących pakietów multimedialnych.

Pakiet metadanych będzie wyglądać następująco:

{ 
    "kind": <string> // What kind of data this is, e.g. AudioMetadata, AudioData. 
    "audioMetadata": { 
        "subscriptionId": <string>, // unique identifier for a subscription request 
        "encoding":<string>, // PCM only supported 
        "sampleRate": <int>, // 16000 default 
        "channels": <int>, // 1 default 
        "length": <int> // 640 default 
    } 
}

Zatrzymywanie przesyłania strumieniowego audio

Jak zatrzymać przesyłanie strumieniowe audio

StopMediaStreamingOptions stopOptions = new StopMediaStreamingOptions() 
    { 
        OperationCallbackUri = new Uri(callbackUriHost) 
    }; 
    await callMedia.StopMediaStreamingAsync(stopOptions);

Obsługa strumieni audio na serwerze websocket

W poniższym przykładzie pokazano, jak nasłuchiwać strumieni audio przy użyciu serwera websocket.

HttpListener httpListener = new HttpListener(); 
httpListener.Prefixes.Add("http://localhost:80/"); 
httpListener.Start(); 

while (true) 
{ 
    HttpListenerContext httpListenerContext = await httpListener.GetContextAsync(); 
    if (httpListenerContext.Request.IsWebSocketRequest) 
    { 
        WebSocketContext websocketContext; 
        try 
        { 
            websocketContext = await httpListenerContext.AcceptWebSocketAsync(subProtocol: null); 
        } 
        catch (Exception ex) 
        { 
            return; 
        } 
        WebSocket webSocket = websocketContext.WebSocket; 
        try 
        { 
            while (webSocket.State == WebSocketState.Open || webSocket.State == WebSocketState.CloseSent) 
            { 
                byte[] receiveBuffer = new byte[2048]; 
                var cancellationToken = new CancellationTokenSource(TimeSpan.FromSeconds(60)).Token; 
                WebSocketReceiveResult receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), cancellationToken); 
                if (receiveResult.MessageType != WebSocketMessageType.Close) 
                { 
                    var data = Encoding.UTF8.GetString(receiveBuffer).TrimEnd('\0'); 
                    try 
                    { 
                        var eventData = JsonConvert.DeserializeObject<AudioBaseClass>(data); 
                        if (eventData != null) 
                        { 
                            if(eventData.kind == "AudioMetadata") 
                            { 
                                //Process audio metadata 
                            } 
                            else if(eventData.kind == "AudioData")  
                            { 
                                //Process audio data 
                                var byteArray = eventData.audioData.data; 
                               //use audio byteArray as you want 
                            } 
                        } 
                    } 
                    catch { } 
                } 
            } 
        } 
        catch (Exception ex) { } 
    } 
}

Wymagania wstępne

Konfigurowanie serwera websocket

Usługi Azure Communication Services wymagają, aby aplikacja serwera skonfigurowała serwer WebSocket w celu strumieniowego przesyłania dźwięku w czasie rzeczywistym. WebSocket to ustandaryzowany protokół, który zapewnia kanał komunikacji pełnodupleksowej za pośrednictwem jednego połączenia TCP. Opcjonalnie możesz użyć usług platformy Azure WebApps, które umożliwiają tworzenie aplikacji w celu odbierania strumieni audio za pośrednictwem połączenia websocket. Postępuj zgodnie z tym przewodnikiem Szybki start.

Ustanawianie połączenia

Ustanów połączenie i podaj szczegóły przesyłania strumieniowego

CallInvite callInvite = new CallInvite(target, caller);  
              
            CallIntelligenceOptions callIntelligenceOptions = new CallIntelligenceOptions().setCognitiveServicesEndpoint(appConfig.getCognitiveServiceEndpoint());  
            MediaStreamingOptions mediaStreamingOptions = new MediaStreamingOptions(appConfig.getWebSocketUrl(), MediaStreamingTransport.WEBSOCKET, MediaStreamingContentType.AUDIO, MediaStreamingAudioChannel.UNMIXED);  
            mediaStreamingOptions.setStartMediaStreaming(false);  
          
            CreateCallOptions createCallOptions = new CreateCallOptions(callInvite, appConfig.getCallBackUri());  
            createCallOptions.setCallIntelligenceOptions(callIntelligenceOptions);  
            createCallOptions.setMediaStreamingOptions(mediaStreamingOptions);  
  
            Response<CreateCallResult> result = client.createCallWithResponse(createCallOptions, Context.NONE);  
            return result.getValue().getCallConnectionProperties().getCallConnectionId(); 

Uruchamianie przesyłania strumieniowego audio

Jak uruchomić przesyłanie strumieniowe audio:

StartMediaStreamingOptions startOptions = new StartMediaStreamingOptions()  
                                                        .setOperationContext("startMediaStreamingContext")  
                                                        .setOperationCallbackUrl(appConfig.getBasecallbackuri());  
         client.getCallConnection(callConnectionId)  
                     .getCallMedia()  
                     .startMediaStreamingWithResponse(startOptions, Context.NONE);     

Gdy usługi Azure Communication Services odbierają adres URL serwera WebSocket, tworzy z nim połączenie. Po pomyślnym nawiązaniu połączenia z serwerem WebSocket i uruchomieniu przesyłania strumieniowego usługi Azure Communication Services usługa będzie wysyłać za pośrednictwem pierwszego pakietu danych zawierającego metadane dotyczące przychodzących pakietów multimedialnych.

Pakiet metadanych będzie wyglądać następująco:

{ 
    "kind": <string> // What kind of data this is, e.g. AudioMetadata, AudioData. 
    "audioMetadata": { 
        "subscriptionId": <string>, // unique identifier for a subscription request 
        "encoding":<string>, // PCM only supported 
        "sampleRate": <int>, // 16000 default 
        "channels": <int>, // 1 default 
        "length": <int> // 640 default 
    } 
}

Zatrzymywanie przesyłania strumieniowego audio

Jak zatrzymać przesyłanie strumieniowe audio

StopMediaStreamingOptions stopOptions = new StopMediaStreamingOptions()  
                                                        .setOperationCallbackUrl(appConfig.getBasecallbackuri());  
         client.getCallConnection(callConnectionId)  
                     .getCallMedia()  
                     .stopMediaStreamingWithResponse(stopOptions, Context.NONE);

Obsługa strumieni multimediów na serwerze websocket

W poniższym przykładzie pokazano, jak nasłuchiwać strumienia multimediów przy użyciu serwera websocket. Będą uruchamiane dwa pliki: App.java i WebSocketServer.java

package com.example;

import org.glassfish.tyrus.server.Server;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class App {
    public static void main(String[] args) {

        Server server = new Server("localhost", 8081, "/ws", null, WebSocketServer.class);

        try {
            server.start();
            System.out.println("Web socket running on port 8081...");
            System.out.println("wss://localhost:8081/ws/server");
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            reader.readLine();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            server.stop();
        }
    }
}

package com.example;

import javax.websocket.OnMessage;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

import com.azure.communication.callautomation.models.streaming.StreamingData;
import com.azure.communication.callautomation.models.streaming.StreamingDataParser;
import com.azure.communication.callautomation.models.streaming.media.AudioData;
import com.azure.communication.callautomation.models.streaming.media.AudioMetadata;

@ServerEndpoint("/server")
public class WebSocketServer {
    @OnMessage
    public void onMessage(String message, Session session) {

        // System.out.println("Received message: " + message);

        StreamingData data = StreamingDataParser.parse(message);

        if (data instanceof AudioMetadata) {
            AudioMetadata audioMetaData = (AudioMetadata) data;
            System.out.println("----------------------------------------------------------------");
            System.out.println("SUBSCRIPTION ID:-->" + audioMetaData.getMediaSubscriptionId());
            System.out.println("ENCODING:-->" + audioMetaData.getEncoding());
            System.out.println("SAMPLE RATE:-->" + audioMetaData.getSampleRate());
            System.out.println("CHANNELS:-->" + audioMetaData.getChannels());
            System.out.println("LENGTH:-->" + audioMetaData.getLength());
            System.out.println("----------------------------------------------------------------");
        }
        if (data instanceof AudioData) {
            System.out.println("----------------------------------------------------------------");
            AudioData audioData = (AudioData) data;
            System.out.println("DATA:-->" + audioData.getData());
            System.out.println("TIMESTAMP:-->" + audioData.getTimestamp());
            // System.out.println("PARTICIPANT:-->" + audioData.getParticipant().getRawId()
            // != null
            // ? audioData.getParticipant().getRawId()
            // : "");
            System.out.println("IS SILENT:-->" + audioData.isSilent());
            System.out.println("----------------------------------------------------------------");
        }
    }
}

Wymagania wstępne

Konfigurowanie serwera websocket

Usługi Azure Communication Services wymagają, aby aplikacja serwera skonfigurowała serwer WebSocket w celu strumieniowego przesyłania dźwięku w czasie rzeczywistym. WebSocket to ustandaryzowany protokół, który zapewnia kanał komunikacji pełnodupleksowej za pośrednictwem jednego połączenia TCP. Opcjonalnie możesz użyć usług platformy Azure WebApps, które umożliwiają tworzenie aplikacji w celu odbierania strumieni audio za pośrednictwem połączenia websocket. Postępuj zgodnie z tym przewodnikiem Szybki start.

Ustanawianie połączenia

Ustanów połączenie i podaj szczegóły przesyłania strumieniowego

const mediaStreamingOptions: MediaStreamingOptions = { 
          transportUrl: "<WEBSOCKET URL>", 
          transportType: "websocket", 
          contentType: "audio", 
          audioChannelType: "unmixed", 
          startMediaStreaming: false 
} 
const options: CreateCallOptions = { 
          callIntelligenceOptions: { cognitiveServicesEndpoint: process.env.COGNITIVE_SERVICES_ENDPOINT }, 
          mediaStreamingOptions: mediaStreamingOptions 
};

Uruchamianie przesyłania strumieniowego audio

Jak uruchomić przesyłanie strumieniowe audio:

const streamingOptions: StartMediaStreamingOptions = { 
        operationContext: "startMediaStreamingContext", 
        operationCallbackUrl: process.env.CALLBACK_URI + "/api/callbacks" 
    } 
await callMedia.startMediaStreaming(streamingOptions);

Gdy usługi Azure Communication Services odbierają adres URL serwera WebSocket, tworzy z nim połączenie. Po pomyślnym nawiązaniu połączenia z serwerem WebSocket i uruchomieniu przesyłania strumieniowego usługi Azure Communication Services usługa będzie wysyłać za pośrednictwem pierwszego pakietu danych zawierającego metadane dotyczące przychodzących pakietów multimedialnych.

Pakiet metadanych będzie wyglądać następująco:

{ 
    "kind": <string> // What kind of data this is, e.g. AudioMetadata, AudioData. 
    "audioMetadata": { 
        "subscriptionId": <string>, // unique identifier for a subscription request 
        "encoding":<string>, // PCM only supported 
        "sampleRate": <int>, // 16000 default 
        "channels": <int>, // 1 default 
        "length": <int> // 640 default 
    } 
}

Zatrzymywanie przesyłania strumieniowego audio

Jak zatrzymać przesyłanie strumieniowe audio

const stopMediaStreamingOptions: StopMediaStreamingOptions = { 
        operationCallbackUrl: process.env.CALLBACK_URI + "/api/callbacks" 
        } 
await callMedia.stopMediaStreaming(stopMediaStreamingOptions);

Obsługa strumieni audio na serwerze websocket

W poniższym przykładzie pokazano, jak nasłuchiwać strumieni audio przy użyciu serwera websocket.

import WebSocket from 'ws'; 
import { streamingData } from '@azure/communication-call-automation/src/utli/streamingDataParser' 
const wss = new WebSocket.Server({ port: 8081 }); 

wss.on('connection', (ws: WebSocket) => { 
    console.log('Client connected'); 
    ws.on('message', (packetData: ArrayBuffer) => { 
        const decoder = new TextDecoder(); 
        const stringJson = decoder.decode(packetData); 
        console.log("STRING JSON=>--" + stringJson) 

        //var response = streamingData(stringJson); 

        var response = streamingData(packetData); 
        if ('locale' in response) { 
            console.log("Transcription Metadata") 
            console.log(response.callConnectionId); 
            console.log(response.correlationId); 
            console.log(response.locale); 
            console.log(response.subscriptionId); 
        } 
        if ('text' in response) { 
            console.log("Transcription Data") 
            console.log(response.text); 
            console.log(response.format); 
            console.log(response.confidence); 
            console.log(response.offset); 
            console.log(response.duration); 
            console.log(response.resultStatus); 
            if ('phoneNumber' in response.participant) { 
                console.log(response.participant.phoneNumber); 
            } 
            response.words.forEach(element => { 
                console.log(element.text) 
                console.log(element.duration) 
                console.log(element.offset) 
            }); 
        } 
    }); 

    ws.on('close', () => { 
        console.log('Client disconnected'); 
    }); 
}); 

// function processData(data: ArrayBuffer) { 
//  const byteArray = new Uint8Array(data); 
// } 

console.log('WebSocket server running on port 8081');

Wymagania wstępne

Konfigurowanie serwera websocket

Usługi Azure Communication Services wymagają, aby aplikacja serwera skonfigurowała serwer WebSocket w celu strumieniowego przesyłania dźwięku w czasie rzeczywistym. WebSocket to ustandaryzowany protokół, który zapewnia kanał komunikacji pełnodupleksowej za pośrednictwem jednego połączenia TCP. Opcjonalnie możesz użyć usług platformy Azure WebApps, które umożliwiają tworzenie aplikacji w celu odbierania strumieni audio za pośrednictwem połączenia websocket. Postępuj zgodnie z tym przewodnikiem Szybki start.

Ustanawianie połączenia

Ustanów połączenie i podaj szczegóły przesyłania strumieniowego

media_streaming_options = MediaStreamingOptions( 
         transport_url="wss://e063-2409-40c2-4004-eced-9487-4dfb-b0e4-10fb.ngrok-free.app", 
         transport_type=MediaStreamingTransportType.WEBSOCKET, 
         content_type=MediaStreamingContentType.AUDIO, 
         audio_channel_type=MediaStreamingAudioChannelType.UNMIXED, 
         start_media_streaming=False 
         ) 

call_connection_properties = call_automation_client.create_call(target_participant,  
                                                                    CALLBACK_EVENTS_URI, 
                                                                    cognitive_services_endpoint=COGNITIVE_SERVICES_ENDPOINT, 
                                                                    source_caller_id_number=source_caller, 
                                                                    media_streaming=media_streaming_options
)

Uruchamianie przesyłania strumieniowego audio

Jak uruchomić przesyłanie strumieniowe audio:

call_connection_client.start_media_streaming()

Gdy usługi Azure Communication Services odbierają adres URL serwera WebSocket, tworzy z nim połączenie. Po pomyślnym nawiązaniu połączenia z serwerem WebSocket i uruchomieniu przesyłania strumieniowego usługi Azure Communication Services usługa będzie wysyłać za pośrednictwem pierwszego pakietu danych zawierającego metadane dotyczące przychodzących pakietów multimedialnych.

Pakiet metadanych będzie wyglądać następująco:

{ 
    "kind": <string> // What kind of data this is, e.g. AudioMetadata, AudioData. 
    "audioMetadata": { 
        "subscriptionId": <string>, // unique identifier for a subscription request 
        "encoding":<string>, // PCM only supported 
        "sampleRate": <int>, // 16000 default 
        "channels": <int>, // 1 default 
        "length": <int> // 640 default 
    } 
}

Zatrzymywanie przesyłania strumieniowego audio

Jak zatrzymać przesyłanie strumieniowe audio

call_connection_client.stop_media_streaming()

Obsługa strumieni audio na serwerze websocket

W poniższym przykładzie pokazano, jak nasłuchiwać strumieni audio przy użyciu serwera websocket.

import asyncio 
import json 
import websockets 

async def handle_client(websocket, path): 
    print("Client connected") 
    try: 
        async for message in websocket: 
            print(message) 
            packet_data = json.loads(message) 
            packet_data = message.encode('utf-8') 
            print("Packet DATA:-->",packet_data) 

    except websockets.exceptions.ConnectionClosedOK: 
        print("Client disconnected") 

start_server = websockets.serve(handle_client, "localhost", 8081) 

print('WebSocket server running on port 8081') 

asyncio.get_event_loop().run_until_complete(start_server) 
asyncio.get_event_loop().run_forever()

Schemat przesyłania strumieniowego audio

Po wysłaniu za pośrednictwem pakietu metadanych usługi Azure Communication Services zaczną przesyłać strumieniowo nośniki audio na serwer WebSocket. Poniżej przedstawiono przykład obiektu multimedialnego, który otrzyma serwer.

{
    "kind": <string>, // What kind of data this is, e.g. AudioMetadata, AudioData.
    "audioData":{
        "data": <string>, // Base64 Encoded audio buffer data
        "timestamp": <string>, // In ISO 8601 format (yyyy-mm-ddThh:mm:ssZ) 
        "participantRawID": <string>, 
        "silent": <boolean> // Indicates if the received audio buffer contains only silence.
    }
}

Czyszczenie zasobów

Jeśli chcesz wyczyścić i usunąć subskrypcję usług Komunikacyjnych, możesz usunąć zasób lub grupę zasobów. Usunięcie grupy zasobów powoduje również usunięcie wszelkich innych skojarzonych z nią zasobów. Dowiedz się więcej o czyszczeniu zasobów.

Następne kroki