@camera.ui/camera-ui-homekit 0.0.15 → 0.0.17

package/dist/camera/sessionWrapper.js

@@ -1,29 +1,15 @@
+import { timeoutPromise } from '@camera.ui/common';
+import { RtpSplitter } from '@camera.ui/common/cameraUtils';
 import { CameraController } from 'hap-nodejs';
 import { spawn } from 'node:child_process';
 import { isIPv6 } from 'node:net';
 import { networkInterfaces } from 'node:os';
-import { ReplaySubject, Subject, firstValueFrom, interval, merge, of } from 'rxjs';
+import { interval, merge, of, Subject } from 'rxjs';
 import { debounceTime, delay, take } from 'rxjs/operators';
 import { RtcpSenderInfo, RtcpSrPacket, RtpPacket, SrtcpSession, SrtpSession } from 'werift';
-import { OpusRepacketizer } from '../utils/opus-repacketizer.js';
+import { AudioProcessor, getSessionConfig, VideoProcessor } from '../utils/processor.js';
 import { ReturnAudioTranscoder } from '../utils/return-audio-transcoder.js';
-import { RtpSplitter } from '../utils/rtp-splitter.js';
 import { generateSrtpOptions } from '../utils/srtp.js';
-import { timeoutPromise } from '../utils/utils.js';
-function getSessionConfig(srtpOptions) {
-    return {
-        keys: {
-            localMasterKey: srtpOptions.srtpKey,
-            localMasterSalt: srtpOptions.srtpSalt,
-            remoteMasterKey: srtpOptions.srtpKey,
-            remoteMasterSalt: srtpOptions.srtpSalt,
-        },
-        profile: 1,
-    };
-}
-function getDurationSeconds(start) {
-    return (Date.now() - start) / 1000;
-}
 export class StreamingSessionWrapper {
     start;
     audioSsrc = CameraController.generateSynchronisationSource();
@@ -35,53 +21,21 @@ export class StreamingSessionWrapper {
     cameraAccessory;
     cameraDevice;
     streamingSession;
-    ffmpegProcess;
     prepareStreamRequest;
+    ffmpegProcess;
     logger;
     repacketizeAudioSplitter = new RtpSplitter();
-    rtcpSubject = new ReplaySubject(1);
-    get receivedFirstRtcpPacket() {
-        return firstValueFrom(this.rtcpSubject);
-    }
-    constructor(cameraAccessory, cameraDevice, streamingSession, prepareStreamRequest, start, logger) {
+    packetReceivedSubject = new Subject();
+    constructor(cameraAccessory, cameraDevice, prepareStreamRequest, start, logger) {
         this.cameraAccessory = cameraAccessory;
         this.cameraDevice = cameraDevice;
-        this.streamingSession = streamingSession;
+        this.streamingSession = this.cameraDevice.streamSource.createSession();
         this.prepareStreamRequest = prepareStreamRequest;
         this.start = start;
         this.logger = logger;
     }
     async prepare() {
-        const { sessionID, targetAddress, addressVersion } = this.prepareStreamRequest;
-        let { sourceAddress } = this.prepareStreamRequest;
-        const socketType = addressVersion === 'ipv6' ? 'udp6' : 'udp4';
-        if (socketType === 'udp4' && sourceAddress.startsWith('::ffff:')) {
-            sourceAddress = sourceAddress.replace('::ffff:', '');
-        }
-        const serverAddresses = await this.cameraAccessory.api.coreManager.getServerAddresses();
-        const found = serverAddresses.find((address) => address.includes(sourceAddress));
-        if (!found && serverAddresses.length) {
-            this.logger.debug(this.cameraDevice.name, `Source address ${sourceAddress} not found in server addresses`);
-            const infos = Object.values(networkInterfaces())
-                .flat()
-                .map((i) => i?.address);
-            const targetAddresses = serverAddresses.filter((address) => {
-                if (socketType === 'udp4') {
-                    return !isIPv6(address);
-                }
-                else {
-                    return isIPv6(address);
-                }
-            });
-            const targetAddressFound = infos.find((address) => targetAddresses.includes(address));
-            if (targetAddressFound) {
-                this.logger.debug(this.cameraDevice.name, `Using target address ${targetAddressFound}`);
-                sourceAddress = targetAddressFound;
-            }
-        }
-        else if (found) {
-            this.logger.debug(this.cameraDevice.name, `Using source address ${sourceAddress}`);
-        }
+        const { socketType, sessionID, sourceAddress, targetAddress, addressVersion } = await this.setupAddress();
         this.logger.debug(this.cameraDevice.name, 'Preparing stream:', { sessionID, sourceAddress, targetAddress, addressVersion });
         await this.videoSplitter.prepare(socketType, sourceAddress);
         await this.audioSplitter.prepare(socketType, sourceAddress);
@@ -89,31 +43,33 @@ export class StreamingSessionWrapper {
         if (!this.videoSplitter.port || !this.audioSplitter.port || !this.repacketizeAudioSplitter.port) {
             throw new Error('Failed to prepare stream');
         }
-        // used to encrypt rtcp to HomeKit for keepalive
         const videoSrtcpSession = new SrtcpSession(getSessionConfig(this.videoSrtp));
-        const onReturnPacketReceived = new Subject();
-        // Watch return packets to detect a dead stream from the HomeKit side
-        // This can happen if the user force-quits the Home app
+        let firstRtcp = false;
+        const logFirstRtcp = () => {
+            this.logger.debug(this.cameraDevice.name, 'Received RTCP packet from HomeKit');
+        };
         this.videoSplitter.addMessageHandler(() => {
-            // this.logger.debug(this.cameraDevice.name, 'Received RTCP packet from HomeKit', RtpPacket.deSerialize(rtp.message));
-            // return packet from HomeKit
-            this.rtcpSubject.next(true);
-            onReturnPacketReceived.next(null);
+            if (!firstRtcp) {
+                firstRtcp = true;
+                logFirstRtcp();
+            }
+            this.packetReceivedSubject.next();
             return null;
         });
         this.audioSplitter.addMessageHandler(() => {
-            // return packet from HomeKit
-            onReturnPacketReceived.next(null);
+            if (!firstRtcp) {
+                firstRtcp = true;
+                logFirstRtcp();
+            }
+            this.packetReceivedSubject.next();
             return null;
         });
-        this.streamingSession.addSubscriptions(merge(of(true).pipe(delay(15000)), onReturnPacketReceived)
+        this.streamingSession.addSubscriptions(merge(of(null).pipe(delay(15000)), this.packetReceivedSubject.asObservable())
             .pipe(debounceTime(5000))
             .subscribe(() => {
-            this.logger.log(this.cameraDevice.name, `Live stream appears to be inactive. (${getDurationSeconds(this.start)}s)`);
+            this.logger.log(this.cameraDevice.name, `Live stream appears to be inactive. (${this.getDurationSeconds()}s)`);
             this.streamingSession.stop();
         }));
-        // Periodically send a blank RTCP packet to the HomeKit video port
-        // Without this, HomeKit assumes the stream is dead after 30 second and sends a stop request
         this.streamingSession.addSubscriptions(interval(500).subscribe(() => {
             const senderInfo = new RtcpSenderInfo({
                 ntpTimestamp: BigInt(0),
@@ -125,8 +81,8 @@ export class StreamingSessionWrapper {
                 ssrc: this.videoSsrc,
                 senderInfo: senderInfo,
             });
-            const message = videoSrtcpSession.encrypt(senderReport.serialize());
-            this.videoSplitter.send(message, {
+            const encryptedPacket = videoSrtcpSession.encrypt(senderReport.serialize());
+            this.videoSplitter.send(encryptedPacket, {
                 port: this.prepareStreamRequest.video.port,
                 address: this.prepareStreamRequest.targetAddress,
             });
@@ -135,13 +91,13 @@ export class StreamingSessionWrapper {
     async activate(startStreamRequest) {
         this.logger.debug(this.cameraDevice.name, 'Starting stream:', startStreamRequest);
         if (!this.isLowBandwidth(startStreamRequest)) {
-            this.run(startStreamRequest);
+            await this.run(startStreamRequest);
             return;
         }
         try {
             this.logger.debug(this.cameraDevice.name, 'Low bandwidth detected, waiting for initial RTCP');
-            await timeoutPromise(5000, this.receivedFirstRtcpPacket);
-            this.run(startStreamRequest);
+            await timeoutPromise(5000, this.packetReceivedSubject.asObservable().pipe(take(1)).toPromise());
+            await this.run(startStreamRequest);
         }
         catch {
             this.logger.error(this.cameraDevice.name, 'Failed to receive initial RTCP packet');
@@ -150,7 +106,6 @@ export class StreamingSessionWrapper {
     }
     stop() {
         this.logger.debug(this.cameraDevice.name, 'Stopping stream');
-        this.rtcpSubject = new ReplaySubject(1);
         this.ffmpegProcess?.kill('SIGKILL');
         this.ffmpegProcess = undefined;
         this.audioSplitter.close();
@@ -159,45 +114,92 @@ export class StreamingSessionWrapper {
         this.streamingSession.stop();
     }
     async run(startStreamRequest) {
-        this.listenForAudioPackets(startStreamRequest);
-        this.listenForVideoPackets(startStreamRequest);
-        this.startRtspSession(startStreamRequest);
-        this.createTwoWayAudioTranscoder(startStreamRequest);
+        const probeStream = await this.cameraDevice.streamSource.probeStream();
+        const audioStream = probeStream?.audio.find((a) => a.direction === 'sendonly');
+        const videoStream = probeStream?.video;
+        const talkbackStream = probeStream?.audio.find((a) => a.direction === 'recvonly');
+        const mpegtsPrebufferingState = await this.cameraDevice.streamSource.getPrebufferingState('mpegts');
+        const transcodeVideoStream = this.cameraAccessory.cameraStorage.values.transcodeStreaming;
+        const useRtsp = transcodeVideoStream || mpegtsPrebufferingState?.url || videoStream?.codec !== 'H264';
+        if (audioStream) {
+            this.listenForAudioPackets(startStreamRequest);
+        }
+        if (useRtsp) {
+            this.listenForVideoRtspPackets(startStreamRequest);
+            await this.startRtspSession(startStreamRequest);
+        }
+        else {
+            this.listenForVideoPackets(startStreamRequest);
+        }
+        if (audioStream) {
+            await this.startAudioSession(startStreamRequest);
+        }
+        else {
+            this.logger.debug(this.cameraDevice.name, 'No audio stream detected, skipping audio transcoding and talkback');
+        }
+        if (talkbackStream) {
+            await this.createTwoWayAudioTranscoder(startStreamRequest, talkbackStream);
+        }
+        else {
+            this.logger.debug(this.cameraDevice.name, 'No talkback stream detected, skipping two-way audio');
+        }
+    }
+    async startAudioSession(startStreamRequest) {
+        const audioMtu = 400;
+        const ffmpegPath = await this.cameraAccessory.api.coreManager.getFFmpegPath();
+        const audioArgs = [];
+        if (startStreamRequest.audio.codec === "OPUS" /* AudioStreamingCodecType.OPUS */) {
+            audioArgs.push(...this.opusTranscodeArgs(startStreamRequest));
+        }
+        else {
+            audioArgs.push(...this.aacTranscodeArgs(startStreamRequest));
+        }
+        await this.streamingSession.startTranscoding({
+            ffmpegPath,
+            input: ['-vn', '-sn', '-dn'],
+            audio: [...audioArgs, '-f', 'rtp', `rtp://${this.repacketizeAudioSplitter.address}:${this.repacketizeAudioSplitter.port}?pkt_size=${audioMtu}`],
+            output: [],
+            logger: {
+                info: (...args) => this.logger.trace(this.cameraDevice.name, 'Audio:', ...args),
+                error: (...args) => this.logger.error(this.cameraDevice.name, 'Audio:', ...args),
+            },
+        });
     }
     async startRtspSession(startStreamRequest) {
         const audioMtu = startStreamRequest.audio.codec === "OPUS" /* AudioStreamingCodecType.OPUS */ ? 400 : 3840 / startStreamRequest.audio.sample_rate;
         const videoMtu = startStreamRequest.video.mtu;
+        const probeStream = await this.cameraDevice.streamSource.probeStream();
+        const audioStream = probeStream?.audio.find((a) => a.direction === 'sendonly');
+        const videoStream = probeStream?.video;
         const ffmpegPath = await this.cameraAccessory.api.coreManager.getFFmpegPath();
         const mpegtsPrebufferingState = await this.cameraDevice.streamSource.getPrebufferingState('mpegts');
-        const isPrebufferingEnabled = mpegtsPrebufferingState?.state;
-        const transcodeVideoStream = this.cameraAccessory.cameraStorage.values.transcodeStreaming;
-        const ffmpegInput = ['-hide_banner', '-loglevel', 'verbose', '-fflags', '+discardcorrupt', '-max_delay', '500000', '-flags', 'low_delay'];
-        if (isPrebufferingEnabled) {
-            ffmpegInput.push('-f', 'mpegts', '-i', mpegtsPrebufferingState.url, ...this.silentAudioSource());
-            ffmpegInput.push('-enc_time_base', '-1', '-fps_mode', 'passthrough', '-muxdelay', '0', '-video_track_timescale', '90000');
-        }
-        else {
-            ffmpegInput.push('-avioflags', 'direct', '-rtsp_transport', 'tcp', '-i', this.cameraDevice.streamSource.urls.rtsp.default, ...this.silentAudioSource());
+        const isPrebufferingEnabled = mpegtsPrebufferingState?.url;
+        const isH264 = videoStream?.codec === 'H264';
+        const transcodeVideoStream = this.cameraAccessory.cameraStorage.values.transcodeStreaming || !isH264;
+        if (!isH264) {
+            this.logger.warn(this.cameraDevice.name, 'Stream is not H264, streaming will be transcoded');
         }
-        ffmpegInput.push('-reset_timestamps', '1');
-        const audioCodec = [
+        const ffmpegInput = [
+            '-hide_banner',
+            '-loglevel',
+            'verbose',
+            '-fflags',
+            '+discardcorrupt',
+            '-max_delay',
+            '500000',
             '-flags',
-            '+global_header',
-            '-ac',
-            `${startStreamRequest.audio.channel}`,
-            '-ar',
-            `${startStreamRequest.audio.sample_rate}k`,
-            '-b:a',
-            `${startStreamRequest.audio.max_bit_rate}k`,
-            '-bufsize',
-            `${startStreamRequest.audio.max_bit_rate * 4}k`,
+            'low_delay',
+            '-thread_queue_size',
+            '1024',
         ];
-        if (startStreamRequest.audio.codec === "OPUS" /* AudioStreamingCodecType.OPUS */) {
-            audioCodec.unshift('-acodec', 'libopus', '-frame_duration', startStreamRequest.audio.packet_time.toString(), '-application', 'lowdelay');
+        if (isPrebufferingEnabled) {
+            ffmpegInput.push('-f', 'mpegts', '-i', mpegtsPrebufferingState.url);
+            ffmpegInput.push('-enc_time_base', '-1', '-muxdelay', '0', '-video_track_timescale', '90000');
         }
         else {
-            audioCodec.unshift('-acodec', 'libfdk_aac', '-profile:a', 'aac_eld', '-eld_sbr:a', '1', '-eld_v2', '1', '-frame_size', (startStreamRequest.audio.packet_time * startStreamRequest.audio.sample_rate).toString(), '-f', 'null');
+            ffmpegInput.push('-avioflags', 'direct', '-rtsp_transport', 'tcp', '-i', this.cameraDevice.streamSource.urls.rtsp.default);
         }
+        ffmpegInput.push('-fps_mode', 'passthrough', '-reset_timestamps', '1');
         const videoCodec = [];
         if (transcodeVideoStream) {
             const idrInterval = 4;
@@ -227,21 +229,17 @@ export class StreamingSessionWrapper {
             'rtp',
             `rtp://${this.videoSplitter.address}:${this.videoSplitter.port}?pkt_size=${videoMtu}`,
         ];
-        const audioArgs = [
-            '-async',
-            '1',
-            ...audioCodec,
-            '-payload_type',
-            startStreamRequest.audio.pt.toString(),
-            '-ssrc',
-            this.audioSsrc.toString(),
-            '-vn',
-            '-sn',
-            '-dn',
-            '-f',
-            'rtp',
-            `rtp://${this.repacketizeAudioSplitter.address}:${this.repacketizeAudioSplitter.port}?pkt_size=${audioMtu}`,
-        ];
+        const audioArgs = [];
+        if (audioStream) {
+            const audioCodecArgs = [];
+            if (startStreamRequest.audio.codec === "OPUS" /* AudioStreamingCodecType.OPUS */) {
+                audioCodecArgs.push(...this.opusTranscodeArgs(startStreamRequest));
+            }
+            else {
+                audioCodecArgs.push(...this.aacTranscodeArgs(startStreamRequest));
+            }
+            audioArgs.push(...audioCodecArgs, '-vn', '-sn', '-dn', '-f', 'rtp', `rtp://${this.repacketizeAudioSplitter.address}:${this.repacketizeAudioSplitter.port}?pkt_size=${audioMtu}`);
+        }
         const ffmpegOutput = [];
         const ffmpegArgs = [...ffmpegInput, ...videoArgs, ...audioArgs, ...ffmpegOutput];
         this.logger.debug(this.cameraDevice.name, 'Starting RTSP session with ffmpeg', ffmpegPath, ffmpegArgs.join(' '));
@@ -264,71 +262,85 @@ export class StreamingSessionWrapper {
             }
         });
     }
-    async createTwoWayAudioTranscoder(startStreamRequest) {
-        const twoWayAudio = await this.cameraAccessory.cameraStorage.getValue('twoWayAudio', true);
-        let returnAudioTranscodedSplitter;
-        let returnAudioTranscoder;
+    async createTwoWayAudioTranscoder(startStreamRequest, talkbackStream) {
         const returnAudioCodecs = [];
-        if (twoWayAudio) {
-            // used to send return audio from HomeKit to Camera
-            returnAudioTranscodedSplitter = new RtpSplitter();
-            await returnAudioTranscodedSplitter.prepare('udp4', '127.0.0.1', ({ message }) => {
-                // deserialize and send to Camera - werift will handle encryption and other header params
-                try {
-                    const rtp = RtpPacket.deSerialize(message);
-                    this.streamingSession.sendAudioPacket(rtp);
-                }
-                catch {
-                    // deSerialize will sometimes fail, but the errors can be ignored
-                }
-                return null;
-            });
-            const returnAudioCodec = this.cameraAccessory.cameraStorage.values.returnAudioCodec;
-            const isCameraUsingOpus = (await this.streamingSession.isUsingOpus) || (returnAudioCodec && returnAudioCodec === 'opus');
-            if (returnAudioCodec === 'opus' || (!returnAudioCodec && isCameraUsingOpus)) {
-                returnAudioCodecs.push('-acodec', 'libopus', '-ac', '2', '-ar', '24k', '-b:a', '24k', '-application', 'lowdelay');
-            }
-            if (returnAudioCodec === 'pcmu' || (!returnAudioCodec && !isCameraUsingOpus)) {
-                returnAudioCodecs.push('-acodec', 'pcm_mulaw', '-ac', '1', '-ar', '8k');
+        const returnAudioCodec = talkbackStream.ffmpegCodec;
+        switch (returnAudioCodec) {
+            case 'aac':
+                returnAudioCodecs.push('-acodec', returnAudioCodec, '-ac', '1', '-ar', '16k', '-b:a', '32k');
+                break;
+            case 'libopus':
+                returnAudioCodecs.push('-acodec', returnAudioCodec, '-ac', '2', '-ar', '24k', '-b:a', '24k', '-application', 'lowdelay');
+                break;
+            case 'pcm_mulaw':
+                returnAudioCodecs.push('-acodec', returnAudioCodec, '-ac', '1', '-ar', '8k');
+                break;
+            case 'pcm_alaw':
+                returnAudioCodecs.push('-acodec', returnAudioCodec, '-ac', '1', '-ar', '8k');
+                break;
+            case 'pcm_s16le':
+                returnAudioCodecs.push('-acodec', returnAudioCodec, '-ac', '1', '-ar', '8k');
+                break;
+            case 'pcm_s16be':
+                returnAudioCodecs.push('-acodec', returnAudioCodec, '-ac', '1', '-ar', '8k');
+                break;
+            case 'g722':
+                returnAudioCodecs.push('-acodec', returnAudioCodec, '-ac', '1', '-ar', '8k');
+                break;
+            case 'mp3':
+                returnAudioCodecs.push('-acodec', returnAudioCodec, '-ac', '1', '-ar', '8k');
+                break;
+            case 'flac':
+                returnAudioCodecs.push('-acodec', returnAudioCodec, '-ac', '1', '-ar', '8k');
+                break;
+            default:
+                returnAudioCodecs.push('-acodec', returnAudioCodec, '-ac', '1', '-ar', '8k');
+        }
+        const returnAudioTranscodedSplitter = new RtpSplitter();
+        await returnAudioTranscodedSplitter.prepare('udp4', '127.0.0.1', ({ message }) => {
+            try {
+                const rtp = RtpPacket.deSerialize(message);
+                this.streamingSession.sendAudioPacket(rtp);
             }
-            if (returnAudioCodec === 'pcma') {
-                returnAudioCodecs.push('-acodec', 'pcm_alaw', '-ac', '1', '-ar', '8k');
+            catch {
+                // Ignore deserialization errors
             }
-            const ffmpegPath = await this.cameraAccessory.api.coreManager.getFFmpegPath();
-            returnAudioTranscoder = new ReturnAudioTranscoder({
-                prepareStreamRequest: this.prepareStreamRequest,
-                startStreamRequest,
-                incomingAudioOptions: {
-                    ssrc: this.audioSsrc,
-                    rtcpPort: 0, // we don't care about rtcp for incoming audio
-                },
-                outputArgs: [
-                    ...returnAudioCodecs,
-                    '-flags',
-                    '+global_header',
-                    '-f',
-                    'rtp',
-                    `rtp://${returnAudioTranscodedSplitter.address}:${returnAudioTranscodedSplitter.port}`,
-                ],
-                ffmpegPath,
-                returnAudioSplitter: this.audioSplitter,
-                logger: {
-                    info: () => { },
-                    // info: (message: string) => this.logger.debug(this.cameraDevice.name, message),
-                    error: (message) => this.logger.error(this.cameraDevice.name, 'Return Audio:', message),
-                },
-            });
-            this.streamingSession.onCallEnded.pipe(take(1)).subscribe(() => {
-                returnAudioTranscoder?.stop();
-                returnAudioTranscodedSplitter?.close();
-            });
-        }
-        await returnAudioTranscoder?.start();
+            return null;
+        });
+        const ffmpegPath = await this.cameraAccessory.api.coreManager.getFFmpegPath();
+        const returnAudioTranscoder = new ReturnAudioTranscoder({
+            prepareStreamRequest: this.prepareStreamRequest,
+            startStreamRequest,
+            incomingAudioOptions: {
+                ssrc: this.audioSsrc,
+                rtcpPort: 0,
+            },
+            outputArgs: [...returnAudioCodecs, '-flags', '+global_header', '-f', 'rtp', `rtp://${returnAudioTranscodedSplitter.address}:${returnAudioTranscodedSplitter.port}`],
+            ffmpegPath,
+            returnAudioSplitter: this.audioSplitter,
+            logger: {
+                info: (...args) => this.logger.trace(this.cameraDevice.name, 'Return Audio:', ...args),
+                error: (...args) => this.logger.error(this.cameraDevice.name, 'Return Audio:', ...args),
+            },
+        });
+        this.streamingSession.onCallEnded.pipe(take(1)).subscribe(() => {
+            returnAudioTranscoder?.stop();
+            returnAudioTranscodedSplitter?.close();
+        });
+        await returnAudioTranscoder.start();
     }
     listenForVideoPackets(startStreamRequest) {
+        const { targetAddress, video: { port }, } = this.prepareStreamRequest;
+        const { video: { mtu, pt: payloadType }, } = startStreamRequest;
+        const processor = new VideoProcessor(this.videoSsrc, this.videoSrtp, this.videoSplitter, targetAddress, port, mtu, payloadType);
+        this.streamingSession.addSubscriptions(this.streamingSession.onVideoRtp.subscribe((rtp) => {
+            processor.processPacket(rtp);
+        }));
+        this.streamingSession.requestKeyFrame();
+    }
+    listenForVideoRtspPackets(startStreamRequest) {
         let sentVideo = false;
         const { targetAddress, video: { port: videoPort }, } = this.prepareStreamRequest;
-        // use to encrypt video to HomeKit
         const videoSrtpSession = new SrtpSession(getSessionConfig(this.videoSrtp));
         this.videoSplitter.addMessageHandler(({ message }) => {
             const rtp = RtpPacket.deSerialize(message);
@@ -337,7 +349,7 @@ export class StreamingSessionWrapper {
             const encryptedPacket = videoSrtpSession.encrypt(rtp.payload, rtp.header);
             if (!sentVideo) {
                 sentVideo = true;
-                this.logger.debug(this.cameraDevice.name, `Received stream data (${getDurationSeconds(this.start)}s)`);
+                this.logger.debug(this.cameraDevice.name, `Received stream data (${this.getDurationSeconds()}s)`);
             }
             this.videoSplitter.send(encryptedPacket, {
                 port: videoPort,
@@ -346,59 +358,96 @@ export class StreamingSessionWrapper {
             return null;
         });
     }
-    async listenForAudioPackets(startStreamRequest) {
+    listenForAudioPackets(startStreamRequest) {
         const { targetAddress, audio: { port: audioPort }, } = this.prepareStreamRequest;
-        const { audio: { codec: audioCodec, sample_rate: audioSampleRate, packet_time: audioPacketTime }, } = startStreamRequest;
-        // Repacketize the audio stream after it's been transcoded
-        const opusRepacketizer = new OpusRepacketizer(audioPacketTime / 20);
-        const audioIntervalScale = ((audioSampleRate / 8) * audioPacketTime) / 20;
-        const audioSrtpSession = new SrtpSession(getSessionConfig(this.audioSrtp));
-        let firstTimestamp;
-        let audioPacketCount = 0;
+        const { audio: { pt: payloadType, codec, packet_time: packetTime, sample_rate: sampleRate }, } = startStreamRequest;
+        const isOpus = codec === "OPUS" /* AudioStreamingCodecType.OPUS */;
+        const processor = new AudioProcessor(this.audioSsrc, this.audioSrtp, this.audioSplitter, targetAddress, audioPort, payloadType, sampleRate, packetTime, isOpus);
         this.repacketizeAudioSplitter.addMessageHandler(({ message }) => {
-            let rtp = RtpPacket.deSerialize(message);
-            if (audioCodec === "OPUS" /* AudioStreamingCodecType.OPUS */) {
-                // borrowed from scrypted
-                // Original source: https://github.com/koush/scrypted/blob/c13ba09889c3e0d9d3724cb7d49253c9d787fb97/plugins/homekit/src/types/camera/camera-streaming-srtp-sender.ts#L124-L143
-                rtp = opusRepacketizer.repacketize(rtp);
-                if (!rtp) {
-                    return null;
+            processor.processPacket(message);
+            return null;
+        });
+    }
+    async setupAddress() {
+        const { sessionID, targetAddress, addressVersion } = this.prepareStreamRequest;
+        let { sourceAddress } = this.prepareStreamRequest;
+        const socketType = addressVersion === 'ipv6' ? 'udp6' : 'udp4';
+        if (socketType === 'udp4' && sourceAddress.startsWith('::ffff:')) {
+            sourceAddress = sourceAddress.replace('::ffff:', '');
+        }
+        const serverAddresses = await this.cameraAccessory.api.coreManager.getServerAddresses();
+        const found = serverAddresses.find((address) => address.includes(sourceAddress));
+        if (!found && serverAddresses.length) {
+            this.logger.debug(this.cameraDevice.name, `Source address ${sourceAddress} not found in server addresses`);
+            const infos = Object.values(networkInterfaces())
+                .flat()
+                .map((i) => i?.address);
+            const targetAddresses = serverAddresses.filter((address) => {
+                if (socketType === 'udp4') {
+                    return !isIPv6(address);
                 }
-                if (!firstTimestamp) {
-                    firstTimestamp = rtp.header.timestamp;
+                else {
+                    return isIPv6(address);
                 }
-                // from HAP spec:
-                // RTP Payload Format for Opus Speech and Audio Codec RFC 7587 with an exception
-                // that Opus audio RTP Timestamp shall be based on RFC 3550.
-                // RFC 3550 indicates that PCM audio based with a sample rate of 8k and a packet
-                // time of 20ms would have a monotonic interval of 8k / (1000 / 20) = 160.
-                // So 24k audio would have a monotonic interval of (24k / 8k) * 160 = 480.
-                // HAP spec also states that it may request packet times of 20, 30, 40, or 60.
-                // In practice, HAP has been seen to request 20 on LAN and 60 over LTE.
-                // So the RTP timestamp must scale accordingly.
-                // Further investigation indicates that HAP doesn't care about the actual sample rate at all,
-                // that's merely a suggestion. When encoding Opus, it can seemingly be an arbitrary sample rate,
-                // audio will work so long as the rtp timestamps are created properly: which is a construct of the sample rate
-                // HAP requests, and the packet time is respected,
-                // opus 48khz will work just fine.
-                rtp.header.timestamp = (firstTimestamp + audioPacketCount * 160 * audioIntervalScale) % 0xffffffff;
-                audioPacketCount++;
-            }
-            // encrypt the packet
-            const encryptedPacket = audioSrtpSession.encrypt(rtp.payload, rtp.header);
-            // send the encrypted packet to HomeKit
-            this.audioSplitter.send(encryptedPacket, {
-                port: audioPort,
-                address: targetAddress,
             });
-            return null;
-        });
+            const targetAddressFound = infos.find((address) => targetAddresses.includes(address));
+            if (targetAddressFound) {
+                this.logger.debug(this.cameraDevice.name, `Using target address ${targetAddressFound}`);
+                sourceAddress = targetAddressFound;
+            }
+        }
+        else if (found) {
+            this.logger.debug(this.cameraDevice.name, `Using source address ${sourceAddress}`);
+        }
+        return { socketType, sessionID, sourceAddress, targetAddress, addressVersion };
     }
-    isLowBandwidth(startStreamRequest) {
-        return startStreamRequest.audio.packet_time >= 60;
+    opusTranscodeArgs(startStreamRequest) {
+        return [
+            '-acodec',
+            'libopus',
+            '-min_comp',
+            '0',
+            '-application',
+            'lowdelay',
+            '-frame_duration',
+            startStreamRequest.audio.packet_time.toString(),
+            '-flags',
+            '+global_header',
+            '-ac',
+            `${startStreamRequest.audio.channel}`,
+            '-ar',
+            `${startStreamRequest.audio.sample_rate}k`,
+            '-b:a',
+            `${startStreamRequest.audio.max_bit_rate}k`,
+            '-bufsize',
+            `${startStreamRequest.audio.max_bit_rate * 4}k`,
+        ];
     }
-    silentAudioSource() {
-        return ['-f', 'lavfi', '-i', 'anullsrc=cl=mono', '-shortest'];
+    aacTranscodeArgs(startStreamRequest) {
+        return [
+            '-acodec',
+            'libfdk_aac',
+            '-profile:a',
+            'aac_eld',
+            '-eld_sbr:a',
+            '1',
+            '-eld_v2',
+            '1',
+            '-frame_size',
+            (startStreamRequest.audio.packet_time * startStreamRequest.audio.sample_rate).toString(),
+            '-f',
+            'null',
+            '-flags',
+            '+global_header',
+            '-ac',
+            `${startStreamRequest.audio.channel}`,
+            '-ar',
+            `${startStreamRequest.audio.sample_rate}k`,
+            '-b:a',
+            `${startStreamRequest.audio.max_bit_rate}k`,
+            '-bufsize',
+            `${startStreamRequest.audio.max_bit_rate * 4}k`,
+        ];
     }
     getH264Level(level, numeric = false) {
         switch (level) {
@@ -424,5 +473,11 @@ export class StreamingSessionWrapper {
                 return numeric ? '77' : 'main';
         }
     }
+    isLowBandwidth(startStreamRequest) {
+        return startStreamRequest.audio.packet_time >= 60;
+    }
+    getDurationSeconds() {
+        return (Date.now() - this.start) / 1000;
+    }
 }
 //# sourceMappingURL=sessionWrapper.js.map