server: fix first run account creation bug

This reverts commit 143a0b2c41.

common/src/ffmpeg-rebroadcast.ts

@@ -361,8 +361,7 @@ export interface RebroadcasterOptions {
     },
 }
 
-export async function handleRebroadcasterClient(duplex: Promise<Duplex> | Duplex, options?: RebroadcasterOptions) {
-    const socket = await duplex;
+export function handleRebroadcasterClient(socket: Duplex, options?: RebroadcasterOptions) {
     const firstWriteData = (data: StreamChunk) => {
         if (data.startStream) {
             socket.write(data.startStream)

common/src/listen-cluster.ts

@@ -62,4 +62,4 @@ export async function bind(server: dgram.Socket, port: number) {
     }
 }
 
-export { listenZero, listenZeroSingleClient } from "@scrypted/server/src/listen-zero";
+export { listenZero, listenZeroSingleClient, ListenZeroSingleClientTimeoutError } from "@scrypted/server/src/listen-zero";

common/src/rtc-signaling.ts

@@ -250,7 +250,8 @@ export class BrowserSignalingSession implements RTCSignalingSession {
 function logSendCandidate(console: Console, type: string, session: RTCSignalingSession): RTCSignalingSendIceCandidate {
     return async (candidate) => {
         try {
-            console.log(`${type} trickled candidate:`, candidate.sdpMLineIndex, candidate.candidate);
+            if (localStorage.getItem('debugLog') === 'true')
+                console.log(`${type} trickled candidate:`, candidate.sdpMLineIndex, candidate.candidate);
             await session.addIceCandidate(candidate);
         }
         catch (e) {
@@ -308,11 +309,13 @@ export async function connectRTCSignalingClients(
 
     const offer = await offerClient.createLocalDescription('offer', offerSetup as RTCAVSignalingSetup,
         disableTrickle ? undefined : answerQueue.queueSendCandidate);
-    console.log('offer sdp', offer.sdp);
+    if (localStorage.getItem('debugLog') === 'true')
+        console.log('offer sdp', offer.sdp);
     await answerClient.setRemoteDescription(offer, answerSetup as RTCAVSignalingSetup);
     const answer = await answerClient.createLocalDescription('answer', answerSetup as RTCAVSignalingSetup,
         disableTrickle ? undefined : offerQueue.queueSendCandidate);
-    console.log('answer sdp', answer.sdp);
+    if (localStorage.getItem('debugLog') === 'true')
+        console.log('answer sdp', answer.sdp);
     await offerClient.setRemoteDescription(answer, offerSetup as RTCAVSignalingSetup);
     offerQueue.flush();
     answerQueue.flush();

common/src/rtsp-server.ts

@@ -129,6 +129,16 @@ export function getNaluTypes(streamChunk: StreamChunk) {
     return getNaluTypesInNalu(streamChunk.chunks[streamChunk.chunks.length - 1].subarray(12))
 }
 
+export function getNaluFragmentInformation(nalu: Buffer) {
+    const naluType = nalu[0] & 0x1f;
+    const fua = naluType === H264_NAL_TYPE_FU_A;
+    return {
+        fua,
+        fuaStart: fua && !!(nalu[1] & 0x80),
+        fuaEnd: fua && !!(nalu[1] & 0x40),
+    }
+}
+
 export function getNaluTypesInNalu(nalu: Buffer, fuaRequireStart = false, fuaRequireEnd = false) {
     const ret = new Set<number>();
     const naluType = nalu[0] & 0x1f;

docker/Dockerfile.full

@@ -63,7 +63,7 @@ RUN apt-get -y install \
 # which causes weird behavior in python which looks at the arch version
 # which still reports 64bit, even if running in 32bit docker.
 # this scenario is not supported and will be reported at runtime.
-RUN if [ "$(uname -m)" = "armv7l" ]; \
+RUN if [ "$(uname -m)" != "x86_64" ]; \
     then \
         apt-get -y install \
         python3-matplotlib \
@@ -95,7 +95,8 @@ ENV SCRYPTED_INSTALL_PATH="/server"
 
 # changing this forces pip and npm to perform reinstalls.
 # if this base image changes, this version must be updated.
-ENV SCRYPTED_BASE_VERSION=20230322
+ENV SCRYPTED_BASE_VERSION=20230329
+ENV SCRYPTED_DOCKER_FLAVOR=full
 
 ################################################################
 # End section generated from template/Dockerfile.full.footer

docker/Dockerfile.lite

@@ -42,4 +42,5 @@ ENV SCRYPTED_INSTALL_PATH="/server"
 
 # changing this forces pip and npm to perform reinstalls.
 # if this base image changes, this version must be updated.
-ENV SCRYPTED_BASE_VERSION=20230322
+ENV SCRYPTED_BASE_VERSION=20230329
+ENV SCRYPTED_DOCKER_FLAVOR=lite

docker/Dockerfile.thin

@@ -21,4 +21,5 @@ ENV SCRYPTED_INSTALL_PATH="/server"
 
 # changing this forces pip and npm to perform reinstalls.
 # if this base image changes, this version must be updated.
-ENV SCRYPTED_BASE_VERSION=20230322
+ENV SCRYPTED_BASE_VERSION=20230329
+ENV SCRYPTED_DOCKER_FLAVOR=thin

docker/fs/etc/avahi/avahi-daemon.conf

@@ -1,7 +1,7 @@
 [server]
 #host-name=
 use-ipv4=yes
-use-ipv6=no
+use-ipv6=yes
 enable-dbus=yes
 ratelimit-interval-usec=1000000
 ratelimit-burst=1000
@@ -14,4 +14,4 @@ rlimit-core=0
 rlimit-data=4194304
 rlimit-fsize=0
 rlimit-nofile=768
-rlimit-stack=4194304
+rlimit-stack=4194304

docker/install-scrypted-docker-compose.sh

@@ -42,7 +42,7 @@ fi
 WATCHTOWER_HTTP_API_TOKEN=$(echo $RANDOM | md5sum)
 DOCKER_COMPOSE_YML=$SCRYPTED_HOME/docker-compose.yml
 echo "Created $DOCKER_COMPOSE_YML"
-curl -s https://raw.githubusercontent.com/koush/scrypted/main/docker/docker-compose.yml | sed s/SET_THIS_TO_SOME_RANDOM_TEXT/"$(echo $RANDOM | md5sum)"/g > $DOCKER_COMPOSE_YML
+curl -s https://raw.githubusercontent.com/koush/scrypted/main/docker/docker-compose.yml | sed s/SET_THIS_TO_SOME_RANDOM_TEXT/"$(echo $RANDOM | md5sum | head -c 32)"/g > $DOCKER_COMPOSE_YML
 
 echo "Setting permissions on $SCRYPTED_HOME"
 chown -R $SERVICE_USER $SCRYPTED_HOME

docker/template/Dockerfile.full.footer

@@ -10,7 +10,8 @@ ENV SCRYPTED_INSTALL_PATH="/server"
 
 # changing this forces pip and npm to perform reinstalls.
 # if this base image changes, this version must be updated.
-ENV SCRYPTED_BASE_VERSION=20230322
+ENV SCRYPTED_BASE_VERSION=20230329
+ENV SCRYPTED_DOCKER_FLAVOR=full
 
 ################################################################
 # End section generated from template/Dockerfile.full.footer

docker/template/Dockerfile.full.header

@@ -60,7 +60,7 @@ RUN apt-get -y install \
 # which causes weird behavior in python which looks at the arch version
 # which still reports 64bit, even if running in 32bit docker.
 # this scenario is not supported and will be reported at runtime.
-RUN if [ "$(uname -m)" = "armv7l" ]; \
+RUN if [ "$(uname -m)" != "x86_64" ]; \
     then \
         apt-get -y install \
         python3-matplotlib \

packages/client/package-lock.json

@@ -9,7 +9,7 @@
       "version": "1.1.43",
       "license": "ISC",
       "dependencies": {
-        "@scrypted/types": "^0.2.76",
+        "@scrypted/types": "^0.2.78",
         "axios": "^0.25.0",
         "engine.io-client": "^6.4.0",
         "rimraf": "^3.0.2"
@@ -21,9 +21,9 @@
       }
     },
     "node_modules/@scrypted/types": {
-      "version": "0.2.76",
-      "resolved": "https://registry.npmjs.org/@scrypted/types/-/types-0.2.76.tgz",
-      "integrity": "sha512-/7n8ICkXj8TGba4cHvckLCgSNsOmOGQ8I+Jd8fX9sxkthgsZhF5At8PHhHdkCDS+yfSmfXHkcqluZZOfYPkpAg=="
+      "version": "0.2.78",
+      "resolved": "https://registry.npmjs.org/@scrypted/types/-/types-0.2.78.tgz",
+      "integrity": "sha512-SiIUh9ph96aZPjt/oO+W/mlJobrP02ADwFDI9jnvw8/UegUti2x/7JE8Pi3kGXOIkN+cX74Qg4xJEMIpdpO1zw=="
     },
     "node_modules/@socket.io/component-emitter": {
       "version": "3.1.0",

packages/client/package.json

@@ -17,7 +17,7 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "@scrypted/types": "^0.2.76",
+    "@scrypted/types": "^0.2.78",
     "axios": "^0.25.0",
     "engine.io-client": "^6.4.0",
     "rimraf": "^3.0.2"

plugins/alexa/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@scrypted/alexa",
-   "version": "0.2.3",
+   "version": "0.2.4",
    "scripts": {
       "scrypted-setup-project": "scrypted-setup-project",
       "prescrypted-setup-project": "scrypted-package-json",

plugins/alexa/src/main.ts

@@ -15,6 +15,11 @@ const includeToken = 4;
 
 export let DEBUG = false;
 
+function debug(...args: any[]) {
+    if (DEBUG)
+        console.debug(...args);
+}
+
 class AlexaPlugin extends ScryptedDeviceBase implements HttpRequestHandler, MixinProvider, Settings {
     storageSettings = new StorageSettings(this, {
         tokenInfo: {
@@ -34,6 +39,14 @@ class AlexaPlugin extends ScryptedDeviceBase implements HttpRequestHandler, Mixi
             description: 'This is the endpoint Alexa will use to send events to. This is set after you login.',
             type: 'string',
             readonly: true
+        },
+        debug: {
+            title: 'Debug Events',
+            description: 'Log all events to the console. This will be very noisy and should not be left enabled.',
+            type: 'boolean',
+            onPut(oldValue: boolean, newValue: boolean) {
+                DEBUG = newValue;
+            }
         }
     });
 
@@ -44,6 +57,8 @@ class AlexaPlugin extends ScryptedDeviceBase implements HttpRequestHandler, Mixi
     constructor(nativeId?: string) {
         super(nativeId);
 
+        DEBUG = this.storageSettings.values.debug ?? false;
+
         alexaHandlers.set('Alexa.Authorization/AcceptGrant', this.onAlexaAuthorization);
         alexaHandlers.set('Alexa.Discovery/Discover', this.onDiscoverEndpoints);
 
@@ -141,12 +156,23 @@ class AlexaPlugin extends ScryptedDeviceBase implements HttpRequestHandler, Mixi
         if (!supportedType)
             return;
 
-        const report = await supportedType.sendEvent(eventSource, eventDetails, eventData);
+        let report = await supportedType.sendEvent(eventSource, eventDetails, eventData);
+
+        if (!report && eventDetails.eventInterface === ScryptedInterface.Online) {
+            report = {};
+        }
+
+        if (!report && eventDetails.eventInterface === ScryptedInterface.Battery) {
+            report = {};
+        }
+
         if (!report) {
             this.console.warn(`${eventDetails.eventInterface}.${eventDetails.property} not supported for device ${eventSource.type}`);
             return;
         }
 
+        debug("event", eventDetails.eventInterface, eventDetails.property, eventSource.type);
+
         let data = {
             "event": {
                 "header": {
@@ -234,7 +260,7 @@ class AlexaPlugin extends ScryptedDeviceBase implements HttpRequestHandler, Mixi
         const endpoint = await this.getAlexaEndpoint();
         const self = this;
 
-        this.console.assert(!DEBUG, `event:`, data);
+        debug("send event to alexa", data);
 
         return axios.post(`https://${endpoint}/v3/events`, data, {
             headers: {
@@ -570,6 +596,8 @@ class AlexaPlugin extends ScryptedDeviceBase implements HttpRequestHandler, Mixi
         const { authorization } = request.headers;
         if (!this.validAuths.has(authorization)) {
             try {
+                debug("making authorization request to Scrypted");
+
                 await axios.get('https://home.scrypted.app/_punch/getcookie', {
                     headers: {
                         'Authorization': authorization,
@@ -590,11 +618,11 @@ class AlexaPlugin extends ScryptedDeviceBase implements HttpRequestHandler, Mixi
         const { directive } = body;
         const { namespace, name } = directive.header;
 
-        this.console.assert(!DEBUG, `request: ${namespace}/${name}`);
-
         const mapName = `${namespace}/${name}`;
-        const handler = alexaHandlers.get(mapName);
 
+        debug("received directive from alexa", mapName, body);
+
+        const handler = alexaHandlers.get(mapName);
         if (handler)
             return handler.apply(this, [request, response, directive]);
 
@@ -641,7 +669,7 @@ class HttpResponseLoggingImpl implements AlexaHttpResponse {
         if (options.code !== 200)
             this.console.error(`response error ${options.code}:`, body);
         else
-            this.console.assert(!DEBUG, `response ${options.code}:`, body);
+            debug("response to alexa directive", options.code, body);
 
         if (typeof body === 'object')
             body = JSON.stringify(body);

plugins/arlo/package-lock.json

@@ -1,12 +1,12 @@
 {
    "name": "@scrypted/arlo",
-   "version": "0.7.4",
+   "version": "0.7.12",
    "lockfileVersion": 2,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/arlo",
-         "version": "0.7.4",
+         "version": "0.7.12",
          "devDependencies": {
             "@scrypted/sdk": "file:../../sdk"
          }

plugins/arlo/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@scrypted/arlo",
-   "version": "0.7.4",
+   "version": "0.7.12",
    "description": "Arlo Plugin for Scrypted",
    "keywords": [
       "scrypted",

plugins/arlo/src/arlo_plugin/arlo/arlo_async.py

@@ -383,6 +383,33 @@ class Arlo(object):
             self.HandleEvents(basestation, resource, [('is', 'motionDetected')], callbackwrapper)
         )
 
+    def SubscribeToAudioEvents(self, basestation, camera, callback):
+        """
+        Use this method to subscribe to audio events. You must provide a callback function which will get called once per audio event.
+
+        The callback function should have the following signature:
+        def callback(self, event)
+
+        This is an example of handling a specific event, in reality, you'd probably want to write a callback for HandleEvents()
+        that has a big switch statement in it to handle all the various events Arlo produces.
+
+        Returns the Task object that contains the subscription loop.
+        """
+        resource = f"cameras/{camera.get('deviceId')}"
+
+        def callbackwrapper(self, event):
+            properties = event.get('properties', {})
+            stop = None
+            if 'audioDetected' in properties:
+                stop = callback(properties['audioDetected'])
+            if not stop:
+                return None
+            return stop
+
+        return asyncio.get_event_loop().create_task(
+            self.HandleEvents(basestation, resource, [('is', 'audioDetected')], callbackwrapper)
+        )
+
     def SubscribeToBatteryEvents(self, basestation, camera, callback):
         """
         Use this method to subscribe to battery events. You must provide a callback function which will get called once per battery event.
@@ -711,7 +738,20 @@ class Arlo(object):
             callback,
         )
 
-    def SirenOn(self, basestation):
+    def SirenOn(self, basestation, camera=None):
+        if camera is not None:
+            resource = f"siren/{camera.get('deviceId')}"
+            return self.Notify(basestation, {
+                "action": "set",
+                "resource": resource,
+                "publishResponse": True,
+                "properties": {
+                    "sirenState": "on",
+                    "duration": 300,
+                    "volume": 8,
+                    "pattern": "alarm"
+                }
+            })
         return self.Notify(basestation, {
             "action": "set",
             "resource": "siren",
@@ -724,7 +764,20 @@ class Arlo(object):
             }
         })
 
-    def SirenOff(self, basestation):
+    def SirenOff(self, basestation, camera=None):
+        if camera is not None:
+            resource = f"siren/{camera.get('deviceId')}"
+            return self.Notify(basestation, {
+                "action": "set",
+                "resource": resource,
+                "publishResponse": True,
+                "properties": {
+                    "sirenState": "off",
+                    "duration": 300,
+                    "volume": 8,
+                    "pattern": "alarm"
+                }
+            })
         return self.Notify(basestation, {
             "action": "set",
             "resource": "siren",
@@ -737,6 +790,58 @@ class Arlo(object):
             }
         })
 
+    def SpotlightOn(self, basestation, camera):
+        resource = f"cameras/{camera.get('deviceId')}"
+        return self.Notify(basestation, {
+            "action": "set",
+            "resource": resource,
+            "publishResponse": True,
+            "properties": {
+                "spotlight": {
+                    "enabled": True,
+                },
+            },
+        })
+
+    def SpotlightOff(self, basestation, camera):
+        resource = f"cameras/{camera.get('deviceId')}"
+        return self.Notify(basestation, {
+            "action": "set",
+            "resource": resource,
+            "publishResponse": True,
+            "properties": {
+                "spotlight": {
+                    "enabled": False,
+                },
+            },
+        })
+
+    def FloodlightOn(self, basestation, camera):
+        resource = f"cameras/{camera.get('deviceId')}"
+        return self.Notify(basestation, {
+            "action": "set",
+            "resource": resource,
+            "publishResponse": True,
+            "properties": {
+                "floodlight": {
+                    "on": True,
+                },
+            },
+        })
+
+    def FloodlightOff(self, basestation, camera):
+        resource = f"cameras/{camera.get('deviceId')}"
+        return self.Notify(basestation, {
+            "action": "set",
+            "resource": resource,
+            "publishResponse": True,
+            "properties": {
+                "floodlight": {
+                    "on": False,
+                },
+            },
+        })
+
     def GetLibrary(self, device, from_date: datetime, to_date: datetime):
         """
         This call returns the following:
@@ -784,4 +889,13 @@ class Arlo(object):
                 'dateFrom': from_date,
                 'dateTo': to_date
             }
-        )
+        )
+
+    def GetSmartFeatures(self, device) -> dict:
+        smart_features = self._getSmartFeaturesCached()
+        key = f"{device['owner']['ownerId']}_{device['deviceId']}"
+        return smart_features["features"].get(key, {})
+
+    @cached(cache=TTLCache(maxsize=1, ttl=60))
+    def _getSmartFeaturesCached(self) -> dict:
+        return self.request.get(f'https://{self.BASE_URL}/hmsweb/users/subscription/smart/features')

plugins/arlo/src/arlo_plugin/base.py

@@ -66,15 +66,4 @@ class ArloDeviceBase(ScryptedDeviceBase, ScryptedDeviceLoggerMixin, BackgroundTa
 
     def get_builtin_child_device_manifests(self) -> List[Device]:
         """Returns the list of child device manifests representing hardware features built into this device."""
-        return []
-
-    @classmethod
-    def async_print_exception_guard(self, fn):
-        """Decorator to print an exception's stack trace before re-raising the exception."""
-        async def wrapped(*args, **kwargs):
-            try:
-                return await fn(*args, **kwargs)
-            except Exception:
-                traceback.print_exc()
-                raise
-        return wrapped
+        return []

plugins/arlo/src/arlo_plugin/basestation.py

@@ -14,11 +14,20 @@ if TYPE_CHECKING:
 
 
 class ArloBasestation(ArloDeviceBase, DeviceProvider):
+    MODELS_WITH_SIRENS = [
+        "vmb4000",
+        "vmb4500"
+    ]
+
     vss: ArloSirenVirtualSecuritySystem = None
 
     def __init__(self, nativeId: str, arlo_basestation: dict, provider: ArloProvider) -> None:
         super().__init__(nativeId=nativeId, arlo_device=arlo_basestation, arlo_basestation=arlo_basestation, provider=provider)
 
+    @property
+    def has_siren(self) -> bool:
+        return any([self.arlo_device["modelId"].lower().startswith(model) for model in ArloBasestation.MODELS_WITH_SIRENS])
+
     def get_applicable_interfaces(self) -> List[str]:
         return [ScryptedInterface.DeviceProvider.value]
 
@@ -26,8 +35,11 @@ class ArloBasestation(ArloDeviceBase, DeviceProvider):
         return ScryptedDeviceType.DeviceProvider.value
 
     def get_builtin_child_device_manifests(self) -> List[Device]:
-        vss_id = f'{self.arlo_device["deviceId"]}.vss'
-        vss = self.get_or_create_vss(vss_id)
+        if not self.has_siren:
+            # this basestation has no builtin siren, so no manifests to return
+            return []
+
+        vss = self.get_or_create_vss()
         return [
             {
                 "info": {
@@ -36,7 +48,7 @@ class ArloBasestation(ArloDeviceBase, DeviceProvider):
                     "firmware": self.arlo_device.get("firmwareVersion"),
                     "serialNumber": self.arlo_device["deviceId"],
                 },
-                "nativeId": vss_id,
+                "nativeId": vss.nativeId,
                 "name": f'{self.arlo_device["deviceName"]} Siren Virtual Security System',
                 "interfaces": vss.get_applicable_interfaces(),
                 "type": vss.get_device_type(),
@@ -48,11 +60,12 @@ class ArloBasestation(ArloDeviceBase, DeviceProvider):
         if not nativeId.startswith(self.nativeId):
             # must be a camera, so get it from the provider
             return await self.provider.getDevice(nativeId)
-        return self.get_or_create_vss(nativeId)
-
-    def get_or_create_vss(self, nativeId: str) -> ArloSirenVirtualSecuritySystem:
         if not nativeId.endswith("vss"):
             return None
+        return self.get_or_create_vss()
+
+    def get_or_create_vss(self) -> ArloSirenVirtualSecuritySystem:
+        vss_id = f'{self.arlo_device["deviceId"]}.vss'
         if not self.vss:
-            self.vss = ArloSirenVirtualSecuritySystem(nativeId, self.arlo_device, self.arlo_basestation, self.provider)
+            self.vss = ArloSirenVirtualSecuritySystem(vss_id, self.arlo_device, self.arlo_basestation, self.provider, self)
         return self.vss

plugins/arlo/src/arlo_plugin/camera.py

@@ -10,24 +10,76 @@ from typing import List, TYPE_CHECKING
 import scrypted_arlo_go
 
 import scrypted_sdk
-from scrypted_sdk.types import Setting, Settings, Camera, VideoCamera, VideoClips, VideoClip, VideoClipOptions, MotionSensor, Battery, MediaObject, ResponsePictureOptions, ResponseMediaStreamOptions, ScryptedMimeTypes, ScryptedInterface, ScryptedDeviceType
+from scrypted_sdk.types import Setting, Settings, Device, Camera, VideoCamera, VideoClips, VideoClip, VideoClipOptions, MotionSensor, AudioSensor, Battery, DeviceProvider, MediaObject, ResponsePictureOptions, ResponseMediaStreamOptions, ScryptedMimeTypes, ScryptedInterface, ScryptedDeviceType
 
 from .base import ArloDeviceBase
+from .spotlight import ArloSpotlight, ArloFloodlight
+from .vss import ArloSirenVirtualSecuritySystem
 from .child_process import HeartbeatChildProcess
-from .util import BackgroundTaskMixin
+from .util import BackgroundTaskMixin, async_print_exception_guard
 
 if TYPE_CHECKING:
     # https://adamj.eu/tech/2021/05/13/python-type-hints-how-to-fix-circular-imports/
     from .provider import ArloProvider
 
 
-class ArloCamera(ArloDeviceBase, Settings, Camera, VideoCamera, VideoClips, MotionSensor, Battery):
+class ArloCamera(ArloDeviceBase, Settings, Camera, VideoCamera, DeviceProvider, VideoClips, MotionSensor, AudioSensor, Battery):
+    MODELS_WITH_SPOTLIGHTS = [
+        "vmc4040p",
+        "vmc2030",
+        "vmc2032",
+        "vmc4041p",
+        "vmc4050p",
+        "vmc5040",
+        "vml2030",
+        "vml4030",
+    ]
+
+    MODELS_WITH_FLOODLIGHTS = ["fb1001"]
+
+    MODELS_WITH_SIRENS = [
+        "vmc4040p",
+        "fb1001",
+        "vmc2030",
+        "vmc2020",
+        "vmc2032",
+        "vmc4041p",
+        "vmc4050p",
+        "vmc5040",
+        "vml2030",
+        "vmc4030",
+        "vml4030",
+        "vmc4030p",
+    ]
+
+    MODELS_WITH_AUDIO_SENSORS = [
+        "vmc4040p",
+        "fb1001",
+        "vmc4041p",
+        "vmc4050p",
+        "vmc5040",
+        "vmc3040",
+        "vmc3040s",
+        "vmc4030",
+        "vml4030",
+        "vmc4030p",
+    ]
+
+    MODELS_WITHOUT_BATTERY = [
+        "avd1001",
+        "vmc3040",
+        "vmc3040s",
+    ]
+
     timeout: int = 30
     intercom_session = None
+    light: ArloSpotlight = None
+    vss: ArloSirenVirtualSecuritySystem = None
 
     def __init__(self, nativeId: str, arlo_device: dict, arlo_basestation: dict, provider: ArloProvider) -> None:
         super().__init__(nativeId=nativeId, arlo_device=arlo_device, arlo_basestation=arlo_basestation, provider=provider)
         self.start_motion_subscription()
+        self.start_audio_subscription()
         self.start_battery_subscription()
 
     def start_motion_subscription(self) -> None:
@@ -39,7 +91,22 @@ class ArloCamera(ArloDeviceBase, Settings, Camera, VideoCamera, VideoClips, Moti
             self.provider.arlo.SubscribeToMotionEvents(self.arlo_basestation, self.arlo_device, callback)
         )
 
+    def start_audio_subscription(self) -> None:
+        if not self.has_audio_sensor:
+            return
+
+        def callback(audioDetected):
+            self.audioDetected = audioDetected
+            return self.stop_subscriptions
+
+        self.register_task(
+            self.provider.arlo.SubscribeToAudioEvents(self.arlo_basestation, self.arlo_device, callback)
+        )
+
     def start_battery_subscription(self) -> None:
+        if self.wired_to_power:
+            return
+
         def callback(batteryLevel):
             self.batteryLevel = batteryLevel
             return self.stop_subscriptions
@@ -53,9 +120,7 @@ class ArloCamera(ArloDeviceBase, Settings, Camera, VideoCamera, VideoClips, Moti
             ScryptedInterface.VideoCamera.value,
             ScryptedInterface.Camera.value,
             ScryptedInterface.MotionSensor.value,
-            ScryptedInterface.Battery.value,
             ScryptedInterface.Settings.value,
-            ScryptedInterface.VideoClips.value,
         ])
 
         if self.two_way_audio:
@@ -66,6 +131,21 @@ class ArloCamera(ArloDeviceBase, Settings, Camera, VideoCamera, VideoClips, Moti
             results.add(ScryptedInterface.RTCSignalingChannel.value)
             results.discard(ScryptedInterface.Intercom.value)
 
+        if self.has_battery:
+            results.add(ScryptedInterface.Battery.value)
+
+        if self.wired_to_power:
+            results.discard(ScryptedInterface.Battery.value)
+
+        if self.has_siren or self.has_spotlight or self.has_floodlight:
+            results.add(ScryptedInterface.DeviceProvider.value)
+
+        if self.has_audio_sensor:
+            results.add(ScryptedInterface.AudioSensor.value)
+
+        if self.has_cloud_recording:
+            results.add(ScryptedInterface.VideoClips.value)
+
         if not self._can_push_to_talk():
             results.discard(ScryptedInterface.RTCSignalingChannel.value)
             results.discard(ScryptedInterface.Intercom.value)
@@ -75,6 +155,42 @@ class ArloCamera(ArloDeviceBase, Settings, Camera, VideoCamera, VideoClips, Moti
     def get_device_type(self) -> str:
         return ScryptedDeviceType.Camera.value
 
+    def get_builtin_child_device_manifests(self) -> List[Device]:
+        results = []
+        if self.has_spotlight or self.has_floodlight:
+            light = self.get_or_create_spotlight_or_floodlight()
+            results.append({
+                "info": {
+                    "model": f"{self.arlo_device['modelId']} {self.arlo_device['properties'].get('hwVersion', '')}".strip(),
+                    "manufacturer": "Arlo",
+                    "firmware": self.arlo_device.get("firmwareVersion"),
+                    "serialNumber": self.arlo_device["deviceId"],
+                },
+                "nativeId": light.nativeId,
+                "name": f'{self.arlo_device["deviceName"]} {"Spotlight" if self.has_spotlight else "Floodlight"}',
+                "interfaces": light.get_applicable_interfaces(),
+                "type": light.get_device_type(),
+                "providerNativeId": self.nativeId,
+            })
+        if self.has_siren:
+            vss = self.get_or_create_vss()
+            results.extend([
+                {
+                    "info": {
+                        "model": f"{self.arlo_device['modelId']} {self.arlo_device['properties'].get('hwVersion', '')}".strip(),
+                        "manufacturer": "Arlo",
+                        "firmware": self.arlo_device.get("firmwareVersion"),
+                        "serialNumber": self.arlo_device["deviceId"],
+                    },
+                    "nativeId": vss.nativeId,
+                    "name": f'{self.arlo_device["deviceName"]} Siren Virtual Security System',
+                    "interfaces": vss.get_applicable_interfaces(),
+                    "type": vss.get_device_type(),
+                    "providerNativeId": self.nativeId,
+                },
+            ] + vss.get_builtin_child_device_manifests())
+        return results
+
     @property
     def webrtc_emulation(self) -> bool:
         if self.storage:
@@ -92,9 +208,53 @@ class ArloCamera(ArloDeviceBase, Settings, Camera, VideoCamera, VideoClips, Moti
         else:
             return True
 
+    @property
+    def wired_to_power(self) -> bool:
+        if self.storage:
+            return True if self.storage.getItem("wired_to_power") else False
+        else:
+            return False
+
+    @property
+    def has_cloud_recording(self) -> bool:
+        return self.provider.arlo.GetSmartFeatures(self.arlo_device).get("planFeatures", {}).get("eventRecording", False)
+
+    @property
+    def has_spotlight(self) -> bool:
+        return any([self.arlo_device["modelId"].lower().startswith(model) for model in ArloCamera.MODELS_WITH_SPOTLIGHTS])
+
+    @property
+    def has_floodlight(self) -> bool:
+        return any([self.arlo_device["modelId"].lower().startswith(model) for model in ArloCamera.MODELS_WITH_FLOODLIGHTS])
+
+    @property
+    def has_siren(self) -> bool:
+        return any([self.arlo_device["modelId"].lower().startswith(model) for model in ArloCamera.MODELS_WITH_SIRENS])
+
+    @property
+    def has_audio_sensor(self) -> bool:
+        return any([self.arlo_device["modelId"].lower().startswith(model) for model in ArloCamera.MODELS_WITH_AUDIO_SENSORS])
+
+    @property
+    def has_battery(self) -> bool:
+        return not any([self.arlo_device["modelId"].lower().startswith(model) for model in ArloCamera.MODELS_WITHOUT_BATTERY])
+
     async def getSettings(self) -> List[Setting]:
+        result = []
+        if self.has_battery:
+            result.append(
+                {
+                    "key": "wired_to_power",
+                    "title": "Plugged In to External Power",
+                    "value": self.wired_to_power,
+                    "description": "Informs Scrypted that this device is plugged in to an external power source. " + \
+                                   "Will allow features like persistent prebuffer to work, however will no longer report this device's battery percentage. " + \
+                                   "Note that a persistent prebuffer may cause excess battery drain if the external power is not able to charge faster than the battery consumption rate.",
+                    "type": "boolean",
+                },
+            )
         if self._can_push_to_talk():
-            return [
+            result.extend([
                 {
                     "key": "two_way_audio",
                     "title": "(Experimental) Enable native two-way audio",
@@ -110,17 +270,18 @@ class ArloCamera(ArloDeviceBase, Settings, Camera, VideoCamera, VideoClips, Moti
                                    "If enabled, takes precedence over native two-way audio. May use increased system resources.",
                     "type": "boolean",
                 },
-            ]
-        return []
+            ])
+        return result
 
     async def putSetting(self, key, value) -> None:
-        if key in ["webrtc_emulation", "two_way_audio"]:
+        if key in ["webrtc_emulation", "two_way_audio", "wired_to_power"]:
             self.storage.setItem(key, value == "true")
-            await self.provider.discoverDevices()
+            await self.provider.discover_devices()
 
     async def getPictureOptions(self) -> List[ResponsePictureOptions]:
         return []
 
+    @async_print_exception_guard
     async def takePicture(self, options: dict = None) -> MediaObject:
         self.logger.info("Taking picture")
 
@@ -128,7 +289,11 @@ class ArloCamera(ArloDeviceBase, Settings, Camera, VideoCamera, VideoClips, Moti
         msos = await real_device.getVideoStreamOptions()
         if any(["prebuffer" in m for m in msos]):
             self.logger.info("Getting snapshot from prebuffer")
-            return await real_device.getVideoStream({"refresh": False})
+            try:
+                return await real_device.getVideoStream({"refresh": False})
+            except Exception as e:
+                self.logger.warning(f"Could not fetch from prebuffer due to: {e}")
+                self.logger.warning("Will try to fetch snapshot from Arlo cloud")
 
         pic_url = await asyncio.wait_for(self.provider.arlo.TriggerFullFrameSnapshot(self.arlo_basestation, self.arlo_device), timeout=self.timeout)
         self.logger.debug(f"Got snapshot URL for at {pic_url}")
@@ -180,32 +345,30 @@ class ArloCamera(ArloDeviceBase, Settings, Camera, VideoCamera, VideoClips, Moti
         }
         return await scrypted_sdk.mediaManager.createFFmpegMediaObject(ffmpeg_input)
 
+    @async_print_exception_guard
     async def startRTCSignalingSession(self, scrypted_session):
-        try:
-            plugin_session = ArloCameraRTCSignalingSession(self)
-            await plugin_session.initialize()
+        plugin_session = ArloCameraRTCSignalingSession(self)
+        await plugin_session.initialize()
 
-            scrypted_setup = {
-                "type": "offer",
-                "audio": {
-                    "direction": "sendrecv" if self._can_push_to_talk() else "recvonly",
-                },
-                "video": {
-                    "direction": "recvonly",
-                }
+        scrypted_setup = {
+            "type": "offer",
+            "audio": {
+                "direction": "sendrecv" if self._can_push_to_talk() else "recvonly",
+            },
+            "video": {
+                "direction": "recvonly",
             }
-            plugin_setup = {}
+        }
+        plugin_setup = {}
 
-            scrypted_offer = await scrypted_session.createLocalDescription("offer", scrypted_setup, sendIceCandidate=plugin_session.addIceCandidate)
-            self.logger.info(f"Scrypted offer sdp:\n{scrypted_offer['sdp']}")
-            await plugin_session.setRemoteDescription(scrypted_offer, plugin_setup)
-            plugin_answer = await plugin_session.createLocalDescription("answer", plugin_setup, scrypted_session.sendIceCandidate)
-            self.logger.info(f"Scrypted answer sdp:\n{plugin_answer['sdp']}")
-            await scrypted_session.setRemoteDescription(plugin_answer, scrypted_setup)
+        scrypted_offer = await scrypted_session.createLocalDescription("offer", scrypted_setup, sendIceCandidate=plugin_session.addIceCandidate)
+        self.logger.info(f"Scrypted offer sdp:\n{scrypted_offer['sdp']}")
+        await plugin_session.setRemoteDescription(scrypted_offer, plugin_setup)
+        plugin_answer = await plugin_session.createLocalDescription("answer", plugin_setup, scrypted_session.sendIceCandidate)
+        self.logger.info(f"Scrypted answer sdp:\n{plugin_answer['sdp']}")
+        await scrypted_session.setRemoteDescription(plugin_answer, scrypted_setup)
 
-            return ArloCameraRTCSessionControl(plugin_session)
-        except Exception as e:
-            self.logger.error(e)
+        return ArloCameraRTCSessionControl(plugin_session)
 
     async def startIntercom(self, media) -> None:
         self.logger.info("Starting intercom")
@@ -281,11 +444,36 @@ class ArloCamera(ArloDeviceBase, Settings, Camera, VideoCamera, VideoClips, Moti
             clips.reverse()
         return clips
 
+    @async_print_exception_guard
     async def removeVideoClips(self, videoClipIds: List[str]) -> None:
         # Arlo does support deleting, but let's be safe and disable that
-        self.logger.error("deleting Arlo video clips is not implemented by this plugin")
         raise Exception("deleting Arlo video clips is not implemented by this plugin")
 
+    async def getDevice(self, nativeId: str) -> ArloDeviceBase:
+        if (nativeId.endswith("spotlight") and self.has_spotlight) or (nativeId.endswith("floodlight") and self.has_floodlight):
+            return self.get_or_create_spotlight_or_floodlight()
+        if nativeId.endswith("vss") and self.has_siren:
+            return self.get_or_create_vss()
+        return None
+
+    def get_or_create_spotlight_or_floodlight(self) -> ArloSpotlight:
+        if self.has_spotlight:
+            light_id = f'{self.arlo_device["deviceId"]}.spotlight'
+            if not self.light:
+                self.light = ArloSpotlight(light_id, self.arlo_device, self.arlo_basestation, self.provider, self)
+        elif self.has_floodlight:
+            light_id = f'{self.arlo_device["deviceId"]}.floodlight'
+            if not self.light:
+                self.light = ArloFloodlight(light_id, self.arlo_device, self.arlo_basestation, self.provider, self)
+        return self.light
+
+    def get_or_create_vss(self) -> ArloSirenVirtualSecuritySystem:
+        if self.has_siren:
+            vss_id = f'{self.arlo_device["deviceId"]}.vss'
+            if not self.vss:
+                self.vss = ArloSirenVirtualSecuritySystem(vss_id, self.arlo_device, self.arlo_basestation, self.provider, self)
+        return self.vss
+
 
 class ArloCameraRTCSignalingSession(BackgroundTaskMixin):
     def __init__(self, camera):

plugins/arlo/src/arlo_plugin/doorbell.py

@@ -31,8 +31,4 @@ class ArloDoorbell(ArloCamera, BinarySensor):
     def get_applicable_interfaces(self) -> List[str]:
         camera_interfaces = super().get_applicable_interfaces()
         camera_interfaces.append(ScryptedInterface.BinarySensor.value)
-
-        model_id = self.arlo_device['modelId'].lower()
-        if model_id.startswith("avd1001"):
-            camera_interfaces.remove(ScryptedInterface.Battery.value)
         return camera_interfaces

plugins/arlo/src/arlo_plugin/provider.py

@@ -10,26 +10,27 @@ from typing import List
 
 import scrypted_sdk
 from scrypted_sdk import ScryptedDeviceBase
-from scrypted_sdk.types import Setting, SettingValue, Settings, DeviceProvider, DeviceDiscovery, ScryptedInterface
+from scrypted_sdk.types import Setting, SettingValue, Settings, DeviceProvider, ScryptedInterface
 
 from .arlo import Arlo
 from .arlo.arlo_async import change_stream_class
 from .arlo.logging import logger as arlo_lib_logger
 from .logging import ScryptedDeviceLoggerMixin
-from .util import BackgroundTaskMixin
+from .util import BackgroundTaskMixin, async_print_exception_guard
 from .camera import ArloCamera
 from .doorbell import ArloDoorbell
 from .basestation import ArloBasestation
 from .base import ArloDeviceBase
 
 
-class ArloProvider(ScryptedDeviceBase, Settings, DeviceProvider, DeviceDiscovery, ScryptedDeviceLoggerMixin, BackgroundTaskMixin):
+class ArloProvider(ScryptedDeviceBase, Settings, DeviceProvider, ScryptedDeviceLoggerMixin, BackgroundTaskMixin):
     arlo_cameras = None
     arlo_basestations = None
     _arlo_mfa_code = None
     scrypted_devices = None
     _arlo = None
     _arlo_mfa_complete_auth = None
+    device_discovery_lock: asyncio.Lock = None
 
     plugin_verbosity_choices = {
         "Normal": logging.INFO,
@@ -50,6 +51,7 @@ class ArloProvider(ScryptedDeviceBase, Settings, DeviceProvider, DeviceDiscovery
         self.imap = None
         self.imap_signal = None
         self.imap_skip_emails = None
+        self.device_discovery_lock = asyncio.Lock()
 
         self.propagate_verbosity()
         self.propagate_transport()
@@ -188,14 +190,11 @@ class ArloProvider(ScryptedDeviceBase, Settings, DeviceProvider, DeviceDiscovery
 
     async def do_arlo_setup(self) -> None:
         try:
-            await self.discoverDevices()
+            await self.discover_devices()
             await self.arlo.Subscribe([
                 (self.arlo_basestations[camera["parentId"]], camera) for camera in self.arlo_cameras.values()
             ])
 
-            for nativeId in self.arlo_cameras.keys():
-                await self.getDevice(nativeId)
-
             self.arlo.event_stream.set_refresh_interval(self.refresh_interval)
         except requests.exceptions.HTTPError as e:
             traceback.print_exc()
@@ -472,11 +471,10 @@ class ArloProvider(ScryptedDeviceBase, Settings, DeviceProvider, DeviceDiscovery
             {
                 "group": "General",
                 "key": "plugin_verbosity",
-                "title": "Plugin Verbosity",
-                "description": "Select the verbosity of this plugin. 'Verbose' will show debugging messages, "
-                               "including events received from connected Arlo cameras.",
-                "value": self.plugin_verbosity,
-                "choices": sorted(self.plugin_verbosity_choices.keys()),
+                "title": "Verbose Logging",
+                "description": "Enable this option to show debug messages, including events received from connected Arlo cameras.",
+                "value": self.plugin_verbosity == "Verbose",
+                "type": "boolean",
             },
         ])
 
@@ -493,13 +491,14 @@ class ArloProvider(ScryptedDeviceBase, Settings, DeviceProvider, DeviceDiscovery
         elif key == "force_reauth":
             # force arlo client to be invalidated and reloaded
             self.invalidate_arlo_client()
+        elif key == "plugin_verbosity":
+            self.storage.setItem(key, "Verbose" if value == "true" else "Normal")
+            self.propagate_verbosity()
+            skip_arlo_client = True
         else:
             self.storage.setItem(key, value)
 
-            if key == "plugin_verbosity":
-                self.propagate_verbosity()
-                skip_arlo_client = True
-            elif key == "arlo_transport":
+            if key == "arlo_transport":
                 self.propagate_transport()
                 # force arlo client to be invalidated and reloaded, but
                 # keep any mfa codes
@@ -558,7 +557,12 @@ class ArloProvider(ScryptedDeviceBase, Settings, DeviceProvider, DeviceDiscovery
                 return False
         return True
 
-    async def discoverDevices(self, duration: int = 0) -> None:
+    @async_print_exception_guard
+    async def discover_devices(self) -> None:
+        async with self.device_discovery_lock:
+            return await self.discover_devices_impl()
+
+    async def discover_devices_impl(self) -> None:
         if not self.arlo:
             raise Exception("Arlo client not connected, cannot discover devices")
 
@@ -573,16 +577,17 @@ class ArloProvider(ScryptedDeviceBase, Settings, DeviceProvider, DeviceDiscovery
         basestations = self.arlo.GetDevices(['basestation', 'siren'])
         for basestation in basestations:
             nativeId = basestation["deviceId"]
+            self.logger.debug(f"Adding {nativeId}")
 
             if nativeId in self.arlo_basestations:
                 self.logger.info(f"Skipping basestation {nativeId} ({basestation['modelId']}) as it has already been added")
                 continue
             self.arlo_basestations[nativeId] = basestation
 
-            device = await self.getDevice(nativeId)
+            device = await self.getDevice_impl(nativeId)
             scrypted_interfaces = device.get_applicable_interfaces()
             manifest = device.get_device_manifest()
-            self.logger.info(f"Interfaces for {nativeId} ({basestation['modelId']}): {scrypted_interfaces}")
+            self.logger.debug(f"Interfaces for {nativeId} ({basestation['modelId']}): {scrypted_interfaces}")
 
             # for basestations, we want to add them to the top level DeviceProvider
             provider_to_device_map.setdefault(None, []).append(manifest)
@@ -601,11 +606,13 @@ class ArloProvider(ScryptedDeviceBase, Settings, DeviceProvider, DeviceDiscovery
 
         cameras = self.arlo.GetDevices(['camera', "arloq", "arloqs", "doorbell"])
         for camera in cameras:
+            nativeId = camera["deviceId"]
+            self.logger.debug(f"Adding {nativeId}")
+
             if camera["deviceId"] != camera["parentId"] and camera["parentId"] not in self.arlo_basestations:
                 self.logger.info(f"Skipping camera {camera['deviceId']} ({camera['modelId']}) because its basestation was not found")
                 continue
 
-            nativeId = camera["deviceId"]
             if nativeId in self.arlo_cameras:
                 self.logger.info(f"Skipping camera {nativeId} ({camera['modelId']}) as it has already been added")
                 continue
@@ -616,10 +623,10 @@ class ArloProvider(ScryptedDeviceBase, Settings, DeviceProvider, DeviceDiscovery
                 # own basestation
                 self.arlo_basestations[camera["deviceId"]] = camera
 
-            device: ArloDeviceBase = await self.getDevice(nativeId)
+            device = await self.getDevice_impl(nativeId)
             scrypted_interfaces = device.get_applicable_interfaces()
             manifest = device.get_device_manifest()
-            self.logger.info(f"Interfaces for {nativeId} ({camera['modelId']}): {scrypted_interfaces}")
+            self.logger.debug(f"Interfaces for {nativeId} ({camera['modelId']}): {scrypted_interfaces}")
 
             if camera["deviceId"] == camera["parentId"]:
                 provider_to_device_map.setdefault(None, []).append(manifest)
@@ -656,6 +663,10 @@ class ArloProvider(ScryptedDeviceBase, Settings, DeviceProvider, DeviceDiscovery
         })
 
     async def getDevice(self, nativeId: str) -> ArloDeviceBase:
+        async with self.device_discovery_lock:
+            return await self.getDevice_impl(nativeId)
+
+    async def getDevice_impl(self, nativeId: str) -> ArloDeviceBase:
         ret = self.scrypted_devices.get(nativeId, None)
         if ret is None:
             ret = self.create_device(nativeId)

plugins/arlo/src/arlo_plugin/siren.py

@@ -5,6 +5,7 @@ from typing import List, TYPE_CHECKING
 from scrypted_sdk.types import OnOff, SecuritySystemMode, ScryptedInterface, ScryptedDeviceType
 
 from .base import ArloDeviceBase
+from .util import async_print_exception_guard
 
 if TYPE_CHECKING:
     # https://adamj.eu/tech/2021/05/13/python-type-hints-how-to-fix-circular-imports/
@@ -25,8 +26,9 @@ class ArloSiren(ArloDeviceBase, OnOff):
     def get_device_type(self) -> str:
         return ScryptedDeviceType.Siren.value
 
-    @ArloDeviceBase.async_print_exception_guard
+    @async_print_exception_guard
     async def turnOn(self) -> None:
+        from .basestation import ArloBasestation
         self.logger.info("Turning on")
 
         if self.vss.securitySystemState["mode"] == SecuritySystemMode.Disarmed.value:
@@ -42,7 +44,12 @@ class ArloSiren(ArloDeviceBase, OnOff):
             }
             return
 
-        self.provider.arlo.SirenOn(self.arlo_device)
+        if isinstance(self.vss.parent, ArloBasestation):
+            self.logger.debug("Parent device is a basestation")
+            self.provider.arlo.SirenOn(self.arlo_basestation)
+        else:
+            self.logger.debug("Parent device is a camera")
+            self.provider.arlo.SirenOn(self.arlo_basestation, self.arlo_device)
 
         self.on = True
         self.vss.securitySystemState = {
@@ -50,10 +57,14 @@ class ArloSiren(ArloDeviceBase, OnOff):
             "triggered": True,
          }
 
-    @ArloDeviceBase.async_print_exception_guard
+    @async_print_exception_guard
     async def turnOff(self) -> None:
+        from .basestation import ArloBasestation
         self.logger.info("Turning off")
-        self.provider.arlo.SirenOff(self.arlo_device)
+        if isinstance(self.vss.parent, ArloBasestation):
+            self.provider.arlo.SirenOff(self.arlo_basestation)
+        else:
+            self.provider.arlo.SirenOff(self.arlo_basestation, self.arlo_device)
         self.on = False
         self.vss.securitySystemState = {
             **self.vss.securitySystemState,

plugins/arlo/src/arlo_plugin/spotlight.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import List, TYPE_CHECKING
+
+from scrypted_sdk.types import OnOff, ScryptedInterface, ScryptedDeviceType
+
+from .base import ArloDeviceBase
+from .util import async_print_exception_guard
+
+if TYPE_CHECKING:
+    # https://adamj.eu/tech/2021/05/13/python-type-hints-how-to-fix-circular-imports/
+    from .provider import ArloProvider
+    from .camera import ArloCamera
+
+
+class ArloSpotlight(ArloDeviceBase, OnOff):
+    camera: ArloCamera = None
+
+    def __init__(self, nativeId: str, arlo_device: dict, arlo_basestation: dict, provider: ArloProvider, camera: ArloCamera) -> None:
+        super().__init__(nativeId=nativeId, arlo_device=arlo_device, arlo_basestation=arlo_basestation, provider=provider)
+        self.camera = camera
+
+    def get_applicable_interfaces(self) -> List[str]:
+        return [ScryptedInterface.OnOff.value]
+
+    def get_device_type(self) -> str:
+        return ScryptedDeviceType.Light.value
+
+    @async_print_exception_guard
+    async def turnOn(self) -> None:
+        self.logger.info("Turning on")
+        self.provider.arlo.SpotlightOn(self.arlo_basestation, self.arlo_device)
+        self.on = True
+
+    @async_print_exception_guard
+    async def turnOff(self) -> None:
+        self.logger.info("Turning off")
+        self.provider.arlo.SpotlightOff(self.arlo_basestation, self.arlo_device)
+        self.on = False
+
+
+class ArloFloodlight(ArloSpotlight):
+
+    @async_print_exception_guard
+    async def turnOn(self) -> None:
+        self.logger.info("Turning on")
+        self.provider.arlo.FloodlightOn(self.arlo_basestation, self.arlo_device)
+        self.on = True
+
+    @async_print_exception_guard
+    async def turnOff(self) -> None:
+        self.logger.info("Turning off")
+        self.provider.arlo.FloodlightOff(self.arlo_basestation, self.arlo_device)
+        self.on = False

plugins/arlo/src/arlo_plugin/util.py

@@ -1,4 +1,5 @@
 import asyncio
+import traceback
 
 
 class BackgroundTaskMixin:
@@ -25,4 +26,14 @@ class BackgroundTaskMixin:
         if not hasattr(self, "background_tasks"):
             return
         for task in self.background_tasks:
-            task.cancel()
+            task.cancel()
+
+def async_print_exception_guard(fn):
+    """Decorator to print an exception's stack trace before re-raising the exception."""
+    async def wrapped(*args, **kwargs):
+        try:
+            return await fn(*args, **kwargs)
+        except Exception:
+            traceback.print_exc()
+            raise
+    return wrapped

plugins/arlo/src/arlo_plugin/vss.py

@@ -7,21 +7,26 @@ from scrypted_sdk.types import Device, DeviceProvider, Setting, Settings, Settin
 
 from .base import ArloDeviceBase
 from .siren import ArloSiren
+from .util import async_print_exception_guard
 
 if TYPE_CHECKING:
     # https://adamj.eu/tech/2021/05/13/python-type-hints-how-to-fix-circular-imports/
     from .provider import ArloProvider
+    from .basestation import ArloBasestation
+    from .camera import ArloCamera
 
 
-class ArloSirenVirtualSecuritySystem(ArloDeviceBase, SecuritySystem, DeviceProvider):
+class ArloSirenVirtualSecuritySystem(ArloDeviceBase, SecuritySystem, Settings, Readme, DeviceProvider):
     """A virtual, emulated security system that controls when scrypted events can trip the real physical siren."""
 
     SUPPORTED_MODES = [SecuritySystemMode.AwayArmed.value, SecuritySystemMode.HomeArmed.value, SecuritySystemMode.Disarmed.value]
 
     siren: ArloSiren = None
+    parent: ArloBasestation | ArloCamera = None
 
-    def __init__(self, nativeId: str, arlo_device: dict, arlo_basestation: dict, provider: ArloProvider) -> None:
+    def __init__(self, nativeId: str, arlo_device: dict, arlo_basestation: dict, provider: ArloProvider, parent: ArloBasestation | ArloCamera) -> None:
         super().__init__(nativeId=nativeId, arlo_device=arlo_device, arlo_basestation=arlo_basestation, provider=provider)
+        self.parent = parent
         self.create_task(self.delayed_init())
 
     @property
@@ -56,7 +61,7 @@ class ArloSirenVirtualSecuritySystem(ArloDeviceBase, SecuritySystem, DeviceProvi
                 }
                 return
             except Exception as e:
-                self.logger.info(f"Delayed init failed, will try again: {e}")
+                self.logger.debug(f"Delayed init failed, will try again: {e}")
                 await asyncio.sleep(0.1)
             iterations += 1
 
@@ -129,6 +134,7 @@ If this virtual security system is synced to Homekit, the siren device will be m
             self.siren = ArloSiren(siren_id, self.arlo_device, self.arlo_basestation, self.provider, self)
         return self.siren
 
+    @async_print_exception_guard
     async def armSecuritySystem(self, mode: SecuritySystemMode) -> None:
         self.logger.info(f"Arming {mode}")
         self.mode = mode
@@ -139,7 +145,7 @@ If this virtual security system is synced to Homekit, the siren device will be m
         if mode == SecuritySystemMode.Disarmed.value:
             await self.get_or_create_siren().turnOff()
 
-    @ArloDeviceBase.async_print_exception_guard
+    @async_print_exception_guard
     async def disarmSecuritySystem(self) -> None:
         self.logger.info(f"Disarming")
         self.mode = SecuritySystemMode.Disarmed.value

plugins/arlo/src/requirements.txt

@@ -1,7 +1,7 @@
 paho-mqtt==1.6.1
 sseclient==0.0.22
-requests
-cachetools
+requests==2.28.2
+cachetools==5.3.0
 scrypted-arlo-go==0.0.1
 --extra-index-url=https://www.piwheels.org/simple/
 --extra-index-url=https://bjia56.github.io/scrypted-arlo-go/

plugins/core/package-lock.json

@@ -1,12 +1,12 @@
 {
    "name": "@scrypted/core",
-   "version": "0.1.103",
+   "version": "0.1.108",
    "lockfileVersion": 2,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/core",
-         "version": "0.1.103",
+         "version": "0.1.108",
          "license": "Apache-2.0",
          "dependencies": {
             "@scrypted/common": "file:../../common",

plugins/core/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@scrypted/core",
-   "version": "0.1.103",
+   "version": "0.1.108",
    "description": "Scrypted Core plugin. Provides the UI, websocket, and engine.io APIs.",
    "author": "Scrypted",
    "license": "Apache-2.0",

plugins/core/src/main.ts

@@ -92,6 +92,17 @@ class ScryptedCore extends ScryptedDeviceBase implements HttpRequestHandler, Eng
             this.automationCore = new AutomationCore();
         })();
 
+        deviceManager.onDeviceDiscovered({
+            name: 'Add to Launcher',
+            nativeId: 'launcher',
+            interfaces: [
+                '@scrypted/launcher-ignore',
+                ScryptedInterface.MixinProvider,
+                ScryptedInterface.Readme,
+            ],
+            type: ScryptedDeviceType.Builtin,
+        });
+
         (async () => {
             await deviceManager.onDeviceDiscovered(
                 {

plugins/core/src/user.ts

@@ -23,6 +23,15 @@ export class User extends ScryptedDeviceBase implements Settings, ScryptedUser {
     })
 
     async getScryptedUserAccessControl(): Promise<ScryptedUserAccessControl> {
+        const usersService = await sdk.systemManager.getComponent('users');
+        const users: DBUser[] = await usersService.getAllUsers();
+        const user = users.find(user => user.username === this.username);
+        if (!user)
+            throw new Error("user not found");
+
+        if (user.admin)
+            return;
+
         const self = sdk.deviceManager.getDeviceState(this.nativeId);
 
         const ret: ScryptedUserAccessControl = {

plugins/core/ui/src/common/mixin.ts

@@ -1,3 +1,4 @@
+import { timeoutPromise } from "@scrypted/common/src/promise-utils";
 import { MixinProvider, ScryptedDevice, ScryptedDeviceType, ScryptedInterface, SystemManager } from "@scrypted/types";
 
 export async function setMixin(systemManager: SystemManager, device: ScryptedDevice, mixinId: string, enabled: boolean) {
@@ -14,19 +15,21 @@ export async function setMixin(systemManager: SystemManager, device: ScryptedDev
     plugins.setMixins(device.id, mixins);
 }
 
-export function getAllDevices(systemManager: SystemManager) {
-    return Object.keys(systemManager.getSystemState()).map(id => systemManager.getDeviceById(id)).filter(device => !!device);
+export function getAllDevices<T>(systemManager: SystemManager) {
+    return Object.keys(systemManager.getSystemState()).map(id => systemManager.getDeviceById(id) as T & ScryptedDevice).filter(device => !!device);
 }
 
 export async function getDeviceAvailableMixins(systemManager: SystemManager, device: ScryptedDevice): Promise<(ScryptedDevice & MixinProvider)[]> {
-    const results = await Promise.all(getAllDevices(systemManager).map(async (check) => {
+    const results = await Promise.all(getAllDevices<MixinProvider>(systemManager).map(async (check) => {
         try {
             if (check.interfaces.includes(ScryptedInterface.MixinProvider)) {
-                if (await (check as any as MixinProvider).canMixin(device.type, device.interfaces))
-                    return check as MixinProvider & ScryptedDevice;
+                const canMixin = await timeoutPromise(5000, check.canMixin(device.type, device.interfaces));
+                if (canMixin)
+                    return check;
             }
         }
         catch (e) {
+            console.warn(check.name, 'canMixin error', e)
         }
     }));
 
@@ -47,7 +50,7 @@ export async function getMixinProviderAvailableDevices(systemManager: SystemMana
         devices.map(async (device) => {
             try {
                 if (device.mixins?.includes(mixinProvider.id) || (await mixinProvider.canMixin(device.type, device.interfaces)))
-                return device;
+                    return device;
             }
             catch (e) {
             }

plugins/core/ui/src/components/Device.vue

@@ -215,6 +215,7 @@ import Notifier from "../interfaces/Notifier.vue";
 import OnOff from "../interfaces/OnOff.vue";
 import Brightness from "../interfaces/Brightness.vue";
 import Battery from "../interfaces/Battery.vue";
+import Charger from "../interfaces/Charger.vue";
 import Lock from "../interfaces/Lock.vue";
 import ColorSettingHsv from "../interfaces/ColorSettingHsv.vue";
 import ColorSettingRgb from "../interfaces/ColorSettingRgb.vue";
@@ -263,6 +264,7 @@ const cardHeaderInterfaces = [
   ScryptedInterface.AudioSensor,
   ScryptedInterface.HumiditySensor,
   ScryptedInterface.Thermometer,
+  ScryptedInterface.Charger,
   ScryptedInterface.Battery,
   ScryptedInterface.Lock,
   ScryptedInterface.OnOff,
@@ -362,6 +364,7 @@ export default {
 
     Lock,
     OnOff,
+    Charger,
     Battery,
     Thermometer,
     HumiditySensor,

plugins/core/ui/src/interfaces/Charger.vue

@@ -0,0 +1,52 @@
+<template>
+  <v-tooltip left>
+    <template v-slot:activator="{ on }">
+      <v-icon
+        v-on="on"
+        v-if="lazyValue.chargeState === Charging"
+        class="mr-1 mr-1"
+        small
+      >fa-plug</v-icon>
+      <v-icon
+        v-on="on"
+        v-else-if="lazyValue.chargeState == Trickle"
+        class="mr-1 mr-1"
+        small
+      >fa-plug-circle-minus</v-icon>
+      <v-icon
+        v-on="on"
+        v-else
+        class="mr-1 mr-1"
+        small
+      >fa-plug-circle-xmark</v-icon>
+    </template>
+    <span>{{ chargeText }}</span>
+  </v-tooltip>
+</template>
+
+<script>
+import { ChargeState } from '@scrypted/types';
+import RPCInterface from "./RPCInterface.vue";
+
+export default {
+  mixins: [RPCInterface],
+  data() {
+    return {
+      Charging: ChargeState.Charging,
+      Trickle: ChargeState.Trickle,
+      NotCharging: ChargeState.NotCharging,
+    };
+  },
+  computed: {
+    chargeText() {
+      if (this.lazyValue.chargeState === "trickle") {
+        return "Trickle Charging";
+      }
+      if (this.lazyValue.chargeState === "charging") {
+        return "Charging";
+      }
+      return "Not Charging";
+    },
+  },
+};
+</script>

plugins/core/ui/src/interfaces/ObjectDetection.vue

@@ -81,6 +81,7 @@ export default {
             const mediaManager = this.$scrypted.mediaManager;
             const mo = await mediaManager.createMediaObject(buffer, 'image/*');
             const detected = await this.rpc().detectObjects(mo);
+            console.log(detected);
             this.lastDetection = detected;
         },
         allowDrop(ev) {

plugins/core/ui/src/interfaces/Setting.vue

@@ -41,8 +41,7 @@
       </template>
     </DevicePicker>
     <DevicePicker v-else-if="lazyValue.type === 'interface'" v-model="lazyValue.value" :multiple="lazyValue.multiple"
-      :readonly="lazyValue.readonly" :devices="interfaces" :title="lazyValue.title"
-      :description="lazyValue.description">
+      :readonly="lazyValue.readonly" :devices="interfaces" :title="lazyValue.title" :description="lazyValue.description">
       <template v-slot:append-outer>
         <v-btn v-if="dirty && device" color="success" @click="save" class="shift-up">
           <v-icon>send</v-icon>
@@ -52,7 +51,7 @@
     <div v-else-if="lazyValue.type === 'clippath'" class="mb-2">
       <v-btn small block @click="editZone">{{ lazyValue.title }} </v-btn>
       <Camera :value="device" :device="device" :clipPathValue="sanitizedClipPathValue" :showDialog="editingZone"
-        :hidePreview="true" @dialog="editingZoneChanged" @clipPath="lazyValue.value = $event"></Camera>
+        :hidePreview="true" @dialog="editingZoneChanged" @clipPath="updateClipPath"></Camera>
     </div>
     <v-textarea v-else-if="lazyValue.type === 'textarea'" v-model="lazyValue.value" outlined persistent-hint
       :hint="lazyValue.description" :label="lazyValue.title">
@@ -88,6 +87,7 @@ export default {
   data() {
     return {
       editingZone: false,
+      clipPathThrottle: null,
     };
   },
   watch: {
@@ -142,7 +142,7 @@ export default {
         );
       },
       set(val) {
-        this.lazyValue.value = val.toString();
+        this.lazyValue.value = !!val;
       },
     },
     dirty() {
@@ -228,6 +228,17 @@ export default {
   },
   methods: {
     onChange() { },
+    updateClipPath(e) {
+      clearTimeout(this.clipPathThrottle);
+      this.clipPathThrottle = setTimeout(() => {
+        this.lazyValue.value = e;
+        this.rpc().putSetting(
+          this.lazyValue.key,
+          this.createInputValue().value
+        );
+        this.onInput();
+      }, 500)
+    },
     editingZoneChanged(value) {
       this.editingZone = value;
       if (!value) {

plugins/core/ui/src/plugins/icons.ts

@@ -58,6 +58,8 @@ import {
   faLightbulb,
   faToggleOn,
   faPlug,
+  faPlugCircleMinus,
+  faPlugCircleXmark,
   faExclamationTriangle,
   faSun,
   faCode,
@@ -150,6 +152,8 @@ const icons: IconDefinition[] =[
   faLightbulb,
   faToggleOn,
   faPlug,
+  faPlugCircleMinus,
+  faPlugCircleXmark,
   faExclamationTriangle,
   faSun,
   faCode,

plugins/coreml/package-lock.json

@@ -1,12 +1,12 @@
 {
    "name": "@scrypted/coreml",
-   "version": "0.1.5",
+   "version": "0.1.8",
    "lockfileVersion": 2,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/coreml",
-         "version": "0.1.5",
+         "version": "0.1.8",
          "devDependencies": {
             "@scrypted/sdk": "file:../../sdk"
          }

plugins/coreml/package.json

@@ -41,5 +41,5 @@
    "devDependencies": {
       "@scrypted/sdk": "file:../../sdk"
    },
-   "version": "0.1.5"
+   "version": "0.1.8"
 }

plugins/coreml/src/coreml/__init__.py

@@ -9,7 +9,7 @@ from PIL import Image
 import asyncio
 import concurrent.futures
 
-predictExecutor = concurrent.futures.ThreadPoolExecutor(2, "CoreML-Predict")
+predictExecutor = concurrent.futures.ThreadPoolExecutor(8, "CoreML-Predict")
 
 def parse_label_contents(contents: str):
     lines = contents.splitlines()

plugins/coreml/src/requirements.txt

@@ -1,4 +1,4 @@
-coremltools~=6.1
+coremltools
 
 # pillow for anything not intel linux, pillow-simd is available on x64 linux
 Pillow>=5.4.1; sys_platform != 'linux' or platform_machine != 'x86_64'

plugins/homekit/package-lock.json

@@ -1,25 +1,25 @@
 {
    "name": "@scrypted/homekit",
-   "version": "1.2.21",
+   "version": "1.2.23",
    "lockfileVersion": 2,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/homekit",
-         "version": "1.2.21",
+         "version": "1.2.23",
          "dependencies": {
             "@koush/werift-src": "file:../../external/werift",
             "check-disk-space": "^3.3.1",
             "hap-nodejs": "^0.11.0",
             "lodash": "^4.17.21",
-            "mkdirp": "^2.1.5"
+            "mkdirp": "^2.1.6"
          },
          "devDependencies": {
             "@scrypted/common": "file:../../common",
             "@scrypted/sdk": "file:../../sdk",
             "@types/debug": "^4.1.7",
-            "@types/lodash": "^4.14.191",
-            "@types/node": "^18.15.5",
+            "@types/lodash": "^4.14.192",
+            "@types/node": "^18.15.11",
             "@types/url-parse": "^1.4.8"
          }
       },
@@ -126,7 +126,7 @@
       },
       "../../sdk": {
          "name": "@scrypted/sdk",
-         "version": "0.2.85",
+         "version": "0.2.86",
          "dev": true,
          "license": "ISC",
          "dependencies": {
@@ -276,9 +276,9 @@
          }
       },
       "node_modules/@types/lodash": {
-         "version": "4.14.191",
-         "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.191.tgz",
-         "integrity": "sha512-BdZ5BCCvho3EIXw6wUCXHe7rS53AIDPLE+JzwgT+OsJk53oBfbSmZZ7CX4VaRoN78N+TJpFi9QPlfIVNmJYWxQ==",
+         "version": "4.14.192",
+         "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.192.tgz",
+         "integrity": "sha512-km+Vyn3BYm5ytMO13k9KTp27O75rbQ0NFw+U//g+PX7VZyjCioXaRFisqSIJRECljcTv73G3i6BpglNGHgUQ5A==",
          "dev": true
       },
       "node_modules/@types/ms": {
@@ -288,9 +288,9 @@
          "dev": true
       },
       "node_modules/@types/node": {
-         "version": "18.15.5",
-         "resolved": "https://registry.npmjs.org/@types/node/-/node-18.15.5.tgz",
-         "integrity": "sha512-Ark2WDjjZO7GmvsyFFf81MXuGTA/d6oP38anyxWOL6EREyBKAxKoFHwBhaZxCfLRLpO8JgVXwqOwSwa7jRcjew==",
+         "version": "18.15.11",
+         "resolved": "https://registry.npmjs.org/@types/node/-/node-18.15.11.tgz",
+         "integrity": "sha512-E5Kwq2n4SbMzQOn6wnmBjuK9ouqlURrcZDVfbo9ftDDTFt3nk7ZKK4GMOzoYgnpQJKcxwQw+lGaBvvlMo0qN/Q==",
          "dev": true
       },
       "node_modules/@types/url-parse": {
@@ -856,9 +856,9 @@
          }
       },
       "node_modules/mkdirp": {
-         "version": "2.1.5",
-         "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-2.1.5.tgz",
-         "integrity": "sha512-jbjfql+shJtAPrFoKxHOXip4xS+kul9W3OzfzzrqueWK2QMGon2bFH2opl6W9EagBThjEz+iysyi/swOoVfB/w==",
+         "version": "2.1.6",
+         "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-2.1.6.tgz",
+         "integrity": "sha512-+hEnITedc8LAtIP9u3HJDFIdcLV2vXP33sqLLIzkv1Db1zO/1OxbvYf0Y1OC/S/Qo5dxHXepofhmxL02PsKe+A==",
          "bin": {
             "mkdirp": "dist/cjs/src/bin.js"
          },
@@ -1276,9 +1276,9 @@
          }
       },
       "@types/lodash": {
-         "version": "4.14.191",
-         "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.191.tgz",
-         "integrity": "sha512-BdZ5BCCvho3EIXw6wUCXHe7rS53AIDPLE+JzwgT+OsJk53oBfbSmZZ7CX4VaRoN78N+TJpFi9QPlfIVNmJYWxQ==",
+         "version": "4.14.192",
+         "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.192.tgz",
+         "integrity": "sha512-km+Vyn3BYm5ytMO13k9KTp27O75rbQ0NFw+U//g+PX7VZyjCioXaRFisqSIJRECljcTv73G3i6BpglNGHgUQ5A==",
          "dev": true
       },
       "@types/ms": {
@@ -1288,9 +1288,9 @@
          "dev": true
       },
       "@types/node": {
-         "version": "18.15.5",
-         "resolved": "https://registry.npmjs.org/@types/node/-/node-18.15.5.tgz",
-         "integrity": "sha512-Ark2WDjjZO7GmvsyFFf81MXuGTA/d6oP38anyxWOL6EREyBKAxKoFHwBhaZxCfLRLpO8JgVXwqOwSwa7jRcjew==",
+         "version": "18.15.11",
+         "resolved": "https://registry.npmjs.org/@types/node/-/node-18.15.11.tgz",
+         "integrity": "sha512-E5Kwq2n4SbMzQOn6wnmBjuK9ouqlURrcZDVfbo9ftDDTFt3nk7ZKK4GMOzoYgnpQJKcxwQw+lGaBvvlMo0qN/Q==",
          "dev": true
       },
       "@types/url-parse": {
@@ -1698,9 +1698,9 @@
          "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="
       },
       "mkdirp": {
-         "version": "2.1.5",
-         "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-2.1.5.tgz",
-         "integrity": "sha512-jbjfql+shJtAPrFoKxHOXip4xS+kul9W3OzfzzrqueWK2QMGon2bFH2opl6W9EagBThjEz+iysyi/swOoVfB/w=="
+         "version": "2.1.6",
+         "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-2.1.6.tgz",
+         "integrity": "sha512-+hEnITedc8LAtIP9u3HJDFIdcLV2vXP33sqLLIzkv1Db1zO/1OxbvYf0Y1OC/S/Qo5dxHXepofhmxL02PsKe+A=="
       },
       "ms": {
          "version": "2.1.2",

plugins/homekit/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@scrypted/homekit",
-   "version": "1.2.21",
+   "version": "1.2.23",
    "description": "HomeKit Plugin for Scrypted",
    "scripts": {
       "scrypted-setup-project": "scrypted-setup-project",
@@ -38,14 +38,14 @@
       "check-disk-space": "^3.3.1",
       "hap-nodejs": "^0.11.0",
       "lodash": "^4.17.21",
-      "mkdirp": "^2.1.5"
+      "mkdirp": "^2.1.6"
    },
    "devDependencies": {
       "@scrypted/common": "file:../../common",
       "@scrypted/sdk": "file:../../sdk",
       "@types/debug": "^4.1.7",
-      "@types/lodash": "^4.14.191",
-      "@types/node": "^18.15.5",
+      "@types/lodash": "^4.14.192",
+      "@types/node": "^18.15.11",
       "@types/url-parse": "^1.4.8"
    }
 }

plugins/homekit/src/types/camera.ts

@@ -303,13 +303,19 @@ addSupportedType({
             }
         }
 
+        // if the camera is a device provider, merge in child devices and 
+        // ensure the devices are skipped by the rest of homekit by
+        // reporting that they've been merged
         if (device.interfaces.includes(ScryptedInterface.DeviceProvider)) {
             // merge in lights
-            const { devices } = mergeOnOffDevicesByType(device as ScryptedDevice as ScryptedDevice & DeviceProvider, accessory, ScryptedDeviceType.Light);
+            mergeOnOffDevicesByType(device as ScryptedDevice as ScryptedDevice & DeviceProvider, accessory, ScryptedDeviceType.Light).devices.forEach(device => {
+                homekitPlugin.mergedDevices.add(device.id)
+            });
 
-            // ensure child devices are skipped by the rest of homekit by
-            // reporting that they've been merged
-            devices.map(device => homekitPlugin.mergedDevices.add(device.id));
+            // merge in sirens
+            mergeOnOffDevicesByType(device as ScryptedDevice as ScryptedDevice & DeviceProvider, accessory, ScryptedDeviceType.Siren).devices.forEach(device => {
+                homekitPlugin.mergedDevices.add(device.id)
+            });
         }
 
         return accessory;

plugins/homekit/src/types/camera/h264-packetizer.ts

@@ -64,6 +64,9 @@ export class H264Repacketizer {
     extraPackets = 0;
     fuaMax: number;
     pendingFuA: RtpPacket[];
+    // log whether a stapa sps/pps has been seen.
+    // resets on every idr frame, to trigger codec information
+    // to be resent.
     seenStapASps = false;
     fuaMin: number;
 
@@ -402,8 +405,12 @@ export class H264Repacketizer {
                 // if this is an idr frame, but no sps has been sent via a stapa, dummy one up.
                 // the stream may not contain codec information in stapa or may be sending it
                 // in separate sps/pps packets which is not supported by homekit.
-                if (originalNalType === NAL_TYPE_IDR && !this.seenStapASps)
-                    this.maybeSendSpsPps(packet, ret);
+                if (originalNalType === NAL_TYPE_IDR) {
+                    if (!this.seenStapASps)
+                        this.maybeSendSpsPps(packet, ret);
+                    this.seenStapASps = false;
+                }
+
             }
             else {
                 if (this.pendingFuA) {
@@ -486,10 +493,12 @@ export class H264Repacketizer {
                 return;
             }
 
-            if (nalType === NAL_TYPE_IDR && !this.seenStapASps) {
+            if (nalType === NAL_TYPE_IDR) {
                 // if this is an idr frame, but no sps has been sent, dummy one up.
                 // the stream may not contain sps.
-                this.maybeSendSpsPps(packet, ret);
+                if (!this.seenStapASps)
+                    this.maybeSendSpsPps(packet, ret);
+                this.seenStapASps = false;
             }
 
             this.fragment(packet, ret);

plugins/homekit/src/types/onoff-base.ts

@@ -9,7 +9,7 @@ export function probe(device: DummyDevice): boolean {
 }
 
 export function getService(device: ScryptedDevice & OnOff, accessory: Accessory, serviceType: any): Service {
-    const service = accessory.addService(serviceType, device.name);
+    const service = accessory.addService(serviceType, device.name, device.nativeId);
     service.getCharacteristic(Characteristic.On)
         .on(CharacteristicEventTypes.SET, (value: CharacteristicValue, callback: CharacteristicSetCallback) => {
             callback();

plugins/objectdetector/package-lock.json

@@ -1,12 +1,12 @@
 {
    "name": "@scrypted/objectdetector",
-   "version": "0.0.119",
+   "version": "0.0.122",
    "lockfileVersion": 2,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/objectdetector",
-         "version": "0.0.119",
+         "version": "0.0.122",
          "license": "Apache-2.0",
          "dependencies": {
             "@scrypted/common": "file:../../common",

plugins/objectdetector/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@scrypted/objectdetector",
-   "version": "0.0.119",
+   "version": "0.0.122",
    "description": "Scrypted Video Analysis Plugin. Installed alongside a detection service like OpenCV or TensorFlow.",
    "author": "Scrypted",
    "license": "Apache-2.0",

plugins/objectdetector/src/ffmpeg-videoframes.ts

@@ -1,12 +1,32 @@
 import { Deferred } from "@scrypted/common/src/deferred";
+import { addVideoFilterArguments } from "@scrypted/common/src/ffmpeg-helpers";
 import { ffmpegLogInitialOutput, safeKillFFmpeg, safePrintFFmpegArguments } from "@scrypted/common/src/media-helpers";
 import { readLength, readLine } from "@scrypted/common/src/read-stream";
-import { addVideoFilterArguments } from "@scrypted/common/src/ffmpeg-helpers";
 import sdk, { FFmpegInput, Image, ImageOptions, MediaObject, ScryptedDeviceBase, ScryptedMimeTypes, VideoFrame, VideoFrameGenerator, VideoFrameGeneratorOptions } from "@scrypted/sdk";
 import child_process from 'child_process';
-import sharp from 'sharp';
+import type sharp from 'sharp';
 import { Readable } from 'stream';
 
+export let sharpLib: (input?:
+    | Buffer
+    | Uint8Array
+    | Uint8ClampedArray
+    | Int8Array
+    | Uint16Array
+    | Int16Array
+    | Uint32Array
+    | Int32Array
+    | Float32Array
+    | Float64Array
+    | string,
+    options?: sharp.SharpOptions) => sharp.Sharp;
+try {
+    sharpLib = require('sharp');
+}
+catch (e) {
+    console.warn('Sharp failed to load. FFmpeg Frame Generator will not function properly.')
+}
+
 async function createVipsMediaObject(image: VipsImage): Promise<VideoFrame & MediaObject> {
     const ret = await sdk.mediaManager.createMediaObject(image, ScryptedMimeTypes.Image, {
         format: null,
@@ -76,7 +96,20 @@ class VipsImage implements Image {
             resolveWithObject: true,
         });
 
-        const newImage = sharp(data, {
+        const sharpLib = require('sharp') as (input?:
+            | Buffer
+            | Uint8Array
+            | Uint8ClampedArray
+            | Int8Array
+            | Uint16Array
+            | Int16Array
+            | Uint32Array
+            | Int32Array
+            | Float32Array
+            | Float64Array
+            | string,
+            options?) => sharp.Sharp;
+        const newImage = sharpLib(data, {
             raw: info,
         });
 
@@ -177,7 +210,7 @@ export class FFmpegVideoFrameGenerator extends ScryptedDeviceBase implements Vid
                 const raw = await frameDeferred.promise;
                 const { width, height, data } = raw;
 
-                const image = sharp(data, {
+                const image = sharpLib(data, {
                     raw: {
                         width,
                         height,

plugins/objectdetector/src/main.ts

@@ -4,7 +4,7 @@ import crypto from 'crypto';
 import { AutoenableMixinProvider } from "../../../common/src/autoenable-mixin-provider";
 import { SettingsMixinDeviceBase } from "../../../common/src/settings-mixin";
 import { DenoisedDetectionState } from './denoise';
-import { FFmpegVideoFrameGenerator } from './ffmpeg-videoframes';
+import { FFmpegVideoFrameGenerator, sharpLib } from './ffmpeg-videoframes';
 import { serverSupportsMixinEventMasking } from './server-version';
 import { sleep } from './sleep';
 import { getAllDevices, safeParseJson } from './util';
@@ -61,6 +61,10 @@ class ObjectDetectionMixin extends SettingsMixinDeviceBase<VideoCamera & Camera
           choices,
         }
       },
+      onPut: () => {
+        this.endObjectDetection();
+        this.maybeStartMotionDetection();
+      },
       defaultValue: 'Default',
     },
     motionSensorSupplementation: {
@@ -201,7 +205,6 @@ class ObjectDetectionMixin extends SettingsMixinDeviceBase<VideoCamera & Camera
     if (this.hasMotionType)
       this.motionDetected = false;
 
-    this.detectorRunning = false;
     this.endObjectDetection();
 
     this.maybeStartMotionDetection();
@@ -333,8 +336,7 @@ class ObjectDetectionMixin extends SettingsMixinDeviceBase<VideoCamera & Camera
         if (!this.detectorRunning) {
           break;
         }
-        const now = Date.now();
-        if (now > this.analyzeStop) {
+        if (!this.hasMotionType && Date.now() > this.analyzeStop) {
           break;
         }
 
@@ -820,9 +822,9 @@ class ObjectDetectionPlugin extends AutoenableMixinProvider implements Settings,
           {
             name: 'FFmpeg Frame Generator',
             type: ScryptedDeviceType.Builtin,
-            interfaces: [
+            interfaces: sharpLib ? [
               ScryptedInterface.VideoFrameGenerator,
-            ],
+            ] : [],
             nativeId: 'ffmpeg',
           }
         ]

plugins/opencv/package-lock.json

@@ -1,12 +1,12 @@
 {
    "name": "@scrypted/opencv",
-   "version": "0.0.70",
+   "version": "0.0.74",
    "lockfileVersion": 2,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/opencv",
-         "version": "0.0.70",
+         "version": "0.0.74",
          "devDependencies": {
             "@scrypted/sdk": "file:../../sdk"
          }

plugins/opencv/package.json

@@ -36,5 +36,5 @@
    "devDependencies": {
       "@scrypted/sdk": "file:../../sdk"
    },
-   "version": "0.0.70"
+   "version": "0.0.74"
 }

plugins/opencv/src/opencv/__init__.py

@@ -1,22 +1,46 @@
 from __future__ import annotations
-from time import sleep
-from detect import DetectionSession, DetectPlugin
-from typing import Any, List, Tuple
-import numpy as np
+
 import asyncio
+import concurrent.futures
+from typing import Any, List, Tuple
+
 import cv2
 import imutils
-Gst = None
-try:
-    from gi.repository import Gst
-except:
-    pass
-from scrypted_sdk.types import ObjectDetectionModel, ObjectDetectionResult, ObjectsDetected, Setting, VideoFrame
+import numpy as np
+import scrypted_sdk
 from PIL import Image
+from scrypted_sdk.types import (ObjectDetectionGeneratorSession,
+                                ObjectDetectionResult, ObjectsDetected,
+                                Setting, VideoFrame)
 
-class OpenCVDetectionSession(DetectionSession):
+from detect import DetectPlugin
+
+# vips is already multithreaded, but needs to be kicked off the python asyncio thread.
+toThreadExecutor = concurrent.futures.ThreadPoolExecutor(max_workers=2, thread_name_prefix="image")
+
+async def to_thread(f):
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(toThreadExecutor, f)
+
+async def ensureGrayData(data: bytes, size: Tuple[int, int], format: str):
+    if format == 'gray':
+        return data
+
+    def convert():
+        if format == 'rgba':
+            image = Image.frombuffer('RGBA', size, data)
+        else:
+            image = Image.frombuffer('RGB', size, data)
+
+        try:
+            return image.convert('L').tobytes()
+        finally:
+            image.close()
+    return await to_thread(convert)
+
+
+class OpenCVDetectionSession:
     def __init__(self) -> None:
-        super().__init__()
         self.cap: cv2.VideoCapture = None
         self.previous_frame: Any = None
         self.curFrame = None
@@ -35,21 +59,6 @@ defaultBlur = 5
 class OpenCVPlugin(DetectPlugin):
     def __init__(self, nativeId: str | None = None):
         super().__init__(nativeId=nativeId)
-        self.color2Gray = None
-        self.pixelFormat = "I420"
-        self.pixelFormatChannelCount = 1
-
-        if True:
-            self.retainAspectRatio = False
-            self.color2Gray = None
-            self.pixelFormat = "I420"
-            self.pixelFormatChannelCount = 1
-        else:
-            self.retainAspectRatio = True
-            self.color2Gray = cv2.COLOR_BGRA2GRAY
-            self.pixelFormat = "BGRA"
-            self.pixelFormatChannelCount = 4
-
 
     def getClasses(self) -> list[str]:
         return ['motion']
@@ -91,9 +100,6 @@ class OpenCVPlugin(DetectPlugin):
         ]
 
         return settings
-
-    def get_pixel_format(self):
-        return self.pixelFormat
     
     def get_input_format(self) -> str:
         return 'gray'
@@ -110,17 +116,10 @@ class OpenCVPlugin(DetectPlugin):
             blur = int(settings.get('blur', blur))
         return area, threshold, interval, blur
 
-    def detect(self, detection_session: OpenCVDetectionSession, frame, src_size, convert_to_src_size) -> ObjectsDetected:
-        settings = detection_session.settings
+    def detect(self, frame, settings: Any, detection_session: OpenCVDetectionSession, src_size, convert_to_src_size) -> ObjectsDetected:
         area, threshold, interval, blur = self.parse_settings(settings)
 
-        # see get_detection_input_size on undocumented size requirements for GRAY8
-        if self.color2Gray != None:
-            detection_session.gray = cv2.cvtColor(
-                frame, self.color2Gray, dst=detection_session.gray)
-            gray = detection_session.gray
-        else:
-            gray = frame
+        gray = frame
         detection_session.curFrame = cv2.GaussianBlur(
             gray, (blur, blur), 0, dst=detection_session.curFrame)
 
@@ -154,8 +153,8 @@ class OpenCVPlugin(DetectPlugin):
             # if w * h != contour_area:
             #     print("mismatch w/h", contour_area - w * h)
 
-            x2, y2, _ = convert_to_src_size((x + w, y + h))
-            x, y, _ = convert_to_src_size((x, y))
+            x2, y2 = convert_to_src_size((x + w, y + h))
+            x, y = convert_to_src_size((x, y))
             w = x2 - x + 1
             h = y2 - y + 1
 
@@ -206,11 +205,24 @@ class OpenCVPlugin(DetectPlugin):
             detection_session.cap = None
         return super().end_session(detection_session)
 
-    async def run_detection_image(self, detection_session: DetectionSession, image: Image.Image, settings: Any, src_size, convert_to_src_size) -> Tuple[ObjectsDetected, Any]:
-        # todo
-        raise Exception('can not run motion detection on image')
-    
-    async def run_detection_videoframe(self, videoFrame: VideoFrame, detection_session: OpenCVDetectionSession) -> ObjectsDetected:
+    async def generateObjectDetections(self, videoFrames: Any, session: ObjectDetectionGeneratorSession = None) -> Any:
+        try:
+            ds = OpenCVDetectionSession()
+            videoFrames = await scrypted_sdk.sdk.connectRPCObject(videoFrames)
+            async for videoFrame in videoFrames:
+               detected = await self.run_detection_videoframe(videoFrame, session and session.get('settings'), ds)
+               yield {
+                   '__json_copy_serialize_children': True,
+                   'detected': detected,
+                   'videoFrame': videoFrame,
+               }
+        finally:
+            try:
+                await videoFrames.aclose()
+            except:
+                pass
+
+    async def run_detection_videoframe(self, videoFrame: VideoFrame, settings: Any, detection_session: OpenCVDetectionSession) -> ObjectsDetected:
         width = videoFrame.width
         height = videoFrame.height
 
@@ -234,64 +246,26 @@ class OpenCVPlugin(DetectPlugin):
                 'height': height,
             }
 
+        format = videoFrame.format or 'gray'
         buffer = await videoFrame.toBuffer({
             'resize': resize,
+            'format': format,
         })
 
-        def convert_to_src_size(point, normalize = False):
-            return point[0] * scale, point[1] * scale, True
-        mat = np.ndarray((height, width, self.pixelFormatChannelCount), buffer=buffer, dtype=np.uint8)
-        detections = self.detect(
-            detection_session, mat, (width, height), convert_to_src_size)
-        return detections
-
-    async def run_detection_avframe(self, detection_session: DetectionSession, avframe, settings: Any, src_size, convert_to_src_size) -> Tuple[ObjectsDetected, Any]:
-        if avframe.format.name != 'yuv420p' and avframe.format.name != 'yuvj420p':
-            mat = avframe.to_ndarray(format='gray8')
+        if format == 'gray':
+            expectedLength = width * height
+            # check if resize could not be completed
+            if expectedLength != len(buffer):
+                image = Image.frombuffer('L', (videoFrame.width, videoFrame.height), buffer)
+                try:
+                    buffer = image.resize((width, height), Image.BILINEAR).tobytes()
+                finally:
+                    image.close()
         else:
-            mat = np.ndarray((avframe.height, avframe.width, self.pixelFormatChannelCount), buffer=avframe.planes[0], dtype=np.uint8)
-        detections = self.detect(
-            detection_session, mat, src_size, convert_to_src_size)
-        if not detections or not len(detections['detections']):
-            await self.detection_sleep(settings)
-            return None, None
-        return detections, None
+            buffer = await ensureGrayData(buffer, (width, height), format)
 
-    async def run_detection_gstsample(self, detection_session: OpenCVDetectionSession, gst_sample, settings: Any, src_size, convert_to_src_size) -> ObjectsDetected:
-        buf = gst_sample.get_buffer()
-        caps = gst_sample.get_caps()
-        # can't trust the width value, compute the stride
-        height = caps.get_structure(0).get_value('height')
-        width = caps.get_structure(0).get_value('width')
-        result, info = buf.map(Gst.MapFlags.READ)
-        if not result:
-            return None, None
-        try:
-            mat = np.ndarray(
-                (height,
-                 width,
-                 self.pixelFormatChannelCount),
-                buffer=info.data,
-                dtype=np.uint8)
-            detections = self.detect(
-                detection_session, mat, src_size, convert_to_src_size)
-            # no point in triggering empty events.
-        finally:
-            buf.unmap(info)
-
-        if not detections or not len(detections['detections']):
-            await self.detection_sleep(settings)
-            return None, None
-        return detections, None
-
-    def create_detection_session(self):
-        return OpenCVDetectionSession()
-
-    async def detection_sleep(self, settings: Any):
-        area, threshold, interval, blur = self.parse_settings(settings)
-        # it is safe to block here because gstreamer creates a queue thread
-        await asyncio.sleep(interval / 1000)
-
-    async def detection_event_notified(self, settings: Any):
-        await self.detection_sleep(settings)
-        return await super().detection_event_notified(settings)
+        def convert_to_src_size(point):
+            return point[0] * scale, point[1] * scale
+        mat = np.ndarray((height, width, 1), buffer=buffer, dtype=np.uint8)
+        detections = self.detect(mat, settings, detection_session, (videoFrame.width, videoFrame.height), convert_to_src_size)
+        return detections

plugins/opencv/src/pipeline

@@ -1 +0,0 @@
-../../tensorflow-lite/src/pipeline

plugins/opencv/src/requirements.txt

@@ -3,10 +3,6 @@ numpy>=1.16.2
 # pillow for anything not intel linux
 Pillow>=5.4.1; sys_platform != 'linux' or platform_machine != 'x86_64'
 pillow-simd; sys_platform == 'linux' and platform_machine == 'x86_64'
-PyGObject>=3.30.4; sys_platform != 'win32'
 imutils>=0.5.0
 # not available on armhf
-av>=10.0.0; sys_platform != 'linux' or platform_machine == 'x86_64' or platform_machine == 'aarch64'
-# not available on armhf
-opencv-python; sys_platform != 'linux' or platform_machine == 'x86_64' or platform_machine == 'aarch64'
-
+opencv-python; sys_platform != 'linux' or platform_machine == 'x86_64'

plugins/pam-diff/package-lock.json

@@ -1,12 +1,12 @@
 {
    "name": "@scrypted/pam-diff",
-   "version": "0.0.18",
+   "version": "0.0.20",
    "lockfileVersion": 2,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/pam-diff",
-         "version": "0.0.18",
+         "version": "0.0.20",
          "hasInstallScript": true,
          "dependencies": {
             "@types/node": "^16.6.1",

plugins/pam-diff/package.json

@@ -43,5 +43,5 @@
    "devDependencies": {
       "@scrypted/sdk": "file:../../sdk"
    },
-   "version": "0.0.18"
+   "version": "0.0.20"
 }

plugins/pam-diff/src/main.ts

@@ -9,7 +9,7 @@ import { PassThrough, Writable } from 'stream';
 const { mediaManager } = sdk;
 
 const defaultDifference = 9;
-const defaultPercentage = 15;
+const defaultPercentage = 2;
 
 interface PamDiffSession {
     id: string;

plugins/prebuffer-mixin/.vscode/launch.json

@@ -10,7 +10,7 @@
             "port": 10081,
             "request": "attach",
             "skipFiles": [
-                "**/plugin-remote-worker.*",
+                "**/plugin-console.*",
                 "<node_internals>/**"
             ],
             "autoAttachChildProcesses": true,

plugins/prebuffer-mixin/package-lock.json

@@ -1,12 +1,12 @@
 {
    "name": "@scrypted/prebuffer-mixin",
-   "version": "0.9.77",
+   "version": "0.9.80",
    "lockfileVersion": 2,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/prebuffer-mixin",
-         "version": "0.9.77",
+         "version": "0.9.80",
          "license": "Apache-2.0",
          "dependencies": {
             "@scrypted/common": "file:../../common",

plugins/prebuffer-mixin/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@scrypted/prebuffer-mixin",
-   "version": "0.9.77",
+   "version": "0.9.80",
    "description": "Video Stream Rebroadcast, Prebuffer, and Management Plugin for Scrypted.",
    "author": "Scrypted",
    "license": "Apache-2.0",

plugins/prebuffer-mixin/src/file-rtsp-server.ts

@@ -1,5 +1,7 @@
+import { Deferred } from "@scrypted/common/src/deferred";
 import { Headers, RtspServer } from "@scrypted/common/src/rtsp-server";
 import fs from 'fs';
+import { format } from "path";
 import { Duplex } from "stream";
 
 // non standard extension that dumps the rtp payload to a file.
@@ -28,17 +30,49 @@ export class FileRtspServer extends RtspServer {
         ws?.end(() => ws?.destroy());
     }
 
-    write(url: string, requestHeaders: Headers) {
-        this.cleanup();
-        this.segmentBytesWritten = 0;
-
+    async write(url: string, requestHeaders: Headers) {
         const file = requestHeaders['x-scrypted-rtsp-file'];
 
         if (!file)
             return this.respond(400, 'Bad Request', requestHeaders, {});
 
+        const truncate = requestHeaders['x-scrypted-rtsp-file-truncate'];
+
         // this.writeConsole?.log('RTSP WRITE file', file);
-        this.writeStream = fs.createWriteStream(file);
+
+        // truncation preparation must happen before cleanup.
+        let truncateWriteStream: fs.WriteStream;
+        if (truncate) {
+            try {
+                const d = new Deferred<number>();
+                fs.open(truncate, 'w', (e, fd) => {
+                    if (e)
+                        d.reject(e);
+                    else
+                        d.resolve(fd);
+                });
+                const fd = await d.promise;
+                try {
+                    await fs.promises.rename(truncate, file);
+                    truncateWriteStream = fs.createWriteStream(undefined, {
+                        fd,
+                    })
+                    // this.writeConsole?.log('truncating', truncate);
+                }
+                catch (e) {
+                    throw e;
+                }
+            }
+            catch (e) {
+                this.writeConsole?.error('RTSP WRITE error during truncate file', truncate, e);
+            }
+        }
+
+        // everything after this point must be sync due to cleanup potentially causing dangling state.
+        this.cleanup();
+        this.segmentBytesWritten = 0;
+
+        this.writeStream = truncateWriteStream || fs.createWriteStream(file);
         this.writeStream.on('error', e => {
             this.writeConsole?.error('RTSP WRITE error', e);
         });

plugins/prebuffer-mixin/src/main.ts

@@ -3,7 +3,7 @@ import { AutoenableMixinProvider } from '@scrypted/common/src/autoenable-mixin-p
 import { getDebugModeH264EncoderArgs, getH264EncoderArgs } from '@scrypted/common/src/ffmpeg-hardware-acceleration';
 import { addVideoFilterArguments } from '@scrypted/common/src/ffmpeg-helpers';
 import { handleRebroadcasterClient, ParserOptions, ParserSession, startParserSession } from '@scrypted/common/src/ffmpeg-rebroadcast';
-import { closeQuiet, listenZeroSingleClient } from '@scrypted/common/src/listen-cluster';
+import { closeQuiet, listenZeroSingleClient, ListenZeroSingleClientTimeoutError } from '@scrypted/common/src/listen-cluster';
 import { readLength } from '@scrypted/common/src/read-stream';
 import { createRtspParser, findH264NaluType, getNaluTypes, H264_NAL_TYPE_FU_B, H264_NAL_TYPE_IDR, H264_NAL_TYPE_MTAP16, H264_NAL_TYPE_MTAP32, H264_NAL_TYPE_RESERVED0, H264_NAL_TYPE_RESERVED30, H264_NAL_TYPE_RESERVED31, H264_NAL_TYPE_SEI, H264_NAL_TYPE_STAP_B, listenSingleRtspClient, RtspServer, RtspTrack } from '@scrypted/common/src/rtsp-server';
 import { addTrackControls, parseSdp } from '@scrypted/common/src/sdp-utils';
@@ -946,23 +946,35 @@ class PrebufferSession {
     const { isActiveClient, container, session, socketPromise, requestedPrebuffer } = options;
     this.console.log('sending prebuffer', requestedPrebuffer);
 
-    // in case the client never connects, do an inactivity check.
-    socketPromise.catch(() => this.inactivityCheck(session, false));
-    socketPromise.then(socket => {
+    let socket: Duplex;
+
+    try {
+      socket = await socketPromise;
+    }
+    catch (e) {
+      // in case the client never connects, do an inactivity check.
+      this.inactivityCheck(session, false);
+      if (e instanceof ListenZeroSingleClientTimeoutError)
+        this.console.warn('client connection timed out');
+      else
+        this.console.error('client connection error', e);
+      return;
+    }
+
+    if (isActiveClient) {
+      this.activeClients++;
+      this.printActiveClients();
+    }
+
+    socket.once('close', () => {
       if (isActiveClient) {
-        this.activeClients++;
+        this.activeClients--;
         this.printActiveClients();
       }
-      socket.once('close', () => {
-        if (isActiveClient) {
-          this.activeClients--;
-          this.printActiveClients();
-        }
-        this.inactivityCheck(session, isActiveClient);
-      })
+      this.inactivityCheck(session, isActiveClient);
     });
 
-    handleRebroadcasterClient(socketPromise, {
+    handleRebroadcasterClient(socket, {
       // console: this.console,
       connect: (connection) => {
         const now = Date.now();
@@ -1138,7 +1150,7 @@ class PrebufferSession {
         }
         // server.console = this.console;
         await server.handlePlayback();
-        server.handleTeardown().finally(() => server.client.destroy());
+        server.handleTeardown().catch(() => {}).finally(() => server.client.destroy());
         for (const track of Object.values(server.setupTracks)) {
           if (track.protocol === 'udp') {
             serverPortMap.set(track.codec, track);

plugins/prebuffer-mixin/src/stream-settings.ts

@@ -111,7 +111,7 @@ export function createStreamSettings(device: MixinDeviceBase<VideoCamera>) {
             placeholder: '-hwaccel auto',
             choices: Object.keys(getH264DecoderArgs()),
             combobox: true,
-            mapPut: (oldValue, newValue) => getH264DecoderArgs()[newValue]?.join(' ') || newValue,
+            mapPut: (oldValue, newValue) => getH264DecoderArgs()[newValue]?.join(' ') || newValue || '',
             hide: true,
         },
         videoFilterArguments: {

plugins/python-codecs/package-lock.json

@@ -1,12 +1,12 @@
 {
    "name": "@scrypted/python-codecs",
-   "version": "0.1.22",
+   "version": "0.1.30",
    "lockfileVersion": 3,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/python-codecs",
-         "version": "0.1.22",
+         "version": "0.1.30",
          "devDependencies": {
             "@scrypted/sdk": "file:../../sdk"
          }

plugins/python-codecs/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@scrypted/python-codecs",
-   "version": "0.1.22",
+   "version": "0.1.30",
    "description": "Python Codecs for Scrypted",
    "keywords": [
       "scrypted",

plugins/python-codecs/src/main.py

@@ -1,3 +1,4 @@
+import traceback
 import asyncio
 import scrypted_sdk
 from scrypted_sdk import Setting, SettingValue
@@ -6,6 +7,7 @@ import gstreamer
 import libav
 import vipsimage
 import pilimage
+import time
 
 Gst = None
 try:
@@ -128,19 +130,29 @@ def create_scrypted_plugin():
 
 class CodecFork:
     async def generateVideoFramesGstreamer(self, mediaObject: scrypted_sdk.MediaObject, options: scrypted_sdk.VideoFrameGeneratorOptions = None, filter: Any = None, h264Decoder: str = None) -> scrypted_sdk.VideoFrame:
+        start = time.time()
         try:
             async for data in gstreamer.generateVideoFramesGstreamer(mediaObject, options, filter, h264Decoder):
                 yield data
+        except Exception as e:
+            traceback.print_exc()
+            raise
         finally:
+            print('gstreamer finished after %s' % (time.time() - start))
             import os
             os._exit(os.EX_OK)
             pass
 
     async def generateVideoFramesLibav(self, mediaObject: scrypted_sdk.MediaObject, options: scrypted_sdk.VideoFrameGeneratorOptions = None, filter: Any = None) -> scrypted_sdk.VideoFrame:
+        start = time.time()
         try:
             async for data in libav.generateVideoFramesLibav(mediaObject, options, filter):
                 yield data
+        except Exception as e:
+            traceback.print_exc()
+            raise
         finally:
+            print('libav finished after %s' % (time.time() - start))
             import os
             os._exit(os.EX_OK)
             pass

plugins/python-codecs/src/pilimage.py

@@ -26,7 +26,7 @@ class PILImage(scrypted_sdk.VideoFrame):
         elif options['format'] == 'rgb':
             def format():
                 rgbx = pilImage.pilImage
-                if rgbx.format != 'RGBA':
+                if rgbx.mode != 'RGBA':
                     return rgbx.tobytes()
                 rgb = rgbx.convert('RGB')
                 try:
@@ -37,7 +37,8 @@ class PILImage(scrypted_sdk.VideoFrame):
 
         def save():
             bytesArray = io.BytesIO()
-            pilImage.pilImage.save(bytesArray, format=options['format'])
+            pilImage.pilImage.save(bytesArray, format='JPEG')
+            # pilImage.pilImage.save(bytesArray, format=options['format'])
             return bytesArray.getvalue()
 
         return await to_thread(lambda: save())
@@ -96,6 +97,7 @@ class ImageReader(scrypted_sdk.ScryptedDeviceBase, scrypted_sdk.BufferConverter)
 
     async def convert(self, data: Any, fromMimeType: str, toMimeType: str, options: scrypted_sdk.MediaObjectOptions = None) -> Any:
         pil = Image.open(io.BytesIO(data))
+        pil.load()
         return await createPILMediaObject(PILImage(pil))
 
 class ImageWriter(scrypted_sdk.ScryptedDeviceBase, scrypted_sdk.BufferConverter):

plugins/python-codecs/src/requirements.txt

@@ -1,3 +1,6 @@
+# needed by libav to_ndarray
+numpy>=1.16.2
+
 # gobject instrospection for gstreamer.
 PyGObject>=3.30.4; sys_platform != 'win32'
 

plugins/python-codecs/src/vipsimage.py

@@ -31,6 +31,10 @@ class VipsImage(scrypted_sdk.VideoFrame):
                 mem = memoryview(rgb.write_to_memory())
                 return mem
             return await to_thread(format)
+        elif options['format'] == 'gray':
+            def format():
+                return memoryview(vipsImage.vipsImage.write_to_memory())
+            return await to_thread(format)
 
         return await to_thread(lambda: vipsImage.vipsImage.write_to_buffer('.' + options['format']))
 

plugins/reolink/package-lock.json

@@ -1,12 +1,12 @@
 {
    "name": "@scrypted/reolink",
-   "version": "0.0.17",
+   "version": "0.0.19",
    "lockfileVersion": 2,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/reolink",
-         "version": "0.0.17",
+         "version": "0.0.19",
          "license": "Apache",
          "dependencies": {
             "@koush/axios-digest-auth": "^0.8.5",

plugins/reolink/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@scrypted/reolink",
-   "version": "0.0.17",
+   "version": "0.0.19",
    "description": "Reolink Plugin for Scrypted",
    "author": "Scrypted",
    "license": "Apache",

plugins/reolink/src/main.ts

@@ -115,6 +115,20 @@ class ReolinkCamera extends RtspSmartCamera implements Camera {
             });
         }
 
+        // rough guesses for rebroadcast stream selection.
+        ret[0].video = {
+            width: 2560,
+            height: 1920,
+        }
+        ret[1].video = {
+            width: 896,
+            height: 672,
+        }
+        ret[2].video = {
+            width: 640,
+            height: 480,
+        }
+
         const channel = (this.getRtspChannel() + 1).toString().padStart(2, '0');
         const rtspPreviews = [
             `h264Preview_${channel}_main`,

plugins/ring/.vscode/settings.json

@@ -1,4 +1,4 @@
 
 {
-    "scrypted.debugHost": "koushik-ubuntu",
+    "scrypted.debugHost": "127.0.0.1",
 }

plugins/ring/package-lock.json

@@ -1,12 +1,12 @@
 {
    "name": "@scrypted/ring",
-   "version": "0.0.106",
+   "version": "0.0.107",
    "lockfileVersion": 3,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/ring",
-         "version": "0.0.106",
+         "version": "0.0.107",
          "dependencies": {
             "@koush/ring-client-api": "file:../../external/ring-client-api",
             "@scrypted/common": "file:../../common",

plugins/ring/package.json

@@ -44,5 +44,5 @@
       "got": "11.8.6",
       "socket.io-client": "^2.5.0"
    },
-   "version": "0.0.106"
+   "version": "0.0.107"
 }

plugins/ring/src/camera.ts

@@ -702,7 +702,6 @@ export class RingCameraDevice extends ScryptedDeviceBase implements DeviceProvid
     }
 
     async getVideoClips(options?: VideoClipOptions): Promise<VideoClip[]> {
-        this.videoClips = new Map<string, VideoClip>;
         const response = await this.camera.videoSearch({
             dateFrom: options.startTime, 
             dateTo: options.endTime,

plugins/tensorflow-lite/src/detect/__init__.py

@@ -75,6 +75,3 @@ class DetectPlugin(scrypted_sdk.ScryptedDeviceBase, ObjectDetection):
             vf = await scrypted_sdk.mediaManager.convertMediaObjectToBuffer(mediaObject, ScryptedMimeTypes.Image.value)
 
         return await self.run_detection_videoframe(vf, session)
-
-    def get_pixel_format(self):
-        return 'RGB'

plugins/tensorflow-lite/src/predict/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import concurrent.futures
 import os
 import re
 import urllib.request
@@ -16,15 +17,24 @@ from detect import DetectPlugin
 from .rectangle import (Rectangle, combine_rect, from_bounding_box,
                         intersect_area, intersect_rect, to_bounding_box)
 
-def ensureRGBData(data: bytes, size: Tuple[int, int], format: str):
-    if format == 'rgba':
+# vips is already multithreaded, but needs to be kicked off the python asyncio thread.
+toThreadExecutor = concurrent.futures.ThreadPoolExecutor(max_workers=2, thread_name_prefix="image")
+
+async def to_thread(f):
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(toThreadExecutor, f)
+
+async def ensureRGBData(data: bytes, size: Tuple[int, int], format: str):
+    if format != 'rgba':
+        return Image.frombuffer('RGB', size, data)
+
+    def convert():
         rgba = Image.frombuffer('RGBA', size, data)
         try:
             return rgba.convert('RGB')
         finally:
             rgba.close()
-    else:
-        return Image.frombuffer('RGB', size, data)
+    return await to_thread(convert)
 
 def parse_label_contents(contents: str):
     lines = contents.splitlines()
@@ -190,12 +200,9 @@ class PredictPlugin(DetectPlugin, scrypted_sdk.BufferConverter, scrypted_sdk.Set
             detection_result['detections'] = []
             for detection in detections:
                 bb = detection['boundingBox']
-                x, y, valid = convert_to_src_size((bb[0], bb[1]), True)
-                x2, y2, valid2 = convert_to_src_size(
-                    (bb[0] + bb[2], bb[1] + bb[3]), True)
-                if not valid or not valid2:
-                    # print("filtering out", detection['className'])
-                    continue
+                x, y = convert_to_src_size((bb[0], bb[1]))
+                x2, y2 = convert_to_src_size(
+                    (bb[0] + bb[2], bb[1] + bb[3]))
                 detection['boundingBox'] = (x, y, x2 - x + 1, y2 - y + 1)
                 detection_result['detections'].append(detection)
 
@@ -224,13 +231,13 @@ class PredictPlugin(DetectPlugin, scrypted_sdk.BufferConverter, scrypted_sdk.Set
         hs = h / ih
         s = max(ws, hs)
         if ws == 1 and hs == 1:
-            def cvss(point, normalize=False):
-                return point[0], point[1], True
+            def cvss(point):
+                return point[0], point[1]
 
             data = await videoFrame.toBuffer({
                 'format': videoFrame.format or 'rgb',
             })
-            image = ensureRGBData(data, (w, h), videoFrame.format)
+            image = await ensureRGBData(data, (w, h), videoFrame.format)
             try:
                 ret = await self.detect_once(image, settings, src_size, cvss)
                 return ret
@@ -275,13 +282,15 @@ class PredictPlugin(DetectPlugin, scrypted_sdk.BufferConverter, scrypted_sdk.Set
             })
         )
 
-        first = ensureRGBData(firstData, (w, h), videoFrame.format)
-        second = ensureRGBData(secondData, (w, h), videoFrame.format)
+        first, second = await asyncio.gather(
+            ensureRGBData(firstData, (w, h), videoFrame.format),
+            ensureRGBData(secondData, (w, h), videoFrame.format)
+        )
 
-        def cvss1(point, normalize=False):
-            return point[0] / s, point[1] / s, True
-        def cvss2(point, normalize=False):
-            return point[0] / s + ow, point[1] / s + oh, True
+        def cvss1(point):
+            return point[0] / s, point[1] / s
+        def cvss2(point):
+            return point[0] / s + ow, point[1] / s + oh
 
         ret1 = await self.detect_once(first, settings, src_size, cvss1)
         first.close()

plugins/tensorflow/package-lock.json

@@ -1,12 +1,12 @@
 {
    "name": "@scrypted/tensorflow-lite",
-   "version": "0.1.7",
+   "version": "0.1.8",
    "lockfileVersion": 2,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/tensorflow-lite",
-         "version": "0.1.7",
+         "version": "0.1.8",
          "devDependencies": {
             "@scrypted/sdk": "file:../../sdk"
          }

plugins/tensorflow/package.json

@@ -41,5 +41,5 @@
    "devDependencies": {
       "@scrypted/sdk": "file:../../sdk"
    },
-   "version": "0.1.7"
+   "version": "0.1.8"
 }

plugins/tensorflow/src/pipeline

@@ -1 +0,0 @@
-../../tensorflow-lite/src/pipeline

plugins/tensorflow/src/requirements.txt

@@ -1,14 +1,8 @@
-# plugin
-numpy>=1.16.2
-# pillow for anything not intel linux
-Pillow>=5.4.1; sys_platform != 'linux' or platform_machine != 'x86_64'
-pillow-simd; sys_platform == 'linux' and platform_machine == 'x86_64'
 tensorflow-macos; sys_platform == 'darwin'
 tensorflow; sys_platform != 'darwin'
-PyGObject>=3.30.4; sys_platform != 'win32'
-# not available on armhf
-av>=10.0.0; sys_platform != 'linux' or platform_machine == 'x86_64' or platform_machine == 'aarch64'
 
-# sort_oh
-scipy
-filterpy
+numpy>=1.16.2
+
+# pillow for anything not intel linux, pillow-simd is available on x64 linux
+Pillow>=5.4.1; sys_platform != 'linux' or platform_machine != 'x86_64'
+pillow-simd; sys_platform == 'linux' and platform_machine == 'x86_64'

plugins/unifi-protect/package-lock.json

@@ -1,12 +1,12 @@
 {
    "name": "@scrypted/unifi-protect",
-   "version": "0.0.131",
+   "version": "0.0.132",
    "lockfileVersion": 2,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/unifi-protect",
-         "version": "0.0.131",
+         "version": "0.0.132",
          "license": "Apache",
          "dependencies": {
             "@koush/unifi-protect": "file:../../external/unifi-protect",
@@ -61,7 +61,7 @@
       },
       "../../sdk": {
          "name": "@scrypted/sdk",
-         "version": "0.2.68",
+         "version": "0.2.86",
          "license": "ISC",
          "dependencies": {
             "@babel/preset-typescript": "^7.18.6",

plugins/unifi-protect/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@scrypted/unifi-protect",
-   "version": "0.0.131",
+   "version": "0.0.132",
    "description": "Unifi Protect Plugin for Scrypted",
    "author": "Scrypted",
    "license": "Apache",

plugins/unifi-protect/src/camera.ts

@@ -1,6 +1,6 @@
 import { ffmpegLogInitialOutput, safeKillFFmpeg } from '@scrypted/common/src/media-helpers';
 import { fitHeightToWidth } from "@scrypted/common/src/resolution-utils";
-import sdk, { Camera, DeviceProvider, FFmpegInput, Intercom, MediaObject, MediaStreamOptions, MediaStreamUrl, MotionSensor, Notifier, NotifierOptions, ObjectDetectionTypes, ObjectDetector, ObjectsDetected, OnOff, PictureOptions, ResponseMediaStreamOptions, ResponsePictureOptions, ScryptedDeviceBase, ScryptedInterface, ScryptedMimeTypes, Setting, Settings, VideoCamera, VideoCameraConfiguration } from "@scrypted/sdk";
+import sdk, { Camera, DeviceProvider, FFmpegInput, Intercom, MediaObject, MediaStreamOptions, MediaStreamUrl, MotionSensor, Notifier, NotifierOptions, ObjectDetectionTypes, ObjectDetector, ObjectsDetected, OnOff, Online, PanTiltZoom, PanTiltZoomCommand, PictureOptions, ResponseMediaStreamOptions, ResponsePictureOptions, ScryptedDeviceBase, ScryptedInterface, ScryptedMimeTypes, Setting, Settings, VideoCamera, VideoCameraConfiguration } from "@scrypted/sdk";
 import child_process, { ChildProcess } from 'child_process';
 import { once } from "events";
 import { Readable } from "stream";
@@ -38,7 +38,7 @@ export class UnifiPackageCamera extends ScryptedDeviceBase implements Camera, Vi
     }
 }
 
-export class UnifiCamera extends ScryptedDeviceBase implements Notifier, Intercom, Camera, VideoCamera, VideoCameraConfiguration, MotionSensor, Settings, ObjectDetector, DeviceProvider, OnOff {
+export class UnifiCamera extends ScryptedDeviceBase implements Notifier, Intercom, Camera, VideoCamera, VideoCameraConfiguration, MotionSensor, Settings, ObjectDetector, DeviceProvider, OnOff, PanTiltZoom, Online {
     motionTimeout: NodeJS.Timeout;
     detectionTimeout: NodeJS.Timeout;
     ringTimeout: NodeJS.Timeout;
@@ -61,6 +61,15 @@ export class UnifiCamera extends ScryptedDeviceBase implements Notifier, Interco
         this.updateState(protectCamera);
     }
 
+    async ptzCommand(command: PanTiltZoomCommand): Promise<void> {
+        const camera = this.findCamera() as any;
+        await this.protect.api.updateCamera(camera, {
+            ispSettings: {
+                zoomPosition: Math.abs(command.zoom * 100),
+            }
+        });
+    }
+
     async setStatusLight(on: boolean) {
         const camera = this.findCamera() as any;
         await this.protect.api.updateCamera(camera, {
@@ -411,6 +420,11 @@ export class UnifiCamera extends ScryptedDeviceBase implements Notifier, Interco
         if (!camera)
             return;
         this.on = !!camera.ledSettings?.isEnabled;
+        this.online = !!camera.isConnected;
         this.setMotionDetected(!!camera.isMotionDetected);
+
+        if (!!camera.featureFlags.canOpticalZoom) {
+            this.ptzCapabilities = { pan: false, tilt: false, zoom: true };
+        }
     }
 }

plugins/unifi-protect/src/main.ts

@@ -376,6 +376,9 @@ export class UnifiProtect extends ScryptedDeviceBase implements Settings, Device
                 if (camera.featureFlags.hasLedStatus) {
                     d.interfaces.push(ScryptedInterface.OnOff);
                 }
+                if (camera.featureFlags.canOpticalZoom) {
+                    d.interfaces.push(ScryptedInterface.PanTiltZoom);
+                }
                 d.interfaces.push(ScryptedInterface.ObjectDetector);
                 devices.push(d);
             }

plugins/webrtc/.vscode/settings.json

@@ -1,4 +1,4 @@
 
 {
-    "scrypted.debugHost": "127.0.0.1",
+    "scrypted.debugHost": "koushik-ubuntu",
 }

plugins/webrtc/package-lock.json

@@ -1,12 +1,12 @@
 {
    "name": "@scrypted/webrtc",
-   "version": "0.1.37",
+   "version": "0.1.41",
    "lockfileVersion": 2,
    "requires": true,
    "packages": {
       "": {
          "name": "@scrypted/webrtc",
-         "version": "0.1.37",
+         "version": "0.1.41",
          "dependencies": {
             "@scrypted/common": "file:../../common",
             "@scrypted/sdk": "file:../../sdk",

plugins/webrtc/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@scrypted/webrtc",
-   "version": "0.1.37",
+   "version": "0.1.41",
    "scripts": {
       "scrypted-setup-project": "scrypted-setup-project",
       "prescrypted-setup-project": "scrypted-package-json",

plugins/webrtc/src/ffmpeg-to-wrtc.ts

@@ -4,7 +4,7 @@ import { Deferred } from "@scrypted/common/src/deferred";
 import sdk, { FFmpegInput, FFmpegTranscodeStream, Intercom, MediaObject, MediaStreamDestination, MediaStreamFeedback, RequestMediaStream, RTCAVSignalingSetup, RTCConnectionManagement, RTCMediaObjectTrack, RTCSignalingOptions, RTCSignalingSession, ScryptedDevice, ScryptedMimeTypes } from "@scrypted/sdk";
 import { ScryptedSessionControl } from "./session-control";
 import { requiredAudioCodecs, requiredVideoCodec } from "./webrtc-required-codecs";
-import { logIsPrivateIceTransport } from "./werift-util";
+import { isPrivateIceTransport, logIsPrivateIceTransport } from "./werift-util";
 
 import { addVideoFilterArguments } from "@scrypted/common/src/ffmpeg-helpers";
 import { connectRTCSignalingClients } from "@scrypted/common/src/rtc-signaling";
@@ -431,10 +431,6 @@ export class WebRTCConnectionManagement implements RTCConnectionManagement {
         waitConnected(this.pc)
             .then(() => logIsPrivateIceTransport(this.console, this.pc)).catch(() => {});
 
-        this.pc.signalingStateChange.subscribe(() => {
-            this.console.log('sig change', this.pc.signalingState);
-        })
-
         this.weriftSignalingSession = new WeriftSignalingSession(console, this.pc);
     }
 
@@ -469,7 +465,7 @@ export class WebRTCConnectionManagement implements RTCConnectionManagement {
             createTrackForwarder: async (videoTransceiver: RTCRtpTransceiver, audioTransceiver: RTCRtpTransceiver) => {
                 const ret = await createTrackForwarder({
                     timeStart,
-                    ...logIsPrivateIceTransport(console, this.pc),
+                    ...isPrivateIceTransport(this.pc),
                     requestMediaStream,
                     videoTransceiver,
                     audioTransceiver,
@@ -582,7 +578,7 @@ export async function createRTCPeerConnectionSink(
     clientOffer = true,
 ) {
     const clientOptions = await clientSignalingSession.getOptions();
-    console.log('remote options', clientOptions);
+    // console.log('remote options', clientOptions);
 
     const connection = new WebRTCConnectionManagement(console, clientSignalingSession, maximumCompatibilityMode, clientOptions, {
         configuration,

plugins/webrtc/src/main.ts

@@ -128,6 +128,7 @@ class WebRTCMixin extends SettingsMixinDeviceBase<RTCSignalingClient & VideoCame
             this.plugin.storageSettings.values.maximumCompatibilityMode,
             this.plugin.getRTCConfiguration(),
             await this.plugin.getWeriftConfiguration(options?.disableTurn),
+            options?.requiresAnswer === true ? false : true,
         );
     }
 
@@ -223,6 +224,10 @@ export class WebRTCPlugin extends AutoenableMixinProvider implements DeviceCreat
             type: 'textarea',
             description: "RTCConfiguration that can be used to specify custom TURN and STUN servers. https://gist.github.com/koush/631d38ac8647a86baaac7b22d863f010",
         },
+        debugLog: {
+            title: 'Debug Log',
+            type: 'boolean',
+        }
     });
     bridge: WebRTCBridge;
     activeConnections = 0;

plugins/webrtc/src/rtp-forwarders.ts

@@ -1,3 +1,4 @@
+import { RtpPacket } from "../../../external/werift/packages/rtp/src/rtp/rtp";
 import { Deferred } from "@scrypted/common/src/deferred";
 import { closeQuiet, createBindZero, listenZeroSingleClient, reserveUdpPort } from "@scrypted/common/src/listen-cluster";
 import { ffmpegLogInitialOutput, safeKillFFmpeg, safePrintFFmpegArguments } from "@scrypted/common/src/media-helpers";
@@ -232,8 +233,6 @@ export async function startRtpForwarderProcess(console: Console, ffmpegInput: FF
                         // if the rtsp client is over tcp, then the restream server must also be tcp, as
                         // the rtp packets (which can be a max of 64k) may be too large for udp.
                         const clientIsTcp = await setupRtspClient(console, rtspClient, channel, audioSection, false, rtp => {
-                            const payload = rtp.subarray(12);
-
                             // live555 sends rtp aac packets without AU header followed by ADTS packets (which contain codec info)
                             // which ffmpeg can not handle.
                             // the solution is to demux the adts and send that to ffmpeg raw.
@@ -241,8 +240,10 @@ export async function startRtpForwarderProcess(console: Console, ffmpegInput: FF
                             if (firstPacket) {
                                 firstPacket = false;
                                 if (audioSection.codec === 'aac') {
+                                    const packet = RtpPacket.deSerialize(rtp);
+                                    const buf = packet.payload;
                                     // adts header is 12 bits of 1s
-                                    if (payload[0] == 0xff && (payload[1] & 0xf0) == 0xf0) {
+                                    if (buf[0] == 0xff && (buf[1] & 0xf0) == 0xf0) {
                                         adts = true;
                                         allowAudioTranscoderExit = true;
                                         const ffmpegArgs = [
@@ -270,7 +271,8 @@ export async function startRtpForwarderProcess(console: Console, ffmpegInput: FF
                                 rtspServer?.sendTrack(audioControl, rtp, false);
                             }
                             else {
-                                audioPipe?.write(payload);
+                                const packet = RtpPacket.deSerialize(rtp);
+                                audioPipe?.write(packet.payload);
                             }
                         });
 

plugins/webrtc/src/werift-util.ts

@@ -42,20 +42,15 @@ export function getWeriftIceServers(configuration: RTCConfiguration): RTCIceServ
     return ret;
 }
 
-export function logIsPrivateIceTransport(console: Console, pc: RTCPeerConnection) {
+export function isPrivateIceTransport(pc: RTCPeerConnection) {
     let isPrivate = true;
     let destinationId: string;
     for (const ice of pc.iceTransports) {
         const [address, port] = (ice.connection as any).nominated[1].remoteAddr;
         if (!destinationId)
             destinationId = address;
-        const { turnServer } = ice.connection;
         isPrivate = isPrivate && ip.isPrivate(address);
-        console.log('ice transport ip', {
-            address,
-            port,
-            turnServer: !!turnServer,
-        });
+
     }
     console.log('Connection is local network:', isPrivate);
     const ipv4 = ip.isV4Format(destinationId);
@@ -65,3 +60,10 @@ export function logIsPrivateIceTransport(console: Console, pc: RTCPeerConnection
         destinationId,
     };
 }
+
+export function logIsPrivateIceTransport(console: Console, pc: RTCPeerConnection) {
+    const ret = isPrivateIceTransport(pc);
+    console.log('ice transport', ret);
+    console.log('Connection is local network:', ret.isPrivate);
+    return ret;
+}

sdk/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@scrypted/sdk",
-  "version": "0.2.85",
+  "version": "0.2.86",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrypted/sdk",
-      "version": "0.2.85",
+      "version": "0.2.86",
       "license": "ISC",
       "dependencies": {
         "@babel/preset-typescript": "^7.18.6",

sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrypted/sdk",
-  "version": "0.2.85",
+  "version": "0.2.86",
   "description": "",
   "main": "dist/src/index.js",
   "exports": {

sdk/types/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@scrypted/types",
-  "version": "0.2.77",
+  "version": "0.2.78",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@scrypted/types",
-      "version": "0.2.77",
+      "version": "0.2.78",
       "license": "ISC",
       "devDependencies": {
         "@types/rimraf": "^3.0.2",

sdk/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrypted/types",
-  "version": "0.2.77",
+  "version": "0.2.78",
   "description": "",
   "main": "dist/index.js",
   "author": "",