camstreamerlib/cjs/CamStreamerAPI.js

Helper library for CamStreamer ACAP applications.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseCameraStreamResponse = exports.CamStreamerAPI = void 0;
const zod_1 = require("zod");
const ProxyClient_1 = require("./internal/ProxyClient");
const utils_1 = require("./internal/utils");
const CamStreamerAPI_1 = require("./types/CamStreamerAPI");
const errors_1 = require("./errors/errors");
const BASE_PATH = '/local/camstreamer';
class CamStreamerAPI {
    client;
    constructor(client) {
        this.client = client;
    }
    getClient(proxyParams) {
        return proxyParams ? new ProxyClient_1.ProxyClient(this.client, proxyParams) : this.client;
    }
    async wsAuthorization(options) {
        const res = await this._getJson(`${BASE_PATH}/ws_authorization.cgi`, undefined, options);
        if (res.status !== 200) {
            throw new errors_1.WsAuthorizationError(res.message);
        }
        return zod_1.z.string().parse(res.data);
    }
    async getUtcTime(options) {
        const res = await this._getJson(`${BASE_PATH}/get_utc_time.cgi`, undefined, options);
        if (res.status !== 200) {
            throw new errors_1.UtcTimeFetchError(res.message);
        }
        return zod_1.z.number().parse(res.data);
    }
    async getStreamList(options) {
        const res = await this._getJson(`${BASE_PATH}/stream/list.cgi`, undefined, options);
        const list = zod_1.z.record(zod_1.z.string(), CamStreamerAPI_1.cameraStreamSchema).parse(res.data);
        const streamList = {};
        for (const [key, data] of Object.entries(list)) {
            const streamId = parseInt(key);
            streamList[streamId] = (0, exports.parseCameraStreamResponse)(data);
        }
        return streamList;
    }
    async getStream(streamId, options) {
        const res = await this._getJson(`${BASE_PATH}/stream/get.cgi`, { stream_id: streamId }, options);
        const cameraData = CamStreamerAPI_1.cameraStreamSchema.parse(res.data);
        return (0, exports.parseCameraStreamResponse)(cameraData);
    }
    async getStreamParameter(streamId, paramName, options) {
        const res = await this._getJson(`${BASE_PATH}/stream/get.cgi`, { stream_id: streamId }, options);
        return zod_1.z.string().parse(res.data[paramName]);
    }
    async setStream(streamId, params, options) {
        const { streamDelay, startTime, stopTime, ...rest } = params;
        await this._getJson(`${BASE_PATH}/stream/set.cgi`, {
            stream_id: streamId,
            streamDelay: streamDelay ?? '',
            startTime: startTime ?? null,
            stopTime: stopTime ?? null,
            ...rest,
        }, options);
    }
    async setStreamParameter(streamId, paramName, value, options) {
        await this._getJson(`${BASE_PATH}/stream/set.cgi`, { stream_id: streamId, [paramName]: value }, options);
    }
    async isStreaming(streamId, options) {
        const res = await this._getJson(`${BASE_PATH}/get_streamstat.cgi`, { stream_id: streamId }, options);
        return res.data.is_streaming === 1;
    }
    async deleteStream(streamId, options) {
        const res = await this._getJson(`${BASE_PATH}/stream/remove.cgi`, { stream_id: streamId }, options);
        return res.data.status === 200;
    }
    async _getJson(path, parameters, options) {
        const agent = this.getClient(options?.proxyParams);
        const res = await agent.get({ path, parameters, timeout: options?.timeout });
        if (res.ok) {
            return await res.json();
        }
        else {
            throw new Error(await (0, utils_1.responseStringify)(res));
        }
    }
}
exports.CamStreamerAPI = CamStreamerAPI;
const parseCameraStreamResponse = (cameraStreamData) => {
    return {
        enabled: parseInt(cameraStreamData.enabled),
        active: parseInt(cameraStreamData.active),
        audioSource: cameraStreamData.audioSource,
        avSyncMsec: parseInt(cameraStreamData.avSyncMsec),
        internalVapixParameters: cameraStreamData.internalVapixParameters,
        userVapixParameters: cameraStreamData.userVapixParameters,
        outputParameters: cameraStreamData.outputParameters,
        outputType: cameraStreamData.outputType,
        mediaServerUrl: cameraStreamData.mediaServerUrl,
        inputType: cameraStreamData.inputType,
        inputUrl: cameraStreamData.inputUrl,
        forceStereo: parseInt(cameraStreamData.forceStereo),
        streamDelay: isNaN(parseInt(cameraStreamData.streamDelay)) ? null : parseInt(cameraStreamData.streamDelay),
        statusLed: parseInt(cameraStreamData.statusLed),
        statusPort: cameraStreamData.statusPort,
        callApi: parseInt(cameraStreamData.callApi),
        trigger: cameraStreamData.trigger,
        schedule: cameraStreamData.schedule,
        prepareAhead: parseInt(cameraStreamData.prepareAhead),
        startTime: isNaN(parseInt(cameraStreamData.startTime)) ? null : parseInt(cameraStreamData.startTime),
        stopTime: isNaN(parseInt(cameraStreamData.stopTime)) ? null : parseInt(cameraStreamData.stopTime),
    };
};
exports.parseCameraStreamResponse = parseCameraStreamResponse;