camstreamerlib/esm/CamStreamerAPI.js

Helper library for CamStreamer ACAP applications.

import { z } from 'zod';
import { ProxyClient } from './internal/ProxyClient';
import { responseStringify } from './internal/utils';
import { cameraStreamSchema } from './types/CamStreamerAPI';
import { UtcTimeFetchError, WsAuthorizationError } from './errors/errors';
const BASE_PATH = '/local/camstreamer';
export class CamStreamerAPI {
    client;
    constructor(client) {
        this.client = client;
    }
    getClient(proxyParams) {
        return proxyParams ? new 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 WsAuthorizationError(res.message);
        }
        return 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 UtcTimeFetchError(res.message);
        }
        return z.number().parse(res.data);
    }
    async getStreamList(options) {
        const res = await this._getJson(`${BASE_PATH}/stream/list.cgi`, undefined, options);
        const list = z.record(z.string(), cameraStreamSchema).parse(res.data);
        const streamList = {};
        for (const [key, data] of Object.entries(list)) {
            const streamId = parseInt(key);
            streamList[streamId] = parseCameraStreamResponse(data);
        }
        return streamList;
    }
    async getStream(streamId, options) {
        const res = await this._getJson(`${BASE_PATH}/stream/get.cgi`, { stream_id: streamId }, options);
        const cameraData = cameraStreamSchema.parse(res.data);
        return parseCameraStreamResponse(cameraData);
    }
    async getStreamParameter(streamId, paramName, options) {
        const res = await this._getJson(`${BASE_PATH}/stream/get.cgi`, { stream_id: streamId }, options);
        return 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 responseStringify(res));
        }
    }
}
export 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),
    };
};