camstreamerlib 4.0.0-beta.99 → 4.0.1

package/esm/internal/convertors.js

@@ -0,0 +1,108 @@
+import { FIRMWARE_WITH_BITRATE_MODES_SUPPORT, FIRMWARE_WITH_OVERLAYS_SUPPORT } from './constants';
+import { isFirmwareVersionAtLeast } from './versionCompare';
+export const parseBitrateOptionsToVapixParams = (firmWareVersion, bitrateMode, cameraOptions) => {
+    if (!isFirmwareVersionAtLeast(firmWareVersion, FIRMWARE_WITH_BITRATE_MODES_SUPPORT)) {
+        return `videomaxbitrate=${cameraOptions.maximumBitRate}`;
+    }
+    if (bitrateMode === undefined) {
+        return '';
+    }
+    const data = {
+        VBR: 'videobitratemode=vbr',
+        MBR: `videobitratemode=mbr&videomaxbitrate=${cameraOptions.maximumBitRate}&videobitratepriority=framerate`,
+        ABR: `videobitratemode=abr&videoabrtargetbitrate=${cameraOptions.maximumBitRate}&videoabrretentiontime=${cameraOptions.retentionTime}&videoabrmaxbitrate=${cameraOptions.bitRateLimit}`,
+    };
+    return data[bitrateMode];
+};
+export const parseVapixParamsToBitrateOptions = (bitrateVapixParams) => {
+    const params = {};
+    const searchParams = new URLSearchParams(bitrateVapixParams);
+    searchParams.forEach((value, key) => {
+        params[key] = value;
+    });
+    const bitrateMode = params['videobitratemode'] !== undefined ? params['videobitratemode'].toUpperCase() : undefined;
+    const hasLowerFw = bitrateMode === undefined && params['videomaxbitrate'] !== undefined;
+    if (hasLowerFw) {
+        const maximumBitRate = parseInt(params['videomaxbitrate'] ?? '0', 10);
+        return {
+            bitrateMode: 'MBR',
+            maximumBitRate: maximumBitRate,
+            retentionTime: 1,
+            bitRateLimit: Math.floor(maximumBitRate * 1.1),
+        };
+    }
+    if (bitrateMode === 'ABR') {
+        const maximumBitRate = parseInt(params['videoabrtargetbitrate'] ?? '0', 10);
+        const retentionTime = parseInt(params['videoabrretentiontime'] ?? '0', 10);
+        const bitRateLimit = parseInt(params['videoabrmaxbitrate'] ?? '0', 10);
+        return {
+            bitrateMode,
+            maximumBitRate,
+            retentionTime,
+            bitRateLimit,
+        };
+    }
+    else if (bitrateMode === 'MBR') {
+        const maximumBitRate = params['videomaxbitrate'] !== undefined ? parseInt(params['videomaxbitrate'], 10) : null;
+        const oldMaximumBitrateParamValue = parseInt(params['videombrmaxbitrate'] ?? '0', 10);
+        return {
+            bitrateMode: bitrateMode,
+            maximumBitRate: maximumBitRate ?? oldMaximumBitrateParamValue,
+            retentionTime: 1,
+            bitRateLimit: Math.floor(maximumBitRate ?? oldMaximumBitrateParamValue * 1.1),
+        };
+    }
+    return {
+        bitrateMode: bitrateMode,
+        retentionTime: 1,
+        maximumBitRate: 0,
+        bitRateLimit: 0,
+    };
+};
+export const parseVideoOptionsToVapixParams = (firmWareVersion, video) => {
+    const bitrateParams = parseBitrateOptionsToVapixParams(firmWareVersion, video.bitrateMode, {
+        maximumBitRate: video.maximumBitRate,
+        retentionTime: video.retentionTime,
+        bitRateLimit: video.bitRateLimit,
+    });
+    let overlaysParams = '';
+    if (isFirmwareVersionAtLeast(firmWareVersion, FIRMWARE_WITH_OVERLAYS_SUPPORT) && video.overlays !== undefined) {
+        overlaysParams = `&overlays=${video.overlays}`;
+    }
+    const nbrOfChannels = video.nbrOfChannels ? (video.audio === 1 ? `&nbrOfChannels=${video.nbrOfChannels}` : '') : '';
+    const audioParams = `audio=${video.audio}${nbrOfChannels}`;
+    const videoCodecParams = video.videoCodec === 'h264'
+        ? `videoCodec=${video.videoCodec}&h264Profile=${video.h264Profile}`
+        : `videoCodec=${video.videoCodec}`;
+    const videoParams = `camera=${video.camera}&resolution=${video.resolution}&fps=${video.fps}&compression=${video.compression}&videokeyframeinterval=${video.govLength}&${videoCodecParams}${overlaysParams}`;
+    return [videoParams, bitrateParams, audioParams].join('&');
+};
+export const parseVapixParamsToVideoOptions = (internalVapixParams) => {
+    const bitrateOptions = parseVapixParamsToBitrateOptions(internalVapixParams);
+    const params = {};
+    const searchParams = new URLSearchParams(internalVapixParams);
+    searchParams.forEach((value, key) => {
+        params[key] = value;
+    });
+    let h264Profile = undefined;
+    if (params['videoCodec'] === 'h264') {
+        h264Profile = (params['h264Profile'] ?? 'high');
+    }
+    let nbrOfChannels = undefined;
+    if (params['audio'] === '1') {
+        nbrOfChannels = parseInt(params['nbrOfChannels'] ?? '1');
+    }
+    return {
+        ...bitrateOptions,
+        camera: params['camera'] ?? '1',
+        resolution: params['resolution'] ?? '',
+        fps: parseInt(params['fps'] ?? '0', 10),
+        compression: parseInt(params['compression'] ?? '0', 10),
+        govLength: parseInt(params['videokeyframeinterval'] ?? '0', 10),
+        videoCodec: (params['videoCodec'] ?? 'h264'),
+        h264Profile,
+        audio: parseInt(params['audio'] ?? '0'),
+        nbrOfChannels,
+        overlays: params['overlays'],
+    };
+};

package/esm/internal/transformers.js

@@ -1,4 +1,4 @@
-import { camelCase, snakeCase, isPlainObject, mapKeys, mapValues } from 'lodash';
+import { camelCase, snakeCase, isPlainObject, mapKeys, mapValues } from 'lodash-es';
 export const toCamelCase = (o) => mapKeys(o, camelCaseKey);
 export const toCamelCaseDeep = (o) => {
     return mapKeysDeep(o, camelCaseKey);

package/esm/types/CamOverlayAPI/CamOverlayAPI.js

@@ -9,6 +9,7 @@ import { customGraphicsSchema } from './customGraphicsSchema';
 import { screenSharingSchema } from './screenSharingSchema';
 import { webCameraSharingSchema } from './webCameraSharingSchema';
 import { baseballScoreBoardAutomaticSchema, baseballScoreBoardSchema, scoreBoardSchema, scoreOverviewSchema, } from './scoreBoardSchema';
+import { htmlOverlaySchema } from './htmlOverlaySchema';
 export const wsResponseSchema = z.object({
     status: z.number(),
     message: z.string(),
@@ -27,6 +28,7 @@ export const servicesSchema = z.discriminatedUnion('name', [
     baseballScoreBoardSchema,
     baseballScoreBoardAutomaticSchema,
     scoreOverviewSchema,
+    htmlOverlaySchema,
 ]);
 export const serviceListSchema = z.object({
     services: z.array(servicesSchema),
@@ -44,33 +46,68 @@ export const isScoreBoard = (service) => service.name === 'scoreBoard';
 export const isBaseballScoreBoard = (service) => service.name === 'baseballScoreBoard';
 export const isBaseballScoreBoardAutomatic = (service) => service.name === 'myBallBaseballWidgets';
 export const isScoreOverview = (service) => service.name === 'scoreOverview';
+export const isHtmlOverlay = (service) => service.name === 'htmlOverlay';
 export var ImageType;
 (function (ImageType) {
     ImageType[ImageType["PNG"] = 0] = "PNG";
     ImageType[ImageType["JPEG"] = 1] = "JPEG";
 })(ImageType || (ImageType = {}));
-export const fileStorageTypeSchema = z.union([
+export const imageFileStorageTypeSchema = z.union([
     z.literal('flash'),
     z.literal('SD0'),
     z.literal('ftp'),
     z.literal('samba'),
     z.literal('url'),
 ]);
-export const storageDataListSchema = z.array(z.object({
-    type: fileStorageTypeSchema,
+export const fontFileStorageTypeSchema = z.union([z.literal('flash'), z.literal('SD0')]);
+export const imageFilestorageDataListSchema = z.array(z.object({
+    type: imageFileStorageTypeSchema,
     state: z.string(),
 }));
-export const storageResponseSchema = z.object({
+export const fontStorageDataListSchema = z.array(z.object({
+    type: fontFileStorageTypeSchema,
+    state: z.string(),
+}));
+export const getStorageDataListSchema = (fileType) => {
+    return fileType === 'image' ? imageFilestorageDataListSchema : fontStorageDataListSchema;
+};
+export const imageStorageResponseSchema = z.object({
     code: z.number(),
-    list: storageDataListSchema,
+    list: imageFilestorageDataListSchema,
 });
-export const fileSchema = z.object({
+export const fontStorageResponseSchema = z.object({
+    code: z.number(),
+    list: fontStorageDataListSchema,
+});
+export const getStorageResponseSchema = (fileType) => {
+    return fileType === 'image' ? imageStorageResponseSchema : fontStorageResponseSchema;
+};
+export const imageFileSchema = z.object({
     name: z.string(),
     path: z.string().url(),
-    storage: fileStorageTypeSchema,
+    storage: imageFileStorageTypeSchema,
+});
+export const fontFileSchema = z.object({
+    name: z.string(),
+    path: z.string().url(),
+    storage: fontFileStorageTypeSchema,
+});
+export const getFileSchema = (fileType) => {
+    return fileType === 'image' ? imageFileSchema : fontFileSchema;
+};
+export const imageFileListSchema = z.array(imageFileSchema);
+export const fontFileListSchema = z.array(fontFileSchema);
+export const getFileListSchema = (fileType) => {
+    return fileType === 'image' ? imageFileListSchema : fontFileListSchema;
+};
+export const imageFileDataSchema = z.object({
+    code: z.number(),
+    list: imageFileListSchema,
 });
-export const fileListSchema = z.array(fileSchema);
-export const fileDataSchema = z.object({
+export const fontFileDataSchema = z.object({
     code: z.number(),
-    list: fileListSchema,
+    list: fontFileListSchema,
 });
+export const getFileDataSchema = (fileType) => {
+    return fileType === 'image' ? imageFileDataSchema : fontFileDataSchema;
+};

package/esm/types/CamOverlayAPI/htmlOverlaySchema.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { serviceNames, serviceCommonSchema, coordinateSystemSchema } from './serviceCommonTypes';
+export const htmlOverlaySchema = serviceCommonSchema.extend({
+    name: z.literal(serviceNames.htmlOverlay),
+    pos_x: z.number().nonnegative(),
+    pos_y: z.number().nonnegative(),
+    coordSystem: coordinateSystemSchema,
+    url: z.string().url().or(z.literal('')).default(''),
+    pageWidth: z.number().nonnegative(),
+    pageHeight: z.number().nonnegative(),
+    fps: z.number().nonnegative(),
+    scale: z.number(),
+    cropEnabled: z.boolean(),
+    cropLeft: z.number().nonnegative(),
+    cropTop: z.number().nonnegative(),
+    cropWidth: z.number().nonnegative(),
+    cropHeight: z.number().nonnegative(),
+});

package/esm/types/CamOverlayAPI/index.js

@@ -9,3 +9,4 @@ export * from './ptzCompassSchema';
 export * from './ptzSchema';
 export * from './screenSharingSchema';
 export * from './webCameraSharingSchema';
+export * from './htmlOverlaySchema';

package/esm/types/CamOverlayAPI/serviceCommonTypes.js

@@ -13,6 +13,7 @@ export const serviceNames = {
     baseballScoreBoard: 'baseballScoreBoard',
     myBallBaseballWidgets: 'myBallBaseballWidgets',
     scoreOverview: 'scoreOverview',
+    htmlOverlay: 'htmlOverlay',
 };
 export const coordinateSystemSchema = z.union([
     z.literal('top_left'),
@@ -51,16 +52,18 @@ export const weatherUnitSchema = z.union([z.literal('Metric'), z.literal('Imperi
 export const serviceCommonSchema = z.object({
     id: z.number().nonnegative(),
     enabled: z.union([z.literal(0), z.literal(1)]),
-    automationType: z.union([
+    automationType: z
+        .union([
         z.literal('time'),
         z.literal('manual'),
         z.literal('schedule'),
         z.custom((val) => {
             return typeof val === 'string' ? /^input\d+$/.test(val) : false;
         }),
-    ]),
+    ])
+        .default('manual'),
     invertInput: z.boolean().optional(),
-    cameraList: z.array(z.number()),
+    cameraList: z.array(z.number()).default([0]),
     camera: z.number().nonnegative().optional(),
     schedule: z.string().optional(),
     customName: z.string().default(''),

package/esm/types/CamScripterAPI.js

@@ -27,7 +27,3 @@ export const camscripterApiResponseSchema = z.object({
     status: z.number(),
     message: z.string(),
 });
-export const cameraTimeResponseSchema = z.object({
-    state: z.boolean(),
-    code: z.number(),
-});

package/esm/types/CamStreamerAPI/CamStreamerAPI.js

@@ -1,25 +1,12 @@
-import { z } from 'zod';
+import { boolean, z } from 'zod';
 import { facebookSchema } from './facebookSchema';
-import { mpegDvbSchema } from './mpegDvbSchema';
-import { rtmpSchema } from './rtmpSchema';
-import { sdCardSchema } from './sdCardSchema';
 import { windySchema } from './windySchema';
 import { youtubeSchema } from './youtubeSchema';
-import { vimeoSchema } from './vimeoSchema';
-import { twitchSchema } from './twitchSchema';
-import { churchSchema } from './churchSchema';
-import { srtSchema } from './srtSchema';
-import { daCastSchema } from './daCastSchema';
-import { hlsPullSchema } from './hlsPullSchema';
-import { hlsPushSchema } from './hlsPushSchema';
-import { wowzaSchema } from './wowzaSchema';
-import { dailymotionSchema } from './dailymotionSchema';
-import { ibmSchema } from './ibmSchema';
-import { microsoftAzureSchema } from './microsoftAzureSchema';
-import { microsoftStreamSchema } from './microsoftStreamSchema';
-import { gameChangerSchema } from './gameChangerSchema';
-export const streamSchema = z.discriminatedUnion('type', [
+import { daCastSchema, dailymotionSchema, facebookRtmpSchema, gameChangerSchema, hlsPullSchema, hlsPushSchema, ibmSchema, microsoftAzureSchema, microsoftStreamSchema, mpegDvbSchema, rtmpSchema, sdCardSchema, srtSchema, streamPlatforms, twitchSchema, vimeoSchema, wowzaSchema, youtubeRtmpSchema, } from './streamsSchema';
+import { fileSchema } from '../common';
+export const streamSchema = z.discriminatedUnion('platform', [
     facebookSchema,
+    facebookRtmpSchema,
     mpegDvbSchema,
     rtmpSchema,
     sdCardSchema,
@@ -27,7 +14,6 @@ export const streamSchema = z.discriminatedUnion('type', [
     youtubeSchema,
     vimeoSchema,
     twitchSchema,
-    churchSchema,
     srtSchema,
     daCastSchema,
     hlsPullSchema,
@@ -38,64 +24,68 @@ export const streamSchema = z.discriminatedUnion('type', [
     microsoftAzureSchema,
     microsoftStreamSchema,
     gameChangerSchema,
+    youtubeRtmpSchema,
 ]);
 export const streamListSchema = z.object({ streamList: z.array(streamSchema) });
 export const isFacebookStream = (stream) => {
-    return stream.type === 'facebook';
+    return stream.platform === streamPlatforms.facebook;
+};
+export const isFacebookRtmpStream = (stream) => {
+    return stream.platform === streamPlatforms.facebook_rtmp;
 };
 export const isMpegDvbStream = (stream) => {
-    return stream.type === 'mpeg_dvb';
+    return stream.platform === streamPlatforms.mpeg_dvb;
 };
 export const isRtmpStream = (stream) => {
-    return stream.type === 'rtmp';
+    return stream.platform === streamPlatforms.rtmp;
 };
 export const isSdCardStream = (stream) => {
-    return stream.type === 'sd_card';
+    return stream.platform === streamPlatforms.sd_card;
 };
 export const isWindyStream = (stream) => {
-    return stream.type === 'windy';
+    return stream.platform === streamPlatforms.windy;
 };
 export const isYouTubeStream = (stream) => {
-    return stream.type === 'youtube';
+    return stream.platform === streamPlatforms.youtube;
 };
 export const isVimeoStream = (stream) => {
-    return stream.type === 'vimeo';
+    return stream.platform === streamPlatforms.vimeo;
 };
 export const isTwitchStream = (stream) => {
-    return stream.type === 'twitch';
-};
-export const isChurchStream = (stream) => {
-    return stream.type === 'church';
+    return stream.platform === streamPlatforms.twitch;
 };
 export const isSrtStream = (stream) => {
-    return stream.type === 'srt';
+    return stream.platform === streamPlatforms.srt;
 };
 export const isDaCastStream = (stream) => {
-    return stream.type === 'da_cast';
+    return stream.platform === streamPlatforms.da_cast;
 };
 export const isHlsPullStream = (stream) => {
-    return stream.type === 'hls_pull';
+    return stream.platform === streamPlatforms.hls_pull;
 };
 export const isHlsPushStream = (stream) => {
-    return stream.type === 'hls_push';
+    return stream.platform === streamPlatforms.hls_push;
 };
 export const isWowzaStream = (stream) => {
-    return stream.type === 'wowza';
+    return stream.platform === streamPlatforms.wowza;
 };
 export const isDailymotionStream = (stream) => {
-    return stream.type === 'dailymotion';
+    return stream.platform === streamPlatforms.dailymotion;
 };
 export const isIbmStream = (stream) => {
-    return stream.type === 'ibm';
+    return stream.platform === streamPlatforms.ibm;
 };
 export const isMicrosoftAzureStream = (stream) => {
-    return stream.type === 'microsoft_azure';
+    return stream.platform === streamPlatforms.microsoft_azure;
 };
 export const isMicrosoftStream = (stream) => {
-    return stream.type === 'microsoft_stream';
+    return stream.platform === streamPlatforms.microsoft_stream;
 };
 export const isGameChangerStream = (stream) => {
-    return stream.type === 'game_changer';
+    return stream.platform === streamPlatforms.game_changer;
+};
+export const isYoutubeRtmpStream = (stream) => {
+    return stream.platform === streamPlatforms.youtube_rtmp;
 };
 export var AudioType;
 (function (AudioType) {
@@ -125,7 +115,85 @@ export const audioUrlSchema = z.object({
     storage: z.literal('url'),
 });
 export const audioLocalSchema = z.object({
-    file: z.instanceof(File),
+    file: fileSchema,
     name: z.string(),
     storage: z.enum(['flash', 'SD0']),
 });
+export const streamStatsSchema = z.object({
+    net_stats: z.string(),
+    stream_bytes_time_ms: z.number().nonnegative(),
+    stream_bytes: z.number().nonnegative(),
+    start_count: z.number().nonnegative(),
+    is_streaming: z.literal(0).or(z.literal(1)),
+});
+export const srtStreamStatisticsSchema = z.object({
+    msTimeStamp: z.number().nonnegative(),
+    pktSentTotal: z.number().nonnegative(),
+    byteSentTotal: z.number().nonnegative(),
+    pktRetransTotal: z.number().nonnegative(),
+    byteRetransTotal: z.number().nonnegative(),
+    pktSndDropTotal: z.number().nonnegative(),
+    byteSndDropTotal: z.number().nonnegative(),
+    mbpsSendRate: z.number().nonnegative(),
+    mbpsBandwidth: z.number().nonnegative(),
+    mbpsMaxBW: z.number().nonnegative(),
+    msRTT: z.number().nonnegative(),
+    msSndBuf: z.number().nonnegative(),
+});
+export const diagnosticsParamsSchema = z.object({
+    camerainfo: boolean().optional(),
+    checkserver: boolean().optional(),
+    checkservertime: boolean().optional(),
+    speedtest: boolean().optional(),
+    pingtest: boolean().optional(),
+    videoHostPort: z.string().optional(),
+    audioHostPort: z.string().optional(),
+});
+export const diagnosticsSchema = z.object({
+    status: z.number(),
+    message: z.string(),
+    data: z.object({
+        audioHostPort: z
+            .object({
+            code: z.number(),
+            message: z.string(),
+        })
+            .optional(),
+        cameraInfo: z
+            .object({
+            uptime: z.string(),
+            availableRAM: z.number(),
+            availableInternal: z.number(),
+        })
+            .optional(),
+        checkServer: z
+            .object({
+            state: z.string(),
+            message: z.string(),
+        })
+            .optional(),
+        checkServerTime: z
+            .object({
+            code: z.number(),
+            message: z.string(),
+        })
+            .optional(),
+        videoHostPort: z
+            .object({
+            code: z.number(),
+            message: z.string(),
+        })
+            .optional(),
+        speedTest: z
+            .object({
+            code: z.string(),
+            data: z.array(z.object({ timestamp: z.number(), speed: z.number() })),
+        })
+            .optional(),
+        pingTest: z
+            .object({
+            output: z.string(),
+        })
+            .optional(),
+    }),
+});

package/esm/types/CamStreamerAPI/facebookSchema.js

@@ -1,5 +1,17 @@
 import z from 'zod';
 import { streamCommonSchema } from './streamCommonTypes';
+const timelinePostSchema = z.object({
+    postLocation: z.literal('timeline'),
+    streamPrivacy: z.union([z.literal('public'), z.literal('friends'), z.literal('only_me')]),
+});
+const pagePostSchema = z.object({
+    postLocation: z.literal('page'),
+    page: z.string(),
+});
 export const facebookSchema = streamCommonSchema.extend({
-    type: z.literal('facebook'),
+    platform: z.literal('facebook'),
+    description: z.string().optional(),
+    deleteAfterEnd: z.boolean(),
+    countdown: z.boolean(),
+    post: z.discriminatedUnion('postLocation', [timelinePostSchema, pagePostSchema]),
 });

package/esm/types/CamStreamerAPI/index.js

@@ -1,8 +1,6 @@
 export * from './CamStreamerAPI';
 export * from './streamCommonTypes';
 export * from './facebookSchema';
-export * from './mpegDvbSchema';
-export * from './rtmpSchema';
-export * from './sdCardSchema';
 export * from './windySchema';
 export * from './youtubeSchema';
+export * from './streamsSchema';

package/esm/types/CamStreamerAPI/oldStreamSchema.js

@@ -23,7 +23,7 @@ export const oldStringStreamSchema = z.object({
     stopTime: z.string(),
 });
 export const oldStringStreamSchemaWithId = oldStringStreamSchema.extend({
-    id: z.string(),
+    streamId: z.string(),
 });
 export const oldStreamSchema = z.object({
     enabled: z.union([z.literal(0), z.literal(1)]),