@scrypted/prebuffer-mixin 0.1.222 → 0.1.225

package/src/stream-settings.ts

@@ -1,4 +1,5 @@
-import { StorageSetting, StorageSettings, StorageSettingsDict } from "@scrypted/common/src/settings";
+import { getH264DecoderArgs } from "@scrypted/common/src/ffmpeg-hardware-acceleration";
+import { StorageSetting, StorageSettings } from "@scrypted/common/src/settings";
 import { MixinDeviceBase, ResponseMediaStreamOptions, VideoCamera } from "@scrypted/sdk";
 
 export function getDefaultPrebufferedStreams(msos: ResponseMediaStreamOptions[]) {
@@ -54,13 +55,13 @@ export function createStreamSettings(device: MixinDeviceBase<VideoCamera>) {
     const streamTypes = getStreamTypes({
         defaultStream: {
             title: 'Local Stream',
-            description: 'The media stream to use when streaming on your local network. This is the default stream. Recommended resolution: 1920x1080 to 4K.',
+            description: 'The media stream to use when streaming on your local network. This stream should be prebuffered. Recommended resolution: 1920x1080 to 4K.',
             hide: true,
             prefersPrebuffer: true,
             preferredResolution: 3840 * 2160,
         },
         remoteStream: {
-            title: 'Remote/Mid Stream',
+            title: 'Remote (Medium Resolution) Stream',
             description: 'The media stream to use when streaming from outside your local network. Selecting a low birate stream is recommended. Recommended resolution: 1270x720.',
             hide: true,
             prefersPrebuffer: false,
@@ -71,18 +72,18 @@ export function createStreamSettings(device: MixinDeviceBase<VideoCamera>) {
             description: 'The media stream to use for low resolution output, such as Apple Watch and Video Analysis. Recommended resolution: 480x360.',
             hide: true,
             prefersPrebuffer: false,
-            preferredResolution: 480 * 320,
+            preferredResolution: 480 * 360,
         },
         recordingStream: {
             title: 'Local Recording Stream',
-            description: 'The media stream to use when recording to local storage such as an NVR.',
+            description: 'The media stream to use when recording to local storage such as an NVR. This stream should be prebuffered. Recommended resolution: 1920x1080 to 4K.',
             hide: true,
             prefersPrebuffer: true,
             preferredResolution: 3840 * 2160,
         },
         remoteRecordingStream: {
             title: 'Remote Recording Stream',
-            description: 'The media stream to use when recording to cloud storage such as HomeKit Secure Video clips in iCloud.',
+            description: 'The media stream to use when recording to cloud storage such as HomeKit Secure Video clips in iCloud. This stream should be prebuffered. Recommended resolution: 1270x720.',
             hide: true,
             prefersPrebuffer: true,
             preferredResolution: 1280 * 720,
@@ -94,21 +95,72 @@ export function createStreamSettings(device: MixinDeviceBase<VideoCamera>) {
             title: 'Prebuffered Streams',
             description: 'Prebuffering maintains an active connection to the stream and improves load times. Prebuffer also retains the recent video for capturing motion events with HomeKit Secure video. Enabling Prebuffer is not recommended on Cloud cameras.',
             multiple: true,
-            hide: true,
+            hide: false,
         },
         ...streamTypes,
+        transcodeStreams: {
+            group: 'Transcoding',
+            title: 'Transcode Streams',
+            description: 'The media streams to transcode. Transcoding audio and video is not recommended and should only be used when necessary. The Rebroadcast Plugin manages the system-wide Transcode settings. See the Rebroadcast Readme for optimal configuration.',
+            multiple: true,
+            choices: Object.values(streamTypes).map(st => st.title),
+        },
+        // 3/6/2022
+        // Ran into an issue where the RTSP source had SPS/PPS in the SDP,
+        // and none in the bitstream. Codec copy will not add SPS/PPS before IDR frames
+        // unless this flag is used.
+        // 3/7/2022
+        // This flag was enabled by default, but I believe this is causing issues with some users.
+        // Make it a setting.
+        missingCodecParameters: {
+            group: 'Transcoding',
+            title: 'Add H264 Extra Data',
+            description: 'Some cameras do not include H264 extra data in the stream and this causes live streaming to always fail (but recordings may be working). This is a inexpensive video filter and does not perform a transcode. Enable this setting only as necessary.',
+            type: 'boolean',
+        },
+        videoDecoderArguments: {
+            group: 'Transcoding',
+            title: 'Video Decoder Arguments',
+            description: 'FFmpeg arguments used to decode input video when transcoding a stream.',
+            placeholder: '-hwaccel auto',
+            choices: Object.keys(getH264DecoderArgs()),
+            combobox: true,
+            mapPut: (oldValue, newValue) => getH264DecoderArgs()[newValue]?.join(' ') || newValue,
+        }
     });
 
-    function getMediaStream(v: StreamStorageSetting, msos: ResponseMediaStreamOptions[]) {
+    function getDefaultMediaStream(v: StreamStorageSetting, msos: ResponseMediaStreamOptions[]) {
         const enabledStreams = getPrebufferedStreams(storageSettings, msos);
         const prebufferPreferenceStreams = v.prefersPrebuffer && enabledStreams?.length > 0 ? enabledStreams : msos;
         return pickBestStream(prebufferPreferenceStreams, v.preferredResolution);
+    }
+
+    function getMediaStream(key: string, msos: ResponseMediaStreamOptions[]) {
+        const v: StreamStorageSetting = storageSettings.settings[key];
+        const value = storageSettings.values[key];
+        let isDefault = value === 'Default';
+        let stream = msos?.find(mso => mso.name === value);
+        if (isDefault || !stream) {
+            isDefault = true;
+            stream = getDefaultMediaStream(v, msos);
+        }
+        return {
+            title: streamTypes[key].title,
+            isDefault,
+            stream,
+        };
     };
+
     function createStreamOptions(v: StreamStorageSetting, msos: ResponseMediaStreamOptions[]) {
-        const choices = msos.map(mso => mso.name);
+        const choices = [
+            'Default',
+            ...msos.map(mso => mso.name),
+        ];
+        const defaultValue = getDefaultMediaStream(v, msos).name;
 
         const streamOptions = {
-            defaultValue: getMediaStream(v, msos)?.name,
+            defaultValue: 'Default',
+            description: v.description + ` The default for this stream is ${defaultValue}.`,
             choices,
             hide: false,
         };
@@ -117,18 +169,20 @@ export function createStreamSettings(device: MixinDeviceBase<VideoCamera>) {
 
     storageSettings.options = {
         onGet: async () => {
+            let enabledStreams: StorageSetting;
+
             try {
                 const msos = await device.mixinDevice.getVideoStreamOptions();
 
-                if (msos?.length > 1) {
-                    const choices = msos.map(mso => mso.name);
+                enabledStreams = {
+                    defaultValue: getDefaultPrebufferedStreams(msos)?.map(mso => mso.name),
+                    choices: msos.map(mso => mso.name),
+                    hide: false,
+                };
 
+                if (msos?.length > 1) {
                     return {
-                        enabledStreams: {
-                            defaultValue: getDefaultPrebufferedStreams(msos)?.map(mso => mso.name),
-                            choices,
-                            hide: false,
-                        },
+                        enabledStreams,
                         defaultStream: createStreamOptions(streamTypes.defaultStream, msos),
                         remoteStream: createStreamOptions(streamTypes.remoteStream, msos),
                         lowResolutionStream: createStreamOptions(streamTypes.lowResolutionStream, msos),
@@ -136,6 +190,11 @@ export function createStreamSettings(device: MixinDeviceBase<VideoCamera>) {
                         remoteRecordingStream: createStreamOptions(streamTypes.remoteRecordingStream, msos),
                     }
                 }
+                else {
+                    return {
+                        enabledStreams,
+                    }
+                }
             }
             catch (e) {
                 device.console.error('error retrieving getVideoStreamOptions', e);
@@ -147,11 +206,11 @@ export function createStreamSettings(device: MixinDeviceBase<VideoCamera>) {
     }
 
     return {
-        getDefaultStream: (msos: ResponseMediaStreamOptions[]) => getMediaStream(streamTypes.defaultStream, msos),
-        getRemoteStream: (msos: ResponseMediaStreamOptions[]) => getMediaStream(streamTypes.remoteStream, msos),
-        getLowResolutionStream: (msos: ResponseMediaStreamOptions[]) => getMediaStream(streamTypes.lowResolutionStream, msos),
-        getRecordingStream: (msos: ResponseMediaStreamOptions[]) => getMediaStream(streamTypes.recordingStream, msos),
-        getRemoteRecordingStream: (msos: ResponseMediaStreamOptions[]) => getMediaStream(streamTypes.remoteRecordingStream, msos),
+        getDefaultStream: (msos: ResponseMediaStreamOptions[]) => getMediaStream(storageSettings.keys.defaultStream, msos),
+        getRemoteStream: (msos: ResponseMediaStreamOptions[]) => getMediaStream(storageSettings.keys.remoteStream, msos),
+        getLowResolutionStream: (msos: ResponseMediaStreamOptions[]) => getMediaStream(storageSettings.keys.lowResolutionStream, msos),
+        getRecordingStream: (msos: ResponseMediaStreamOptions[]) => getMediaStream(storageSettings.keys.recordingStream, msos),
+        getRemoteRecordingStream: (msos: ResponseMediaStreamOptions[]) => getMediaStream(storageSettings.keys.remoteRecordingStream, msos),
         storageSettings,
     };
 }