Delen via

Quickstart: Audiostreaming aan serverzijde

  • Artikel

Belangrijk

De functionaliteit die in dit artikel wordt beschreven, is momenteel beschikbaar als openbare preview. Deze preview-versie wordt geleverd zonder een service level agreement en we raden deze niet aan voor productieworkloads. Misschien worden bepaalde functies niet ondersteund of zijn de mogelijkheden ervan beperkt. Zie Aanvullende gebruiksvoorwaarden voor Microsoft Azure-previews voor meer informatie.

Aan de slag met het gebruik van audiostreams via de Audio Streaming-API van Azure Communication Services. In deze quickstart wordt ervan uitgegaan dat u al bekend bent met Call Automation-API's om een geautomatiseerde oplossing voor oproeproutering te bouwen.

De functionaliteit die in deze quickstart wordt beschreven, is momenteel beschikbaar als openbare preview.

Vereisten

Een websocket-server instellen

Voor Azure Communication Services moet uw servertoepassing een WebSocket-server instellen om audio in realtime te streamen. WebSocket is een gestandaardiseerd protocol dat een full-duplex communicatiekanaal biedt via één TCP-verbinding. U kunt eventueel Azure-services van Azure WebApps gebruiken waarmee u een toepassing kunt maken voor het ontvangen van audiostreams via een websocket-verbinding. Volg deze quickstart.

Een oproep tot stand brengen

Een oproep tot stand brengen en streaminggegevens opgeven

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

Audiostreaming starten

Audiostreaming starten:

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

Wanneer Azure Communication Services de URL voor uw WebSocket-server ontvangt, wordt er een verbinding met de server gemaakt. Zodra Azure Communication Services verbinding heeft gemaakt met uw WebSocket-server en streaming is gestart, wordt het verzonden via het eerste gegevenspakket, dat metagegevens bevat over de binnenkomende mediapakketten.

Het metagegevenspakket ziet er als volgt uit:

{ 
    "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 
    } 
}

Audiostreaming stoppen

Audiostreaming stoppen

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

Audiostreams verwerken in uw websocket-server

In het onderstaande voorbeeld ziet u hoe u audiostreams kunt beluisteren met behulp van uw websocket-server.

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

Vereisten

Een websocket-server instellen

Voor Azure Communication Services moet uw servertoepassing een WebSocket-server instellen om audio in realtime te streamen. WebSocket is een gestandaardiseerd protocol dat een full-duplex communicatiekanaal biedt via één TCP-verbinding. U kunt eventueel Azure-services van Azure WebApps gebruiken waarmee u een toepassing kunt maken voor het ontvangen van audiostreams via een websocket-verbinding. Volg deze quickstart.

Een oproep tot stand brengen

Een oproep tot stand brengen en streaminggegevens opgeven

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(); 

Audiostreaming starten

Audiostreaming starten:

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

Wanneer Azure Communication Services de URL voor uw WebSocket-server ontvangt, wordt er een verbinding met de server gemaakt. Zodra Azure Communication Services verbinding heeft gemaakt met uw WebSocket-server en streaming is gestart, wordt het verzonden via het eerste gegevenspakket, dat metagegevens bevat over de binnenkomende mediapakketten.

Het metagegevenspakket ziet er als volgt uit:

{ 
    "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 
    } 
}

Audiostreaming stoppen

Audiostreaming stoppen

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

Mediastreams verwerken in uw websocket-server

In het onderstaande voorbeeld ziet u hoe u naar mediastream kunt luisteren met behulp van uw websocket-server. Er zijn twee bestanden die moeten worden uitgevoerd: App.java en 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("----------------------------------------------------------------");
        }
    }
}

Vereisten

  • Azure-account met een actief abonnement, zie Gratis een account maken voor meer informatie .
  • Een Azure Communication Services-resource. Zie Een Azure Communication Services-resource maken.
  • Een nieuwe webservicetoepassing die is gemaakt met behulp van de Call Automation SDK.
  • Node.js LTS-installatie
  • Een websocket-server die mediastreams kan ontvangen.

Een websocket-server instellen

Voor Azure Communication Services moet uw servertoepassing een WebSocket-server instellen om audio in realtime te streamen. WebSocket is een gestandaardiseerd protocol dat een full-duplex communicatiekanaal biedt via één TCP-verbinding. U kunt eventueel Azure-services van Azure WebApps gebruiken waarmee u een toepassing kunt maken voor het ontvangen van audiostreams via een websocket-verbinding. Volg deze quickstart.

Een oproep tot stand brengen

Een oproep tot stand brengen en streaminggegevens opgeven

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

Audiostreaming starten

Audiostreaming starten:

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

Wanneer Azure Communication Services de URL voor uw WebSocket-server ontvangt, wordt er een verbinding met de server gemaakt. Zodra Azure Communication Services verbinding heeft gemaakt met uw WebSocket-server en streaming is gestart, wordt het verzonden via het eerste gegevenspakket, dat metagegevens bevat over de binnenkomende mediapakketten.

Het metagegevenspakket ziet er als volgt uit:

{ 
    "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 
    } 
}

Audiostreaming stoppen

Audiostreaming stoppen

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

Audiostreams verwerken in uw websocket-server

In het onderstaande voorbeeld ziet u hoe u audiostreams kunt beluisteren met behulp van uw websocket-server.

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');

Vereisten

Een websocket-server instellen

Voor Azure Communication Services moet uw servertoepassing een WebSocket-server instellen om audio in realtime te streamen. WebSocket is een gestandaardiseerd protocol dat een full-duplex communicatiekanaal biedt via één TCP-verbinding. U kunt eventueel Azure-services van Azure WebApps gebruiken waarmee u een toepassing kunt maken voor het ontvangen van audiostreams via een websocket-verbinding. Volg deze quickstart.

Een oproep tot stand brengen

Een oproep tot stand brengen en streaminggegevens opgeven

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
)

Audiostreaming starten

Audiostreaming starten:

call_connection_client.start_media_streaming()

Wanneer Azure Communication Services de URL voor uw WebSocket-server ontvangt, wordt er een verbinding met de server gemaakt. Zodra Azure Communication Services verbinding heeft gemaakt met uw WebSocket-server en streaming is gestart, wordt het verzonden via het eerste gegevenspakket, dat metagegevens bevat over de binnenkomende mediapakketten.

Het metagegevenspakket ziet er als volgt uit:

{ 
    "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 
    } 
}

Audiostreaming stoppen

Audiostreaming stoppen

call_connection_client.stop_media_streaming()

Audiostreams verwerken in uw websocket-server

In het onderstaande voorbeeld ziet u hoe u audiostreams kunt beluisteren met behulp van uw websocket-server.

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

Audiostreamingschema

Nadat het metagegevenspakket is verzonden, begint Azure Communication Services met het streamen van audiomedia naar uw WebSocket-server. Hieronder ziet u een voorbeeld van hoe het mediaobject dat uw server ontvangt eruitziet.

{
    "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.
    }
}

Resources opschonen

Als u een Communication Services-abonnement wilt opschonen en verwijderen, kunt u de resource of resourcegroep verwijderen. Als u de resourcegroep verwijdert, worden ook alle bijbehorende resources verwijderd. Meer informatie over het opschonen van resources.

Volgende stappen