@epicgames-ps/lib-pixelstreamingfrontend-ue5.5 0.1.4 → 0.3.0

package/src/PeerConnectionController/PeerConnectionController.ts

@@ -5,6 +5,7 @@ import { Config, OptionParameters, Flags } from '../Config/Config';
 import { AggregatedStats } from './AggregatedStats';
 import { parseRtpParameters, splitSections } from 'sdp';
 import { RTCUtils } from '../Util/RTCUtils';
+import { CodecStats } from './CodecStats';
 
 /**
  * Handles the Peer Connection
@@ -23,11 +24,7 @@ export class PeerConnectionController {
      * @param options - Peer connection Options
      * @param config - The config for our PS experience.
      */
-    constructor(
-        options: RTCConfiguration,
-        config: Config,
-        preferredCodec: string
-    ) {
+    constructor(options: RTCConfiguration, config: Config, preferredCodec: string) {
         this.config = config;
         this.createPeerConnection(options, preferredCodec);
     }
@@ -36,26 +33,18 @@ export class PeerConnectionController {
         // Set the ICE transport to relay if TURN enabled
         if (this.config.isFlagEnabled(Flags.ForceTURN)) {
             options.iceTransportPolicy = 'relay';
-            Logger.Log(
-                Logger.GetStackTrace(),
-                'Forcing TURN usage by setting ICE Transport Policy in peer connection config.'
-            );
+            Logger.Info('Forcing TURN usage by setting ICE Transport Policy in peer connection config.');
         }
 
         // build a new peer connection with the options
         this.peerConnection = new RTCPeerConnection(options);
-        this.peerConnection.onsignalingstatechange = (ev: Event) =>
-            this.handleSignalStateChange(ev);
+        this.peerConnection.onsignalingstatechange = (ev: Event) => this.handleSignalStateChange(ev);
         this.peerConnection.oniceconnectionstatechange = (ev: Event) =>
             this.handleIceConnectionStateChange(ev);
-        this.peerConnection.onicegatheringstatechange = (ev: Event) =>
-            this.handleIceGatheringStateChange(ev);
-        this.peerConnection.ontrack = (ev: RTCTrackEvent) =>
-            this.handleOnTrack(ev);
-        this.peerConnection.onicecandidate = (ev: RTCPeerConnectionIceEvent) =>
-            this.handleIceCandidate(ev);
-        this.peerConnection.ondatachannel = (ev: RTCDataChannelEvent) =>
-            this.handleDataChannel(ev);
+        this.peerConnection.onicegatheringstatechange = (ev: Event) => this.handleIceGatheringStateChange(ev);
+        this.peerConnection.ontrack = (ev: RTCTrackEvent) => this.handleOnTrack(ev);
+        this.peerConnection.onicecandidate = (ev: RTCPeerConnectionIceEvent) => this.handleIceCandidate(ev);
+        this.peerConnection.ondatachannel = (ev: RTCDataChannelEvent) => this.handleDataChannel(ev);
         this.aggregatedStats = new AggregatedStats();
         this.preferredCodec = preferredCodec;
         this.updateCodecSelection = true;
@@ -66,26 +55,24 @@ export class PeerConnectionController {
      * @param offerOptions - RTC Offer Options
      */
     async createOffer(offerOptions: RTCOfferOptions, config: Config) {
-        Logger.Log(Logger.GetStackTrace(), 'Create Offer', 6);
+        Logger.Info('Create Offer');
 
-        const isLocalhostConnection =
-            location.hostname === 'localhost' ||
-            location.hostname === '127.0.0.1';
+        const isLocalhostConnection = location.hostname === 'localhost' || location.hostname === '127.0.0.1';
         const isHttpsConnection = location.protocol === 'https:';
         let useMic = config.isFlagEnabled(Flags.UseMic);
-        if (useMic && !(isLocalhostConnection || isHttpsConnection)) {
+        let useCamera = config.isFlagEnabled(Flags.UseCamera);
+        if ((useMic || useCamera) && !(isLocalhostConnection || isHttpsConnection)) {
             useMic = false;
+            useCamera = false;
             Logger.Error(
-                Logger.GetStackTrace(),
-                'Microphone access in the browser will not work if you are not on HTTPS or localhost. Disabling mic access.'
+                'Microphone and Webcam access in the browser will not work if you are not on HTTPS or localhost. Disabling mic and webcam access.'
             );
             Logger.Error(
-                Logger.GetStackTrace(),
                 "For testing you can enable HTTP microphone access Chrome by visiting chrome://flags/ and enabling 'unsafely-treat-insecure-origin-as-secure'"
             );
         }
 
-        this.setupTransceiversAsync(useMic).finally(() => {
+        this.setupTransceiversAsync(useMic, useCamera).finally(() => {
             this.peerConnection
                 ?.createOffer(offerOptions)
                 .then((offer: RTCSessionDescriptionInit) => {
@@ -104,31 +91,32 @@ export class PeerConnectionController {
      *
      */
     async receiveOffer(offer: RTCSessionDescriptionInit, config: Config) {
-
-        Logger.Log(Logger.GetStackTrace(), 'Receive Offer', 6);
+        Logger.Info('Receive Offer');
 
         this.peerConnection?.setRemoteDescription(offer).then(() => {
             const isLocalhostConnection =
-                location.hostname === 'localhost' ||
-                location.hostname === '127.0.0.1';
+                location.hostname === 'localhost' || location.hostname === '127.0.0.1';
             const isHttpsConnection = location.protocol === 'https:';
             let useMic = config.isFlagEnabled(Flags.UseMic);
-            if (useMic && !(isLocalhostConnection || isHttpsConnection)) {
+            let useCamera = config.isFlagEnabled(Flags.UseCamera);
+            if ((useMic || useCamera) && !(isLocalhostConnection || isHttpsConnection)) {
                 useMic = false;
+                useCamera = false;
                 Logger.Error(
-                    Logger.GetStackTrace(),
-                    'Microphone access in the browser will not work if you are not on HTTPS or localhost. Disabling mic access.'
+                    'Microphone and Webcam access in the browser will not work if you are not on HTTPS or localhost. Disabling mic and webcam access.'
                 );
                 Logger.Error(
-                    Logger.GetStackTrace(),
                     "For testing you can enable HTTP microphone access Chrome by visiting chrome://flags/ and enabling 'unsafely-treat-insecure-origin-as-secure'"
                 );
             }
 
             // Add our list of preferred codecs, in order of preference
-            this.config.setOptionSettingOptions(OptionParameters.PreferredCodec, this.fuzzyIntersectUEAndBrowserCodecs(offer));
+            this.config.setOptionSettingOptions(
+                OptionParameters.PreferredCodec,
+                this.fuzzyIntersectUEAndBrowserCodecs(offer)
+            );
 
-            this.setupTransceiversAsync(useMic).finally(() => {
+            this.setupTransceiversAsync(useMic, useCamera).finally(() => {
                 this.peerConnection
                     ?.createAnswer()
                     .then((Answer: RTCSessionDescriptionInit) => {
@@ -136,21 +124,16 @@ export class PeerConnectionController {
                         return this.peerConnection?.setLocalDescription(Answer);
                     })
                     .then(() => {
-                        this.onSendWebRTCAnswer(
-                            this.peerConnection?.currentLocalDescription
-                        );
+                        this.onSendWebRTCAnswer(this.peerConnection?.currentLocalDescription);
                     })
                     .catch(() => {
-                        Logger.Error(
-                            Logger.GetStackTrace(),
-                            'createAnswer() failed'
-                        );
+                        Logger.Error('createAnswer() failed');
                     });
             });
         });
     }
 
-	/**
+    /**
      * Set the Remote Descriptor from the signaling server to the RTC Peer Connection
      * @param answer - RTC Session Descriptor from the Signaling Server
      */
@@ -158,30 +141,59 @@ export class PeerConnectionController {
         this.peerConnection?.setRemoteDescription(answer);
 
         // Add our list of preferred codecs, in order of preference
-        this.config.setOptionSettingOptions(OptionParameters.PreferredCodec, this.fuzzyIntersectUEAndBrowserCodecs(answer));
+        this.config.setOptionSettingOptions(
+            OptionParameters.PreferredCodec,
+            this.fuzzyIntersectUEAndBrowserCodecs(answer)
+        );
     }
 
     /**
      * Generate Aggregated Stats and then fire a onVideo Stats event
      */
     generateStats() {
-        const statsHandler = (StatsData: RTCStatsReport) => {
-            this.aggregatedStats.processStats(StatsData);
-        };
-
-        const audioPromise = this.peerConnection?.getStats(this.audioTrack).then(statsHandler);
-        const videoPromise = this.peerConnection?.getStats(this.videoTrack).then(statsHandler);
+        const audioPromise = this.audioTrack
+            ? this.peerConnection?.getStats(this.audioTrack).then((statsData: RTCStatsReport) => {
+                  this.aggregatedStats.processStats(statsData);
+              })
+            : Promise.resolve();
+        const videoPromise = this.videoTrack
+            ? this.peerConnection?.getStats(this.videoTrack).then((statsData: RTCStatsReport) => {
+                  this.aggregatedStats.processStats(statsData);
+              })
+            : Promise.resolve();
 
         Promise.allSettled([audioPromise, videoPromise]).then(() => {
             this.onVideoStats(this.aggregatedStats);
             // Update the preferred codec selection based on what was actually negotiated
             if (this.updateCodecSelection && !!this.aggregatedStats.inboundVideoStats.codecId) {
-                this.config.setOptionSettingValue(
-                    OptionParameters.PreferredCodec,
-                    this.aggregatedStats.codecs.get(
-                        this.aggregatedStats.inboundVideoStats.codecId
-                    )
+                // Construct the qualified codec name from the mimetype and fmtp
+                const codecStats: CodecStats = this.aggregatedStats.codecs.get(
+                    this.aggregatedStats.inboundVideoStats.codecId
+                );
+                const codecShortname = codecStats.mimeType.replace('video/', '');
+                let fullCodecName = codecShortname;
+                if (codecStats.sdpFmtpLine && codecStats.sdpFmtpLine.trim() !== '') {
+                    fullCodecName = `${codecShortname} ${codecStats.sdpFmtpLine.trim()}`;
+                }
+
+                const allBrowserCodecs: string[] = this.config.getSettingOption(
+                    OptionParameters.PreferredCodec
+                ).options;
+
+                // The list of codecs directly contains the one that was negotiated, select that
+                if (allBrowserCodecs.includes(fullCodecName)) {
+                    this.config.setOptionSettingValue(OptionParameters.PreferredCodec, fullCodecName);
+                    return;
+                }
+
+                // If we couldn't match on the full name, try to match on just the codec shortname
+                const filteredList = allBrowserCodecs.filter(
+                    (option: string) => option.indexOf(codecShortname) !== -1
                 );
+                if (filteredList.length > 0) {
+                    this.config.setOptionSettingValue(OptionParameters.PreferredCodec, filteredList[0]);
+                    return;
+                }
             }
         });
     }
@@ -217,9 +229,7 @@ export class PeerConnectionController {
         }
 
         // Force mono or stereo based on whether ?forceMono was passed or not
-        audioSDP += this.config.isFlagEnabled(Flags.ForceMonoAudio)
-            ? 'stereo=0;'
-            : 'stereo=1;';
+        audioSDP += this.config.isFlagEnabled(Flags.ForceMonoAudio) ? 'stereo=0;' : 'stereo=1;';
 
         // enable in-band forward error correction for opus audio
         audioSDP += 'useinbandfec=1';
@@ -235,16 +245,14 @@ export class PeerConnectionController {
      * @param iceCandidate - RTC Ice Candidate from the Signaling Server
      */
     handleOnIce(iceCandidate: RTCIceCandidate) {
-        Logger.Log(Logger.GetStackTrace(), 'peerconnection handleOnIce', 6);
+        Logger.Info('peerconnection handleOnIce');
 
         // // if forcing TURN, reject any candidates not relay
         if (this.config.isFlagEnabled(Flags.ForceTURN)) {
             // check if no relay address is found, if so, we are assuming it means no TURN server
             if (iceCandidate.candidate.indexOf('relay') < 0) {
                 Logger.Info(
-                    Logger.GetStackTrace(),
-                    `Dropping candidate because it was not TURN relay. | Type= ${iceCandidate.type} | Protocol= ${iceCandidate.protocol} | Address=${iceCandidate.address} | Port=${iceCandidate.port} |`,
-                    6
+                    `Dropping candidate because it was not TURN relay. | Type= ${iceCandidate.type} | Protocol= ${iceCandidate.protocol} | Address=${iceCandidate.address} | Port=${iceCandidate.port} |`
                 );
                 return;
             }
@@ -258,11 +266,7 @@ export class PeerConnectionController {
      * @param state - Signaling Server State Change Event
      */
     handleSignalStateChange(state: Event) {
-        Logger.Log(
-            Logger.GetStackTrace(),
-            'signaling state change: ' + state,
-            6
-        );
+        Logger.Info('signaling state change: ' + state);
     }
 
     /**
@@ -270,11 +274,7 @@ export class PeerConnectionController {
      * @param state - Ice Connection State
      */
     handleIceConnectionStateChange(state: Event) {
-        Logger.Log(
-            Logger.GetStackTrace(),
-            'ice connection state change: ' + state,
-            6
-        );
+        Logger.Info('ice connection state change: ' + state);
         this.onIceConnectionStateChange(state);
     }
 
@@ -283,11 +283,7 @@ export class PeerConnectionController {
      * @param state - Ice Gathering State Change
      */
     handleIceGatheringStateChange(state: Event) {
-        Logger.Log(
-            Logger.GetStackTrace(),
-            'ice gathering state change: ' + JSON.stringify(state),
-            6
-        );
+        Logger.Info('ice gathering state change: ' + JSON.stringify(state));
     }
 
     /**
@@ -364,23 +360,25 @@ export class PeerConnectionController {
      * @param sdp The remote sdp
      * @returns The intersection between browser supported codecs and ue supported codecs.
      */
-    fuzzyIntersectUEAndBrowserCodecs(sdp: RTCSessionDescriptionInit) : string[] {
+    fuzzyIntersectUEAndBrowserCodecs(sdp: RTCSessionDescriptionInit): string[] {
         // We want to build an array of all supported codecs on both sides
         const allSupportedCodecs: Array<string> = new Array<string>();
         const allUECodecs: string[] = this.parseAvailableCodecs(sdp);
-        const allBrowserCodecs: string[] = this.config.getSettingOption(OptionParameters.PreferredCodec).options;
-        for(const ueCodec of allUECodecs) {
+        const allBrowserCodecs: string[] = this.config.getSettingOption(
+            OptionParameters.PreferredCodec
+        ).options;
+        for (const ueCodec of allUECodecs) {
             // Check if browser codecs directly matches UE codec (with parameters and everything)
-            if(allBrowserCodecs.includes(ueCodec)) {
+            if (allBrowserCodecs.includes(ueCodec)) {
                 allSupportedCodecs.push(ueCodec);
                 continue;
             }
             // Otherwise check if browser codec at least contains a match for the UE codec name (without parameters).
             else {
-                const ueCodecNameAndParams: string[] = ueCodec.split(" ");
+                const ueCodecNameAndParams: string[] = ueCodec.split(' ');
                 const ueCodecName = ueCodecNameAndParams[0];
-                for(const browserCodec of allBrowserCodecs) {
-                    if(browserCodec.includes(ueCodecName)) {
+                for (const browserCodec of allBrowserCodecs) {
+                    if (browserCodec.includes(ueCodecName)) {
                         // We pass browser codec here as they option contain extra parameters.
                         allSupportedCodecs.push(browserCodec);
                         break;
@@ -394,22 +392,31 @@ export class PeerConnectionController {
     /**
      * Setup tracks on the RTC Peer Connection
      * @param useMic - is mic in use
+     * @param useCamera - is webcam in use
      */
-    async setupTransceiversAsync(useMic: boolean) {
-
-        // Setup a transceiver for receiving video (if we need to)
+    async setupTransceiversAsync(useMic: boolean, useCamera: boolean) {
         let hasVideoReceiver = false;
         for (const transceiver of this.peerConnection?.getTransceivers() ?? []) {
-            if (transceiver && transceiver.receiver && transceiver.receiver.track && transceiver.receiver.track.kind === 'video') {
+            if (
+                transceiver &&
+                transceiver.receiver &&
+                transceiver.receiver.track &&
+                transceiver.receiver.track.kind === 'video'
+            ) {
                 hasVideoReceiver = true;
                 break;
             }
         }
-        if(!hasVideoReceiver) {
-            this.peerConnection?.addTransceiver('video', { direction: 'recvonly' });
+
+        // Setup a transceiver for sending webcam video to UE and receiving video from UE
+        if (!useCamera) {
+            if (!hasVideoReceiver) {
+                this.peerConnection?.addTransceiver('video', { direction: 'recvonly' });
+            }
+        } else {
+            await this.setupVideoSender(hasVideoReceiver);
         }
 
-        // We can only set preferred codec on Chrome
         if (RTCRtpReceiver.getCapabilities && this.preferredCodec != '') {
             for (const transceiver of this.peerConnection?.getTransceivers() ?? []) {
                 if (
@@ -419,51 +426,52 @@ export class PeerConnectionController {
                     transceiver.receiver.track.kind === 'video' &&
                     transceiver.setCodecPreferences
                 ) {
+                    // Get our preferred codec from the codecs options drop down
                     const preferredRTPCodec = this.preferredCodec.split(' ');
-                    const codecs = [
-                        {
-                            mimeType:
-                                'video/' + preferredRTPCodec[0] /* Name */,
-                            clockRate: 90000,
-                            sdpFmtpLine: preferredRTPCodec[1] /* sdpFmtpLine */
-                                ? preferredRTPCodec[1]
-                                : ''
+                    const preferredRTCRtpCodecCapability: RTCRtpCodecCapability = {
+                        mimeType: 'video/' + preferredRTPCodec[0] /* Name */,
+                        clockRate: 90000 /* All current video formats in browsers have 90khz clock rate */,
+                        sdpFmtpLine: preferredRTPCodec[1] ? preferredRTPCodec[1] : ''
+                    };
+
+                    // Populate a list of codecs we will support with our preferred one in the first position
+                    const ourSupportedCodecs: Array<RTCRtpCodecCapability> = [preferredRTCRtpCodecCapability];
+
+                    // Go through all codecs the browser supports and add them to the list (in any order)
+                    RTCRtpReceiver.getCapabilities('video').codecs.forEach(
+                        (browserSupportedCodec: RTCRtpCodecCapability) => {
+                            // Don't add our preferred codec again, but add everything else
+                            if (browserSupportedCodec.mimeType != preferredRTCRtpCodecCapability.mimeType) {
+                                ourSupportedCodecs.push(browserSupportedCodec);
+                            } else if (
+                                browserSupportedCodec?.sdpFmtpLine !=
+                                preferredRTCRtpCodecCapability?.sdpFmtpLine
+                            ) {
+                                ourSupportedCodecs.push(browserSupportedCodec);
+                            }
                         }
-                    ];
-
-                    this.config
-                        .getSettingOption(OptionParameters.PreferredCodec)
-                        .options.filter((option) => {
-                            // Remove the preferred codec from the list of possible codecs as we've set it already
-                            return option != this.preferredCodec;
-                        })
-                        .forEach((option) => {
-                            // Amend the rest of the browsers supported codecs
-                            const altCodec = option.split(' ');
-                            codecs.push({
-                                mimeType: 'video/' + altCodec[0] /* Name */,
-                                clockRate: 90000,
-                                sdpFmtpLine: altCodec[1] /* sdpFmtpLine */
-                                    ? altCodec[1]
-                                    : ''
-                            });
-                        });
+                    );
 
-                    for (const codec of codecs) {
-                        if (codec.sdpFmtpLine === '') {
+                    for (const codec of ourSupportedCodecs) {
+                        if (codec?.sdpFmtpLine === undefined || codec.sdpFmtpLine === '') {
                             // We can't dynamically add members to the codec, so instead remove the field if it's empty
                             delete codec.sdpFmtpLine;
                         }
                     }
 
-                    transceiver.setCodecPreferences(codecs);
+                    transceiver.setCodecPreferences(ourSupportedCodecs);
                 }
             }
         }
 
         let hasAudioReceiver = false;
         for (const transceiver of this.peerConnection?.getTransceivers() ?? []) {
-            if (transceiver && transceiver.receiver && transceiver.receiver.track && transceiver.receiver.track.kind === 'audio') {
+            if (
+                transceiver &&
+                transceiver.receiver &&
+                transceiver.receiver.track &&
+                transceiver.receiver.track.kind === 'audio'
+            ) {
                 hasAudioReceiver = true;
                 break;
             }
@@ -471,62 +479,101 @@ export class PeerConnectionController {
 
         // Setup a transceiver for sending mic audio to UE and receiving audio from UE
         if (!useMic) {
-            if(!hasAudioReceiver) {
+            if (!hasAudioReceiver) {
                 this.peerConnection?.addTransceiver('audio', {
                     direction: 'recvonly'
                 });
             }
         } else {
-            // set the audio options based on mic usage
-            const audioOptions = {
-                autoGainControl: false,
-                channelCount: 1,
-                echoCancellation: false,
-                latency: 0,
-                noiseSuppression: false,
-                sampleRate: 48000,
-                sampleSize: 16,
-                volume: 1.0
-            }
+            await this.setupAudioSender(hasAudioReceiver);
+        }
+    }
 
-            // set the media send options
-            const mediaSendOptions: MediaStreamConstraints = {
-                video: false,
-                audio: audioOptions
-            };
+    async setupVideoSender(hasVideoReceiver: boolean) {
+        // set the media send options
+        const mediaSendOptions: MediaStreamConstraints = {
+            video: true
+        };
 
-            // Note using mic on android chrome requires SSL or chrome://flags/ "unsafely-treat-insecure-origin-as-secure"
-            const stream = await navigator.mediaDevices.getUserMedia(
-                mediaSendOptions
-            );
-            if (stream) {
-                if (hasAudioReceiver) {
-                    for (const transceiver of this.peerConnection?.getTransceivers() ?? []) {
-                        if (RTCUtils.canTransceiverReceiveAudio(transceiver)) {
-                            for (const track of stream.getTracks()) {
-                                if (track.kind && track.kind == 'audio') {
-                                    transceiver.sender.replaceTrack(track);
-                                    transceiver.direction = 'sendrecv';
-                                }
+        // Note using webcam on android chrome requires SSL or chrome://flags/ "unsafely-treat-insecure-origin-as-secure"
+        const stream = await navigator.mediaDevices.getUserMedia(mediaSendOptions);
+
+        if (stream) {
+            if (hasVideoReceiver) {
+                for (const transceiver of this.peerConnection?.getTransceivers() ?? []) {
+                    if (RTCUtils.canTransceiverReceiveVideo(transceiver)) {
+                        for (const track of stream.getTracks()) {
+                            if (track.kind && track.kind == 'video') {
+                                transceiver.sender.replaceTrack(track);
+                                transceiver.direction = 'sendrecv';
                             }
                         }
                     }
-                } else {
-                    for (const track of stream.getTracks()) {
-                        if (track.kind && track.kind == 'audio') {
-                            this.peerConnection?.addTransceiver(track, {
-                                direction: 'sendrecv'
-                            });
+                }
+            } else {
+                for (const track of stream.getTracks()) {
+                    if (track.kind && track.kind == 'video') {
+                        this.peerConnection?.addTransceiver(track, {
+                            direction: 'sendrecv'
+                        });
+                    }
+                }
+            }
+        } else {
+            if (!hasVideoReceiver) {
+                this.peerConnection?.addTransceiver('video', { direction: 'recvonly' });
+            }
+        }
+    }
+
+    async setupAudioSender(hasAudioReceiver: boolean) {
+        // set the audio options based on mic usage
+        const audioOptions = {
+            autoGainControl: false,
+            channelCount: 1,
+            echoCancellation: false,
+            latency: 0,
+            noiseSuppression: false,
+            sampleRate: 48000,
+            sampleSize: 16,
+            volume: 1.0
+        };
+
+        // set the media send options
+        const mediaSendOptions: MediaStreamConstraints = {
+            video: false,
+            audio: audioOptions
+        };
+
+        // Note using mic on android chrome requires SSL or chrome://flags/ "unsafely-treat-insecure-origin-as-secure"
+        const stream = await navigator.mediaDevices.getUserMedia(mediaSendOptions);
+        if (stream) {
+            if (hasAudioReceiver) {
+                for (const transceiver of this.peerConnection?.getTransceivers() ?? []) {
+                    if (RTCUtils.canTransceiverReceiveAudio(transceiver)) {
+                        for (const track of stream.getTracks()) {
+                            if (track.kind && track.kind == 'audio') {
+                                transceiver.sender.replaceTrack(track);
+                                transceiver.direction = 'sendrecv';
+                            }
                         }
                     }
                 }
             } else {
-                if(!hasAudioReceiver) {
-                    this.peerConnection?.addTransceiver('audio', {
-                        direction: 'recvonly'
-                    });
+                for (const track of stream.getTracks()) {
+                    if (track.kind && track.kind == 'audio') {
+                        this.peerConnection?.addTransceiver(track, {
+                            direction: 'sendrecv'
+                        });
+                    }
                 }
             }
+        } else {
+            if (!hasAudioReceiver) {
+                this.peerConnection?.addTransceiver('audio', {
+                    direction: 'recvonly'
+                });
+            }
         }
     }
 
@@ -571,12 +618,9 @@ export class PeerConnectionController {
         // Default Functionality: Do Nothing
     }
 
-    parseAvailableCodecs(
-        rtcSessionDescription: RTCSessionDescriptionInit
-    ): Array<string> {
+    parseAvailableCodecs(rtcSessionDescription: RTCSessionDescriptionInit): Array<string> {
         // No point in updating the available codecs if on FF
-        if (!RTCRtpReceiver.getCapabilities)
-            return ['Only available on Chrome'];
+        if (!RTCRtpReceiver.getCapabilities) return ['Only available on Chrome'];
 
         const ueSupportedCodecs: Array<string> = [];
         const sections = splitSections(rtcSessionDescription.sdp);