homebridge-ring 10.0.0-beta.0 → 10.0.0-beta.1

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [10.0.0-beta.1](https://github.com/dgreif/ring/compare/v10.0.0-beta.0...v10.0.0-beta.1) (2022-02-27)
+
+
+### ⚠ BREAKING CHANGES
+
+* **homebridge:** For anyone who updated to the 10.0 beta and had their cameras reset in HomeKit, this change will cause another reset.  This moves the audio codecs back to what they were before the 10.0 beta, which means anyone upgrading directly from v9 will _not_ experience a reset of the cameras.  Using native Opus was an experimental feature, which ultimately lead to a degraded user experience.
+
+### Bug Fixes
+
+* allow video transcoding to be skipped ([1ef8cdd](https://github.com/dgreif/ring/commit/1ef8cdd54d1f118a8fdcfd28f6970d9c8b7c65f9))
+* **homebridge:** switch back to aac-eld from opus ([7dcd2a0](https://github.com/dgreif/ring/commit/7dcd2a087da7c1b24cc9bdd3c3919af5e6fb7997))
+
 ## [10.0.0-beta.0](https://github.com/dgreif/ring/compare/v9.25.0-beta.1...v10.0.0-beta.0) (2022-02-18)
 
 

package/lib/api/live-call.js

@@ -19,6 +19,14 @@ const operators_1 = require("rxjs/operators");
 const subscribed_1 = require("./subscribed");
 const camera_utils_1 = require("@homebridge/camera-utils");
 const ffmpeg_1 = require("./ffmpeg");
+function getCleanSdp(sdp, includeVideo) {
+    return sdp
+        .split('\nm=')
+        .slice(1)
+        .map((section) => 'm=' + section)
+        .filter((section) => includeVideo || !section.startsWith('m=video'))
+        .join('\n');
+}
 class LiveCall extends subscribed_1.Subscribed {
     constructor(sessionId, camera) {
         super();
@@ -92,7 +100,7 @@ class LiveCall extends subscribed_1.Subscribed {
                 ...(ffmpegOptions.input || []),
                 '-i',
                 'pipe:',
-            ], inputSdp = (yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered))
+            ], ringSdp = yield (0, rxjs_1.firstValueFrom)(this.onCallAnswered), inputSdp = getCleanSdp(ringSdp, transcodeVideoStream)
                 .replace(/m=audio \d+/, `m=audio ${audioPort}`)
                 .replace(/m=video \d+/, `m=video ${videoPort}`), ff = new camera_utils_1.FfmpegProcess({
                 ffmpegArgs: ffmpegInputArguments.concat(...(ffmpegOptions.audio || ['-acodec', 'aac']), ...(transcodeVideoStream

package/lib/homebridge/camera-source.js

@@ -17,6 +17,7 @@ const operators_1 = require("rxjs/operators");
 const rxjs_1 = require("rxjs");
 const fs_1 = require("fs");
 const util_2 = require("util");
+const ffmpeg_1 = require("../api/ffmpeg");
 const werift_1 = require("@koush/werift");
 const readFileAsync = (0, util_2.promisify)(fs_1.readFile), cameraOfflinePath = require.resolve('../../media/camera-offline.jpg'), snapshotsBlockedPath = require.resolve('../../media/snapshots-blocked.jpg');
 function getDurationSeconds(start) {
@@ -45,13 +46,18 @@ class StreamingSession {
         this.videoSrtp = (0, camera_utils_1.generateSrtpOptions)();
         this.audioSplitter = new camera_utils_1.RtpSplitter();
         this.videoSplitter = new camera_utils_1.RtpSplitter();
-        this.cameraSpeakerActive = false;
-        const { targetAddress, audio: { srtp_key: remoteAudioSrtpKey, srtp_salt: remoteAudioSrtpSalt }, video: { port: videoPort }, } = prepareStreamRequest, 
-        // used to decrypt return audio from HomeKit
-        returnAudioSrtpSession = new werift_1.SrtpSession(getSessionConfig({
-            srtpKey: remoteAudioSrtpKey,
-            srtpSalt: remoteAudioSrtpSalt,
-        })), 
+        this.libfdkAacInstalledPromise = (0, camera_utils_1.doesFfmpegSupportCodec)('libfdk_aac', (0, ffmpeg_1.getFfmpegPath)())
+            .then((supported) => {
+            if (!supported) {
+                (0, util_1.logError)('Streaming video only - found ffmpeg, but libfdk_aac is not installed. See https://github.com/dgreif/ring/wiki/FFmpeg for details.');
+            }
+            return supported;
+        })
+            .catch(() => {
+            (0, util_1.logError)('Streaming video only - ffmpeg was not found. See https://github.com/dgreif/ring/wiki/FFmpeg for details.');
+            return false;
+        });
+        const { targetAddress, video: { port: videoPort }, } = prepareStreamRequest, 
         // used to encrypt rtcp to HomeKit for keepalive
         videoSrtcpSession = new werift_1.SrtcpSession(getSessionConfig(this.videoSrtp)), onReturnPacketReceived = new rxjs_1.Subject();
         // Watch return packets to detect a dead stream from the HomeKit side
@@ -61,21 +67,9 @@ class StreamingSession {
             onReturnPacketReceived.next(null);
             return null;
         });
-        this.audioSplitter.addMessageHandler(({ message, isRtpMessage }) => {
-            if (!isRtpMessage) {
-                return null;
-            }
+        this.audioSplitter.addMessageHandler(() => {
             // return packet from HomeKit
             onReturnPacketReceived.next(null);
-            // Make sure the external speaker on the camera is active since we will be sending packets to it
-            if (!this.cameraSpeakerActive) {
-                this.cameraSpeakerActive = true;
-                this.liveCall.activateCameraSpeaker().catch(util_1.logError);
-            }
-            // decrypt the packet
-            const decryptedMessage = returnAudioSrtpSession.decrypt(message), rtp = werift_1.RtpPacket.deSerialize(decryptedMessage);
-            // send to Ring - werift will handle encryption and other header params
-            this.liveCall.sendAudioPacket(rtp);
             return null;
         });
         liveCall.addSubscriptions((0, rxjs_1.merge)((0, rxjs_1.of)(true).pipe((0, operators_1.delay)(15000)), onReturnPacketReceived)
@@ -107,27 +101,9 @@ class StreamingSession {
     activate(request) {
         return __awaiter(this, void 0, void 0, function* () {
             let sentVideo = false;
-            const { targetAddress, audio: { port: audioPort }, video: { port: videoPort }, } = this.prepareStreamRequest, 
+            const { targetAddress, audio: { port: audioPort, srtp_key: remoteAudioSrtpKey, srtp_salt: remoteAudioSrtpSalt, }, video: { port: videoPort }, } = this.prepareStreamRequest, 
             // use to encrypt Ring video to HomeKit
-            audioSrtpSession = new werift_1.SrtpSession(getSessionConfig(this.audioSrtp)), videoSrtpSession = new werift_1.SrtpSession(getSessionConfig(this.videoSrtp));
-            let firstTimestamp = 0, packetCount = 0;
-            // Set up packet forwarding for audio stream
-            this.liveCall.addSubscriptions(this.liveCall.onAudioRtp.subscribe(({ header, payload }) => {
-                if (!firstTimestamp) {
-                    firstTimestamp = header.timestamp;
-                }
-                header.ssrc = this.audioSsrc;
-                header.payloadType = request.audio.pt;
-                header.timestamp = firstTimestamp + packetCount * 3 * 160;
-                packetCount++;
-                const encryptedPacket = audioSrtpSession.encrypt(payload, header);
-                this.audioSplitter
-                    .send(encryptedPacket, {
-                    port: audioPort,
-                    address: targetAddress,
-                })
-                    .catch(util_1.logError);
-            }));
+            videoSrtpSession = new werift_1.SrtpSession(getSessionConfig(this.videoSrtp));
             // Set up packet forwarding for video stream
             this.liveCall.addSubscriptions(this.liveCall.onVideoRtp.subscribe(({ header, payload }) => {
                 header.ssrc = this.videoSsrc;
@@ -144,7 +120,109 @@ class StreamingSession {
                 })
                     .catch(util_1.logError);
             }));
-            yield this.liveCall.activate();
+            const shouldTranscodeAudio = yield this.libfdkAacInstalledPromise;
+            if (!shouldTranscodeAudio) {
+                return this.liveCall.activate();
+            }
+            const transcodingPromise = this.liveCall.startTranscoding({
+                input: ['-vn'],
+                audio: [
+                    '-map',
+                    '0:a',
+                    // OPUS specific - it works, but audio is very choppy
+                    // '-acodec',
+                    // 'libopus',
+                    // '-vbr',
+                    // 'on',
+                    // '-frame_duration',
+                    // 20,
+                    // '-application',
+                    // 'lowdelay',
+                    // AAC-eld specific
+                    '-acodec',
+                    'libfdk_aac',
+                    '-profile:a',
+                    'aac_eld',
+                    // Shared options
+                    '-flags',
+                    '+global_header',
+                    '-ac',
+                    `${request.audio.channel}`,
+                    '-ar',
+                    `${request.audio.sample_rate}k`,
+                    '-b:a',
+                    `${request.audio.max_bit_rate}k`,
+                    '-bufsize',
+                    `${request.audio.max_bit_rate * 4}k`,
+                    '-payload_type',
+                    request.audio.pt,
+                    '-ssrc',
+                    this.audioSsrc,
+                    '-f',
+                    'rtp',
+                    '-srtp_out_suite',
+                    'AES_CM_128_HMAC_SHA1_80',
+                    '-srtp_out_params',
+                    (0, camera_utils_1.encodeSrtpOptions)(this.audioSrtp),
+                    `srtp://${targetAddress}:${audioPort}?pkt_size=188`,
+                ],
+                video: false,
+                output: [],
+            });
+            let cameraSpeakerActive = false;
+            // used to decrypt return audio from HomeKit to Ring
+            const remoteAudioSrtpOptions = {
+                srtpKey: remoteAudioSrtpKey,
+                srtpSalt: remoteAudioSrtpSalt,
+            }, audioSrtpSession = new werift_1.SrtpSession(getSessionConfig(remoteAudioSrtpOptions)), returnAudioTranscodedSplitter = new camera_utils_1.RtpSplitter(({ message }) => {
+                if (!cameraSpeakerActive) {
+                    cameraSpeakerActive = true;
+                    this.liveCall.activateCameraSpeaker().catch(util_1.logError);
+                }
+                // decrypt the message
+                try {
+                    const rtp = werift_1.RtpPacket.deSerialize(message);
+                    rtp.payload = audioSrtpSession.decrypt(rtp.payload);
+                    // send to Ring - werift will handle encryption and other header params
+                    this.liveCall.sendAudioPacket(rtp);
+                }
+                catch (_) {
+                    // deSerialize will sometimes fail, but the errors can be ignored
+                }
+                return null;
+            }), returnAudioTranscoder = new camera_utils_1.ReturnAudioTranscoder({
+                prepareStreamRequest: this.prepareStreamRequest,
+                incomingAudioOptions: {
+                    ssrc: this.audioSsrc,
+                    rtcpPort: 0, // we don't care about rtcp for incoming audio
+                },
+                outputArgs: [
+                    '-acodec',
+                    'libopus',
+                    '-flags',
+                    '+global_header',
+                    '-ac',
+                    2,
+                    '-ar',
+                    '48k',
+                    '-f',
+                    'rtp',
+                    `rtp://127.0.0.1:${yield returnAudioTranscodedSplitter.portPromise}`,
+                ],
+                ffmpegPath: (0, ffmpeg_1.getFfmpegPath)(),
+                logger: {
+                    info: util_1.logDebug,
+                    error: util_1.logError,
+                },
+                logLabel: `Return Audio (${this.ringCamera.name})`,
+                returnAudioSplitter: this.audioSplitter,
+            });
+            this.liveCall.onCallEnded.pipe((0, operators_1.take)(1)).subscribe(() => {
+                returnAudioTranscoder.stop();
+                returnAudioTranscodedSplitter.close();
+            });
+            yield returnAudioTranscoder.start();
+            yield transcodingPromise;
         });
     }
     stop() {
@@ -181,8 +259,8 @@ class CameraSource {
                 audio: {
                     codecs: [
                         {
-                            type: "OPUS" /* OPUS */,
-                            samplerate: 24 /* KHZ_24 */,
+                            type: "AAC-eld" /* AAC_ELD */,
+                            samplerate: 16 /* KHZ_16 */,
                         },
                     ],
                 },

package/lib/homebridge/ring-platform.js

@@ -211,8 +211,7 @@ class RingPlatform {
                 }
                 this.log.info(`Configuring ${cameras.length} cameras and ${hapDevices.length} devices for location "${location.name}" - locationId: ${location.id}`);
                 hapDevices.forEach(({ deviceType, device, isCamera, id, name, AccessoryClass }) => {
-                    // the opus qualifier is used to force new camera accessories to be created that support opus instead of aac
-                    const cameraOpusQualifier = isCamera ? 'opus' : '', uuid = hap_1.hap.uuid.generate(debugPrefix + id + cameraOpusQualifier), displayName = debugPrefix + name;
+                    const uuid = hap_1.hap.uuid.generate(debugPrefix + id), displayName = debugPrefix + name;
                     if (!AccessoryClass ||
                         (config.hideLightGroups &&
                             deviceType === api_1.RingDeviceType.BeamsLightGroupSwitch) ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "homebridge-ring",
-  "version": "10.0.0-beta.0",
+  "version": "10.0.0-beta.1",
   "description": "Homebridge plugin for Ring doorbells, cameras, security alarm system and smart lighting",
   "main": "lib/homebridge/index.js",
   "bin": {