rpc: async generator should throw if yielded and when the peer has been killed. garbage collection does not trigger async generator return or throw.

prebeta
detect: connect to rpc object for every videoframe
2026-02-06 23:42:19 +00:00 · 2023-04-19 21:35:46 -07:00 · 2023-04-19 21:17:59 -07:00 · 2023-04-19 12:18:02 -07:00 · 2023-04-19 12:17:27 -07:00 · 2023-04-19 12:16:56 -07:00
19 changed files with 1085 additions and 27 deletions
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -69,12 +69,18 @@ jobs:
          tags: |
            ${{ format('koush/scrypted:{0}{1}-v{2}', matrix.BASE, matrix.SUPERVISOR, github.event.inputs.package_version || steps.package-version.outputs.current-version) }}
            ${{ matrix.BASE == '18-bullseye-full' && matrix.SUPERVISOR == '.s6' && format('koush/scrypted:{0}', github.event.inputs.docker_tag) || '' }}
+            ${{ github.event.inputs.docker_tag == 'latest' && matrix.BASE == '18-bullseye-full' && matrix.SUPERVISOR == '' && 'koush/scrypted:full' || '' }}
            ${{ github.event.inputs.docker_tag == 'latest' && matrix.BASE == '18-bullseye-lite' && matrix.SUPERVISOR == '' && 'koush/scrypted:lite' || '' }}
            ${{ github.event.inputs.docker_tag == 'latest' && matrix.BASE == '18-bullseye-thin' && matrix.SUPERVISOR == '' && 'koush/scrypted:thin' || '' }}
+            ${{ github.event.inputs.docker_tag == 'latest' && matrix.BASE == '18-bullseye-lite' && matrix.SUPERVISOR == '.s6' && 'koush/scrypted:lite-s6' || '' }}
+            ${{ github.event.inputs.docker_tag == 'latest' && matrix.BASE == '18-bullseye-thin' && matrix.SUPERVISOR == '.s6' && 'koush/scrypted:thin-s6' || '' }}

            ${{ format('ghcr.io/koush/scrypted:{0}{1}-v{2}', matrix.BASE, matrix.SUPERVISOR, github.event.inputs.package_version || steps.package-version.outputs.current-version) }}
            ${{ matrix.BASE == '18-bullseye-full' && matrix.SUPERVISOR == '.s6' && format('ghcr.io/koush/scrypted:{0}', github.event.inputs.docker_tag) || '' }}
+            ${{ github.event.inputs.docker_tag == 'latest' && matrix.BASE == '18-bullseye-full' && matrix.SUPERVISOR == '' && 'ghcr.io/koush/scrypted:full' || '' }}
            ${{ github.event.inputs.docker_tag == 'latest' && matrix.BASE == '18-bullseye-lite' && matrix.SUPERVISOR == '' && 'ghcr.io/koush/scrypted:lite' || '' }}
            ${{ github.event.inputs.docker_tag == 'latest' && matrix.BASE == '18-bullseye-thin' && matrix.SUPERVISOR == '' && 'ghcr.io/koush/scrypted:thin' || '' }}
+            ${{ github.event.inputs.docker_tag == 'latest' && matrix.BASE == '18-bullseye-lite' && matrix.SUPERVISOR == '.s6' && 'ghcr.io/koush/scrypted:lite-s6' || '' }}
+            ${{ github.event.inputs.docker_tag == 'latest' && matrix.BASE == '18-bullseye-thin' && matrix.SUPERVISOR == '.s6' && 'ghcr.io/koush/scrypted:thin-s6' || '' }}
          cache-from: type=gha
          cache-to: type=gha,mode=max
--- a/plugins/doorbird/.gitignore
+++ b/plugins/doorbird/.gitignore
@@ -0,0 +1,4 @@
+.DS_Store
+out/
+node_modules/
+dist/
--- a/plugins/doorbird/.npmignore
+++ b/plugins/doorbird/.npmignore
@@ -0,0 +1,11 @@
+.DS_Store
+out/
+node_modules/
+*.map
+fs
+src
+.vscode
+dist/*.js
+dist/*.txt
+HAP-NodeJS
+.gitmodules
--- a/plugins/doorbird/.vscode/launch.json
+++ b/plugins/doorbird/.vscode/launch.json
@@ -0,0 +1,23 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Scrypted Debugger",
+            "address": "${config:scrypted.debugHost}",
+            "port": 10081,
+            "request": "attach",
+            "skipFiles": [
+                "**/plugin-remote-worker.*",
+                "<node_internals>/**"
+            ],
+            "preLaunchTask": "scrypted: deploy+debug",
+            "sourceMaps": true,
+            "localRoot": "${workspaceFolder}/out",
+            "remoteRoot": "/plugin/",
+            "type": "node"
+        }
+    ]
+}
--- a/plugins/doorbird/.vscode/settings.json
+++ b/plugins/doorbird/.vscode/settings.json
@@ -0,0 +1,4 @@
+
+{
+    "scrypted.debugHost": "127.0.0.1",
+}
--- a/plugins/doorbird/.vscode/tasks.json
+++ b/plugins/doorbird/.vscode/tasks.json
@@ -0,0 +1,20 @@
+{
+    // See https://go.microsoft.com/fwlink/?LinkId=733558
+    // for the documentation about the tasks.json format
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "scrypted: deploy+debug",
+            "type": "shell",
+            "presentation": {
+                "echo": true,
+                "reveal": "silent",
+                "focus": false,
+                "panel": "shared",
+                "showReuseMessage": true,
+                "clear": false
+            },
+            "command": "npm run scrypted-vscode-launch ${config:scrypted.debugHost}",
+        },
+    ]
+}
--- a/plugins/doorbird/README.md
+++ b/plugins/doorbird/README.md
@@ -0,0 +1,9 @@
+# Doorbird Plugin for Scrypted
+
+The Doorbird Plugin bridges compatible Doorbird video doorbell cameras to Scrypted.
+
+# Notes
+* Make sure that the user you want to use for the Doorbird plugin login has the API access rights.
+* Doorbrid cameras are quite limited in terms of maximum number of concurrent streams. Keep this in mind if you are also using other software with the Doorbird station. You have the possibility to override the internally used RTSP URL and provide another RTSP server which provides the video stream.
+* The doorbird mobile apps always have precedence over the public LAN API. So when somebody uses the Doorbird app to talk to the Doorbird station, the streams will be interrupted.
+* The doorbird camera just provides JPEG snapshots with VGA resolution. You can use the scrypted snapshot plugin to get a snapshot from the higher resolution video stream. Just set the option in the snapshot plugin to "enabled".
--- a/plugins/doorbird/package-lock.json
+++ b/plugins/doorbird/package-lock.json
@@ -0,0 +1,264 @@
+{
+   "name": "@scrypted/doorbird",
+   "version": "0.0.1",
+   "lockfileVersion": 3,
+   "requires": true,
+   "packages": {
+      "": {
+         "name": "@scrypted/doorbird",
+         "version": "0.0.1",
+         "dependencies": {
+            "@koush/axios-digest-auth": "^0.8.5",
+            "doorbird": "^2.1.2"
+         },
+         "devDependencies": {
+            "@scrypted/common": "file:../../common",
+            "@scrypted/sdk": "file:../../sdk",
+            "@types/node": "^18.15.11"
+         }
+      },
+      "../../common": {
+         "name": "@scrypted/common",
+         "version": "1.0.1",
+         "dev": true,
+         "license": "ISC",
+         "dependencies": {
+            "@scrypted/sdk": "file:../sdk",
+            "@scrypted/server": "file:../server",
+            "http-auth-utils": "^3.0.2",
+            "node-fetch-commonjs": "^3.1.1",
+            "typescript": "^4.4.3"
+         },
+         "devDependencies": {
+            "@types/node": "^16.9.0"
+         }
+      },
+      "../../sdk": {
+         "name": "@scrypted/sdk",
+         "version": "0.2.97",
+         "dev": true,
+         "license": "ISC",
+         "dependencies": {
+            "@babel/preset-typescript": "^7.18.6",
+            "adm-zip": "^0.4.13",
+            "axios": "^0.21.4",
+            "babel-loader": "^9.1.0",
+            "babel-plugin-const-enum": "^1.1.0",
+            "esbuild": "^0.15.9",
+            "ncp": "^2.0.0",
+            "raw-loader": "^4.0.2",
+            "rimraf": "^3.0.2",
+            "tmp": "^0.2.1",
+            "ts-loader": "^9.4.2",
+            "typescript": "^4.9.4",
+            "webpack": "^5.75.0",
+            "webpack-bundle-analyzer": "^4.5.0"
+         },
+         "bin": {
+            "scrypted-changelog": "bin/scrypted-changelog.js",
+            "scrypted-debug": "bin/scrypted-debug.js",
+            "scrypted-deploy": "bin/scrypted-deploy.js",
+            "scrypted-deploy-debug": "bin/scrypted-deploy-debug.js",
+            "scrypted-package-json": "bin/scrypted-package-json.js",
+            "scrypted-setup-project": "bin/scrypted-setup-project.js",
+            "scrypted-webpack": "bin/scrypted-webpack.js"
+         },
+         "devDependencies": {
+            "@types/node": "^18.11.18",
+            "@types/stringify-object": "^4.0.0",
+            "stringify-object": "^3.3.0",
+            "ts-node": "^10.4.0",
+            "typedoc": "^0.23.21"
+         }
+      },
+      "node_modules/@koush/axios-digest-auth": {
+         "version": "0.8.5",
+         "resolved": "https://registry.npmjs.org/@koush/axios-digest-auth/-/axios-digest-auth-0.8.5.tgz",
+         "integrity": "sha512-EZMM0gMJ3hMUD4EuUqSwP6UGt5Vmw2TZtY7Ypec55AnxkExSXM0ySgPtqkAcnL43g1R27yAg/dQL7dRTLMqO3Q==",
+         "dependencies": {
+            "auth-header": "^1.0.0",
+            "axios": "^0.21.4"
+         }
+      },
+      "node_modules/@koush/axios-digest-auth/node_modules/axios": {
+         "version": "0.21.4",
+         "resolved": "https://registry.npmjs.org/axios/-/axios-0.21.4.tgz",
+         "integrity": "sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==",
+         "dependencies": {
+            "follow-redirects": "^1.14.0"
+         }
+      },
+      "node_modules/@scrypted/common": {
+         "resolved": "../../common",
+         "link": true
+      },
+      "node_modules/@scrypted/sdk": {
+         "resolved": "../../sdk",
+         "link": true
+      },
+      "node_modules/@types/node": {
+         "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/asynckit": {
+         "version": "0.4.0",
+         "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+         "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+      },
+      "node_modules/auth-header": {
+         "version": "1.0.0",
+         "resolved": "https://registry.npmjs.org/auth-header/-/auth-header-1.0.0.tgz",
+         "integrity": "sha512-CPPazq09YVDUNNVWo4oSPTQmtwIzHusZhQmahCKvIsk0/xH6U3QsMAv3sM+7+Q0B1K2KJ/Q38OND317uXs4NHA=="
+      },
+      "node_modules/axios": {
+         "version": "1.3.5",
+         "resolved": "https://registry.npmjs.org/axios/-/axios-1.3.5.tgz",
+         "integrity": "sha512-glL/PvG/E+xCWwV8S6nCHcrfg1exGx7vxyUIivIA1iL7BIh6bePylCfVHwp6k13ao7SATxB6imau2kqY+I67kw==",
+         "dependencies": {
+            "follow-redirects": "^1.15.0",
+            "form-data": "^4.0.0",
+            "proxy-from-env": "^1.1.0"
+         }
+      },
+      "node_modules/chacha-js": {
+         "version": "2.1.1",
+         "resolved": "https://registry.npmjs.org/chacha-js/-/chacha-js-2.1.1.tgz",
+         "integrity": "sha512-0ySdjUv/oUkr2cjCo00CNil8Y9f39nm5/3pCgc6hO3X7LvMLBnmugQ5WZ+3Z2SwP9jX7oMIjU3m6p23thtMnHA==",
+         "dependencies": {
+            "inherits": "^2.0.1",
+            "readable-stream": "^1.0.33"
+         }
+      },
+      "node_modules/combined-stream": {
+         "version": "1.0.8",
+         "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+         "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+         "dependencies": {
+            "delayed-stream": "~1.0.0"
+         },
+         "engines": {
+            "node": ">= 0.8"
+         }
+      },
+      "node_modules/core-util-is": {
+         "version": "1.0.3",
+         "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
+         "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ=="
+      },
+      "node_modules/delayed-stream": {
+         "version": "1.0.0",
+         "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+         "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+         "engines": {
+            "node": ">=0.4.0"
+         }
+      },
+      "node_modules/doorbird": {
+         "version": "2.1.2",
+         "resolved": "https://registry.npmjs.org/doorbird/-/doorbird-2.1.2.tgz",
+         "integrity": "sha512-ivwwsS/nOslDnuLg3UB60Axo76w5LQuZ67mCPEeWFr5+HbGYRL7PCY3iLjWYaIakh5+IvZyFPHKR4yHAvAc1WQ==",
+         "dependencies": {
+            "axios": "^1.2.1",
+            "chacha-js": "^2.1.1",
+            "libsodium-wrappers-sumo": "^0.7.11"
+         }
+      },
+      "node_modules/follow-redirects": {
+         "version": "1.15.2",
+         "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz",
+         "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==",
+         "funding": [
+            {
+               "type": "individual",
+               "url": "https://github.com/sponsors/RubenVerborgh"
+            }
+         ],
+         "engines": {
+            "node": ">=4.0"
+         },
+         "peerDependenciesMeta": {
+            "debug": {
+               "optional": true
+            }
+         }
+      },
+      "node_modules/form-data": {
+         "version": "4.0.0",
+         "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
+         "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+         "dependencies": {
+            "asynckit": "^0.4.0",
+            "combined-stream": "^1.0.8",
+            "mime-types": "^2.1.12"
+         },
+         "engines": {
+            "node": ">= 6"
+         }
+      },
+      "node_modules/inherits": {
+         "version": "2.0.4",
+         "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+         "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
+      },
+      "node_modules/isarray": {
+         "version": "0.0.1",
+         "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
+         "integrity": "sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ=="
+      },
+      "node_modules/libsodium-sumo": {
+         "version": "0.7.11",
+         "resolved": "https://registry.npmjs.org/libsodium-sumo/-/libsodium-sumo-0.7.11.tgz",
+         "integrity": "sha512-bY+7ph7xpk51Ez2GbE10lXAQ5sJma6NghcIDaSPbM/G9elfrjLa0COHl/7P6Wb/JizQzl5UQontOOP1z0VwbLA=="
+      },
+      "node_modules/libsodium-wrappers-sumo": {
+         "version": "0.7.11",
+         "resolved": "https://registry.npmjs.org/libsodium-wrappers-sumo/-/libsodium-wrappers-sumo-0.7.11.tgz",
+         "integrity": "sha512-DGypHOmJbB1nZn89KIfGOAkDgfv5N6SBGC3Qvmy/On0P0WD1JQvNRS/e3UL3aFF+xC0m+MYz5M+MnRnK2HMrKQ==",
+         "dependencies": {
+            "libsodium-sumo": "^0.7.11"
+         }
+      },
+      "node_modules/mime-db": {
+         "version": "1.52.0",
+         "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+         "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+         "engines": {
+            "node": ">= 0.6"
+         }
+      },
+      "node_modules/mime-types": {
+         "version": "2.1.35",
+         "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+         "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+         "dependencies": {
+            "mime-db": "1.52.0"
+         },
+         "engines": {
+            "node": ">= 0.6"
+         }
+      },
+      "node_modules/proxy-from-env": {
+         "version": "1.1.0",
+         "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+         "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="
+      },
+      "node_modules/readable-stream": {
+         "version": "1.1.14",
+         "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz",
+         "integrity": "sha512-+MeVjFf4L44XUkhM1eYbD8fyEsxcV81pqMSR5gblfcLCHfZvbrqy4/qYHE+/R5HoBUT11WV5O08Cr1n3YXkWVQ==",
+         "dependencies": {
+            "core-util-is": "~1.0.0",
+            "inherits": "~2.0.1",
+            "isarray": "0.0.1",
+            "string_decoder": "~0.10.x"
+         }
+      },
+      "node_modules/string_decoder": {
+         "version": "0.10.31",
+         "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
+         "integrity": "sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ=="
+      }
+   }
+}
--- a/plugins/doorbird/package.json
+++ b/plugins/doorbird/package.json
@@ -0,0 +1,45 @@
+{
+   "name": "@scrypted/doorbird",
+   "version": "0.0.1",
+   "scripts": {
+      "scrypted-setup-project": "scrypted-setup-project",
+      "prescrypted-setup-project": "scrypted-package-json",
+      "build": "scrypted-webpack",
+      "prepublishOnly": "cross-env NODE_ENV=production scrypted-webpack",
+      "prescrypted-vscode-launch": "scrypted-webpack",
+      "scrypted-vscode-launch": "scrypted-deploy-debug",
+      "scrypted-deploy-debug": "scrypted-deploy-debug",
+      "scrypted-debug": "scrypted-debug",
+      "scrypted-deploy": "scrypted-deploy",
+      "scrypted-readme": "scrypted-readme",
+      "scrypted-package-json": "scrypted-package-json"
+   },
+   "keywords": [
+      "scrypted",
+      "plugin",
+      "doorbird"
+   ],
+   "scrypted": {
+      "name": "Doorbird Plugin",
+      "type": "DeviceProvider",
+      "interfaces": [
+         "DeviceProvider",
+         "DeviceCreator",
+         "Settings"
+      ],
+      "pluginDependencies": [
+         "@scrypted/prebuffer-mixin",
+         "@scrypted/pam-diff",
+         "@scrypted/snapshot"
+      ]
+   },
+   "dependencies": {
+      "@koush/axios-digest-auth": "^0.8.5",
+      "doorbird": "^2.1.2"
+   },
+   "devDependencies": {
+      "@scrypted/common": "file:../../common",
+      "@scrypted/sdk": "file:../../sdk",
+      "@types/node": "^18.15.11"
+   }
+}
--- a/plugins/doorbird/src/doorbird-api.ts
+++ b/plugins/doorbird/src/doorbird-api.ts
@@ -0,0 +1,92 @@
+import Doorbird, { DoorbirdUdpSocket, Scheme, Response, DoorbirdInfoBHA } from 'doorbird';
+
+export interface ApiRingEvent {
+    event: string;
+    timestamp: Date;
+}
+export interface ApiMotionEvent {
+    timestamp: Date;
+}
+
+export type ApiRingCallback = (event: ApiRingEvent) => void;
+export type ApiMotionCallback = (event: ApiMotionEvent) => void;
+
+export class DoorbirdAPI {
+
+    private console?: Console
+    private doorbird: Doorbird;
+    private doorbirdUdpSocket: DoorbirdUdpSocket;
+    private ringCallback: ApiRingCallback;
+    private motionCallback: ApiMotionCallback;
+    private intercomId: String;
+
+    constructor(host: string, username: string, password: string, console?: Console) {
+        this.console = console;
+        this.doorbird = new Doorbird({
+            scheme: Scheme.http,
+            host: host,
+            username: username,
+            password: password
+        });
+        this.intercomId = username.substring(0, 6);
+        this.console?.log("Doorbird: Our intercomId is: ", this.intercomId);
+    }
+
+    startEventSocket() {
+        this.console?.log("Doorbird: starting event socket listening...");
+
+        // initialize dgram UDP socket where Doorbird stations broadcast their event info
+        this.doorbirdUdpSocket = this.doorbird.startUdpSocket(6524); // 6524 or 35344 - both shall contain the same payload
+
+        // register a listener for ring events
+        this.doorbirdUdpSocket.registerRingListener(ringEvent => {
+            this.console?.log("Doorbird: Event from IntercomId:", ringEvent.intercomId);
+            // Make sure that we only call this if the intercom ID matches our desired one
+            if (ringEvent.intercomId === this.intercomId) {
+                this.ringCallback({
+                    event: ringEvent.event,
+                    timestamp: ringEvent.timestamp
+                });
+            }
+        });
+
+        // register a listener for motion events
+        this.doorbirdUdpSocket.registerMotionListener(motionEvent => {
+            this.console?.log("Doorbird: Event from IntercomId:", motionEvent.intercomId);
+            // Make sure that we only call this if the intercom ID matches our desired one
+            if (motionEvent.intercomId === this.intercomId) {
+                this.motionCallback({
+                    timestamp: motionEvent.timestamp
+                });
+            }
+        });
+    }
+
+    stopEventSocket() {
+        this.console?.log("Doorbird: stopping event socket listening...");
+        this.doorbirdUdpSocket.close();        
+    }
+
+    registerRingCallback(ringCallback: ApiRingCallback) {
+        this.ringCallback = ringCallback;
+    }
+
+    registerMotionCallback(motionCallback: ApiMotionCallback) {
+        this.motionCallback = motionCallback;
+    }
+
+    async getImage(): Promise<Buffer> {
+        this.console?.log("Doorbird: getting JPEG image...");
+        return this.doorbird.getImage();
+    }
+
+    async getInfo(): Promise<any> {
+        const dbInfo = await this.doorbird.getInfo();
+        return {
+            deviceType: dbInfo.BHA.VERSION[0]['DEVICE-TYPE'],
+            firmwareVersion: dbInfo.BHA.VERSION[0].FIRMWARE,
+            buildNumber: dbInfo.BHA.VERSION[0].BUILD_NUMBER,
+            serialNumber: dbInfo.BHA.VERSION[0].WIFI_MAC_ADDR,
+        }
+    }
+}
--- a/plugins/doorbird/src/main.ts
+++ b/plugins/doorbird/src/main.ts
@@ -0,0 +1,565 @@
+import { listenZero } from '@scrypted/common/src/listen-cluster';
+import sdk, { BinarySensor, Camera, DeviceProvider, DeviceCreator, DeviceCreatorSettings, DeviceInformation, FFmpegInput, Intercom, MediaObject, PictureOptions, ResponseMediaStreamOptions, ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, ScryptedMimeTypes, Setting, Settings, VideoCamera, MotionSensor } from '@scrypted/sdk';
+import child_process, { ChildProcess } from 'child_process';
+import { ffmpegLogInitialOutput, safePrintFFmpegArguments } from "@scrypted/common/src/media-helpers";
+import net from 'net';
+import { randomBytes } from 'crypto';
+import { PassThrough, Readable } from "stream";
+import AxiosDigestAuth from '@koush/axios-digest-auth';
+import { readLength } from "@scrypted/common/src/read-stream";
+import { ApiRingEvent, ApiMotionEvent, DoorbirdAPI } from "./doorbird-api";
+
+const { deviceManager, mediaManager } = sdk;
+
+class DoorbirdCamera extends ScryptedDeviceBase implements Intercom, Camera, VideoCamera, Settings, BinarySensor, MotionSensor {
+    doorbirdApi: DoorbirdAPI | undefined;
+    binarySensorTimeout: NodeJS.Timeout;
+    motionSensorTimeout: NodeJS.Timeout;
+    doorbellAudioActive: boolean;
+    audioTXProcess: ChildProcess;
+    audioRXProcess: ChildProcess;
+    audioSilenceProcess: ChildProcess;
+    audioRXClientSocket: net.Socket;
+    pendingPicture: Promise<MediaObject>;
+
+    constructor(nativeId: string, public provider: DoorbirdCamProvider) {
+        super(nativeId);
+        this.binaryState = false;
+        this.doorbellAudioActive = false;
+
+        this.updateDeviceInfo();        
+    }
+
+    getDoorbirdApi() {
+        const ip = this.storage.getItem('ip');
+        if (!ip)
+            return undefined;
+
+        if (!this.doorbirdApi) {
+            this.doorbirdApi = new DoorbirdAPI(this.getIPAddress(), this.getUsername(), this.getPassword(), this.console);
+
+            this.getDoorbirdApi()?.registerRingCallback((event: ApiRingEvent) => {
+                this.console?.log("Ring event");
+                this.console?.log("Event:", event.event);
+                this.console?.log("Time:", event.timestamp);
+                this.triggerBinarySensor();
+            });
+            this.getDoorbirdApi()?.registerMotionCallback((event: ApiMotionEvent) => {
+                this.console?.log("Motion event");
+                this.console?.log("Time:", event.timestamp);
+                this.triggerMotionSensor();
+            });
+            this.getDoorbirdApi()?.startEventSocket();        
+        }    
+        return this.doorbirdApi;
+    }
+
+    async updateDeviceInfo(): Promise<void> {
+        const ip = this.storage.getItem('ip');
+        if (!ip)
+            return;
+
+        const deviceInfo: DeviceInformation = {
+            ...this.info,
+            ip
+        };
+
+        const response = await this.getDoorbirdApi()?.getInfo();
+
+        deviceInfo.firmware = response.firmwareVersion + '-' + response.buildNumber;
+
+        this.info = deviceInfo;
+    }
+
+    async takePicture(option?: PictureOptions): Promise<MediaObject> {
+        if (!this.pendingPicture) {
+            this.pendingPicture = this.takePictureThrottled(option);
+            this.pendingPicture.finally(() => this.pendingPicture = undefined);
+        }
+
+        return this.pendingPicture;
+    }
+
+    async takePictureThrottled(option?: PictureOptions): Promise<MediaObject> {
+        return this.createMediaObject(await this.getDoorbirdApi().getImage(), 'image/jpeg');
+    }
+
+    // Unfortunately, the Doorbird public API only offers JPEG snapshots with VGA resolution.
+    // Recommendation: use the snapshot plugin to get snapshots with maximum resolution.
+    public async getPictureOptions(): Promise<PictureOptions[]> {
+        return [{
+            id: 'VGA',
+            picture: { width: 640, height: 480 }
+        }];
+    }
+
+    public async putSetting(key: string, value: string | number | boolean) {
+
+        this.doorbirdApi?.stopEventSocket();
+        this.doorbirdApi = undefined;
+
+        this.storage.setItem(key, value.toString());
+        this.onDeviceEvent(ScryptedInterface.Settings, undefined);
+
+        this.provider.updateDevice(this.nativeId, this.name);
+    }
+
+    async getSettings(): Promise<Setting[]> {
+        return [
+            {
+                key: 'username',
+                title: 'Username',
+                value: this.storage.getItem('username'),
+                description: 'Required: Username for Doorbird HTTP API.',
+            },
+            {
+                key: 'password',
+                title: 'Password',
+                value: this.storage.getItem('password'),
+                type: 'password',
+                description: 'Required: Password for Doorbird HTTP API.',
+            },
+            {
+                key: 'ip',
+                title: 'IP Address',
+                placeholder: '192.168.1.100',
+                value: this.storage.getItem('ip'),
+                description: 'Required: IP address of the Doorbird station.',
+            },
+            {
+                key: 'httpPort',
+                subgroup: 'Advanced',
+                title: 'HTTP Port Override',
+                placeholder: '80',
+                value: this.storage.getItem('httpPort'),
+                description: 'Use this if you have some network firewall rules which change the HTTP port of the camera HTTP port.',
+            },
+            {
+                key: 'rtspUrl',
+                subgroup: 'Advanced',
+                title: 'RTSP URL Override',
+                placeholder: 'rtsp://192.168.2.100/my_doorbird_video_stream',
+                value: this.storage.getItem('rtspUrl'),
+                description: 'Use this in case you are already using another RTSP server/proxy (e.g. mediamtx, go2rtc, etc.) to limit the number of streams from the camera.',
+            }
+        ];
+    }
+
+    // When the intercom is started, we also start the audio receiver which receives audio fro the doorbird microphone.
+    // This audio is then fed into ffmpeg instead of the silent audio from the silence generator.
+    // We also start another process(audioTXProcess) which sends audio to the doorbird speaker.
+    async startIntercom(media: MediaObject): Promise<void> {
+        await this.startAudioReceiver();
+        await this.startAudioTransmitter(media);
+    }
+
+    async stopIntercom(): Promise<void> {
+        this.stopAudioTransmitter();
+        this.stopAudioReceiver();
+    }
+    
+    async startAudioTransmitter(media: MediaObject): Promise<void> {
+        const ffmpegInput: FFmpegInput = JSON.parse((await mediaManager.convertMediaObjectToBuffer(media, ScryptedMimeTypes.FFmpegInput)).toString());
+
+        const ffmpegArgs = ffmpegInput.inputArguments.slice();
+        ffmpegArgs.push(
+            '-vn', '-dn', '-sn',
+            '-acodec', 'pcm_mulaw',
+            '-flags', '+global_header',
+            '-ac', '1',
+            '-ar', '8k',
+            '-f', 'mulaw',
+            'pipe:3'
+        );
+
+        safePrintFFmpegArguments(console, ffmpegArgs);
+        const cp = child_process.spawn(await mediaManager.getFFmpegPath(), ffmpegArgs, {
+            stdio: ['pipe', 'pipe', 'pipe', 'pipe'],
+        });
+        this.audioTXProcess = cp;
+        ffmpegLogInitialOutput(console, cp);
+        cp.on('exit', () => this.console.log('Doorbird: Audio transmitter ended.'));
+        cp.stdout.on('data', data => this.console.log(data.toString()));
+        cp.stderr.on('data', data => this.console.log(data.toString()));
+
+        const socket = cp.stdio[3] as Readable;
+
+        const username: string = this.getUsername();
+        const password: string = this.getPassword();
+        const audioTxUrl: string = `${this.getHttpBaseAddress()}/bha-api/audio-transmit.cgi`;
+
+        this.console.log('Doorbird: Starting audio transmitter...');
+
+        (async () => {
+            this.console.log('Doorbird: audio transmitter started.');
+
+            const passthrough = new PassThrough();
+            const digestAuth = new AxiosDigestAuth({
+                username,
+                password
+            });
+            digestAuth.request({
+                method: 'POST',
+                url: audioTxUrl,
+                headers: {
+                    'Content-Type': 'audio/basic',
+                    'Content-Length': '9999999'
+                },
+                data: passthrough,
+            });
+
+            try {
+                while (true) {
+                    const data = await readLength(socket, 1024);
+                    passthrough.push(data);
+                }
+            }
+            catch (e) {
+            }
+            finally {
+                this.console.log('Doorbird: audio transmitter finished.');
+                passthrough.end();
+            }
+
+            this.stopAudioTransmitter();
+        })();
+    }
+
+    stopAudioTransmitter() {
+        this.audioTXProcess?.kill('SIGKILL');
+        this.audioTXProcess = undefined;
+    }
+
+    async startAudioReceiver(): Promise<void> {
+
+        const audioRxUrl = `${this.getHttpBaseAddress()}/bha-api/audio-receive.cgi`;
+
+        this.console.log('Doorbird: Starting audio receiver...');
+
+        const ffmpegPath = await mediaManager.getFFmpegPath();
+
+        const ffmpegArgs = [
+            '-hide_banner',
+            '-nostats',
+            '-analyzeduration', '0',
+            '-probesize', '32',
+            '-re',
+            '-ar', '8000',
+            '-ac', '1',
+            '-f', 'mulaw',
+            '-i', `${audioRxUrl}`,
+            '-acodec', 'copy',
+            '-f', 'mulaw',
+            'pipe:3'
+        ];
+
+        safePrintFFmpegArguments(console, ffmpegArgs);
+        const cp = child_process.spawn(ffmpegPath, ffmpegArgs, {
+            stdio: ['pipe', 'pipe', 'pipe', 'pipe'],
+        });
+        this.audioRXProcess = cp;
+        ffmpegLogInitialOutput(console, cp);
+
+        cp.on('exit', () => {
+            this.console.log('Doorbird: audio receiver ended.')
+            this.audioRXProcess = undefined;
+        });
+        cp.stdout.on('data', data => this.console.log(data.toString()));
+        cp.stderr.on('data', data => this.console.log(data.toString()));
+
+        this.doorbellAudioActive = true;
+        cp.stdio[3].on('data', data => {
+            if (this.doorbellAudioActive && this.audioRXClientSocket) {
+                this.audioRXClientSocket.write(data);
+            }
+        });
+    }
+
+    stopAudioReceiver() {
+        this.doorbellAudioActive = false;
+        this.audioRXProcess?.kill('SIGKILL');
+        this.audioRXProcess = undefined;
+    }
+
+    async getVideoStreamOptions(): Promise<ResponseMediaStreamOptions[]> {
+        return [{
+            id: 'default',
+            name: 'default',
+            container: '', // must be empty to support prebuffering
+            video: {
+                codec: 'h264'
+            },
+            audio: { /*this.isAudioDisabled() ? null : {}, */
+                // this is a hint to let homekit, et al, know that it's OPUS audio and does not need transcoding.
+                codec: 'pcm_mulaw',
+            }
+        }];    }
+
+    async getVideoStream(options?: ResponseMediaStreamOptions): Promise<MediaObject> {
+
+        const port = await this.startAudioRXServer();
+
+        const ffmpegInput: FFmpegInput = {
+            url: undefined,
+            inputArguments: [
+                '-analyzeduration', '0',
+                '-probesize', '32',
+                '-fflags', 'nobuffer',
+                '-flags', 'low_delay',
+                '-f', 'rtsp',
+                '-rtsp_transport', 'tcp',
+                '-i', `${this.getRtspAddress()}`,
+                '-f', 'mulaw',
+                '-ac', '1',
+                '-ar', '8000',
+                '-channel_layout', 'mono',
+                '-use_wallclock_as_timestamps', 'true',
+                '-i', `tcp://127.0.0.1:${port}?tcp_nodelay=1`,
+            ],
+            mediaStreamOptions: options,
+        };
+
+        return mediaManager.createFFmpegMediaObject(ffmpegInput);
+    }
+
+    async startSilenceGenerator() {
+
+        if (this.audioSilenceProcess)
+            return;
+
+        this.console.log('Doorbird: starting audio silence generator...')            
+
+        const ffmpegPath = await mediaManager.getFFmpegPath();
+        const ffmpegArgs = [
+            '-hide_banner',
+            '-nostats',
+            '-re',
+            '-f', 'lavfi',
+            '-i', 'anullsrc=r=8000:cl=mono',
+            '-f', 'mulaw',
+            'pipe:3'
+        ];
+
+        safePrintFFmpegArguments(console, ffmpegArgs);
+        const cp = child_process.spawn(ffmpegPath, ffmpegArgs, {
+            stdio: ['pipe', 'pipe', 'pipe', 'pipe'],
+        });
+        this.audioSilenceProcess = cp;
+        ffmpegLogInitialOutput(console, cp);
+
+        cp.on('exit', () => {
+            this.console.log('Doorbird: audio silence generator ended.')
+            this.audioSilenceProcess = undefined;
+        });
+        cp.stdout.on('data', data => this.console.log(data.toString()));
+        cp.stderr.on('data', data => this.console.log(data.toString()));
+        cp.stdio[3].on('data', data => {
+            if (!this.doorbellAudioActive && this.audioRXClientSocket) {
+                this.audioRXClientSocket.write(data);
+            }
+        });
+    }
+
+    stopSilenceGenerator() {
+        this.audioSilenceProcess?.kill();
+        this.audioSilenceProcess = null;
+    }
+
+    async startAudioRXServer(): Promise<number> {
+
+        const server = net.createServer(async (clientSocket) => {
+            clearTimeout(serverTimeout);
+
+            this.audioRXClientSocket = clientSocket;
+
+            this.startSilenceGenerator();
+
+            this.audioRXClientSocket.on('close', () => {
+                this.stopSilenceGenerator();
+                this.audioRXClientSocket = null;
+            });
+        });
+        const serverTimeout = setTimeout(() => {
+            this.console.log('Doorbird: timed out waiting for tcp client from ffmpeg');
+            server.close();
+        }, 30000);
+        const port = await listenZero(server);
+
+        return port;
+    }
+
+    triggerBinarySensor() {
+        this.binaryState = true;
+        clearTimeout(this.binarySensorTimeout);
+        this.binarySensorTimeout = setTimeout(() => this.binaryState = false, 3000);
+    }
+
+    triggerMotionSensor() {
+        this.motionDetected = true;
+        clearTimeout(this.motionSensorTimeout);
+        this.motionSensorTimeout = setTimeout(() => this.motionDetected = false, 3000);
+    }
+
+    setHttpPortOverride(port: string) {
+        this.storage.setItem('httpPort', port || '');
+    }
+
+    getHttpBaseAddress() {
+        return `http://${this.getUsername()}:${this.getPassword()}@${this.getIPAddress()}:${this.storage.getItem('httpPort') || 80}`;
+    }
+
+    getRtspAddress() {
+        if (this.storage.getItem('rtspUrl') !== undefined) {
+            return this.storage.getItem('rtspUrl');
+        }
+        else {
+            return this.getRtspDefaultAddress();
+        }
+    }
+
+    getRtspDefaultAddress() {
+        return `rtsp://${this.getUsername()}:${this.getPassword()}@${this.getIPAddress()}/mpeg/media.amp`;
+    }
+
+    getIPAddress() {
+        return this.storage.getItem('ip');
+    }
+
+    setIPAddress(ip: string) {
+        return this.storage.setItem('ip', ip);
+    }
+
+    getUsername() {
+        return this.storage.getItem('username');
+    }
+
+    getPassword() {
+        return this.storage.getItem('password');
+    }
+}
+
+export class DoorbirdCamProvider extends ScryptedDeviceBase implements DeviceProvider, DeviceCreator {
+
+    devices = new Map<string, any>();
+
+    constructor(nativeId?: string) {
+        super(nativeId);
+
+        for (const camId of deviceManager.getNativeIds()) {
+            if (camId)
+                this.getDevice(camId);
+        }
+    }
+
+    async createDevice(settings: DeviceCreatorSettings, nativeId?: string): Promise<string> {
+
+        let info: DeviceInformation = {};
+
+        const host = settings.ip?.toString();
+        const username = settings.username?.toString();
+        const password = settings.password?.toString();
+        const skipValidate = settings.skipValidate === 'true';
+
+        if (!skipValidate) {
+            const api = new DoorbirdAPI(host, username, password, this.console);
+            try {
+                const deviceInfo = await api.getInfo();
+
+                settings.newCamera = deviceInfo.deviceType;
+                info.model = deviceInfo.deviceType;
+                info.serialNumber = deviceInfo.serialNumber;
+                info.mac = deviceInfo.serialNumber;
+                info.manufacturer = 'Bird Home Automation GmbH';
+                info.managementUrl = 'https://webadmin.doorbird.com';
+            }
+            catch (e) {
+                this.console.error('Error adding Doorbird camera', e);
+                throw e;
+            }
+        }
+        settings.newCamera ||= 'Doorbird Camera';
+
+        nativeId ||= randomBytes(4).toString('hex');
+        const name = settings.newCamera?.toString();
+        await this.updateDevice(nativeId, name);
+
+        const device = await this.getDevice(nativeId) as DoorbirdCamera;
+        device.info = info;
+        device.putSetting('username', username);
+        device.putSetting('password', password);
+        device.setIPAddress(settings.ip.toString());
+        device.setHttpPortOverride(settings.httpPort?.toString());
+
+        return nativeId;
+    }
+
+    async getCreateDeviceSettings(): Promise<Setting[]> {
+        return [
+            {
+                key: 'username',
+                title: 'Username',
+            },
+            {
+                key: 'password',
+                title: 'Password',
+                type: 'password',
+            },
+            {
+                key: 'ip',
+                title: 'IP Address',
+                placeholder: '192.168.2.222',
+            },
+            {
+                key: 'httpPort',
+                title: 'HTTP Port',
+                description: 'Optional: Override the HTTP Port from the default value of 80',
+                placeholder: '80',
+            },
+            {
+                key: 'skipValidate',
+                title: 'Skip Validation',
+                description: 'Add the device without verifying the credentials and network settings.',
+                type: 'boolean',
+            }
+        ]
+    }
+
+    updateDevice(nativeId: string, name: string) {
+        return deviceManager.onDeviceDiscovered({
+            nativeId,
+            name,
+            interfaces: [
+                ScryptedInterface.Camera,
+                ScryptedInterface.VideoCamera,
+                ScryptedInterface.Settings,
+                ScryptedInterface.Intercom,
+                ScryptedInterface.BinarySensor,
+                ScryptedInterface.MotionSensor
+            ],
+            type: ScryptedDeviceType.Doorbell,
+            info: deviceManager.getNativeIds().includes(nativeId) ? deviceManager.getDeviceState(nativeId)?.info : undefined,
+        });
+    }
+
+    getDevice(nativeId: string) {
+        let ret = this.devices.get(nativeId);
+        if (!ret) {
+            ret = this.createCamera(nativeId);
+            if (ret)
+                this.devices.set(nativeId, ret);
+        }
+        return ret;
+    }
+
+    async releaseDevice(id: string, nativeId: string): Promise<void> {
+        if( this.devices.delete( nativeId ) ) {
+            this.console.log("Doorbird: Removed device from list: " + id + " / " + nativeId )   
+        }
+    }    
+
+    createCamera(nativeId: string): DoorbirdCamera {
+        return new DoorbirdCamera(nativeId, this);
+    }
+}
+
+export default new DoorbirdCamProvider();
--- a/plugins/doorbird/tsconfig.json
+++ b/plugins/doorbird/tsconfig.json
@@ -0,0 +1,11 @@
+{
+    "compilerOptions": {
+        "target": "esnext",
+        "moduleResolution": "Node16",
+        "esModuleInterop": true,
+        "sourceMap": true
+    },
+    "include": [
+        "src/**/*"
+    ]
+}
--- a/plugins/tensorflow-lite/src/detect/init.py
+++ b/plugins/tensorflow-lite/src/detect/init.py
@@ -71,7 +71,7 @@ class DetectPlugin(scrypted_sdk.ScryptedDeviceBase, ObjectDetection):
    async def detectObjects(self, mediaObject: MediaObject, session: ObjectDetectionSession = None, callbacks: ObjectDetectionCallbacks = None) -> ObjectsDetected:
        vf: scrypted_sdk.VideoFrame
        if mediaObject and mediaObject.mimeType == ScryptedMimeTypes.Image.value:
-            vf = mediaObject
+            vf = await scrypted_sdk.sdk.connectRPCObject(mediaObject)
        else:
            vf = await scrypted_sdk.mediaManager.convertMediaObjectToBuffer(mediaObject, ScryptedMimeTypes.Image.value)

--- a/sdk/types/scrypted_python/scrypted_sdk/types.py
+++ b/sdk/types/scrypted_python/scrypted_sdk/types.py
@@ -240,12 +240,6 @@ class HttpResponseOptions(TypedDict):
    headers: object
    pass

-class ImageOptions(TypedDict):
-    crop: Any
-    format: ImageFormat
-    resize: Any
-    pass
-
 class ObjectDetectionResult(TypedDict):
    boundingBox: tuple[float, float, float, float]
    className: str
@@ -490,7 +484,7 @@ class NotifierOptions(TypedDict):
 class ObjectDetectionGeneratorResult(TypedDict):
    __json_copy_serialize_children: Any
    detected: ObjectsDetected
-    videoFrame: VideoFrame
+    videoFrame: Any
    pass

 class ObjectDetectionGeneratorSession(TypedDict):
@@ -709,6 +703,8 @@ class VideoClipOptions(TypedDict):
 class VideoFrameGeneratorOptions(TypedDict):
    crop: Any
    format: ImageFormat
+    fps: float
+    queue: float
    resize: Any
    pass

@@ -938,7 +934,7 @@ class OauthClient:
 class ObjectDetection:
    async def detectObjects(self, mediaObject: MediaObject, session: ObjectDetectionSession = None, callbacks: ObjectDetectionCallbacks = None) -> ObjectsDetected:
        pass
-    async def generateObjectDetections(self, videoFrames: VideoFrame, session: ObjectDetectionGeneratorSession) -> ObjectDetectionGeneratorResult:
+    async def generateObjectDetections(self, videoFrames: AsyncGenerator, session: ObjectDetectionGeneratorSession) -> ObjectDetectionGeneratorResult:
        pass
    async def getDetectionModel(self, settings: Any = None) -> ObjectDetectionModel:
        pass
@@ -2561,14 +2557,3 @@ class ObjectDetectionCallbacks:
        pass
    pass

-class VideoFrame:
-    format: ImageFormat
-    height: float
-    timestamp: float
-    width: float
-    async def toBuffer(self, options: ImageOptions = None) -> bytearray:
-        pass
-    async def toImage(self, options: ImageOptions = None) -> Any:
-        pass
-    pass
-
--- a/sdk/types/src/types.input.ts
+++ b/sdk/types/src/types.input.ts
@@ -1317,7 +1317,7 @@ export interface ObjectDetectionCallbacks {
 }
 export interface ObjectDetectionGeneratorResult {
  __json_copy_serialize_children: true,
-  videoFrame: VideoFrame;
+  videoFrame: VideoFrame & MediaObject;
  detected: ObjectsDetected;
 }
 /**
@@ -1325,7 +1325,7 @@ export interface ObjectDetectionGeneratorResult {
 * E.g. TensorFlow, OpenCV, or a Coral TPU.
 */
 export interface ObjectDetection {
-  generateObjectDetections(videoFrames: AsyncGenerator<VideoFrame>, session: ObjectDetectionGeneratorSession): Promise<AsyncGenerator<ObjectDetectionGeneratorResult>>;
+  generateObjectDetections(videoFrames: AsyncGenerator<VideoFrame & MediaObject>, session: ObjectDetectionGeneratorSession): Promise<AsyncGenerator<ObjectDetectionGeneratorResult>>;
  detectObjects(mediaObject: MediaObject, session?: ObjectDetectionSession, callbacks?: ObjectDetectionCallbacks): Promise<ObjectsDetected>;
  getDetectionModel(settings?: { [key: string]: any }): Promise<ObjectDetectionModel>;
 }
@@ -1357,8 +1357,12 @@ export interface Image {
 }
 export interface VideoFrame extends Image {
  timestamp: number;
+  queued: number;
+  flush(count?: number): Promise<void>;
 }
 export interface VideoFrameGeneratorOptions extends ImageOptions {
+  queue?: number;
+  fps?: number;
 }
 export interface VideoFrameGenerator {
  generateVideoFrames(mediaObject: MediaObject, options?: VideoFrameGeneratorOptions, filter?: (videoFrame: VideoFrame & MediaObject) => Promise<boolean>): Promise<AsyncGenerator<VideoFrame & MediaObject>>;
--- a/server/package-lock.json
+++ b/server/package-lock.json
@@ -1,12 +1,12 @@
 {
  "name": "@scrypted/server",
-  "version": "0.7.78",
+  "version": "0.7.83",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@scrypted/server",
-      "version": "0.7.78",
+      "version": "0.7.83",
      "license": "ISC",
      "dependencies": {
        "@mapbox/node-pre-gyp": "^1.0.10",
--- a/server/package.json
+++ b/server/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@scrypted/server",
-  "version": "0.7.79",
+  "version": "0.7.83",
  "description": "",
  "dependencies": {
    "@mapbox/node-pre-gyp": "^1.0.10",
--- a/server/python/plugin_remote.py
+++ b/server/python/plugin_remote.py
@@ -422,7 +422,7 @@ class PluginRemote:
            peer, peerReadLoop = await rpc_reader.prepare_peer_readloop(self.loop, rpcTransport)
            peer.onProxySerialization = lambda value, proxyId: onProxySerialization(
                value, proxyId, clusterPeerPort)
-            future = asyncio.Future[rpc.RpcPeer]()
+            future: asyncio.Future[rpc.RpcPeer] = asyncio.Future()
            future.set_result(peer)
            clusterPeers[clusterPeerPort] = future

--- a/server/src/rpc.ts
+++ b/server/src/rpc.ts
@@ -320,6 +320,7 @@ export class RpcPeer {
    killed: Promise<string>;
    killedDeferred: Deferred;
    tags: any = {};
+    yieldedAsyncIterators = new Set<AsyncGenerator>();

    static readonly finalizerIdSymbol = Symbol('rpcFinalizerId');
    static remotesCollected = 0;
@@ -445,6 +446,10 @@ export class RpcPeer {
        for (const result of Object.values(this.pendingResults)) {
            result.reject(error);
        }
+        for (const y of this.yieldedAsyncIterators) {
+            y.throw(error);
+        }
+        this.yieldedAsyncIterators.clear();
        this.pendingResults = Object.freeze({});
        this.params = Object.freeze({});
        this.remoteWeakProxies = Object.freeze({});
@@ -735,9 +740,13 @@ export class RpcPeer {
                            const method = target[rpcApply.method];
                            if (!method)
                                throw new Error(`target ${target?.constructor?.name} does not have method ${rpcApply.method}`);
+
+                            const isIteratorNext = RpcPeer.getIteratorNext(target) === rpcApply.method;
+                            if (isIteratorNext)
+                                this.yieldedAsyncIterators.delete(target);
                            value = await target[rpcApply.method](...args);

-                            if (RpcPeer.getIteratorNext(target) === rpcApply.method) {
+                            if (isIteratorNext) {
                                if (value.done) {
                                    const errorType: ErrorType = {
                                        name: 'StopAsyncIteration',
@@ -746,6 +755,12 @@ export class RpcPeer {
                                    throw errorType;
                                }
                                else {
+                                    if (Object.isFrozen(this.pendingResults)) {
+                                        (target as AsyncGenerator).throw(new RPCResultError(this, 'RpcPeer has been killed (yield)'));
+                                    }
+                                    else {
+                                        this.yieldedAsyncIterators.add(target);
+                                    }
                                    value = value.value;
                                }
                            }
Author	SHA1	Message	Date
Koushik Dutta	c492c15081	rpc: async generator should throw if yielded and when the peer has been killed. garbage collection does not trigger async generator return or throw.	2023-04-19 21:35:46 -07:00
Koushik Dutta	ee7076384b	prebeta	2023-04-19 21:17:59 -07:00
Koushik Dutta	717cac721a	detect: connect to rpc object for every videoframe	2023-04-19 12:18:02 -07:00
Koushik Dutta	af41c853bc	Merge branch 'main' of github.com:koush/scrypted	2023-04-19 12:17:27 -07:00
Koushik Dutta	109b716753	sdk: update	2023-04-19 12:16:56 -07:00
Qasim Mehmood	07930508fe	Publish mutable docker tags for all variants (#738 ) This should add mutable docker tags for all variants that allow for updating via docker pull	2023-04-19 12:12:29 -07:00
nanosonde	a291abe375	Initial version of Doorbird plugin (#736 ) save work Add audio-transmit part Fetch VGA JPEG snapshots from the camera save work Use fixed doorbird module 2.1.2 save work Add doorbell and motion events Clean up. Improved initial camera setup like amcrest plugin Update README	2023-04-19 12:12:18 -07:00
Koushik Dutta	f4f34b2da8	server: fix script	2023-04-18 10:47:32 -07:00
Koushik Dutta	3b4de526ba	postrelease	2023-04-18 10:45:28 -07:00
Koushik Dutta	5de67fca86	server: fix python 3.8 issues	2023-04-18 10:45:20 -07:00
Koushik Dutta	98dc0b1b6d	postrelease	2023-04-18 10:44:57 -07:00