camstreamerlib/cjs/internal/convertors.js

Helper library for CamStreamer ACAP applications.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseVapixParamsToVideoOptions = exports.parseVideoOptionsToVapixParams = exports.parseVapixParamsToBitrateOptions = exports.parseBitrateOptionsToVapixParams = void 0;
const constants_1 = require("./constants");
const versionCompare_1 = require("./versionCompare");
const parseBitrateOptionsToVapixParams = (firmWareVersion, bitrateMode, cameraOptions) => {
    if (!(0, versionCompare_1.isFirmwareVersionAtLeast)(firmWareVersion, constants_1.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];
};
exports.parseBitrateOptionsToVapixParams = parseBitrateOptionsToVapixParams;
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,
    };
};
exports.parseVapixParamsToBitrateOptions = parseVapixParamsToBitrateOptions;
const parseVideoOptionsToVapixParams = (firmWareVersion, video) => {
    const bitrateParams = (0, exports.parseBitrateOptionsToVapixParams)(firmWareVersion, video.bitrateMode, {
        maximumBitRate: video.maximumBitRate,
        retentionTime: video.retentionTime,
        bitRateLimit: video.bitRateLimit,
    });
    let overlaysParams = '';
    if ((0, versionCompare_1.isFirmwareVersionAtLeast)(firmWareVersion, constants_1.FIRMWARE_WITH_OVERLAYS_SUPPORT)) {
        overlaysParams = `&overlays=${video.overlays}`;
    }
    const 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('&');
};
exports.parseVideoOptionsToVapixParams = parseVideoOptionsToVapixParams;
const parseVapixParamsToVideoOptions = (internalVapixParams) => {
    const bitrateOptions = (0, exports.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'],
    };
};
exports.parseVapixParamsToVideoOptions = parseVapixParamsToVideoOptions;