matter-all-in-one-addon 1.8.21
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +183 -0
- package/dist/camera/ai/camera-ai-detector.d.ts +44 -0
- package/dist/camera/ai/camera-ai-detector.js +329 -0
- package/dist/camera/ai/camera-ai-detector.js.map +1 -0
- package/dist/camera/camera-capabilities.d.ts +13 -0
- package/dist/camera/camera-capabilities.js +186 -0
- package/dist/camera/camera-capabilities.js.map +1 -0
- package/dist/camera/camera-source-resolver.d.ts +18 -0
- package/dist/camera/camera-source-resolver.js +187 -0
- package/dist/camera/camera-source-resolver.js.map +1 -0
- package/dist/camera/camera-types.d.ts +124 -0
- package/dist/camera/camera-types.js +8 -0
- package/dist/camera/camera-types.js.map +1 -0
- package/dist/camera/cameraui/cameraui-client.d.ts +54 -0
- package/dist/camera/cameraui/cameraui-client.js +698 -0
- package/dist/camera/cameraui/cameraui-client.js.map +1 -0
- package/dist/camera/cameraui/cameraui-homekit-bridge.d.ts +21 -0
- package/dist/camera/cameraui/cameraui-homekit-bridge.js +343 -0
- package/dist/camera/cameraui/cameraui-homekit-bridge.js.map +1 -0
- package/dist/camera/cameraui/cameraui-storage.d.ts +17 -0
- package/dist/camera/cameraui/cameraui-storage.js +916 -0
- package/dist/camera/cameraui/cameraui-storage.js.map +1 -0
- package/dist/camera/cameraui/cameraui-types.d.ts +89 -0
- package/dist/camera/cameraui/cameraui-types.js +5 -0
- package/dist/camera/cameraui/cameraui-types.js.map +1 -0
- package/dist/camera/homekit/ffmpeg-helper.d.ts +88 -0
- package/dist/camera/homekit/ffmpeg-helper.js +673 -0
- package/dist/camera/homekit/ffmpeg-helper.js.map +1 -0
- package/dist/camera/homekit/fmp4-parser.d.ts +48 -0
- package/dist/camera/homekit/fmp4-parser.js +156 -0
- package/dist/camera/homekit/fmp4-parser.js.map +1 -0
- package/dist/camera/homekit/hevc-eligibility.d.ts +16 -0
- package/dist/camera/homekit/hevc-eligibility.js +153 -0
- package/dist/camera/homekit/hevc-eligibility.js.map +1 -0
- package/dist/camera/homekit/homekit-camera-recording.delegate.d.ts +73 -0
- package/dist/camera/homekit/homekit-camera-recording.delegate.js +445 -0
- package/dist/camera/homekit/homekit-camera-recording.delegate.js.map +1 -0
- package/dist/camera/homekit/homekit-camera-stream.delegate.d.ts +47 -0
- package/dist/camera/homekit/homekit-camera-stream.delegate.js +833 -0
- package/dist/camera/homekit/homekit-camera-stream.delegate.js.map +1 -0
- package/dist/camera/homekit/homekit-camera.accessory.d.ts +53 -0
- package/dist/camera/homekit/homekit-camera.accessory.js +697 -0
- package/dist/camera/homekit/homekit-camera.accessory.js.map +1 -0
- package/dist/camera/matter/camera-endpoint.builder.d.ts +7 -0
- package/dist/camera/matter/camera-endpoint.builder.js +127 -0
- package/dist/camera/matter/camera-endpoint.builder.js.map +1 -0
- package/dist/camera/matter/camera-session-manager.d.ts +46 -0
- package/dist/camera/matter/camera-session-manager.js +120 -0
- package/dist/camera/matter/camera-session-manager.js.map +1 -0
- package/dist/camera/matter/camera-webrtc-adapter.d.ts +62 -0
- package/dist/camera/matter/camera-webrtc-adapter.js +298 -0
- package/dist/camera/matter/camera-webrtc-adapter.js.map +1 -0
- package/dist/camera/motion/ffmpeg-motion-detector.d.ts +46 -0
- package/dist/camera/motion/ffmpeg-motion-detector.js +200 -0
- package/dist/camera/motion/ffmpeg-motion-detector.js.map +1 -0
- package/dist/camera/nest/nest-camera-adapter.d.ts +38 -0
- package/dist/camera/nest/nest-camera-adapter.js +109 -0
- package/dist/camera/nest/nest-camera-adapter.js.map +1 -0
- package/dist/camera/scrypted/scrypted-camera-card.d.ts +39 -0
- package/dist/camera/scrypted/scrypted-camera-card.js +38 -0
- package/dist/camera/scrypted/scrypted-camera-card.js.map +1 -0
- package/dist/camera/scrypted/scrypted-camera-detail.d.ts +33 -0
- package/dist/camera/scrypted/scrypted-camera-detail.js +34 -0
- package/dist/camera/scrypted/scrypted-camera-detail.js.map +1 -0
- package/dist/camera/scrypted/scrypted-camera-discovery-adapter.d.ts +17 -0
- package/dist/camera/scrypted/scrypted-camera-discovery-adapter.js +24 -0
- package/dist/camera/scrypted/scrypted-camera-discovery-adapter.js.map +1 -0
- package/dist/camera/scrypted/scrypted-camera-normalizer.d.ts +44 -0
- package/dist/camera/scrypted/scrypted-camera-normalizer.js +44 -0
- package/dist/camera/scrypted/scrypted-camera-normalizer.js.map +1 -0
- package/dist/camera/scrypted/scrypted-camera-policy.d.ts +11 -0
- package/dist/camera/scrypted/scrypted-camera-policy.js +13 -0
- package/dist/camera/scrypted/scrypted-camera-policy.js.map +1 -0
- package/dist/camera/scrypted/scrypted-camera-presentation.d.ts +13 -0
- package/dist/camera/scrypted/scrypted-camera-presentation.js +23 -0
- package/dist/camera/scrypted/scrypted-camera-presentation.js.map +1 -0
- package/dist/camera/scrypted/scrypted-client-discovery-adapter.d.ts +6 -0
- package/dist/camera/scrypted/scrypted-client-discovery-adapter.js +12 -0
- package/dist/camera/scrypted/scrypted-client-discovery-adapter.js.map +1 -0
- package/dist/camera/scrypted/scrypted-client.d.ts +152 -0
- package/dist/camera/scrypted/scrypted-client.js +1170 -0
- package/dist/camera/scrypted/scrypted-client.js.map +1 -0
- package/dist/camera/scrypted/scrypted-crypto.d.ts +21 -0
- package/dist/camera/scrypted/scrypted-crypto.js +90 -0
- package/dist/camera/scrypted/scrypted-crypto.js.map +1 -0
- package/dist/camera/scrypted/scrypted-discovery-provider.d.ts +9 -0
- package/dist/camera/scrypted/scrypted-discovery-provider.js +25 -0
- package/dist/camera/scrypted/scrypted-discovery-provider.js.map +1 -0
- package/dist/camera/scrypted/scrypted-homekit-bridge.d.ts +12 -0
- package/dist/camera/scrypted/scrypted-homekit-bridge.js +214 -0
- package/dist/camera/scrypted/scrypted-homekit-bridge.js.map +1 -0
- package/dist/camera/scrypted/scrypted-matter-bridge.d.ts +36 -0
- package/dist/camera/scrypted/scrypted-matter-bridge.js +226 -0
- package/dist/camera/scrypted/scrypted-matter-bridge.js.map +1 -0
- package/dist/camera/scrypted/scrypted-reconnect-manager.d.ts +40 -0
- package/dist/camera/scrypted/scrypted-reconnect-manager.js +353 -0
- package/dist/camera/scrypted/scrypted-reconnect-manager.js.map +1 -0
- package/dist/camera/scrypted/scrypted-runtime-connector.d.ts +7 -0
- package/dist/camera/scrypted/scrypted-runtime-connector.js +17 -0
- package/dist/camera/scrypted/scrypted-runtime-connector.js.map +1 -0
- package/dist/camera/scrypted/scrypted-runtime-facade.d.ts +13 -0
- package/dist/camera/scrypted/scrypted-runtime-facade.js +29 -0
- package/dist/camera/scrypted/scrypted-runtime-facade.js.map +1 -0
- package/dist/camera/scrypted/scrypted-runtime-ingest.d.ts +5 -0
- package/dist/camera/scrypted/scrypted-runtime-ingest.js +54 -0
- package/dist/camera/scrypted/scrypted-runtime-ingest.js.map +1 -0
- package/dist/camera/scrypted/scrypted-storage.d.ts +95 -0
- package/dist/camera/scrypted/scrypted-storage.js +698 -0
- package/dist/camera/scrypted/scrypted-storage.js.map +1 -0
- package/dist/camera/scrypted/scrypted-stream-validator.d.ts +46 -0
- package/dist/camera/scrypted/scrypted-stream-validator.js +412 -0
- package/dist/camera/scrypted/scrypted-stream-validator.js.map +1 -0
- package/dist/camera/scrypted/scrypted-types.d.ts +354 -0
- package/dist/camera/scrypted/scrypted-types.js +6 -0
- package/dist/camera/scrypted/scrypted-types.js.map +1 -0
- package/dist/converters/binary_sensor.converter.d.ts +18 -0
- package/dist/converters/binary_sensor.converter.js +21 -0
- package/dist/converters/binary_sensor.converter.js.map +1 -0
- package/dist/converters/camera.converter.d.ts +18 -0
- package/dist/converters/camera.converter.js +24 -0
- package/dist/converters/camera.converter.js.map +1 -0
- package/dist/converters/climate.converter.d.ts +21 -0
- package/dist/converters/climate.converter.js +55 -0
- package/dist/converters/climate.converter.js.map +1 -0
- package/dist/converters/cover.converter.d.ts +14 -0
- package/dist/converters/cover.converter.js +22 -0
- package/dist/converters/cover.converter.js.map +1 -0
- package/dist/converters/energy_tariff.converter.d.ts +10 -0
- package/dist/converters/energy_tariff.converter.js +12 -0
- package/dist/converters/energy_tariff.converter.js.map +1 -0
- package/dist/converters/fan.converter.d.ts +233 -0
- package/dist/converters/fan.converter.js +353 -0
- package/dist/converters/fan.converter.js.map +1 -0
- package/dist/converters/index.d.ts +14 -0
- package/dist/converters/index.js +15 -0
- package/dist/converters/index.js.map +1 -0
- package/dist/converters/light.converter.d.ts +26 -0
- package/dist/converters/light.converter.js +36 -0
- package/dist/converters/light.converter.js.map +1 -0
- package/dist/converters/lock.converter.d.ts +20 -0
- package/dist/converters/lock.converter.js +29 -0
- package/dist/converters/lock.converter.js.map +1 -0
- package/dist/converters/sensor.converter.d.ts +18 -0
- package/dist/converters/sensor.converter.js +33 -0
- package/dist/converters/sensor.converter.js.map +1 -0
- package/dist/converters/soil_sensor.converter.d.ts +14 -0
- package/dist/converters/soil_sensor.converter.js +21 -0
- package/dist/converters/soil_sensor.converter.js.map +1 -0
- package/dist/converters/vacuum.converter.d.ts +168 -0
- package/dist/converters/vacuum.converter.js +288 -0
- package/dist/converters/vacuum.converter.js.map +1 -0
- package/dist/device-profiles.d.ts +14 -0
- package/dist/device-profiles.js +245 -0
- package/dist/device-profiles.js.map +1 -0
- package/dist/device-registry.d.ts +58 -0
- package/dist/device-registry.js +288 -0
- package/dist/device-registry.js.map +1 -0
- package/dist/entities/base.entity.d.ts +40 -0
- package/dist/entities/base.entity.js +826 -0
- package/dist/entities/base.entity.js.map +1 -0
- package/dist/entities/camera.entity.d.ts +48 -0
- package/dist/entities/camera.entity.js +127 -0
- package/dist/entities/camera.entity.js.map +1 -0
- package/dist/entities/closure.entity.d.ts +9 -0
- package/dist/entities/closure.entity.js +52 -0
- package/dist/entities/closure.entity.js.map +1 -0
- package/dist/entities/composite-device.entity.d.ts +61 -0
- package/dist/entities/composite-device.entity.js +986 -0
- package/dist/entities/composite-device.entity.js.map +1 -0
- package/dist/entities/cooktop.entity.d.ts +20 -0
- package/dist/entities/cooktop.entity.js +59 -0
- package/dist/entities/cooktop.entity.js.map +1 -0
- package/dist/entities/energy_tariff.entity.d.ts +7 -0
- package/dist/entities/energy_tariff.entity.js +32 -0
- package/dist/entities/energy_tariff.entity.js.map +1 -0
- package/dist/entities/humidifier.entity.d.ts +27 -0
- package/dist/entities/humidifier.entity.js +187 -0
- package/dist/entities/humidifier.entity.js.map +1 -0
- package/dist/entities/lock.entity.d.ts +12 -0
- package/dist/entities/lock.entity.js +58 -0
- package/dist/entities/lock.entity.js.map +1 -0
- package/dist/entities/media-player.entity.d.ts +13 -0
- package/dist/entities/media-player.entity.js +52 -0
- package/dist/entities/media-player.entity.js.map +1 -0
- package/dist/entities/oven.entity.d.ts +20 -0
- package/dist/entities/oven.entity.js +112 -0
- package/dist/entities/oven.entity.js.map +1 -0
- package/dist/entities/pet_feeder.entity.d.ts +28 -0
- package/dist/entities/pet_feeder.entity.js +67 -0
- package/dist/entities/pet_feeder.entity.js.map +1 -0
- package/dist/entities/soil_sensor.entity.d.ts +7 -0
- package/dist/entities/soil_sensor.entity.js +40 -0
- package/dist/entities/soil_sensor.entity.js.map +1 -0
- package/dist/entities/vacuum.entity.d.ts +37 -0
- package/dist/entities/vacuum.entity.js +352 -0
- package/dist/entities/vacuum.entity.js.map +1 -0
- package/dist/frontend/assets/index-DPXu3al2.js +26 -0
- package/dist/frontend/assets/index-DalMl4eS.css +1 -0
- package/dist/frontend/assets/logo-B_gEBugV.png +0 -0
- package/dist/frontend/index.html +14 -0
- package/dist/frontend/logo.png +0 -0
- package/dist/homeAssistant.d.ts +1268 -0
- package/dist/homeAssistant.js +1623 -0
- package/dist/homeAssistant.js.map +1 -0
- package/dist/homekit.compat.d.ts +40 -0
- package/dist/homekit.compat.js +43 -0
- package/dist/homekit.compat.js.map +1 -0
- package/dist/index.d.ts +7 -0
- package/dist/index.js +31 -0
- package/dist/index.js.map +1 -0
- package/dist/mqtt/mqtt-client.d.ts +33 -0
- package/dist/mqtt/mqtt-client.js +138 -0
- package/dist/mqtt/mqtt-client.js.map +1 -0
- package/dist/mqtt/mqtt.entity.d.ts +30 -0
- package/dist/mqtt/mqtt.entity.js +286 -0
- package/dist/mqtt/mqtt.entity.js.map +1 -0
- package/dist/platform.d.ts +318 -0
- package/dist/platform.js +6144 -0
- package/dist/platform.js.map +1 -0
- package/dist/proxy.d.ts +1 -0
- package/dist/proxy.js +226 -0
- package/dist/proxy.js.map +1 -0
- package/dist/utils/ha-discovery.d.ts +30 -0
- package/dist/utils/ha-discovery.js +175 -0
- package/dist/utils/ha-discovery.js.map +1 -0
- package/dist/utils/ha-state.d.ts +48 -0
- package/dist/utils/ha-state.js +21 -0
- package/dist/utils/ha-state.js.map +1 -0
- package/dist/utils/light-color.d.ts +63 -0
- package/dist/utils/light-color.js +213 -0
- package/dist/utils/light-color.js.map +1 -0
- package/dist/utils/log-buffer.d.ts +13 -0
- package/dist/utils/log-buffer.js +50 -0
- package/dist/utils/log-buffer.js.map +1 -0
- package/dist/utils/matter-attributes.d.ts +13 -0
- package/dist/utils/matter-attributes.js +35 -0
- package/dist/utils/matter-attributes.js.map +1 -0
- package/dist/utils/matter-device-identity.d.ts +22 -0
- package/dist/utils/matter-device-identity.js +70 -0
- package/dist/utils/matter-device-identity.js.map +1 -0
- package/dist/utils/thread-credentials.d.ts +22 -0
- package/dist/utils/thread-credentials.js +29 -0
- package/dist/utils/thread-credentials.js.map +1 -0
- package/package.json +80 -0
|
@@ -0,0 +1,833 @@
|
|
|
1
|
+
import { EventEmitter } from "node:events";
|
|
2
|
+
import fs from "node:fs/promises";
|
|
3
|
+
import fsSync from "node:fs";
|
|
4
|
+
import { CameraController, } from "hap-nodejs";
|
|
5
|
+
import { spawn } from "node:child_process";
|
|
6
|
+
import dgram from "node:dgram";
|
|
7
|
+
import { getFfmpegVersion, resolveFfmpegPath, sanitizeUrlCredentials, supportsFdkAac, } from "./ffmpeg-helper.js";
|
|
8
|
+
const FALLBACK_JPEG_BUFFER = Buffer.from("/9j/4AAQSkZJRgABAgAAAQABAAD//gAPTGF2YzYwLjMuMTAwAP/bAEMACAYGBwYHCAgICAgICQkJCgoKCQkJCQoKCgoKCgwMDAoKCgoKCgoMDAwMDQ4NDQ0MDQ4ODw8PEhIRERUVFRkZH//EAEwAAQEAAAAAAAAAAAAAAAAAAAAHAQEBAAAAAAAAAAAAAAAAAAAAARABAAAAAAAAAAAAAAAAAAAAABEBAAAAAAAAAAAAAAAAAAAAAP/AABEIAPABQAMBIgACEQADEQD/2gAMAwEAAhEDEQA/AI2AoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//9k=", "base64");
|
|
9
|
+
function isJpeg(buffer) {
|
|
10
|
+
return (buffer.length > 128 &&
|
|
11
|
+
buffer[0] === 0xff &&
|
|
12
|
+
buffer[1] === 0xd8 &&
|
|
13
|
+
buffer[buffer.length - 2] === 0xff &&
|
|
14
|
+
buffer[buffer.length - 1] === 0xd9);
|
|
15
|
+
}
|
|
16
|
+
function isPng(buffer) {
|
|
17
|
+
return (buffer.length > 8 &&
|
|
18
|
+
buffer[0] === 0x89 &&
|
|
19
|
+
buffer[1] === 0x50 &&
|
|
20
|
+
buffer[2] === 0x4e &&
|
|
21
|
+
buffer[3] === 0x47);
|
|
22
|
+
}
|
|
23
|
+
function convertImageToJpeg(inputBuffer, width, height) {
|
|
24
|
+
const ffmpegPath = resolveFfmpegPath();
|
|
25
|
+
if (!ffmpegPath)
|
|
26
|
+
return Promise.resolve(null);
|
|
27
|
+
return new Promise((resolve) => {
|
|
28
|
+
const scaleFilter = width && height
|
|
29
|
+
? `scale=w='min(${width},iw)':h='min(${height},ih)':force_original_aspect_ratio=decrease:force_divisible_by=2`
|
|
30
|
+
: undefined;
|
|
31
|
+
const args = [
|
|
32
|
+
"-hide_banner",
|
|
33
|
+
"-loglevel",
|
|
34
|
+
"error",
|
|
35
|
+
"-i",
|
|
36
|
+
"pipe:0",
|
|
37
|
+
"-frames:v",
|
|
38
|
+
"1",
|
|
39
|
+
];
|
|
40
|
+
if (scaleFilter) {
|
|
41
|
+
args.push("-vf", scaleFilter);
|
|
42
|
+
}
|
|
43
|
+
args.push("-f", "image2", "-c:v", "mjpeg", "-q:v", "3", "pipe:1");
|
|
44
|
+
const proc = spawn(ffmpegPath, args, {
|
|
45
|
+
stdio: ["pipe", "pipe", "ignore"],
|
|
46
|
+
});
|
|
47
|
+
const chunks = [];
|
|
48
|
+
const timer = setTimeout(() => {
|
|
49
|
+
try {
|
|
50
|
+
proc.kill("SIGKILL");
|
|
51
|
+
}
|
|
52
|
+
catch { }
|
|
53
|
+
resolve(null);
|
|
54
|
+
}, 2000);
|
|
55
|
+
proc.stdout?.on("data", (c) => chunks.push(c));
|
|
56
|
+
proc.once("error", () => {
|
|
57
|
+
clearTimeout(timer);
|
|
58
|
+
resolve(null);
|
|
59
|
+
});
|
|
60
|
+
proc.once("close", (code) => {
|
|
61
|
+
clearTimeout(timer);
|
|
62
|
+
if (code === 0) {
|
|
63
|
+
const out = Buffer.concat(chunks);
|
|
64
|
+
if (isJpeg(out) && out.length > 256) {
|
|
65
|
+
resolve(out);
|
|
66
|
+
return;
|
|
67
|
+
}
|
|
68
|
+
}
|
|
69
|
+
resolve(null);
|
|
70
|
+
});
|
|
71
|
+
try {
|
|
72
|
+
if (proc.stdin && !proc.stdin.destroyed) {
|
|
73
|
+
proc.stdin.write(inputBuffer);
|
|
74
|
+
proc.stdin.end();
|
|
75
|
+
}
|
|
76
|
+
}
|
|
77
|
+
catch {
|
|
78
|
+
clearTimeout(timer);
|
|
79
|
+
resolve(null);
|
|
80
|
+
}
|
|
81
|
+
});
|
|
82
|
+
}
|
|
83
|
+
function formatHost(address) {
|
|
84
|
+
// Strip IPv6 interface identifier like %en0 or %eth0 if present
|
|
85
|
+
let cleanAddr = address;
|
|
86
|
+
const pct = cleanAddr.indexOf("%");
|
|
87
|
+
if (pct !== -1) {
|
|
88
|
+
cleanAddr = cleanAddr.substring(0, pct);
|
|
89
|
+
}
|
|
90
|
+
// Strip IPv4-mapped IPv6 prefix (::ffff:192.168.x.x -> 192.168.x.x)
|
|
91
|
+
cleanAddr = cleanAddr.replace(/^::ffff:/i, "");
|
|
92
|
+
if (!cleanAddr.includes(":"))
|
|
93
|
+
return cleanAddr;
|
|
94
|
+
return cleanAddr.startsWith("[") ? cleanAddr : `[${cleanAddr}]`;
|
|
95
|
+
}
|
|
96
|
+
function suiteName(suite) {
|
|
97
|
+
return suite === 1 /* SRTPCryptoSuites.AES_CM_256_HMAC_SHA1_80 */
|
|
98
|
+
? "AES_CM_256_HMAC_SHA1_80"
|
|
99
|
+
: "AES_CM_128_HMAC_SHA1_80";
|
|
100
|
+
}
|
|
101
|
+
function h264Profile(profile) {
|
|
102
|
+
if (profile === 2 /* H264Profile.HIGH */)
|
|
103
|
+
return "high";
|
|
104
|
+
if (profile === 1 /* H264Profile.MAIN */)
|
|
105
|
+
return "main";
|
|
106
|
+
return "baseline";
|
|
107
|
+
}
|
|
108
|
+
function h264Level(level) {
|
|
109
|
+
if (level === 2 /* H264Level.LEVEL4_0 */)
|
|
110
|
+
return "4.0";
|
|
111
|
+
if (level === 1 /* H264Level.LEVEL3_2 */)
|
|
112
|
+
return "3.2";
|
|
113
|
+
return "3.1";
|
|
114
|
+
}
|
|
115
|
+
export class HomeKitCameraStreamingDelegate extends EventEmitter {
|
|
116
|
+
platform;
|
|
117
|
+
entityId;
|
|
118
|
+
capabilities;
|
|
119
|
+
streamSource;
|
|
120
|
+
activeSessions = new Map();
|
|
121
|
+
lastSnapshotBuffer = FALLBACK_JPEG_BUFFER;
|
|
122
|
+
get isStreaming() {
|
|
123
|
+
return this.activeSessions.size > 0;
|
|
124
|
+
}
|
|
125
|
+
isTakingSnapshot = false;
|
|
126
|
+
lastSnapshotTime = 0;
|
|
127
|
+
constructor(platform, entityId, capabilities, streamSource) {
|
|
128
|
+
super();
|
|
129
|
+
this.platform = platform;
|
|
130
|
+
this.entityId = entityId;
|
|
131
|
+
this.capabilities = capabilities;
|
|
132
|
+
this.streamSource = streamSource;
|
|
133
|
+
this.loadPersistedSnapshot();
|
|
134
|
+
}
|
|
135
|
+
loadPersistedSnapshot() {
|
|
136
|
+
try {
|
|
137
|
+
const snapPath = `/data/snapshots/${this.entityId.replaceAll(".", "_")}.jpg`;
|
|
138
|
+
if (fsSync.existsSync(snapPath)) {
|
|
139
|
+
const buf = fsSync.readFileSync(snapPath);
|
|
140
|
+
if (isJpeg(buf) && buf.length > 2048) {
|
|
141
|
+
this.lastSnapshotBuffer = buf;
|
|
142
|
+
this.lastSnapshotTime = Date.now();
|
|
143
|
+
}
|
|
144
|
+
}
|
|
145
|
+
}
|
|
146
|
+
catch { }
|
|
147
|
+
}
|
|
148
|
+
async persistSnapshotToDisk(buffer) {
|
|
149
|
+
try {
|
|
150
|
+
const dir = "/data/snapshots";
|
|
151
|
+
if (!fsSync.existsSync(dir)) {
|
|
152
|
+
fsSync.mkdirSync(dir, { recursive: true });
|
|
153
|
+
}
|
|
154
|
+
const snapPath = `${dir}/${this.entityId.replaceAll(".", "_")}.jpg`;
|
|
155
|
+
await fs.writeFile(snapPath, buffer);
|
|
156
|
+
}
|
|
157
|
+
catch { }
|
|
158
|
+
}
|
|
159
|
+
async handleSnapshotRequest(request, callback) {
|
|
160
|
+
const started = Date.now();
|
|
161
|
+
let completed = false;
|
|
162
|
+
const finish = (source, buffer) => {
|
|
163
|
+
this.isTakingSnapshot = false;
|
|
164
|
+
if (completed)
|
|
165
|
+
return;
|
|
166
|
+
completed = true;
|
|
167
|
+
const selected = isJpeg(buffer) && buffer.length > 2048
|
|
168
|
+
? buffer
|
|
169
|
+
: this.lastSnapshotBuffer;
|
|
170
|
+
if (isJpeg(selected) && selected !== FALLBACK_JPEG_BUFFER) {
|
|
171
|
+
this.lastSnapshotBuffer = selected;
|
|
172
|
+
this.lastSnapshotTime = Date.now();
|
|
173
|
+
void this.persistSnapshotToDisk(selected);
|
|
174
|
+
}
|
|
175
|
+
this.platform?.log?.notice?.(`[HomeKitCamera][${this.entityId}] Snapshot source=${source} bytes=${selected.length} duration=${Date.now() - started}ms validJpeg=${isJpeg(selected)}`);
|
|
176
|
+
callback(undefined, selected);
|
|
177
|
+
};
|
|
178
|
+
// NEVER open a competing RTSP connection while live viewing is active.
|
|
179
|
+
// Cameras like Tapo allow max 2 RTSP connections; opening a 3rd connection kills the live stream.
|
|
180
|
+
if (this.activeSessions.size > 0) {
|
|
181
|
+
finish("active-session-protect", this.lastSnapshotBuffer);
|
|
182
|
+
return;
|
|
183
|
+
}
|
|
184
|
+
// If a live stream is actively running, reuse last snapshot immediately to avoid RTSP socket contention
|
|
185
|
+
if (this.activeSessions.size > 0 &&
|
|
186
|
+
this.lastSnapshotBuffer &&
|
|
187
|
+
this.lastSnapshotBuffer !== FALLBACK_JPEG_BUFFER) {
|
|
188
|
+
finish("cached-active-stream", this.lastSnapshotBuffer);
|
|
189
|
+
return;
|
|
190
|
+
}
|
|
191
|
+
const now = Date.now();
|
|
192
|
+
if (this.lastSnapshotBuffer &&
|
|
193
|
+
this.lastSnapshotBuffer !== FALLBACK_JPEG_BUFFER &&
|
|
194
|
+
(this.isTakingSnapshot || now - this.lastSnapshotTime < 5000)) {
|
|
195
|
+
finish("cached-session-guard", this.lastSnapshotBuffer);
|
|
196
|
+
return;
|
|
197
|
+
}
|
|
198
|
+
this.isTakingSnapshot = true;
|
|
199
|
+
try {
|
|
200
|
+
let haEntityToQuery = this.entityId.startsWith("camera.")
|
|
201
|
+
? this.entityId
|
|
202
|
+
: undefined;
|
|
203
|
+
if (!haEntityToQuery && this.platform?.ha?.hassStates) {
|
|
204
|
+
const cleanName = this.entityId.replace(/^scrypted\./, "").toLowerCase();
|
|
205
|
+
const cameraModel = (this.streamSource.metadata?.model || "").toLowerCase();
|
|
206
|
+
for (const [id, state] of this.platform.ha.hassStates.entries()) {
|
|
207
|
+
if (!id.startsWith("camera."))
|
|
208
|
+
continue;
|
|
209
|
+
const fn = (state.attributes?.friendly_name || "").toLowerCase();
|
|
210
|
+
if (id.includes(cleanName) ||
|
|
211
|
+
fn.includes(cleanName) ||
|
|
212
|
+
(cameraModel && fn.includes(cameraModel))) {
|
|
213
|
+
haEntityToQuery = id;
|
|
214
|
+
break;
|
|
215
|
+
}
|
|
216
|
+
}
|
|
217
|
+
}
|
|
218
|
+
if (haEntityToQuery &&
|
|
219
|
+
this.platform?.ha?.fetchSnapshot &&
|
|
220
|
+
typeof this.platform.ha.fetchSnapshot === "function") {
|
|
221
|
+
try {
|
|
222
|
+
const buffer = await this.platform.ha.fetchSnapshot(haEntityToQuery);
|
|
223
|
+
if (buffer && isJpeg(buffer) && buffer.length > 512) {
|
|
224
|
+
finish("ha-fetch-snapshot", buffer);
|
|
225
|
+
return;
|
|
226
|
+
}
|
|
227
|
+
else if (buffer && isPng(buffer)) {
|
|
228
|
+
const converted = await convertImageToJpeg(buffer, request.width, request.height);
|
|
229
|
+
if (converted) {
|
|
230
|
+
finish("ha-fetch-png-converted", converted);
|
|
231
|
+
return;
|
|
232
|
+
}
|
|
233
|
+
}
|
|
234
|
+
}
|
|
235
|
+
catch { }
|
|
236
|
+
}
|
|
237
|
+
const snapshotUrl = this.streamSource.snapshotUrl;
|
|
238
|
+
if (snapshotUrl?.startsWith("http://") || snapshotUrl?.startsWith("https://")) {
|
|
239
|
+
try {
|
|
240
|
+
const headers = {};
|
|
241
|
+
const token = this.platform?.ha?.getAccessToken?.() ||
|
|
242
|
+
this.platform?.ha?.wsAccessToken;
|
|
243
|
+
if (token) {
|
|
244
|
+
headers["Authorization"] = `Bearer ${token}`;
|
|
245
|
+
}
|
|
246
|
+
const response = await fetch(snapshotUrl, {
|
|
247
|
+
headers,
|
|
248
|
+
signal: AbortSignal.timeout(2500),
|
|
249
|
+
});
|
|
250
|
+
if (response.ok) {
|
|
251
|
+
const buffer = Buffer.from(await response.arrayBuffer());
|
|
252
|
+
if (isJpeg(buffer) && buffer.length > 512) {
|
|
253
|
+
finish("http-snapshot", buffer);
|
|
254
|
+
return;
|
|
255
|
+
}
|
|
256
|
+
else if (isPng(buffer)) {
|
|
257
|
+
const converted = await convertImageToJpeg(buffer, request.width, request.height);
|
|
258
|
+
if (converted) {
|
|
259
|
+
finish("http-png-converted", converted);
|
|
260
|
+
return;
|
|
261
|
+
}
|
|
262
|
+
}
|
|
263
|
+
}
|
|
264
|
+
}
|
|
265
|
+
catch (error) {
|
|
266
|
+
this.platform?.log?.debug?.(`[HomeKitCamera][${this.entityId}] Snapshot HTTP failed: ${String(error)}`);
|
|
267
|
+
}
|
|
268
|
+
}
|
|
269
|
+
const ffmpegPath = resolveFfmpegPath();
|
|
270
|
+
const sourceUrl = this.getCleanSourceUrl();
|
|
271
|
+
if (!ffmpegPath || !sourceUrl) {
|
|
272
|
+
finish("fallback-no-source", this.lastSnapshotBuffer);
|
|
273
|
+
return;
|
|
274
|
+
}
|
|
275
|
+
const args = ["-hide_banner", "-loglevel", "error"];
|
|
276
|
+
if (sourceUrl.startsWith("rtsp://")) {
|
|
277
|
+
args.push("-probesize", "32768", "-analyzeduration", "0", "-rtsp_transport", "tcp", "-fflags", "+nobuffer+flush_packets", "-flags", "low_delay");
|
|
278
|
+
}
|
|
279
|
+
else if (sourceUrl.startsWith("http://") || sourceUrl.startsWith("https://")) {
|
|
280
|
+
args.push("-probesize", "32768", "-analyzeduration", "0", "-fflags", "+nobuffer+flush_packets", "-flags", "low_delay");
|
|
281
|
+
const token = this.platform?.ha?.getAccessToken?.() ||
|
|
282
|
+
this.platform?.ha?.wsAccessToken;
|
|
283
|
+
if (token) {
|
|
284
|
+
args.push("-headers", `Authorization: Bearer ${token}\r\n`);
|
|
285
|
+
}
|
|
286
|
+
}
|
|
287
|
+
args.push("-i", sourceUrl, "-frames:v", "1", "-vf", `scale=w='min(${request.width},iw)':h='min(${request.height},ih)':force_original_aspect_ratio=decrease:force_divisible_by=2`, "-f", "image2", "-q:v", "3", "pipe:1");
|
|
288
|
+
const process = spawn(ffmpegPath, args, {
|
|
289
|
+
stdio: ["ignore", "pipe", "ignore"],
|
|
290
|
+
});
|
|
291
|
+
const chunks = [];
|
|
292
|
+
const timer = setTimeout(() => {
|
|
293
|
+
try {
|
|
294
|
+
process.kill("SIGKILL");
|
|
295
|
+
}
|
|
296
|
+
catch { }
|
|
297
|
+
finish("fallback-timeout", this.lastSnapshotBuffer);
|
|
298
|
+
}, 3000);
|
|
299
|
+
process.stdout.on("data", (chunk) => chunks.push(chunk));
|
|
300
|
+
process.once("error", () => {
|
|
301
|
+
clearTimeout(timer);
|
|
302
|
+
finish("fallback-ffmpeg-error", this.lastSnapshotBuffer);
|
|
303
|
+
});
|
|
304
|
+
process.once("close", () => {
|
|
305
|
+
clearTimeout(timer);
|
|
306
|
+
const buffer = Buffer.concat(chunks);
|
|
307
|
+
finish(isJpeg(buffer) && buffer.length > 2048
|
|
308
|
+
? "ffmpeg"
|
|
309
|
+
: "fallback-invalid-jpeg", buffer);
|
|
310
|
+
});
|
|
311
|
+
}
|
|
312
|
+
catch (error) {
|
|
313
|
+
this.platform?.log?.warn?.(`[HomeKitCamera][${this.entityId}] Snapshot fatal error: ${String(error)}`);
|
|
314
|
+
finish("fatal-error", this.lastSnapshotBuffer);
|
|
315
|
+
}
|
|
316
|
+
}
|
|
317
|
+
prepareStream(request, callback) {
|
|
318
|
+
void this.prepareStreamAsync(request, callback);
|
|
319
|
+
}
|
|
320
|
+
async prepareStreamAsync(request, callback) {
|
|
321
|
+
try {
|
|
322
|
+
// Purge any zombie sessions (process died but Map entry survived) before
|
|
323
|
+
// setting up a new one — otherwise the old dead entry corrupts cleanup.
|
|
324
|
+
for (const [sid, s] of [...this.activeSessions.entries()]) {
|
|
325
|
+
if (!s.process || s.process.killed || s.process.exitCode !== null) {
|
|
326
|
+
this.platform?.log?.notice?.(`[HomeKitCamera][${this.entityId}] Purging zombie session=${sid} before new prepare`);
|
|
327
|
+
if (s.pipeController) {
|
|
328
|
+
try {
|
|
329
|
+
s.pipeController.abort();
|
|
330
|
+
}
|
|
331
|
+
catch { }
|
|
332
|
+
}
|
|
333
|
+
if (s.process) {
|
|
334
|
+
try {
|
|
335
|
+
s.process.kill("SIGKILL");
|
|
336
|
+
}
|
|
337
|
+
catch { }
|
|
338
|
+
}
|
|
339
|
+
this.activeSessions.delete(sid);
|
|
340
|
+
}
|
|
341
|
+
}
|
|
342
|
+
const localVideoPort = await this.allocateUdpPort([
|
|
343
|
+
request.video.port,
|
|
344
|
+
]);
|
|
345
|
+
const localAudioPort = request.audio
|
|
346
|
+
? await this.allocateUdpPort([request.audio.port, localVideoPort])
|
|
347
|
+
: undefined;
|
|
348
|
+
const session = {
|
|
349
|
+
sessionId: request.sessionID,
|
|
350
|
+
targetAddress: request.targetAddress,
|
|
351
|
+
videoPort: request.video.port,
|
|
352
|
+
localVideoPort,
|
|
353
|
+
videoSsrc: CameraController.generateSynchronisationSource(),
|
|
354
|
+
videoCryptoSuite: request.video.srtpCryptoSuite,
|
|
355
|
+
videoKeySalt: Buffer.concat([
|
|
356
|
+
request.video.srtp_key,
|
|
357
|
+
request.video.srtp_salt,
|
|
358
|
+
]),
|
|
359
|
+
};
|
|
360
|
+
if (request.audio && localAudioPort) {
|
|
361
|
+
session.audioPort = request.audio.port;
|
|
362
|
+
session.localAudioPort = localAudioPort;
|
|
363
|
+
session.audioSsrc = CameraController.generateSynchronisationSource();
|
|
364
|
+
session.audioCryptoSuite = request.audio.srtpCryptoSuite;
|
|
365
|
+
session.audioKeySalt = Buffer.concat([
|
|
366
|
+
request.audio.srtp_key,
|
|
367
|
+
request.audio.srtp_salt,
|
|
368
|
+
]);
|
|
369
|
+
}
|
|
370
|
+
this.activeSessions.set(request.sessionID, session);
|
|
371
|
+
const response = {
|
|
372
|
+
video: {
|
|
373
|
+
port: localVideoPort,
|
|
374
|
+
ssrc: session.videoSsrc,
|
|
375
|
+
srtp_key: request.video.srtp_key,
|
|
376
|
+
srtp_salt: request.video.srtp_salt,
|
|
377
|
+
},
|
|
378
|
+
};
|
|
379
|
+
if (request.audio && localAudioPort) {
|
|
380
|
+
response.audio = {
|
|
381
|
+
port: localAudioPort,
|
|
382
|
+
ssrc: session.audioSsrc,
|
|
383
|
+
srtp_key: request.audio.srtp_key,
|
|
384
|
+
srtp_salt: request.audio.srtp_salt,
|
|
385
|
+
};
|
|
386
|
+
}
|
|
387
|
+
this.platform?.log?.notice?.(`[HomeKitCamera][${this.entityId}] HAP SetupEndpoints session=${request.sessionID} remote=${request.targetAddress}:${request.video.port} localVideoRTCP=${localVideoPort} videoSSRC=${session.videoSsrc}${localAudioPort ? ` localAudioRTCP=${localAudioPort} audioSSRC=${session.audioSsrc}` : ""}`);
|
|
388
|
+
callback(undefined, response);
|
|
389
|
+
}
|
|
390
|
+
catch (error) {
|
|
391
|
+
callback(error);
|
|
392
|
+
}
|
|
393
|
+
}
|
|
394
|
+
allocateUdpPort(excluded) {
|
|
395
|
+
return new Promise((resolve, reject) => {
|
|
396
|
+
const socket = dgram.createSocket("udp4");
|
|
397
|
+
socket.once("error", (error) => {
|
|
398
|
+
try {
|
|
399
|
+
socket.close();
|
|
400
|
+
}
|
|
401
|
+
catch { }
|
|
402
|
+
reject(error);
|
|
403
|
+
});
|
|
404
|
+
socket.bind(0, "0.0.0.0", () => {
|
|
405
|
+
const address = socket.address();
|
|
406
|
+
const port = typeof address === "string" ? 0 : address.port;
|
|
407
|
+
socket.close(() => {
|
|
408
|
+
if (!port || excluded.includes(port)) {
|
|
409
|
+
void this.allocateUdpPort(excluded).then(resolve, reject);
|
|
410
|
+
}
|
|
411
|
+
else {
|
|
412
|
+
resolve(port);
|
|
413
|
+
}
|
|
414
|
+
});
|
|
415
|
+
});
|
|
416
|
+
});
|
|
417
|
+
}
|
|
418
|
+
handleStreamRequest(request, callback) {
|
|
419
|
+
if (request.type === "start" /* StreamRequestTypes.START */) {
|
|
420
|
+
const session = this.activeSessions.get(request.sessionID);
|
|
421
|
+
if (!session) {
|
|
422
|
+
callback(new Error(`Session ${request.sessionID} was not prepared`));
|
|
423
|
+
return;
|
|
424
|
+
}
|
|
425
|
+
void this.startStream(session, request, callback);
|
|
426
|
+
return;
|
|
427
|
+
}
|
|
428
|
+
if (request.type === "reconfigure" /* StreamRequestTypes.RECONFIGURE */) {
|
|
429
|
+
const video = request.video;
|
|
430
|
+
this.platform?.log?.notice?.(`[HomeKitCamera][${this.entityId}] HAP RECONFIGURE ${video.width}x${video.height}@${video.fps}`);
|
|
431
|
+
callback();
|
|
432
|
+
return;
|
|
433
|
+
}
|
|
434
|
+
this.stopStream(request.sessionID);
|
|
435
|
+
callback();
|
|
436
|
+
}
|
|
437
|
+
getCleanSourceUrl() {
|
|
438
|
+
let url = this.streamSource.url;
|
|
439
|
+
if (!url)
|
|
440
|
+
return undefined;
|
|
441
|
+
const hashIdx = url.indexOf("#");
|
|
442
|
+
if (hashIdx !== -1) {
|
|
443
|
+
url = url.substring(0, hashIdx);
|
|
444
|
+
}
|
|
445
|
+
// Replace localhost with 127.0.0.1 to avoid IPv6 connection issues in FFmpeg
|
|
446
|
+
url = url.replace(/^(rtsps?|https?):\/\/localhost(?=[:/])/i, "$1://127.0.0.1");
|
|
447
|
+
return url;
|
|
448
|
+
}
|
|
449
|
+
async startStream(session, request, callback) {
|
|
450
|
+
const ffmpegPath = resolveFfmpegPath();
|
|
451
|
+
const sourceUrl = this.getCleanSourceUrl();
|
|
452
|
+
if (!ffmpegPath || !sourceUrl) {
|
|
453
|
+
callback(new Error("FFmpeg or RTSP source is unavailable"));
|
|
454
|
+
return;
|
|
455
|
+
}
|
|
456
|
+
const video = request.video;
|
|
457
|
+
const fps = Math.max(1, Math.min(video.fps || 30, 60));
|
|
458
|
+
// HomeKit on iOS can request default low bitrates (e.g. 299k).
|
|
459
|
+
// Ensure a high-fidelity floor: at least 3500k-5000k for 2K (Tapo/Wyze), 6000k-8000k for 4K.
|
|
460
|
+
const qualityFloor = video.width >= 3840
|
|
461
|
+
? 6000
|
|
462
|
+
: video.width >= 2304
|
|
463
|
+
? 3500
|
|
464
|
+
: video.width >= 1920
|
|
465
|
+
? 2500
|
|
466
|
+
: 1500;
|
|
467
|
+
const maxBitrateCap = video.width >= 3840
|
|
468
|
+
? 12000
|
|
469
|
+
: video.width >= 2304
|
|
470
|
+
? 6000
|
|
471
|
+
: video.width >= 1920
|
|
472
|
+
? 4000
|
|
473
|
+
: 2500;
|
|
474
|
+
const bitrate = Math.max(qualityFloor, Math.min(video.max_bit_rate || 2500, maxBitrateCap));
|
|
475
|
+
const mtu = video.mtu || 1378;
|
|
476
|
+
const host = formatHost(session.targetAddress);
|
|
477
|
+
const videoUrl = `srtp://${host}:${session.videoPort}` +
|
|
478
|
+
`?rtcpport=${session.videoPort}&localrtcpport=${session.localVideoPort}&pkt_size=${mtu}`;
|
|
479
|
+
this.emit("session-start", session.sessionId);
|
|
480
|
+
// Yield event loop without artificial delay so background listeners handle pause immediately
|
|
481
|
+
await new Promise((resolve) => setImmediate(resolve));
|
|
482
|
+
let callbackSettled = false;
|
|
483
|
+
const settle = (error) => {
|
|
484
|
+
if (callbackSettled)
|
|
485
|
+
return;
|
|
486
|
+
callbackSettled = true;
|
|
487
|
+
callback(error);
|
|
488
|
+
};
|
|
489
|
+
this.spawnFfmpegProcess(session, request, settle, false);
|
|
490
|
+
}
|
|
491
|
+
spawnFfmpegProcess(session, request, settle, forceTranscode = false) {
|
|
492
|
+
const ffmpegPath = resolveFfmpegPath() || "ffmpeg";
|
|
493
|
+
const sourceUrl = this.getCleanSourceUrl();
|
|
494
|
+
const video = request.video;
|
|
495
|
+
const fps = Math.max(1, Math.min(video.fps || 30, 60));
|
|
496
|
+
const mtu = video.mtu || 1378;
|
|
497
|
+
const args = this.buildStreamArgs(session, request, forceTranscode);
|
|
498
|
+
this.platform?.log?.notice?.(`[HomeKitCamera][${this.entityId}] HAP START ${video.width}x${video.height}@${fps} transcode=${forceTranscode} profile=${h264Profile(video.profile)} level=${h264Level(video.level)} mtu=${mtu} source=${sanitizeUrlCredentials(sourceUrl || "")} ffmpeg=${ffmpegPath} ${getFfmpegVersion(ffmpegPath) || "unknown"}`);
|
|
499
|
+
const isHaProxyStream = this.streamSource.sourceType === "ha_proxy" ||
|
|
500
|
+
this.streamSource.sourceType === "mjpeg" ||
|
|
501
|
+
Boolean(sourceUrl &&
|
|
502
|
+
(sourceUrl.includes("/api/camera_proxy_stream/") ||
|
|
503
|
+
sourceUrl.includes("/api/camera_proxy/")));
|
|
504
|
+
try {
|
|
505
|
+
const process = spawn(ffmpegPath, args, {
|
|
506
|
+
stdio: [isHaProxyStream ? "pipe" : "ignore", "ignore", "pipe"],
|
|
507
|
+
});
|
|
508
|
+
session.process = process;
|
|
509
|
+
if (isHaProxyStream && sourceUrl) {
|
|
510
|
+
this.startHaCameraProxyPipe(session, process, sourceUrl);
|
|
511
|
+
}
|
|
512
|
+
let stderr = "";
|
|
513
|
+
process.stderr?.on("data", (chunk) => {
|
|
514
|
+
stderr = `${stderr}${chunk.toString()}`.slice(-6000);
|
|
515
|
+
});
|
|
516
|
+
// Settle HomeKit once process is spawned and confirmed active (80ms)
|
|
517
|
+
const guard = setTimeout(() => {
|
|
518
|
+
if (process.exitCode === null && !process.killed) {
|
|
519
|
+
this.platform?.log?.notice?.(`[HomeKitCamera][${this.entityId}] HAP START callback success; FFmpeg active session=${session.sessionId}`);
|
|
520
|
+
settle();
|
|
521
|
+
}
|
|
522
|
+
else {
|
|
523
|
+
settle(new Error("FFmpeg exited during HAP startup"));
|
|
524
|
+
}
|
|
525
|
+
}, 80);
|
|
526
|
+
process.once("error", (error) => {
|
|
527
|
+
clearTimeout(guard);
|
|
528
|
+
settle(error);
|
|
529
|
+
});
|
|
530
|
+
process.once("close", (code) => {
|
|
531
|
+
clearTimeout(guard);
|
|
532
|
+
session.process = undefined;
|
|
533
|
+
this.platform?.log?.warn?.(`[HomeKitCamera][${this.entityId}] FFmpeg closed code=${code} ${stderr.trim()}`);
|
|
534
|
+
// Automatic fallback recovery: if initial attempt failed (e.g. missing audio track or incompatible passthrough),
|
|
535
|
+
// retry immediately with safe transcoding and/or silent audio fallback
|
|
536
|
+
if (code !== 0 && !session.retried && this.activeSessions.has(session.sessionId)) {
|
|
537
|
+
session.retried = true;
|
|
538
|
+
const isAudioFailure = stderr.includes("matches no streams") ||
|
|
539
|
+
stderr.includes("0:a:0") ||
|
|
540
|
+
stderr.includes("does not contain any stream") ||
|
|
541
|
+
stderr.includes("Output file #1");
|
|
542
|
+
if (isAudioFailure) {
|
|
543
|
+
this.capabilities.hasAudio = false;
|
|
544
|
+
}
|
|
545
|
+
let retryTranscode = forceTranscode;
|
|
546
|
+
if (!isAudioFailure &&
|
|
547
|
+
(stderr.includes("dump_extra") ||
|
|
548
|
+
stderr.includes("extradata") ||
|
|
549
|
+
stderr.includes("codec") ||
|
|
550
|
+
stderr.includes("Error") ||
|
|
551
|
+
!forceTranscode)) {
|
|
552
|
+
retryTranscode = true;
|
|
553
|
+
}
|
|
554
|
+
this.platform?.log?.notice?.(`[HomeKitCamera][${this.entityId}] Retrying stream with safe fallback: forceTranscode=${retryTranscode} hasAudio=${this.capabilities.hasAudio}`);
|
|
555
|
+
this.spawnFfmpegProcess(session, request, settle, retryTranscode);
|
|
556
|
+
return;
|
|
557
|
+
}
|
|
558
|
+
settle(new Error(`FFmpeg exited during HAP startup (code ${code})`));
|
|
559
|
+
// Clean up the ghost session entry so the next HomeKit reconnect
|
|
560
|
+
// finds a clean Map — otherwise stopStream() later can't properly
|
|
561
|
+
// emit session-end and activeSessions grows with stale entries.
|
|
562
|
+
this.activeSessions.delete(session.sessionId);
|
|
563
|
+
if (this.activeSessions.size === 0) {
|
|
564
|
+
this.emit("session-end");
|
|
565
|
+
}
|
|
566
|
+
});
|
|
567
|
+
}
|
|
568
|
+
catch (error) {
|
|
569
|
+
settle(error);
|
|
570
|
+
}
|
|
571
|
+
}
|
|
572
|
+
buildStreamArgs(session, request, forceTranscode = false) {
|
|
573
|
+
const sourceUrl = this.getCleanSourceUrl();
|
|
574
|
+
if (!sourceUrl) {
|
|
575
|
+
return [];
|
|
576
|
+
}
|
|
577
|
+
const video = request.video;
|
|
578
|
+
const fps = Math.max(1, Math.min(video.fps || 30, 60));
|
|
579
|
+
const mtu = video.mtu || 1378;
|
|
580
|
+
const host = formatHost(session.targetAddress);
|
|
581
|
+
const videoUrl = `srtp://${host}:${session.videoPort}` +
|
|
582
|
+
`?rtcpport=${session.videoPort}&pkt_size=${mtu}`;
|
|
583
|
+
const isHaProxyStream = this.streamSource.sourceType === "ha_proxy" ||
|
|
584
|
+
this.streamSource.sourceType === "mjpeg" ||
|
|
585
|
+
Boolean(sourceUrl &&
|
|
586
|
+
(sourceUrl.includes("/api/camera_proxy_stream/") ||
|
|
587
|
+
sourceUrl.includes("/api/camera_proxy/")));
|
|
588
|
+
const args = [
|
|
589
|
+
"-hide_banner",
|
|
590
|
+
"-loglevel",
|
|
591
|
+
"warning",
|
|
592
|
+
"-protocol_whitelist",
|
|
593
|
+
"pipe,udp,rtp,file,crypto,srtp,tcp,tls,http,https,lavfi",
|
|
594
|
+
];
|
|
595
|
+
if (isHaProxyStream) {
|
|
596
|
+
args.push("-f", "image2pipe", "-c:v", "png", "-r", "15", "-i", "pipe:0");
|
|
597
|
+
}
|
|
598
|
+
else if (sourceUrl.startsWith("rtsp://") || sourceUrl.startsWith("rtsps://")) {
|
|
599
|
+
args.push("-rtsp_transport", "tcp", "-timeout", "10000000", "-probesize", "32768", "-analyzeduration", "0", "-fpsprobesize", "0", "-fflags", "+nobuffer+flush_packets+genpts+discardcorrupt", "-flags", "low_delay", "-avioflags", "direct", "-thread_queue_size", "1024", "-i", sourceUrl);
|
|
600
|
+
}
|
|
601
|
+
else if (sourceUrl.startsWith("http://") || sourceUrl.startsWith("https://")) {
|
|
602
|
+
args.push("-reconnect", "1", "-reconnect_at_eof", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "2", "-rw_timeout", "10000000", "-probesize", "1048576", "-analyzeduration", "1000000", "-fflags", "+nobuffer+flush_packets+genpts", "-flags", "low_delay", "-max_delay", "500000");
|
|
603
|
+
if (sourceUrl.startsWith("https://")) {
|
|
604
|
+
args.push("-tls_verify", "0");
|
|
605
|
+
}
|
|
606
|
+
if (this.streamSource.metadata?.scryptedToken) {
|
|
607
|
+
const sToken = String(this.streamSource.metadata.scryptedToken).trim();
|
|
608
|
+
if (sToken) {
|
|
609
|
+
args.push("-headers", `Authorization: ${sToken.startsWith("Bearer ") ? sToken : `Bearer ${sToken}`}\r\n`);
|
|
610
|
+
}
|
|
611
|
+
}
|
|
612
|
+
args.push("-i", sourceUrl);
|
|
613
|
+
}
|
|
614
|
+
else {
|
|
615
|
+
args.push("-i", sourceUrl);
|
|
616
|
+
}
|
|
617
|
+
const hasAudioRequested = Boolean(request.audio &&
|
|
618
|
+
session.audioPort &&
|
|
619
|
+
session.localAudioPort &&
|
|
620
|
+
session.audioSsrc &&
|
|
621
|
+
session.audioKeySalt);
|
|
622
|
+
const needsSilentAudio = hasAudioRequested &&
|
|
623
|
+
(isHaProxyStream || this.capabilities.hasAudio === false);
|
|
624
|
+
const sampleRate = request.audio?.sample_rate === 24 /* AudioStreamingSamplerate.KHZ_24 */
|
|
625
|
+
? 24000
|
|
626
|
+
: 16000;
|
|
627
|
+
if (needsSilentAudio) {
|
|
628
|
+
args.push("-f", "lavfi", "-i", `anullsrc=channel_layout=mono:sample_rate=${sampleRate}`);
|
|
629
|
+
}
|
|
630
|
+
const codec = (this.capabilities.videoCodec || "h264").toLowerCase();
|
|
631
|
+
// HAP's RTP VideoStream service advertises H.264 profiles only. Copying
|
|
632
|
+
// HEVC into that RTP session makes FFmpeg appear healthy while Apple Home
|
|
633
|
+
// receives packets it did not negotiate, ending in "No Response". HEVC
|
|
634
|
+
// remains native up to this output boundary, then is converted solely for
|
|
635
|
+
// the HAP session (and never changes the Camera.UI source).
|
|
636
|
+
const canPassthrough = !forceTranscode &&
|
|
637
|
+
!isHaProxyStream &&
|
|
638
|
+
codec === "h264" &&
|
|
639
|
+
(this.capabilities.strategy === "passthrough_h264" ||
|
|
640
|
+
this.streamSource.supportsPassthrough ||
|
|
641
|
+
!this.capabilities.requiresTranscoding);
|
|
642
|
+
if (canPassthrough) {
|
|
643
|
+
// Pure passthrough remuxing without transcoding CPU overhead (native 4K, 2K, 1080p, 720p @ max fps)
|
|
644
|
+
// Preserve the native H.264 or HEVC stream negotiated by Apple Home.
|
|
645
|
+
const videoPassArgs = [
|
|
646
|
+
"-map", "0:v:0",
|
|
647
|
+
"-an",
|
|
648
|
+
"-c:v", "copy",
|
|
649
|
+
// A cold RTSP/restream join may start after the source emitted SPS/PPS.
|
|
650
|
+
// Repeat codec headers with each keyframe so HomeKit can decode the
|
|
651
|
+
// first received GOP instead of waiting for a later camera keyframe.
|
|
652
|
+
"-bsf:v", "dump_extra=freq=keyframe",
|
|
653
|
+
"-f", "rtp",
|
|
654
|
+
"-fflags", "+nobuffer+flush_packets",
|
|
655
|
+
"-max_delay", "0",
|
|
656
|
+
"-payload_type", String(video.pt || 99),
|
|
657
|
+
"-ssrc", String(session.videoSsrc),
|
|
658
|
+
"-srtp_out_suite", suiteName(session.videoCryptoSuite),
|
|
659
|
+
"-srtp_out_params", session.videoKeySalt.toString("base64"),
|
|
660
|
+
videoUrl,
|
|
661
|
+
];
|
|
662
|
+
args.push(...videoPassArgs);
|
|
663
|
+
}
|
|
664
|
+
else {
|
|
665
|
+
// High-fidelity transcoding fallback for HEVC / MJPEG / incompatible formats
|
|
666
|
+
const videoBitrate = video.width >= 3840
|
|
667
|
+
? 8000
|
|
668
|
+
: video.width >= 2560
|
|
669
|
+
? 5000
|
|
670
|
+
: video.width >= 1920
|
|
671
|
+
? 3500
|
|
672
|
+
: 2000;
|
|
673
|
+
args.push("-map", "0:v:0", "-an", "-c:v", "libx264", "-pix_fmt", "yuv420p", "-profile:v", h264Profile(video.profile), "-preset", "ultrafast", "-tune", "zerolatency", "-bf", "0", "-crf", "18", "-threads", "0", "-vf", `scale=w='min(${video.width},iw)':h='min(${video.height},ih)':force_original_aspect_ratio=decrease:force_divisible_by=2`, "-r", String(fps), "-g", String(fps), "-keyint_min", String(fps), "-b:v", `${videoBitrate}k`, "-maxrate", `${videoBitrate}k`, "-bufsize", `${videoBitrate * 2}k`, "-f", "rtp", "-payload_type", String(video.pt || 99), "-ssrc", String(session.videoSsrc), "-srtp_out_suite", suiteName(session.videoCryptoSuite), "-srtp_out_params", session.videoKeySalt.toString("base64"), videoUrl);
|
|
674
|
+
}
|
|
675
|
+
if (hasAudioRequested &&
|
|
676
|
+
session.audioKeySalt &&
|
|
677
|
+
session.audioSsrc &&
|
|
678
|
+
request.audio) {
|
|
679
|
+
const audioUrl = `srtp://${host}:${session.audioPort}` +
|
|
680
|
+
`?rtcpport=${session.audioPort}&pkt_size=188`;
|
|
681
|
+
const isOpus = request.audio.codec === "OPUS" /* AudioStreamingCodecType.OPUS */;
|
|
682
|
+
const hasFdk = supportsFdkAac();
|
|
683
|
+
const audioBitrate = Math.min(request.audio.max_bit_rate || 24, 24);
|
|
684
|
+
if (needsSilentAudio) {
|
|
685
|
+
args.push("-map", "1:a:0", "-vn");
|
|
686
|
+
}
|
|
687
|
+
else {
|
|
688
|
+
args.push("-map", "0:a:0?", "-vn");
|
|
689
|
+
}
|
|
690
|
+
if (isOpus) {
|
|
691
|
+
// HomeKit explicitly negotiated OPUS — use it
|
|
692
|
+
args.push("-c:a", "libopus", "-application", "lowdelay", "-frame_duration", "20", "-packet_loss", "5");
|
|
693
|
+
}
|
|
694
|
+
else if (hasFdk) {
|
|
695
|
+
// libfdk_aac: best quality AAC-ELD encoder (premium, low-delay)
|
|
696
|
+
args.push("-c:a", "libfdk_aac", "-profile:a", "aac_eld", "-flags", "+global_header");
|
|
697
|
+
}
|
|
698
|
+
else {
|
|
699
|
+
args.push("-c:a", "aac");
|
|
700
|
+
}
|
|
701
|
+
args.push("-ar", String(sampleRate), "-ac", "1", "-b:a", `${audioBitrate}k`, "-f", "rtp", "-payload_type", String(request.audio.pt || 110), "-ssrc", String(session.audioSsrc), "-srtp_out_suite", suiteName(session.audioCryptoSuite || session.videoCryptoSuite), "-srtp_out_params", session.audioKeySalt.toString("base64"), audioUrl);
|
|
702
|
+
}
|
|
703
|
+
return args;
|
|
704
|
+
}
|
|
705
|
+
startHaCameraProxyPipe(session, process, sourceUrl) {
|
|
706
|
+
const controller = new AbortController();
|
|
707
|
+
session.pipeController = controller;
|
|
708
|
+
const cleanup = () => {
|
|
709
|
+
try {
|
|
710
|
+
controller.abort();
|
|
711
|
+
}
|
|
712
|
+
catch { }
|
|
713
|
+
};
|
|
714
|
+
process.once("close", cleanup);
|
|
715
|
+
process.once("error", cleanup);
|
|
716
|
+
const token = this.platform?.ha?.getAccessToken?.() ||
|
|
717
|
+
this.platform?.ha?.wsAccessToken;
|
|
718
|
+
void (async () => {
|
|
719
|
+
try {
|
|
720
|
+
const res = await fetch(sourceUrl, {
|
|
721
|
+
headers: token ? { Authorization: `Bearer ${token}` } : {},
|
|
722
|
+
signal: controller.signal,
|
|
723
|
+
});
|
|
724
|
+
if (!res.ok || !res.body) {
|
|
725
|
+
this.platform?.log?.warn?.(`[HomeKitCamera][${this.entityId}] Failed to connect to HA camera proxy: HTTP ${res.status}`);
|
|
726
|
+
return;
|
|
727
|
+
}
|
|
728
|
+
const reader = res.body.getReader();
|
|
729
|
+
let buffer = Buffer.alloc(0);
|
|
730
|
+
while (!controller.signal.aborted && process.exitCode === null) {
|
|
731
|
+
const { done, value } = await reader.read();
|
|
732
|
+
if (done)
|
|
733
|
+
break;
|
|
734
|
+
if (value) {
|
|
735
|
+
buffer = Buffer.concat([buffer, Buffer.from(value)]);
|
|
736
|
+
// Extract complete frames from buffer (supports both PNG and JPEG)
|
|
737
|
+
while (buffer.length > 8) {
|
|
738
|
+
const pngIdx = buffer.indexOf(Buffer.from([0x89, 0x50, 0x4e, 0x47]));
|
|
739
|
+
const jpegIdx = buffer.indexOf(Buffer.from([0xff, 0xd8]));
|
|
740
|
+
if (pngIdx !== -1 && (jpegIdx === -1 || pngIdx < jpegIdx)) {
|
|
741
|
+
const iendIdx = buffer.indexOf(Buffer.from([0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82]), pngIdx);
|
|
742
|
+
if (iendIdx !== -1) {
|
|
743
|
+
const frameEnd = iendIdx + 8;
|
|
744
|
+
const frame = buffer.subarray(pngIdx, frameEnd);
|
|
745
|
+
buffer = buffer.subarray(frameEnd);
|
|
746
|
+
if (process.stdin && !process.stdin.destroyed) {
|
|
747
|
+
process.stdin.write(frame);
|
|
748
|
+
}
|
|
749
|
+
continue;
|
|
750
|
+
}
|
|
751
|
+
else {
|
|
752
|
+
if (pngIdx > 0)
|
|
753
|
+
buffer = buffer.subarray(pngIdx);
|
|
754
|
+
break;
|
|
755
|
+
}
|
|
756
|
+
}
|
|
757
|
+
else if (jpegIdx !== -1) {
|
|
758
|
+
const eoiIdx = buffer.indexOf(Buffer.from([0xff, 0xd9]), jpegIdx + 2);
|
|
759
|
+
if (eoiIdx !== -1) {
|
|
760
|
+
const frameEnd = eoiIdx + 2;
|
|
761
|
+
const frame = buffer.subarray(jpegIdx, frameEnd);
|
|
762
|
+
buffer = buffer.subarray(frameEnd);
|
|
763
|
+
if (process.stdin && !process.stdin.destroyed) {
|
|
764
|
+
process.stdin.write(frame);
|
|
765
|
+
}
|
|
766
|
+
continue;
|
|
767
|
+
}
|
|
768
|
+
else {
|
|
769
|
+
if (jpegIdx > 0)
|
|
770
|
+
buffer = buffer.subarray(jpegIdx);
|
|
771
|
+
break;
|
|
772
|
+
}
|
|
773
|
+
}
|
|
774
|
+
else {
|
|
775
|
+
buffer = buffer.subarray(-8);
|
|
776
|
+
break;
|
|
777
|
+
}
|
|
778
|
+
}
|
|
779
|
+
}
|
|
780
|
+
}
|
|
781
|
+
}
|
|
782
|
+
catch (err) {
|
|
783
|
+
if (!controller.signal.aborted) {
|
|
784
|
+
this.platform?.log?.debug?.(`[HomeKitCamera][${this.entityId}] HA camera pipe ended: ${err?.message || String(err)}`);
|
|
785
|
+
}
|
|
786
|
+
}
|
|
787
|
+
})();
|
|
788
|
+
}
|
|
789
|
+
stopStream(sessionId) {
|
|
790
|
+
const session = this.activeSessions.get(sessionId);
|
|
791
|
+
if (!session)
|
|
792
|
+
return;
|
|
793
|
+
if (session.pipeController) {
|
|
794
|
+
try {
|
|
795
|
+
session.pipeController.abort();
|
|
796
|
+
}
|
|
797
|
+
catch { }
|
|
798
|
+
session.pipeController = undefined;
|
|
799
|
+
}
|
|
800
|
+
if (session.process) {
|
|
801
|
+
const proc = session.process;
|
|
802
|
+
session.process = undefined;
|
|
803
|
+
try {
|
|
804
|
+
// SIGKILL immediately — SIGTERM can be ignored by FFmpeg when blocked
|
|
805
|
+
// on RTSP reads or SRTP writes, leaving a zombie that holds the camera
|
|
806
|
+
// RTSP connection and prevents the next session from connecting.
|
|
807
|
+
proc.kill("SIGKILL");
|
|
808
|
+
}
|
|
809
|
+
catch { }
|
|
810
|
+
// Belt-and-suspenders: ensure the OS reclaims the process handle
|
|
811
|
+
const killTimer = setTimeout(() => {
|
|
812
|
+
try {
|
|
813
|
+
if (proc.exitCode === null && !proc.killed)
|
|
814
|
+
proc.kill("SIGKILL");
|
|
815
|
+
}
|
|
816
|
+
catch { }
|
|
817
|
+
}, 300);
|
|
818
|
+
killTimer.unref();
|
|
819
|
+
}
|
|
820
|
+
this.activeSessions.delete(sessionId);
|
|
821
|
+
this.platform?.log?.notice?.(`[HomeKitCamera][${this.entityId}] HAP STOP cleanup session=${sessionId}`);
|
|
822
|
+
if (this.activeSessions.size === 0) {
|
|
823
|
+
this.emit("session-end");
|
|
824
|
+
}
|
|
825
|
+
}
|
|
826
|
+
cleanupAllSessions() {
|
|
827
|
+
for (const sessionId of [...this.activeSessions.keys()]) {
|
|
828
|
+
this.stopStream(sessionId);
|
|
829
|
+
}
|
|
830
|
+
this.emit("session-end");
|
|
831
|
+
}
|
|
832
|
+
}
|
|
833
|
+
//# sourceMappingURL=homekit-camera-stream.delegate.js.map
|