camstreamerlib 4.0.0-beta.2 → 4.0.0-beta.4

package/cjs/CamOverlayPainter/Frame.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Frame = void 0;
+const events_1 = require("events");
+class Frame extends events_1.EventEmitter {
+    enabled;
+    posX;
+    posY;
+    width;
+    height;
+    text = '';
+    fontColor;
+    fontName;
+    font;
+    align = 'A_LEFT';
+    textType = 'TFM_OVERFLOW';
+    bgColor;
+    bgImageName;
+    bgImage;
+    bgType;
+    borderRadius;
+    borderWidth;
+    borderColor;
+    customDraw;
+    layer;
+    children = new Array();
+    constructor(opt) {
+        super();
+        this.enabled = opt.enabled ?? true;
+        this.posX = opt.x;
+        this.posY = opt.y;
+        this.width = opt.width;
+        this.height = opt.height;
+        this.setText(opt.text ?? '', 'A_LEFT');
+        this.fontColor = opt.fontColor ?? [1.0, 1.0, 1.0];
+        this.fontName = opt.font;
+        this.bgColor = opt.bgColor;
+        this.bgImageName = opt.bgImage;
+        this.bgType = opt.bgType;
+        this.borderRadius = opt.borderRadius ?? 0;
+        this.borderWidth = opt.borderWidth ?? 0;
+        this.borderColor = opt.borderColor ?? [1, 1, 1, 1];
+        this.customDraw = opt.customDraw;
+        this.layer = opt.layer ?? 0;
+    }
+    enable() {
+        this.enabled = true;
+    }
+    disable() {
+        this.enabled = false;
+    }
+    setFramePosition(x, y) {
+        this.posX = x;
+        this.posY = y;
+    }
+    setFrameSize(width, height) {
+        this.width = width;
+        this.height = height;
+    }
+    setText(text, align, textType = 'TFM_OVERFLOW', fontColor) {
+        this.text = text;
+        this.align = align;
+        this.textType = textType;
+        if (fontColor) {
+            this.fontColor = fontColor;
+        }
+    }
+    setFontColor(fontColor) {
+        this.fontColor = fontColor;
+    }
+    setFont(fontName) {
+        this.fontName = fontName;
+        this.font = undefined;
+    }
+    setFontData(fontData) {
+        this.fontName = undefined;
+        this.font = fontData;
+    }
+    setBgColor(color) {
+        this.bgColor = color;
+    }
+    setBgImage(imageName, type = 'fit') {
+        this.bgImageName = imageName;
+        this.bgImage = undefined;
+        this.bgType = type;
+    }
+    setBgImageData(imageData, type = 'fit') {
+        this.bgImageName = undefined;
+        this.bgImage = imageData;
+        this.bgType = type;
+    }
+    setBgType(type) {
+        this.bgType = type;
+    }
+    setBorderRadius(radius) {
+        this.borderRadius = radius;
+    }
+    setBorderWidth(width) {
+        this.borderWidth = width;
+    }
+    setBorderColor(color) {
+        this.borderColor = color;
+    }
+    setCustomDraw(customDraw) {
+        this.customDraw = customDraw;
+    }
+    resetFont() {
+        this.font = undefined;
+    }
+    resetBgColor() {
+        this.bgColor = undefined;
+    }
+    resetBgImage() {
+        this.bgImage = undefined;
+        this.bgType = undefined;
+    }
+    resetCustomDraw() {
+        this.customDraw = undefined;
+    }
+    clear() {
+        this.text = '';
+        this.align = 'A_LEFT';
+        this.textType = 'TFM_OVERFLOW';
+        this.fontColor = [1.0, 1.0, 1.0];
+        this.font = undefined;
+        this.bgColor = undefined;
+        this.bgImage = undefined;
+        this.bgType = undefined;
+        this.customDraw = undefined;
+    }
+    insert(...frames) {
+        this.children.push(...frames);
+        for (const frame of frames) {
+            frame.on('layoutChanged', () => this.layoutChanged());
+        }
+        this.layoutChanged();
+    }
+    getLayers() {
+        const uniqueLayers = new Set();
+        uniqueLayers.add(this.layer);
+        for (const child of this.children) {
+            for (const layer of child.getLayers()) {
+                uniqueLayers.add(layer);
+            }
+        }
+        return uniqueLayers;
+    }
+    layoutChanged() {
+        this.emit('layoutChanged');
+    }
+    async displayImage(cod, resourceManager, cairo, ppX, ppY, scale, layer) {
+        if (this.enabled) {
+            const posX = ppX + this.posX;
+            const posY = ppY + this.posY;
+            await this.prepareResources(resourceManager);
+            await cod.cairo('cairo_save', cairo);
+            await this.clipDrawing(cod, cairo, scale, posX, posY);
+            if (this.layer === layer) {
+                await this.displayOwnImage(cod, cairo, posX, posY, scale);
+            }
+            for (const child of this.children) {
+                await child.displayImage(cod, resourceManager, cairo, posX, posY, scale, layer);
+            }
+            await cod.cairo('cairo_restore', cairo);
+        }
+    }
+    async prepareResources(resourceManager) {
+        if (this.bgImageName !== undefined) {
+            this.bgImage = await resourceManager.image(this.bgImageName);
+        }
+        if (this.fontName !== undefined) {
+            this.font = await resourceManager.font(this.fontName);
+        }
+    }
+    async displayOwnImage(cod, cairo, ppX, ppY, scale) {
+        if (!this.enabled) {
+            return;
+        }
+        const promises = new Array();
+        if (this.font !== undefined) {
+            promises.push(cod.cairo('cairo_set_font_face', cairo, this.font.var));
+        }
+        else {
+            promises.push(cod.cairo('cairo_set_font_face', cairo, 'NULL'));
+        }
+        if (this.bgColor !== undefined) {
+            promises.push(this.drawFrame(cod, cairo, scale, ppX, ppY));
+        }
+        if (this.bgImage !== undefined) {
+            promises.push(this.drawImage(cod, cairo, scale, ppX, ppY));
+        }
+        if (this.borderWidth > 0) {
+            promises.push(this.drawBorder(cod, cairo, scale, ppX, ppY));
+        }
+        if (this.text) {
+            promises.push(this.drawText(cod, cairo, scale, ppX, ppY));
+        }
+        if (this.customDraw) {
+            promises.push(cod.cairo('cairo_identity_matrix', cairo));
+            promises.push(cod.cairo('cairo_translate', cairo, scale * ppX, scale * ppY));
+            promises.push(cod.cairo('cairo_scale', cairo, scale, scale));
+            promises.push(this.customDraw(cod, cairo, { width: this.width, height: this.height }));
+        }
+        await Promise.all(promises);
+    }
+    async clipDrawing(cod, cairo, scale, ppX, ppY) {
+        if (this.borderRadius === 0) {
+            return;
+        }
+        await Promise.all([
+            this.drawRectPath(cod, cairo, scale, ppX, ppY, this.borderRadius),
+            cod.cairo('cairo_clip', cairo),
+        ]);
+    }
+    async drawFrame(cod, cairo, scale, ppX, ppY) {
+        if (this.bgColor) {
+            const promises = [
+                cod.cairo('cairo_identity_matrix', cairo),
+                cod.cairo('cairo_translate', cairo, scale * ppX, scale * ppY),
+                cod.cairo('cairo_scale', cairo, scale, scale),
+                cod.cairo('cairo_set_source_rgba', cairo, this.bgColor[0], this.bgColor[1], this.bgColor[2], this.bgColor[3]),
+                cod.cairo('cairo_rectangle', cairo, 0, 0, this.width, this.height),
+                cod.cairo('cairo_fill', cairo),
+                cod.cairo('cairo_stroke', cairo),
+            ];
+            await Promise.all(promises);
+        }
+        else {
+            throw new Error('Color of the frame is undefined.');
+        }
+    }
+    async drawImage(cod, cairo, scale, ppX, ppY) {
+        if (this.bgImage === undefined) {
+            return;
+        }
+        const bgImage = this.bgImage.var;
+        const bgWidth = this.bgImage.width;
+        const bgHeight = this.bgImage.height;
+        const promises = new Array();
+        promises.push(cod.cairo('cairo_identity_matrix', cairo));
+        promises.push(cod.cairo('cairo_translate', cairo, scale * ppX, scale * ppY));
+        if (this.bgType === 'fill') {
+            const sx = (scale * this.width) / bgWidth;
+            const sy = (scale * this.height) / bgHeight;
+            promises.push(cod.cairo('cairo_scale', cairo, sx, sy));
+        }
+        else if (this.bgType === 'fit') {
+            const sx = this.width / bgWidth;
+            const sy = this.height / bgHeight;
+            const scaleRatio = scale * Math.min(sx, sy);
+            promises.push(cod.cairo('cairo_scale', cairo, scaleRatio, scaleRatio));
+        }
+        else {
+            promises.push(cod.cairo('cairo_scale', cairo, scale, scale));
+        }
+        promises.push(cod.cairo('cairo_set_source_surface', cairo, bgImage, 0, 0));
+        promises.push(cod.cairo('cairo_paint', cairo));
+        await Promise.all(promises);
+    }
+    async drawText(cod, cairo, scale, ppX, ppY) {
+        const promises = [
+            cod.cairo('cairo_identity_matrix', cairo),
+            cod.cairo('cairo_set_source_rgb', cairo, this.fontColor[0], this.fontColor[1], this.fontColor[2]),
+            cod.writeText(cairo, '' + this.text, Math.floor(scale * ppX), Math.floor(scale * ppY), Math.floor(scale * this.width), Math.floor(scale * this.height), this.align, this.textType),
+        ];
+        await Promise.all(promises);
+    }
+    async drawBorder(cod, cairo, scale, ppX, ppY) {
+        await Promise.all([
+            this.drawRectPath(cod, cairo, scale, ppX, ppY, this.borderRadius),
+            cod.cairo('cairo_set_source_rgba', cairo, this.borderColor[0], this.borderColor[1], this.borderColor[2], this.borderColor[3]),
+            cod.cairo('cairo_set_line_width', cairo, this.borderWidth),
+            cod.cairo('cairo_stroke', cairo),
+        ]);
+    }
+    async drawRectPath(cod, cairo, scale, ppX, ppY, radius) {
+        if (radius === 0) {
+            return await Promise.all([
+                cod.cairo('cairo_identity_matrix', cairo),
+                cod.cairo('cairo_translate', cairo, scale * ppX, scale * ppY),
+                cod.cairo('cairo_scale', cairo, scale, scale),
+                cod.cairo('cairo_rectangle', cairo, 0, 0, this.width, this.height),
+            ]);
+        }
+        else {
+            const degrees = Math.PI / 180;
+            return await Promise.all([
+                cod.cairo('cairo_identity_matrix', cairo),
+                cod.cairo('cairo_translate', cairo, scale * ppX, scale * ppY),
+                cod.cairo('cairo_scale', cairo, scale, scale),
+                cod.cairo('cairo_new_sub_path', cairo),
+                cod.cairo('cairo_arc', cairo, this.width - radius, radius, radius, -90 * degrees, 0 * degrees),
+                cod.cairo('cairo_arc', cairo, this.width - radius, this.height - radius, radius, 0 * degrees, 90 * degrees),
+                cod.cairo('cairo_arc', cairo, radius, this.height - radius, radius, 90 * degrees, 180 * degrees),
+                cod.cairo('cairo_arc', cairo, radius, radius, radius, 180 * degrees, 270 * degrees),
+                cod.cairo('cairo_close_path', cairo),
+            ]);
+        }
+    }
+}
+exports.Frame = Frame;

package/{CamOverlayPainter → cjs/CamOverlayPainter}/Painter.d.ts

@@ -1,11 +1,22 @@
 import { CamOverlayDrawingAPI, CamOverlayDrawingOptions } from '../CamOverlayDrawingAPI';
 import ResourceManager from './ResourceManager';
 import { Frame, TFrameOptions } from './Frame';
-export declare const COORD: Record<string, [number, number]>;
+export declare const COORD: {
+    readonly top_left: readonly [-1, -1];
+    readonly center_left: readonly [-1, 0];
+    readonly bottom_left: readonly [-1, 1];
+    readonly top_center: readonly [0, -1];
+    readonly center: readonly [0, 0];
+    readonly bottom_center: readonly [0, 1];
+    readonly top_right: readonly [1, -1];
+    readonly center_right: readonly [1, 0];
+    readonly bottom_right: readonly [1, 1];
+};
+type TCoAlignment = keyof typeof COORD;
 export type TPainterOptions = TFrameOptions & {
     screenWidth: number;
     screenHeight: number;
-    coAlignment: string;
+    coAlignment: TCoAlignment;
 };
 export declare class Painter extends Frame {
     private screenWidth;
@@ -24,7 +35,7 @@ export declare class Painter extends Frame {
     registerImage(moniker: string, fileName: string): void;
     registerFont(moniker: string, fileName: string): void;
     setScreenSize(sw: number, sh: number): void;
-    setCoAlignment(coAlignment: string): void;
+    setCoAlignment(coAlignment: TCoAlignment): void;
     protected layoutChanged(): void;
     display(scale?: number): Promise<void>;
     hide(): Promise<void>;

package/cjs/CamOverlayPainter/Painter.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceManager = exports.Frame = exports.Painter = exports.COORD = void 0;
+const CamOverlayDrawingAPI_1 = require("../CamOverlayDrawingAPI");
+const ResourceManager_1 = require("./ResourceManager");
+exports.ResourceManager = ResourceManager_1.default;
+const Frame_1 = require("./Frame");
+Object.defineProperty(exports, "Frame", { enumerable: true, get: function () { return Frame_1.Frame; } });
+exports.COORD = {
+    top_left: [-1, -1],
+    center_left: [-1, 0],
+    bottom_left: [-1, 1],
+    top_center: [0, -1],
+    center: [0, 0],
+    bottom_center: [0, 1],
+    top_right: [1, -1],
+    center_right: [1, 0],
+    bottom_right: [1, 1],
+};
+class Painter extends Frame_1.Frame {
+    screenWidth;
+    screenHeight;
+    coAlignment;
+    cod;
+    rm;
+    refreshLayers = true;
+    layers = [];
+    constructor(opt, coopt) {
+        super(opt);
+        this.coAlignment = exports.COORD[opt.coAlignment];
+        this.screenWidth = opt.screenWidth;
+        this.screenHeight = opt.screenHeight;
+        this.cod = new CamOverlayDrawingAPI_1.CamOverlayDrawingAPI(coopt);
+        this.rm = new ResourceManager_1.default(this.cod);
+    }
+    get camOverlayDrawingAPI() {
+        return this.cod;
+    }
+    get resourceManager() {
+        return this.rm;
+    }
+    connect() {
+        this.cod.on('open', () => {
+            this.rm.clear();
+            this.layers = [];
+            this.refreshLayers = true;
+            this.emit('open');
+        });
+        this.cod.on('close', () => {
+            this.emit('close');
+        });
+        this.cod.on('error', (err) => {
+            console.error('Painter:', err);
+        });
+        this.cod.connect();
+    }
+    disconnect() {
+        this.cod.disconnect();
+    }
+    isConnected() {
+        return this.cod.isConnected();
+    }
+    registerImage(moniker, fileName) {
+        this.rm.registerImage(moniker, fileName);
+    }
+    registerFont(moniker, fileName) {
+        this.rm.registerFont(moniker, fileName);
+    }
+    setScreenSize(sw, sh) {
+        this.screenWidth = sw;
+        this.screenHeight = sh;
+    }
+    setCoAlignment(coAlignment) {
+        this.coAlignment = exports.COORD[coAlignment];
+    }
+    layoutChanged() {
+        this.refreshLayers = true;
+    }
+    async display(scale = 1.0) {
+        if (this.enabled) {
+            if (this.refreshLayers) {
+                this.refreshLayers = false;
+                await this.prepareLayers();
+            }
+            let cairo;
+            let surface;
+            let lastCachedLayer;
+            for (let i = 0; i < this.layers.length; i++) {
+                const layer = this.layers[i];
+                if (layer === undefined) {
+                    continue;
+                }
+                if (layer.cairoCache !== undefined &&
+                    layer.surfaceCache !== undefined &&
+                    surface === undefined &&
+                    cairo === undefined) {
+                    lastCachedLayer = layer;
+                    continue;
+                }
+                if (surface === undefined || cairo === undefined) {
+                    [surface, cairo] = await this.prepareSurface(scale, lastCachedLayer?.surfaceCache, lastCachedLayer?.cairoCache);
+                }
+                await this.displayImage(this.cod, this.rm, cairo, -this.posX, -this.posY, scale, layer.layer);
+                if (i < this.layers.length - 1) {
+                    const [surfaceToCache, cairoToCache] = await this.prepareSurface(scale, surface, cairo);
+                    layer.surfaceCache = surfaceToCache;
+                    layer.cairoCache = cairoToCache;
+                }
+            }
+            if (surface !== undefined && cairo !== undefined) {
+                await this.cod.showCairoImage(surface, this.positionConvertor(this.coAlignment[0], this.screenWidth, this.posX, scale * this.width), this.positionConvertor(this.coAlignment[1], this.screenHeight, this.posY, scale * this.height));
+                await this.cleanupSurface(surface, cairo);
+            }
+        }
+    }
+    async hide() {
+        await this.cod.removeImage();
+    }
+    async invalidateLayer(layer) {
+        const layerIdx = this.layers.findIndex((l) => l.layer === layer);
+        if (layerIdx === -1) {
+            return;
+        }
+        for (let i = layerIdx; i < this.layers.length; i++) {
+            const currentLayer = this.layers[i];
+            if (currentLayer?.surfaceCache !== undefined && currentLayer.cairoCache !== undefined) {
+                await this.cleanupSurface(currentLayer.surfaceCache, currentLayer.cairoCache);
+                currentLayer.surfaceCache = undefined;
+                currentLayer.cairoCache = undefined;
+            }
+        }
+    }
+    async prepareLayers() {
+        for (const layer of this.layers) {
+            if (layer.surfaceCache !== undefined && layer.cairoCache !== undefined) {
+                await this.cleanupSurface(layer.surfaceCache, layer.cairoCache);
+            }
+        }
+        const uniqueLayers = this.getLayers();
+        const sortedLayers = Array.from(uniqueLayers).sort((a, b) => a - b);
+        this.layers = sortedLayers.map((layer) => {
+            return { layer };
+        });
+    }
+    async prepareSurface(scale, cachedSurface, cachedCairo) {
+        const surface = (await this.cod.cairo('cairo_image_surface_create', 'CAIRO_FORMAT_ARGB32', Math.floor(this.width * scale), Math.floor(this.height * scale)));
+        const cairo = (await this.cod.cairo('cairo_create', surface.var));
+        if (cachedSurface !== undefined && cachedCairo !== undefined) {
+            await this.cod.cairo('cairo_set_source_surface', cairo.var, cachedSurface, 0, 0);
+            await this.cod.cairo('cairo_paint', cairo.var);
+        }
+        return [surface.var, cairo.var];
+    }
+    async cleanupSurface(surface, cairo) {
+        await this.cod.cairo('cairo_surface_destroy', surface);
+        await this.cod.cairo('cairo_destroy', cairo);
+    }
+    positionConvertor(alignment, screenSize, position, graphicsSize) {
+        switch (alignment) {
+            case -1:
+                return alignment + (2.0 * position) / screenSize;
+            case 0:
+                return alignment - (2.0 * (position + graphicsSize / 2)) / screenSize;
+            case 1:
+                return alignment - (2.0 * (position + graphicsSize)) / screenSize;
+            default:
+                throw new Error('Invalid graphics alignment.');
+        }
+    }
+}
+exports.Painter = Painter;

package/cjs/CamOverlayPainter/ResourceManager.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs/promises");
+class ResourceManager {
+    co;
+    imgFileNames = {};
+    fontFileNames = {};
+    images = {};
+    fonts = {};
+    constructor(co) {
+        this.co = co;
+    }
+    registerImage(moniker, fileName) {
+        this.imgFileNames[moniker] = process.env.INSTALL_PATH + '/images/' + fileName;
+    }
+    registerFont(moniker, fileName) {
+        this.fontFileNames[moniker] = process.env.INSTALL_PATH + '/fonts/' + fileName;
+    }
+    async image(moniker) {
+        if (this.images[moniker] !== undefined) {
+            return this.images[moniker];
+        }
+        if (this.imgFileNames[moniker] !== undefined) {
+            const imgData = await fs.readFile(this.imgFileNames[moniker]);
+            this.images[moniker] = await this.co.uploadImageData(imgData);
+            return this.images[moniker];
+        }
+        throw new Error('Error! Unknown image requested!');
+    }
+    async font(moniker) {
+        if (this.fonts[moniker] !== undefined) {
+            return this.fonts[moniker];
+        }
+        if (this.fontFileNames[moniker] !== undefined) {
+            const fontData = await fs.readFile(this.fontFileNames[moniker]);
+            this.fonts[moniker] = await this.co.uploadFontData(fontData);
+            return this.fonts[moniker];
+        }
+        throw new Error('Error! Unknown font requested!');
+    }
+    clear() {
+        this.images = {};
+        this.fonts = {};
+    }
+}
+exports.default = ResourceManager;

package/cjs/CamScripterAPI.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CamOverlayAPI = void 0;
+const common_1 = require("./internal/common");
+const DefaultClient_1 = require("./node/DefaultClient");
+const CamScripterAPI_1 = require("./types/CamScripterAPI");
+const common_2 = require("./types/common");
+class CamOverlayAPI {
+    client;
+    constructor(options = {}) {
+        if ((0, common_1.isClient)(options)) {
+            this.client = options;
+        }
+        else {
+            this.client = new DefaultClient_1.DefaultClient(options);
+        }
+    }
+    async checkCameraTime() {
+        return (await this.get('/local/camscripter/camera_time.cgi')).state;
+    }
+    async getStorageInfo() {
+        const data = await this.get(`/local/camscripter/package/get_storage.cgi`);
+        return CamScripterAPI_1.storageSchema.parse(data);
+    }
+    async getNetworkCameraList() {
+        const response = await this.get('/local/camscripter/network_camera_list.cgi');
+        return common_2.networkCameraListSchema.parse(response.camera_list);
+    }
+    async getPackageList() {
+        const data = await this.get('/local/camscripter/package/list.cgi');
+        return CamScripterAPI_1.packageInfoListSchema.parse(data);
+    }
+    async installPackages(formData, storage) {
+        await this.post(`/local/camscripter/package/install.cgi?storage=${storage}`, formData);
+    }
+    async uninstallPackage(packageId) {
+        await this.get(`/local/camscripter/package/remove.cgi?package_name=${packageId}`);
+    }
+    async importSettings(packageId, formData) {
+        await this.post(`/local/camscripter/package/data.cgi?action=IMPORT&package_name=${packageId}`, formData);
+    }
+    async exportSettings(packageId, formData) {
+        await this.post(`/local/camscripter/package/data.cgi?action=EXPORT&package_name=${packageId}`, formData);
+    }
+    async getNodejsStatus() {
+        return (await this.get('/local/camscripter/diagnostics.cgi')).node_state;
+    }
+    async installNodejs(storage) {
+        await this.get(`/local/camscripter/node_update.cgi?storage=${storage}`);
+    }
+    async get(path, params) {
+        const res = await this.client.get(path, params);
+        if (res.ok) {
+            return await res.json();
+        }
+        else {
+            throw new Error(await (0, common_1.responseStringify)(res));
+        }
+    }
+    async post(path, data, params) {
+        const res = await this.client.post(path, data, params);
+        if (res.ok) {
+            return await res.json();
+        }
+        else {
+            throw new Error(await (0, common_1.responseStringify)(res));
+        }
+    }
+}
+exports.CamOverlayAPI = CamOverlayAPI;