@camera.ui/server 0.0.49 → 0.0.50-internal.1

package/dist/server/src/api/services/cameras.service.js

@@ -13,8 +13,6 @@ import { container, delay, registry } from 'tsyringe';
 import { CAMERA_EXTENSIONS } from '../../plugins/types.js';
 import { ConfigService } from '../../services/config/index.js';
 import { Database } from '../database/index.js';
-import { detectionZoneSchema } from '../schemas/cameras.schema.js';
-import { generateInternalCameraSources, isInternalSource } from '../utils/cameraSource.js';
 import { PluginsService } from './plugins.service.js';
 import { UsersService } from './users.service.js';
 const cameraSourceProbeCache = new TTLCache({ max: 100, ttl: Infinity });
@@ -36,67 +34,64 @@ let CamerasService = class CamerasService {
     async createCamera(cameraData) {
         const cameras = this.dbs.camerasDB.get('cameras') ?? [];
         const plugin = this.pluginsService.getPluginById(cameraData.pluginId);
-        if (plugin?.contract.builtIns) {
-            plugin.contract.builtIns.forEach((extensionType) => {
-                if (!cameraData.extensions[extensionType]) {
-                    cameraData.extensions[extensionType] = plugin.pluginName;
+        if (plugin) {
+            plugin.contract.extensions.forEach((extensionType) => {
+                if (extensionType !== 'hub') {
+                    cameraData.extensions[extensionType] = {
+                        id: plugin.id,
+                        name: plugin.pluginName,
+                    };
+                }
+                else {
+                    cameraData.extensions[extensionType] ??= [];
+                    cameraData.extensions[extensionType].push({
+                        id: plugin.id,
+                        name: plugin.pluginName,
+                    });
                 }
             });
         }
-        if (!cameraData.detectionZone.length) {
-            cameraData.detectionZone.push(this.defaultZone());
-        }
-        this.addInternalSources(cameraData);
-        await this.addCameraSourcesToConfig(cameraData.name, cameraData.sources);
+        await this.addCameraSourcesToConfig(cameraData._id, cameraData.name, cameraData.sources);
         cameras.push(cameraData);
         await this.dbs.camerasDB.put('cameras', cameras);
         const transformedCamera = this.transformCamera(cameraData);
         await this.api.addCamera(transformedCamera);
         return cameraData;
     }
-    async createZone(cameraname, zoneData) {
+    async patchZones(cameraname, zoneData) {
         const cameras = this.dbs.camerasDB.get('cameras') ?? [];
         const camera = cameras.find((camera) => camera.name === cameraname);
         if (camera) {
-            camera.detectionZone = [zoneData];
+            camera.detectionZones = zoneData;
             await this.dbs.camerasDB.put('cameras', cameras);
             this.api.updateCamera(this.transformCamera(camera));
         }
         return camera;
     }
-    async patchZoneByName(cameraname, zonename, zoneData) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const camera = cameras.find((camera) => camera.name === cameraname);
-        if (camera) {
-            const zone = camera.detectionZone.find((zone) => zone.name === zonename);
-            if (zone) {
-                mergeWith(zone, zoneData, (source, target) => {
-                    if (Array.isArray(source)) {
-                        return target;
-                    }
-                });
-                await this.dbs.camerasDB.put('cameras', cameras);
-                this.api.updateCamera(this.transformCamera(camera));
-            }
-        }
-        return camera;
-    }
-    async removeZoneByName(cameraname, zonename) {
-        const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        const camera = cameras.find((cameraObj) => cameraObj.name === cameraname);
-        if (camera) {
-            const zoneExists = camera.detectionZone.some((zone) => zone.name === zonename);
-            if (zoneExists) {
-                camera.detectionZone = [];
-                await this.dbs.camerasDB.put('cameras', cameras);
-                this.api.updateCamera(this.transformCamera(camera));
-            }
-        }
-    }
     list() {
         const cameras = this.dbs.camerasDB.get('cameras') ?? [];
         return cameras;
     }
+    async discoverCameras(type, src) {
+        switch (type?.toLowerCase()) {
+            case 'homekit':
+                return this.go2rtcApi.discoverApi.discoverHomekit();
+            case 'onvif':
+                return this.go2rtcApi.discoverApi.discoverOnvif(src ? { src } : undefined);
+            case 'hass':
+                return this.go2rtcApi.discoverApi.discoverHass();
+            case 'gopro':
+                return this.go2rtcApi.discoverApi.discoverGopro();
+            case 'ffmpeg':
+                return this.go2rtcApi.discoverApi.discoverFFmpeg();
+            case 'dvrip':
+                return this.go2rtcApi.discoverApi.discoverDvrip();
+            case 'webtorrent':
+                return this.go2rtcApi.discoverApi.discoverWebtorrent();
+            default:
+                return this.go2rtcApi.discoverApi.discoverSources();
+        }
+    }
     listTransformed() {
         const cameras = this.dbs.camerasDB.get('cameras') ?? [];
         const transformedCameras = cameras.map((camera) => this.transformCamera(camera));
@@ -114,7 +109,7 @@ let CamerasService = class CamerasService {
     }
     listByExtension(pluginName) {
         const cameras = this.dbs.camerasDB.get('cameras') ?? [];
-        return cameras.filter((camera) => camera.extensions.plugins.includes(pluginName));
+        return cameras.filter((camera) => camera.extensions.plugins.some((p) => p.name === pluginName));
     }
     listTransformedByExtension(pluginName, extensions) {
         const cameras = this.dbs.camerasDB.get('cameras') ?? [];
@@ -122,10 +117,10 @@ let CamerasService = class CamerasService {
         for (const type of extensions) {
             let dbCameras = [];
             if (type === 'hub') {
-                dbCameras = cameras.filter((camera) => camera.extensions[type]?.includes(pluginName));
+                dbCameras = cameras.filter((camera) => camera.extensions[type]?.some((p) => p.name === pluginName));
             }
             else {
-                dbCameras = cameras.filter((camera) => camera.extensions[type] === pluginName);
+                dbCameras = cameras.filter((camera) => camera.extensions[type]?.name === pluginName);
             }
             dbCameras.forEach((camera) => camerasMap.set(camera._id, this.transformCamera(camera)));
         }
@@ -169,7 +164,7 @@ let CamerasService = class CamerasService {
         const camera = cameras.find((camera) => camera.name === cameraname);
         const cameraController = this.api.getCamera(camera?._id ?? '');
         const cameraOld = structuredClone(camera);
-        if (camera && cameraOld && cameraController) {
+        if (camera && cameraOld) {
             mergeWith(camera, cameraData, (source, target, key) => {
                 if (key === 'sources') {
                     return target.map((srcItem) => {
@@ -186,23 +181,19 @@ let CamerasService = class CamerasService {
                 }
             });
             if (!isEqual(cameraOld, camera, true)) {
-                // cameraController.disconnect();
                 if (cameraOld.name !== camera.name) {
                     await this.removeCameraSourcesFromConfig(cameraOld.name, cameraOld.sources);
                 }
                 const orphanedSources = cameraOld.sources.filter((source) => !camera.sources.find((s) => s.name === source.name));
-                if (orphanedSources.length) {
-                    orphanedSources.forEach((source) => {
-                        cameraController.streamInfos.delete(source._id);
-                    });
-                    await this.removeCameraSourcesFromConfig(camera.name, orphanedSources);
-                }
+                await this.removeCameraSourcesFromConfig(camera.name, orphanedSources);
             }
-            this.addInternalSources(camera);
-            await this.addCameraSourcesToConfig(camera.name, camera.sources, true);
+            await this.addCameraSourcesToConfig(camera._id, camera.name, camera.sources);
             await this.dbs.camerasDB.put('cameras', cameras);
+            const sourcesChanged = !isEqual(cameraOld.sources, camera.sources, true);
+            if (sourcesChanged) {
+                cameraController?.streamInfos.clear();
+            }
             this.api.updateCamera(this.transformCamera(camera));
-            // cameraController.connect();
         }
         return camera;
     }
@@ -215,18 +206,21 @@ let CamerasService = class CamerasService {
             if (CAMERA_EXTENSIONS.includes(extensionType) &&
                 extensionType !== 'hub' &&
                 extensionType !== 'cameraController' &&
-                camera.extensions[extensionType] !== plugin.pluginName &&
-                (camera.extensions.plugins.includes(plugin.pluginName) || plugin.contract.builtIns?.includes(extensionType))) {
-                const oldExtension = camera.extensions[extensionType];
+                camera.extensions[extensionType]?.name !== plugin.pluginName &&
+                camera.extensions.plugins.some((p) => p.name === plugin.pluginName)) {
+                const oldExtension = camera.extensions[extensionType]?.name;
                 const oldPlugin = oldExtension ? this.pluginsService.getPluginByName(oldExtension) : undefined;
-                camera.extensions[extensionType] = plugin.pluginName;
+                camera.extensions[extensionType] = {
+                    id: plugin.id,
+                    name: plugin.pluginName,
+                };
                 const transformedCamera = this.transformCamera(camera);
                 await this.dbs.camerasDB.put('cameras', cameras);
                 if (oldPlugin && oldExtension) {
-                    this.api.deselectCamera(oldPlugin.id, transformedCamera, extensionType);
+                    await this.api.deselectCamera(oldPlugin.id, transformedCamera, extensionType);
                 }
                 this.api.updateCamera(transformedCamera);
-                this.api.selectCamera(plugin.id, transformedCamera, extensionType);
+                await this.api.selectCamera(plugin.id, transformedCamera, extensionType);
             }
         }
         return camera;
@@ -240,12 +234,12 @@ let CamerasService = class CamerasService {
             if (CAMERA_EXTENSIONS.includes(extensionType) &&
                 extensionType !== 'hub' &&
                 extensionType !== 'cameraController' &&
-                camera.extensions[extensionType] === plugin.pluginName &&
-                (camera.extensions.plugins.includes(plugin.pluginName) || plugin.contract.builtIns?.includes(extensionType))) {
+                camera.extensions[extensionType]?.name === plugin.pluginName &&
+                camera.extensions.plugins.some((p) => p.name === plugin.pluginName)) {
                 camera.extensions[extensionType] = undefined;
                 const transformedCamera = this.transformCamera(camera);
                 await this.dbs.camerasDB.put('cameras', cameras);
-                this.api.deselectCamera(plugin.id, transformedCamera, extensionType);
+                await this.api.deselectCamera(plugin.id, transformedCamera, extensionType);
                 this.api.updateCamera(transformedCamera);
                 setTimeout(() => {
                     this.api.resetCameraState(camera._id, extensionType);
@@ -254,127 +248,88 @@ let CamerasService = class CamerasService {
         }
         return camera;
     }
-    async addExtensionByName(cameraname, pluginNameOrId) {
+    async addExtensionByName(cameraname, pluginNameOrId, extension) {
         const cameras = this.dbs.camerasDB.get('cameras') ?? [];
         const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
         const camera = cameras.find((camera) => camera.name === cameraname);
         const cameraOld = structuredClone(camera);
-        if (camera && cameraOld && (plugin?.contract.extension || plugin?.contract.supportAdditionalCameras) && !camera.extensions.plugins.includes(plugin.pluginName)) {
-            camera.extensions.plugins.push(plugin.pluginName);
+        if (camera && cameraOld && plugin && !camera.extensions.plugins.some((p) => p.name === plugin.pluginName)) {
+            camera.extensions.plugins.push({
+                id: plugin.id,
+                name: plugin.pluginName,
+            });
             const addedExtensions = [];
-            if (plugin?.contract.extension) {
-                const extensionType = plugin.contract.extension;
-                if (extensionType !== 'hub') {
-                    if (!camera.extensions[extensionType]) {
-                        camera.extensions[extensionType] = plugin.pluginName;
-                        addedExtensions.push(extensionType);
-                    }
-                }
-                else {
-                    if (!camera.extensions[extensionType]) {
-                        camera.extensions[extensionType] = [];
-                    }
-                    camera.extensions[extensionType].push(plugin.pluginName);
-                    addedExtensions.push(extensionType);
+            if (extension !== 'hub') {
+                if (!camera.extensions[extension]) {
+                    camera.extensions[extension] = {
+                        id: plugin.id,
+                        name: plugin.pluginName,
+                    };
+                    addedExtensions.push(extension);
                 }
             }
             else {
-                const extensionTypes = plugin.contract.builtIns;
-                extensionTypes.forEach((extensionType) => {
-                    if (!camera.extensions[extensionType]) {
-                        camera.extensions[extensionType] = plugin.pluginName;
-                        addedExtensions.push(extensionType);
-                    }
+                camera.extensions[extension] ??= [];
+                camera.extensions[extension].push({
+                    id: plugin.id,
+                    name: plugin.pluginName,
                 });
+                addedExtensions.push(extension);
             }
             const transformedCamera = this.transformCamera(camera);
             await this.dbs.camerasDB.put('cameras', cameras);
             this.api.updateCamera(transformedCamera);
-            for (const extensionType of addedExtensions) {
-                this.api.selectCamera(plugin.id, transformedCamera, extensionType);
-            }
+            await Promise.allSettled(addedExtensions.map((extensionType) => this.api.selectCamera(plugin.id, transformedCamera, extensionType)));
         }
         return camera;
     }
-    async removeExtensionByName(cameraname, pluginNameOrId) {
+    async removeExtensionByName(cameraname, pluginNameOrId, extension) {
         const cameras = this.dbs.camerasDB.get('cameras') ?? [];
         const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
         const camera = cameras.find((camera) => camera.name === cameraname);
         const cameraOld = structuredClone(camera);
-        if (camera && cameraOld && (plugin?.contract.extension || plugin?.contract.supportAdditionalCameras) && camera.extensions.plugins.includes(plugin.pluginName)) {
-            camera.extensions.plugins = camera.extensions.plugins.filter((extension) => extension !== plugin.pluginName);
+        if (camera && cameraOld && plugin && camera.extensions.plugins.some((p) => p.name === plugin.pluginName)) {
+            camera.extensions.plugins = camera.extensions.plugins.filter((p) => p.name !== plugin.pluginName);
             const removedExtensions = new Set();
-            if (plugin?.contract.extension) {
-                const extensionType = plugin.contract.extension;
-                if (extensionType !== 'hub') {
-                    if (camera.extensions[extensionType] === plugin.pluginName) {
-                        camera.extensions[extensionType] = undefined;
-                        removedExtensions.add(extensionType);
-                    }
-                }
-                else {
-                    if (!camera.extensions[extensionType]) {
-                        camera.extensions[extensionType] = [];
-                    }
-                    camera.extensions[extensionType] = camera.extensions[extensionType].filter((extension) => extension !== plugin.pluginName);
-                    removedExtensions.add(extensionType);
+            if (extension !== 'hub') {
+                if (camera.extensions[extension]?.name === plugin.pluginName) {
+                    camera.extensions[extension] = undefined;
+                    removedExtensions.add(extension);
                 }
             }
-            else if (plugin?.contract.supportAdditionalCameras) {
-                const extensionTypes = plugin.contract.builtIns;
-                extensionTypes.forEach((extensionType) => {
-                    if (camera.extensions[extensionType] === plugin.pluginName) {
-                        camera.extensions[extensionType] = undefined;
-                        removedExtensions.add(extensionType);
-                    }
-                });
+            else {
+                camera.extensions[extension] ??= [];
+                camera.extensions[extension] = camera.extensions[extension].filter((p) => p.name !== plugin.pluginName);
+                removedExtensions.add(extension);
             }
             const transformedCamera = this.transformCamera(camera);
             await this.dbs.camerasDB.put('cameras', cameras);
-            for (const extensionType of removedExtensions) {
-                this.api.deselectCamera(plugin.id, transformedCamera, extensionType);
-            }
+            await Promise.allSettled(Array.from(removedExtensions).map((extensionType) => this.api.deselectCamera(plugin.id, transformedCamera, extensionType)));
             this.api.updateCamera(transformedCamera);
         }
         return camera;
     }
-    async removeExtension(pluginNameOrId) {
+    async removeExtension(pluginNameOrId, extension) {
         const cameras = this.dbs.camerasDB.get('cameras') ?? [];
         for (const camera of cameras) {
             const plugin = this.pluginsService.getPluginByName(pluginNameOrId) ?? this.pluginsService.getPluginById(pluginNameOrId);
-            if ((plugin?.contract.extension || plugin?.contract.supportAdditionalCameras) && camera.extensions.plugins.includes(plugin.pluginName)) {
-                camera.extensions.plugins = camera.extensions.plugins.filter((extension) => extension !== plugin.pluginName);
+            if (plugin && camera.extensions.plugins.some((p) => p.name === plugin.pluginName)) {
+                camera.extensions.plugins = camera.extensions.plugins.filter((p) => p.name !== plugin.pluginName);
                 const removedExtensions = new Set();
-                if (plugin?.contract.extension) {
-                    const extensionType = plugin.contract.extension;
-                    if (extensionType !== 'hub') {
-                        if (camera.extensions[extensionType] === plugin.pluginName) {
-                            camera.extensions[extensionType] = undefined;
-                            removedExtensions.add(extensionType);
-                        }
-                    }
-                    else {
-                        if (!camera.extensions[extensionType]) {
-                            camera.extensions[extensionType] = [];
-                        }
-                        camera.extensions[extensionType] = camera.extensions[extensionType].filter((extension) => extension !== plugin.pluginName);
-                        removedExtensions.add(extensionType);
+                if (extension !== 'hub') {
+                    if (camera.extensions[extension]?.name === plugin.pluginName) {
+                        camera.extensions[extension] = undefined;
+                        removedExtensions.add(extension);
                     }
                 }
-                else if (plugin?.contract.supportAdditionalCameras) {
-                    const extensionTypes = plugin.contract.builtIns;
-                    for (const extensionType of extensionTypes) {
-                        if (camera.extensions[extensionType] === plugin.pluginName) {
-                            camera.extensions[extensionType] = undefined;
-                            removedExtensions.add(extensionType);
-                        }
-                    }
+                else {
+                    camera.extensions[extension] ??= [];
+                    camera.extensions[extension] = camera.extensions[extension].filter((p) => p.name !== plugin.pluginName);
+                    removedExtensions.add(extension);
                 }
                 const transformedCamera = this.transformCamera(camera);
                 await this.dbs.camerasDB.put('cameras', cameras);
-                for (const extensionType of removedExtensions) {
-                    this.api.deselectCamera(plugin.id, transformedCamera, extensionType);
-                }
+                await Promise.allSettled(Array.from(removedExtensions).map((extensionType) => this.api.deselectCamera(plugin.id, transformedCamera, extensionType)));
                 this.api.updateCamera(this.transformCamera(camera));
             }
         }
@@ -449,122 +404,58 @@ let CamerasService = class CamerasService {
         cameraSourceProbeCache.clear();
         await this.usersService.resetAllPreferences();
         await this.dbs.camerasDB.put('cameras', cameras);
-        for (const camera of camerasToRemove) {
-            await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
-        }
+        await Promise.all(camerasToRemove.map((camera) => this.removeCameraSourcesFromConfig(camera.name, camera.sources)));
         await Promise.all(camerasToRemove.map((camera) => this.api.removeCamera(this.transformCamera(camera), camera.extensions)));
     }
-    async probeCameraSource(camera, source) {
+    async probeCameraSource(camera, source, probeData) {
         cameraSourceProbeCache.purgeStale();
         const inCache = cameraSourceProbeCache.get(source._id);
         if (inCache) {
             return inCache;
         }
         const src = createSourceName(camera.name, source.name);
-        const probe = await this.go2rtcApi.streamsApi.probeStreamSource({ src });
+        const probe = await this.go2rtcApi.streamsApi.probeStreamSource({ src }, probeData);
         cameraSourceProbeCache.set(source._id, probe);
         return probe;
     }
     transformCamera(camera) {
         const transformedCamera = {
-            _id: camera._id,
-            nativeId: camera.nativeId,
-            pluginId: camera.pluginId,
-            name: camera.name,
-            disabled: camera.disabled,
-            info: camera.info,
-            type: camera.type,
-            snapshotTTL: camera.snapshotTTL,
-            isCloud: camera.isCloud,
-            hasLight: camera.hasLight,
-            hasSiren: camera.hasSiren,
-            hasBinarySensor: camera.hasBinarySensor,
-            hasBattery: camera.hasBattery,
-            hasAudioDetector: this.extensionIsEnabled(camera.extensions.audioDetection, 'audioDetection'),
-            hasMotionDetector: this.extensionIsEnabled(camera.extensions.motionDetection, 'motionDetection'),
-            extendedMotionDetector: this.isExtendedMotionDetector(camera.extensions.motionDetection),
-            hasObjectDetector: this.extensionIsEnabled(camera.extensions.objectDetection, 'objectDetection'),
-            hasPtz: this.extensionIsEnabled(camera.extensions.ptz, 'ptz'),
-            detectionZones: this.convertToDetectionZones(camera.detectionZone),
-            detectionSettings: camera.detectionSettings,
-            frameWorkerSettings: camera.frameWorkerSettings,
+            ...camera,
             sources: camera.sources.map((source) => ({
                 _id: source._id,
                 name: source.name,
-                roles: source.roles,
+                role: source.role,
+                useForSnapshot: source.useForSnapshot,
+                hotMode: source.hotMode,
                 urls: {
                     ws: this.generateWsUrls(camera, source),
                     rtsp: this.generateRTSPUrls(camera, source),
-                    www: this.generateWWWUrls(camera, source),
+                    snapshot: this.generateSnapshotUrls(camera, source),
                 },
-                internal: isInternalSource(source),
             })),
         };
         return transformedCamera;
     }
-    defaultZone() {
-        return detectionZoneSchema.parse({
-            name: 'Default',
-            regions: [
-                {
-                    _id: '',
-                    classes: ['motion', 'person'],
-                    coords: [
-                        {
-                            _id: '',
-                            points: [0, 0],
-                        },
-                        {
-                            _id: '',
-                            points: [0, 100],
-                        },
-                        {
-                            _id: '',
-                            points: [100, 100],
-                        },
-                        {
-                            _id: '',
-                            points: [100, 0],
-                        },
-                    ],
-                    filter: 'include',
-                    isPrivacyMask: false,
-                    type: 'contain',
-                },
-            ],
-        });
-    }
-    addInternalSources(camera) {
-        camera.sources = camera.sources.filter((source) => !isInternalSource(source));
-        const sourcesToAdd = [];
-        for (const source of camera.sources) {
-            const internalSources = generateInternalCameraSources(camera.name, source) ?? [];
-            sourcesToAdd.push(...internalSources.map((internalSource) => {
-                delete internalSource.convertedName;
-                return internalSource;
-            }));
-        }
-        camera.sources.push(...sourcesToAdd);
-    }
-    async addCameraSourcesToConfig(cameraname, sources, overwrite) {
+    async addCameraSourcesToConfig(cameraId, cameraname, sources) {
         for (const source of sources) {
-            if (isInternalSource(source)) {
-                continue;
-            }
+            source.urls = source.urls.map((url) => {
+                if (url.startsWith('cui://')) {
+                    url = `cui://127.0.0.1:${this.configService.config.port}/api/cameras/streams/${cameraId}/${source.name}`;
+                }
+                return url;
+            });
             const sourceName = createSourceName(cameraname, source.name);
-            const internalSources = generateInternalCameraSources(cameraname, source) ?? [];
+            const ffmpegUrl = `ffmpeg:${sourceName}#cameraui#audio=pcma#audio=opus#audio=aac`;
+            const baseUrls = [...source.urls];
             const cameraSources = [];
-            if (!this.sourceExistAndEqual(sourceName, source.urls)) {
-                cameraSources.push({ name: sourceName, src: source.urls });
-            }
-            for (const internalSource of internalSources) {
-                if (!this.configService.go2rtcConfig.streams?.[internalSource.convertedName] || overwrite) {
-                    cameraSources.push({ name: internalSource.convertedName, src: internalSource.urls });
-                }
+            const hasFFmpegUrl = baseUrls.some((url) => url.startsWith('ffmpeg:') && url.includes('#cameraui'));
+            if (!hasFFmpegUrl && source.role !== 'snapshot') {
+                baseUrls.push(ffmpegUrl);
             }
-            if (!this.configService.go2rtcConfig.streams) {
-                this.configService.go2rtcConfig.streams = {};
+            if (!this.sourceExistAndEqual(sourceName, baseUrls)) {
+                cameraSources.push({ name: sourceName, src: baseUrls });
             }
+            this.configService.go2rtcConfig.streams ??= {};
             for (const sourceData of cameraSources) {
                 await this.go2rtcApi.streamsApi.createStream({
                     name: sourceData.name,
@@ -576,23 +467,12 @@ let CamerasService = class CamerasService {
     }
     async removeCameraSourcesFromConfig(cameraname, oldSources) {
         for (const source of oldSources) {
-            if (isInternalSource(source)) {
-                continue;
-            }
             const sourceName = createSourceName(cameraname, source.name);
-            const internalSources = generateInternalCameraSources(cameraname, source) ?? [];
             const sourcesToRemove = [];
             if (this.configService.go2rtcConfig.streams?.[sourceName]) {
                 sourcesToRemove.push(sourceName);
             }
-            for (const internalSource of internalSources) {
-                if (this.configService.go2rtcConfig.streams?.[internalSource.convertedName]) {
-                    sourcesToRemove.push(internalSource.convertedName);
-                }
-            }
-            if (!this.configService.go2rtcConfig.streams) {
-                this.configService.go2rtcConfig.streams = {};
-            }
+            this.configService.go2rtcConfig.streams ??= {};
             for (const src of sourcesToRemove) {
                 await this.go2rtcApi.streamsApi.deleteStream({ src });
                 delete this.configService.go2rtcConfig.streams?.[src];
@@ -613,7 +493,8 @@ let CamerasService = class CamerasService {
     }
     generateWsUrls(camera, source) {
         const sourceName = createSourceName(camera.name, source.name);
-        const baseWebRtcUrl = `ws://${this.go2rtcAddress()}/api/ws?src=${sourceName}`;
+        const go2rtcAddress = this.configService.go2rtcAddress('ws');
+        const baseWebRtcUrl = `${go2rtcAddress}/api/ws?src=${sourceName}`;
         return {
             webrtc: baseWebRtcUrl,
             mse: baseWebRtcUrl,
@@ -621,80 +502,32 @@ let CamerasService = class CamerasService {
     }
     generateRTSPUrls(camera, source) {
         const sourceName = createSourceName(camera.name, source.name);
-        const baseRtspUrl = `rtsp://${this.go2rtcAddress('rtsp')}/${sourceName}`;
+        const go2rtcAddress = this.configService.go2rtcAddress('rtsp');
+        const onvifAddress = this.configService.go2rtcAddress('onvif');
+        const baseRtspUrl = `${go2rtcAddress}/${sourceName}`;
+        const baseOnvifUrl = `${onvifAddress}/${sourceName}`;
         return {
-            default: `${baseRtspUrl}?video=all&audio=all&timeout=15`,
-            defaultMicrophone: `${baseRtspUrl}?video=all&audio=all&backchannel=1&timeout=15`,
-            muted: `${baseRtspUrl}?video=all&timeout=15`,
-            h264: `${baseRtspUrl}?video=h264&audio=all&backchannel=1&timeout=15`,
-            h265: `${baseRtspUrl}?video=h265&audio=all&backchannel=1&timeout=15`,
+            base: baseRtspUrl,
+            default: `${baseRtspUrl}?video&audio&backchannel=1&timeout=15`,
+            muted: `${baseRtspUrl}?video&timeout=15`,
             aac: `${baseRtspUrl}?video&audio=aac&backchannel=1&timeout=15`,
             opus: `${baseRtspUrl}?video&audio=opus&backchannel=1&timeout=15`,
             pcma: `${baseRtspUrl}?video&audio=pcma&backchannel=1&timeout=15`,
-            mp4: `${baseRtspUrl}?mp4&timeout=15`,
+            onvif: baseOnvifUrl,
         };
     }
-    generateWWWUrls(camera, source) {
+    generateSnapshotUrls(camera, source) {
         const sourceName = createSourceName(camera.name, source.name);
-        const baseStreamUrl = `http://${this.go2rtcAddress()}/stream.html?src=${sourceName}`;
-        const baseMjpegStreamUrl = `http://${this.go2rtcAddress()}/api/stream.mjpeg?src=${sourceName}`;
-        const baseMp4StreamUrl = `http://${this.go2rtcAddress()}/api/stream.mp4?src=${sourceName}`;
-        const baseFrameMp4StreamUrl = `http://${this.go2rtcAddress()}/api/frame.mp4?src=${sourceName}`;
-        const baseFrameJpegStreamUrl = `http://${this.go2rtcAddress()}/api/frame.jpeg?src=${sourceName}`;
-        const baseHlsStreamUrl = `http://${this.go2rtcAddress()}/api/stream.m3u8?src=${sourceName}`;
+        const go2rtcAddress = this.configService.go2rtcAddress('api');
+        const baseMjpegStreamUrl = `${go2rtcAddress}/api/stream.mjpeg?src=${sourceName}`;
+        const baseFrameMp4StreamUrl = `${go2rtcAddress}/api/frame.mp4?src=${sourceName}`;
+        const baseFrameJpegStreamUrl = `${go2rtcAddress}/api/frame.jpeg?src=${sourceName}`;
         return {
-            webrtc: `${baseStreamUrl}&mode=webrtc`,
-            mse: `${baseStreamUrl}&mode=mse`,
-            lmp4: baseMp4StreamUrl,
-            mmp4: `${baseMp4StreamUrl}&mp4=flac`,
-            mp4: `${baseMp4StreamUrl}&mp4=all`,
-            mp4Snapshot: baseFrameMp4StreamUrl,
-            jpegSnapshot: baseFrameJpegStreamUrl,
-            lHlsTs: baseHlsStreamUrl,
-            lHlsFmp4: `${baseHlsStreamUrl}&mp4`,
-            mHlsFmp4: `${baseHlsStreamUrl}&mp4=flac`,
+            mp4: baseFrameMp4StreamUrl,
+            jpeg: baseFrameJpegStreamUrl,
             mjpeg: baseMjpegStreamUrl,
-            mjpegHtml: `${baseStreamUrl}&mode=mjpeg`,
         };
     }
-    extensionIsEnabled(extension, type) {
-        if (!extension || !type) {
-            return false;
-        }
-        const plugin = this.pluginsService.getPluginByName(extension);
-        if (plugin && !plugin.disabled && (plugin.contract.extension === type || plugin.contract.builtIns?.includes(type))) {
-            return true;
-        }
-        return false;
-    }
-    isExtendedMotionDetector(extension) {
-        if (!extension) {
-            return false;
-        }
-        const plugin = this.pluginsService.getPluginByName(extension);
-        if (plugin && !plugin.disabled && (plugin.contract.extension === 'motionDetection' || plugin.contract.builtIns?.includes('motionDetection'))) {
-            return plugin.contract.options?.extendedMotionDetection ?? false;
-        }
-        return false;
-    }
-    convertToDetectionZones(cameraZones) {
-        return cameraZones.flatMap((zone) => {
-            return zone.regions.map((region) => {
-                return {
-                    name: zone.name,
-                    points: region.coords.map((coord) => coord.points),
-                    type: region.type,
-                    filter: region.filter,
-                    classes: region.classes,
-                    isPrivacyMask: region.isPrivacyMask,
-                };
-            });
-        });
-    }
-    go2rtcAddress(mod = 'api') {
-        const go2rtcPort = parseInt(this.configService.go2rtcConfig[mod].listen.split(':')[1], 10);
-        return `127.0.0.1:${go2rtcPort}`;
-    }
 };
 CamerasService = __decorate([
     registry([