camstreamerlib 3.2.4 → 3.3.0

package/CamOverlayPainter/Frame.d.ts

@@ -1,50 +1,74 @@
-import { CamOverlayDrawingAPI, TAlign, TUploadImageResponse } from '../CamOverlayDrawingAPI';
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { CamOverlayDrawingAPI, TAlign, TCairoCreateResponse, TUploadImageResponse } from '../CamOverlayDrawingAPI';
 import ResourceManager from './ResourceManager';
 export type TRgb = [number, number, number];
 export type TRgba = [number, number, number, number];
 export type TTmf = 'TFM_OVERFLOW' | 'TFM_SCALE' | 'TFM_TRUNCATE';
 export type TObjectFitType = 'fill' | 'fit' | 'none';
-export type FrameOptions = {
+export type TFrameOptions = {
+    enabled?: boolean;
     x: number;
     y: number;
     width: number;
     height: number;
-    enabled?: boolean;
-    bgImage?: string;
     text?: string;
     fontColor?: TRgb;
+    font?: string;
     bgColor?: TRgba;
+    bgImage?: string;
     bgType?: TObjectFitType;
+    borderRadius?: number;
+    borderWidth?: number;
+    borderColor?: TRgba;
+    customDraw?: TDrawingCallback;
+    layer?: number;
 };
 export type TFrameInfo = {
     width: number;
     height: number;
 };
 export type TDrawingCallback = (cod: CamOverlayDrawingAPI, cairo: string, info: TFrameInfo) => Promise<void>;
-export default class Frame {
-    private customDraw?;
+export interface Frame {
+    on(event: 'layoutChanged', listener: () => void): this;
+    emit(event: 'layoutChanged'): boolean;
+}
+export declare class Frame extends EventEmitter {
+    protected enabled: boolean;
     protected posX: number;
     protected posY: number;
     protected width: number;
     protected height: number;
-    protected enabled: boolean;
     private text;
+    private fontColor;
+    private font?;
     private align;
     private textType;
-    private fontColor;
-    private fontName?;
     private bgColor?;
     private bgImage?;
     private bgType?;
+    private borderRadius;
+    private borderWidth;
+    private borderColor;
+    private customDraw?;
+    private layer;
     protected children: Frame[];
-    constructor(opt: FrameOptions, customDraw?: TDrawingCallback | undefined);
+    constructor(opt: TFrameOptions);
+    enable(): void;
+    disable(): void;
     setFramePosition(x: number, y: number): void;
     setFrameSize(width: number, height: number): void;
-    setText(text: string, align: TAlign, textType?: TTmf, color?: TRgb): void;
+    setText(text: string, align: TAlign, textType?: TTmf, fontColor?: TRgb): void;
+    setFontColor(fontColor: TRgb): void;
     setFont(fontName: string): void;
+    setFontData(fontData: TCairoCreateResponse): void;
     setBgColor(color: TRgba): void;
     setBgImage(imageName: string, type?: TObjectFitType): void;
     setBgImageData(imageData: TUploadImageResponse, type?: TObjectFitType): void;
+    setBgType(type: TObjectFitType): void;
+    setBorderRadius(radius: number): void;
+    setBorderWidth(width: number): void;
+    setBorderColor(color: TRgba): void;
     setCustomDraw(customDraw: TDrawingCallback): void;
     resetFont(): void;
     resetBgColor(): void;
@@ -52,12 +76,15 @@ export default class Frame {
     resetCustomDraw(): void;
     clear(): void;
     insert(...frames: Frame[]): void;
-    enable(): void;
-    disable(): void;
-    displayImage(cod: CamOverlayDrawingAPI, rm: ResourceManager, cairo: string, ppX: number, ppY: number, scale?: number): Promise<void>;
-    protected displayOwnImage(cod: CamOverlayDrawingAPI, rm: ResourceManager, cairo: string, ppX: number, ppY: number, scale: number): Promise<void>;
+    getLayers(): Set<number>;
+    protected layoutChanged(): void;
+    displayImage(cod: CamOverlayDrawingAPI, resourceManager: ResourceManager, cairo: string, ppX: number, ppY: number, scale: number, layer: number): Promise<void>;
+    private prepareResources;
+    protected displayOwnImage(cod: CamOverlayDrawingAPI, cairo: string, ppX: number, ppY: number, scale: number): Promise<void>;
+    private clipDrawing;
     private drawFrame;
     private drawImage;
     private drawText;
+    private drawBorder;
+    private drawRectPath;
 }
-export { Frame };

package/CamOverlayPainter/Frame.js

@@ -10,24 +10,37 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Frame = void 0;
-class Frame {
-    constructor(opt, customDraw) {
-        var _a, _b, _c;
-        this.customDraw = customDraw;
+const events_1 = require("events");
+class Frame extends events_1.EventEmitter {
+    constructor(opt) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        super();
         this.text = '';
         this.align = 'A_LEFT';
         this.textType = 'TFM_OVERFLOW';
         this.children = new Array();
+        this.enabled = (_a = opt.enabled) !== null && _a !== void 0 ? _a : true;
         this.posX = opt.x;
         this.posY = opt.y;
         this.width = opt.width;
         this.height = opt.height;
-        this.enabled = (_a = opt.enabled) !== null && _a !== void 0 ? _a : true;
         this.setText((_b = opt.text) !== null && _b !== void 0 ? _b : '', 'A_LEFT');
         this.fontColor = (_c = opt.fontColor) !== null && _c !== void 0 ? _c : [1.0, 1.0, 1.0];
+        this.font = opt.font;
         this.bgColor = opt.bgColor;
         this.bgImage = opt.bgImage;
         this.bgType = opt.bgType;
+        this.borderRadius = (_d = opt.borderRadius) !== null && _d !== void 0 ? _d : 0;
+        this.borderWidth = (_e = opt.borderWidth) !== null && _e !== void 0 ? _e : 0;
+        this.borderColor = (_f = opt.borderColor) !== null && _f !== void 0 ? _f : [1, 1, 1, 1];
+        this.customDraw = opt.customDraw;
+        this.layer = (_g = opt.layer) !== null && _g !== void 0 ? _g : 0;
+    }
+    enable() {
+        this.enabled = true;
+    }
+    disable() {
+        this.enabled = false;
     }
     setFramePosition(x, y) {
         this.posX = x;
@@ -37,16 +50,22 @@ class Frame {
         this.width = width;
         this.height = height;
     }
-    setText(text, align, textType = 'TFM_OVERFLOW', color) {
+    setText(text, align, textType = 'TFM_OVERFLOW', fontColor) {
         this.text = text;
         this.align = align;
         this.textType = textType;
-        if (color) {
-            this.fontColor = color;
+        if (fontColor) {
+            this.fontColor = fontColor;
         }
     }
+    setFontColor(fontColor) {
+        this.fontColor = fontColor;
+    }
     setFont(fontName) {
-        this.fontName = fontName;
+        this.font = fontName;
+    }
+    setFontData(fontData) {
+        this.font = fontData;
     }
     setBgColor(color) {
         this.bgColor = color;
@@ -59,11 +78,23 @@ class Frame {
         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.fontName = undefined;
+        this.font = undefined;
     }
     resetBgColor() {
         this.bgColor = undefined;
@@ -80,7 +111,7 @@ class Frame {
         this.align = 'A_LEFT';
         this.textType = 'TFM_OVERFLOW';
         this.fontColor = [1.0, 1.0, 1.0];
-        this.fontName = undefined;
+        this.font = undefined;
         this.bgColor = undefined;
         this.bgImage = undefined;
         this.bgType = undefined;
@@ -88,55 +119,96 @@ class Frame {
     }
     insert(...frames) {
         this.children.push(...frames);
+        for (const frame of frames) {
+            frame.on('layoutChanged', () => this.layoutChanged());
+        }
+        this.layoutChanged();
     }
-    enable() {
-        this.enabled = true;
+    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;
     }
-    disable() {
-        this.enabled = false;
+    layoutChanged() {
+        this.emit('layoutChanged');
     }
-    displayImage(cod, rm, cairo, ppX, ppY, scale = 1) {
+    displayImage(cod, resourceManager, cairo, ppX, ppY, scale, layer) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.enabled) {
                 ppX += this.posX;
                 ppY += this.posY;
-                yield this.displayOwnImage(cod, rm, cairo, ppX, ppY, scale);
+                yield this.prepareResources(resourceManager);
+                yield cod.cairo('cairo_save', cairo);
+                yield this.clipDrawing(cod, cairo, scale, ppX, ppY);
+                if (this.layer === layer) {
+                    yield this.displayOwnImage(cod, cairo, ppX, ppY, scale);
+                }
                 for (const child of this.children) {
-                    yield child.displayImage(cod, rm, cairo, ppX, ppY, scale);
+                    yield child.displayImage(cod, resourceManager, cairo, ppX, ppY, scale, layer);
                 }
+                yield cod.cairo('cairo_restore', cairo);
             }
         });
     }
-    displayOwnImage(cod, rm, cairo, ppX, ppY, scale) {
+    prepareResources(resourceManager) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.enabled) {
-                const promises = new Array();
-                if (this.fontName !== undefined) {
-                    const fontData = yield rm.font(this.fontName);
-                    promises.push(cod.cairo('cairo_set_font_face', cairo, fontData.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, rm, 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 }));
-                }
-                yield Promise.all(promises);
+            if (typeof this.bgImage === 'string') {
+                this.bgImage = yield resourceManager.image(this.bgImage);
+            }
+            if (typeof this.font === 'string') {
+                this.font = yield resourceManager.font(this.font);
             }
         });
     }
+    displayOwnImage(cod, cairo, ppX, ppY, scale) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.enabled) {
+                return;
+            }
+            const promises = new Array();
+            if (this.font !== undefined && typeof this.font !== 'string') {
+                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 }));
+            }
+            yield Promise.all(promises);
+        });
+    }
+    clipDrawing(cod, cairo, scale, ppX, ppY) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.borderRadius === 0) {
+                return;
+            }
+            yield Promise.all([
+                this.drawRectPath(cod, cairo, scale, ppX, ppY, this.borderRadius),
+                cod.cairo('cairo_clip', cairo),
+            ]);
+        });
+    }
     drawFrame(cod, cairo, scale, ppX, ppY) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.bgColor) {
@@ -152,16 +224,18 @@ class Frame {
                 yield Promise.all(promises);
             }
             else {
-                throw new Error('Colour of this frame is undefined.');
+                throw new Error('Color of the frame is undefined.');
             }
         });
     }
-    drawImage(cod, rm, cairo, scale, ppX, ppY) {
+    drawImage(cod, cairo, scale, ppX, ppY) {
         return __awaiter(this, void 0, void 0, function* () {
-            const imageData = typeof this.bgImage === 'string' ? yield rm.image(this.bgImage) : this.bgImage;
-            const bgImage = imageData.var;
-            const bgWidth = imageData.width;
-            const bgHeight = imageData.height;
+            if (this.bgImage === undefined || typeof this.bgImage === 'string') {
+                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));
@@ -194,6 +268,41 @@ class Frame {
             yield Promise.all(promises);
         });
     }
+    drawBorder(cod, cairo, scale, ppX, ppY) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield 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),
+            ]);
+        });
+    }
+    drawRectPath(cod, cairo, scale, ppX, ppY, radius) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (radius === 0) {
+                return yield 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 yield 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.default = Frame;
 exports.Frame = Frame;

package/CamOverlayPainter/Painter.d.ts

@@ -1,34 +1,37 @@
 import { CamOverlayDrawingAPI, CamOverlayDrawingOptions } from '../CamOverlayDrawingAPI';
 import ResourceManager from './ResourceManager';
-import { Frame, FrameOptions } from './Frame';
+import { Frame, TFrameOptions } from './Frame';
 export declare const COORD: Record<string, [number, number]>;
-export type PainterOptions = FrameOptions & {
+export type TPainterOptions = TFrameOptions & {
     screenWidth: number;
     screenHeight: number;
     coAlignment: string;
 };
-export default class Painter extends Frame {
+export declare class Painter extends Frame {
     private screenWidth;
     private screenHeight;
     private coAlignment;
-    private surface?;
-    private cairo?;
     private cod;
     private rm;
+    private refreshLayers;
+    private layers;
+    constructor(opt: TPainterOptions, coopt: CamOverlayDrawingOptions);
     get camOverlayDrawingAPI(): CamOverlayDrawingAPI;
     get resourceManager(): ResourceManager;
-    constructor(opt: PainterOptions, coopt: CamOverlayDrawingOptions);
     connect(): void;
     disconnect(): void;
     isConnected(): boolean;
     registerImage(moniker: string, fileName: string): void;
     registerFont(moniker: string, fileName: string): void;
     setScreenSize(sw: number, sh: number): void;
-    setCoAlignment(coa: string): void;
+    setCoAlignment(coAlignment: string): void;
+    protected layoutChanged(): void;
     display(scale?: number): Promise<void>;
     hide(): Promise<void>;
+    invalidateLayer(layer: number): Promise<void>;
+    private prepareLayers;
+    private prepareSurface;
+    private cleanupSurface;
     private positionConvertor;
-    private prepareDrawing;
-    private destroy;
 }
-export { Painter, Frame, FrameOptions, ResourceManager, CamOverlayDrawingOptions };
+export { Frame, TFrameOptions as FrameOptions, ResourceManager, CamOverlayDrawingOptions };

package/CamOverlayPainter/Painter.js

@@ -27,20 +27,22 @@ exports.COORD = {
     bottom_right: [1, 1],
 };
 class Painter extends Frame_1.Frame {
-    get camOverlayDrawingAPI() {
-        return this.cod;
-    }
-    get resourceManager() {
-        return this.rm;
-    }
     constructor(opt, coopt) {
         super(opt);
+        this.refreshLayers = true;
+        this.layers = [];
         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();
@@ -66,19 +68,45 @@ class Painter extends Frame_1.Frame {
         this.screenWidth = sw;
         this.screenHeight = sh;
     }
-    setCoAlignment(coa) {
-        this.coAlignment = exports.COORD[coa];
+    setCoAlignment(coAlignment) {
+        this.coAlignment = exports.COORD[coAlignment];
     }
-    display(scale = 1) {
+    layoutChanged() {
+        this.refreshLayers = true;
+    }
+    display(scale = 1.0) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.enabled) {
-                [this.surface, this.cairo] = yield this.prepareDrawing(scale);
-                yield this.displayOwnImage(this.cod, this.rm, this.cairo, 0, 0, scale);
-                for (const child of this.children) {
-                    yield child.displayImage(this.cod, this.rm, this.cairo, 0, 0, scale);
+                if (this.refreshLayers) {
+                    this.refreshLayers = false;
+                    yield this.prepareLayers();
+                }
+                let cairo;
+                let surface;
+                let lastCachedLayer;
+                for (let i = 0; i < this.layers.length; i++) {
+                    const layer = this.layers[i];
+                    if (layer.cairoCache !== undefined &&
+                        layer.surfaceCache !== undefined &&
+                        surface === undefined &&
+                        cairo === undefined) {
+                        lastCachedLayer = layer;
+                        continue;
+                    }
+                    if (surface === undefined || cairo === undefined) {
+                        [surface, cairo] = yield this.prepareSurface(scale, lastCachedLayer === null || lastCachedLayer === void 0 ? void 0 : lastCachedLayer.surfaceCache, lastCachedLayer === null || lastCachedLayer === void 0 ? void 0 : lastCachedLayer.cairoCache);
+                    }
+                    yield this.displayImage(this.cod, this.rm, cairo, 0, 0, scale, layer.layer);
+                    if (i < this.layers.length - 1) {
+                        const [surfaceToCache, cairoToCache] = yield this.prepareSurface(scale, surface, cairo);
+                        layer.surfaceCache = surfaceToCache;
+                        layer.cairoCache = cairoToCache;
+                    }
+                }
+                if (surface !== undefined && cairo !== undefined) {
+                    yield 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));
+                    yield this.cleanupSurface(surface, cairo);
                 }
-                yield this.cod.showCairoImage(this.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));
-                yield this.destroy();
             }
         });
     }
@@ -87,6 +115,53 @@ class Painter extends Frame_1.Frame {
             yield this.cod.removeImage();
         });
     }
+    invalidateLayer(layer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const layerIdx = this.layers.findIndex((l) => l.layer === layer);
+            if (layerIdx === -1) {
+                return;
+            }
+            for (let i = layerIdx; i < this.layers.length; i++) {
+                const layer = this.layers[i];
+                if (layer.surfaceCache !== undefined && layer.cairoCache !== undefined) {
+                    yield this.cleanupSurface(layer.surfaceCache, layer.cairoCache);
+                    layer.surfaceCache = undefined;
+                    layer.cairoCache = undefined;
+                }
+            }
+        });
+    }
+    prepareLayers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const layer of this.layers) {
+                if (layer.surfaceCache !== undefined && layer.cairoCache !== undefined) {
+                    yield 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 };
+            });
+        });
+    }
+    prepareSurface(scale, cachedSurface, cachedCairo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const surface = (yield this.cod.cairo('cairo_image_surface_create', 'CAIRO_FORMAT_ARGB32', Math.floor(this.width * scale), Math.floor(this.height * scale)));
+            const cairo = (yield this.cod.cairo('cairo_create', surface.var));
+            if (cachedSurface !== undefined && cachedCairo !== undefined) {
+                yield this.cod.cairo('cairo_set_source_surface', cairo.var, cachedSurface, 0, 0);
+                yield this.cod.cairo('cairo_paint', cairo.var);
+            }
+            return [surface.var, cairo.var];
+        });
+    }
+    cleanupSurface(surface, cairo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.cod.cairo('cairo_surface_destroy', surface);
+            yield this.cod.cairo('cairo_destroy', cairo);
+        });
+    }
     positionConvertor(alignment, screenSize, position, graphicsSize) {
         switch (alignment) {
             case -1:
@@ -99,19 +174,5 @@ class Painter extends Frame_1.Frame {
                 throw new Error('Invalid graphics alignment.');
         }
     }
-    prepareDrawing(scale) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const surface = (yield this.cod.cairo('cairo_image_surface_create', 'CAIRO_FORMAT_ARGB32', Math.floor(this.width * scale), Math.floor(this.height * scale)));
-            const cairo = (yield this.cod.cairo('cairo_create', surface.var));
-            return [surface.var, cairo.var];
-        });
-    }
-    destroy() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.cod.cairo('cairo_surface_destroy', this.surface);
-            yield this.cod.cairo('cairo_destroy', this.cairo);
-        });
-    }
 }
-exports.default = Painter;
 exports.Painter = Painter;

package/CameraVapix.d.ts

@@ -78,13 +78,13 @@ export declare class CameraVapix {
     getTimezone(): Promise<string>;
     getHeaders(): Promise<Record<string, string>>;
     setHeaders(headers: Record<string, string>): Promise<Response>;
-    private parseGetParametrs;
+    private parseParameters;
     getParameterGroup(groupNames: string): Promise<Record<string, string>>;
     setParameter(params: Record<string, string>): Promise<Response>;
     getGuardTourList(): Promise<TGuardTour[]>;
-    setGuardTourEnabled(gourTourID: string, enable: boolean): Promise<Response>;
+    setGuardTourEnabled(guardTourID: string, enable: boolean): Promise<Response>;
     private parsePtz;
-    private parseCameraPtzFromReq;
+    private parseCameraPtzResponse;
     getPTZPresetList(channel: number): Promise<string[]>;
     listPtzVideoSourceOverview(): Promise<TPtzOverview>;
     goToPreset(channel: number, presetName: string): Promise<Response>;

package/CameraVapix.js

@@ -46,8 +46,7 @@ class CameraVapix {
     }
     getCameraImage(camera, compression, resolution, outputStream) {
         return __awaiter(this, void 0, void 0, function* () {
-            const path = `/axis-cgi/jpg/image.cgi?resolution=${resolution}&compression=${compression}&camera=${camera}`;
-            const res = yield this.vapixGet(path);
+            const res = yield this.vapixGet('/axis-cgi/jpg/image.cgi', { resolution, compression, camera });
             if (res.body) {
                 void res.body.pipeTo(outputStream);
             }
@@ -181,40 +180,26 @@ class CameraVapix {
             return this.vapixPost('/axis-cgi/customhttpheader.cgi', data);
         });
     }
-    parseGetParametrs(response) {
+    parseParameters(response) {
         const params = {};
         const lines = response.split(/[\r\n]/);
         for (let i = 0; i < lines.length; i++) {
-            if (lines[i].substring(0, 7) === '# Error') {
+            if (lines[i].length === 0 || lines[i].substring(0, 7) === '# Error') {
                 continue;
             }
-            if (lines[i].length) {
-                const p = lines[i].split(/=(.+)/);
-                if (p.length >= 2) {
-                    const paramName = p[0].replace('root.', '');
-                    params[paramName] = String(p[1]);
-                }
-                else if (p[0].substring(0, 7) !== '# Error') {
-                    params[p[0].slice(0, -1)] = '';
-                }
+            const delimiterPos = lines[i].indexOf('=');
+            if (delimiterPos !== -1) {
+                const paramName = lines[i].substring(0, delimiterPos);
+                const paramValue = lines[i].substring(delimiterPos + 1);
+                params[paramName] = paramValue;
             }
         }
         return params;
     }
     getParameterGroup(groupNames) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield (yield this.vapixGet(`/axis-cgi/param.cgi?action=list&group=${encodeURIComponent(groupNames)}`)).text();
-            const params = {};
-            const lines = response.split(/[\r\n]/);
-            for (let i = 0; i < lines.length; i++) {
-                if (lines[i].length) {
-                    const p = lines[i].split('=');
-                    if (p.length >= 2) {
-                        params[p[0]] = p[1];
-                    }
-                }
-            }
-            return params;
+            const response = yield this.vapixGet('/axis-cgi/param.cgi', { action: 'list', group: groupNames });
+            return this.parseParameters(yield response.text());
         });
     }
     setParameter(params) {
@@ -263,26 +248,26 @@ class CameraVapix {
             return gTourList;
         });
     }
-    setGuardTourEnabled(gourTourID, enable) {
+    setGuardTourEnabled(guardTourID, enable) {
         const options = {};
-        options[gourTourID + '.Running'] = enable ? 'yes' : 'no';
+        options[guardTourID + '.Running'] = enable ? 'yes' : 'no';
         return this.setParameter(options);
     }
     parsePtz(parsed) {
         const res = [];
         parsed.forEach((value) => {
-            const valueData = value.split('=');
-            if (valueData.length < 2) {
+            const delimiterPos = value.indexOf('=');
+            if (delimiterPos === -1) {
                 return;
             }
-            if (!valueData[0].startsWith('presetposno')) {
+            if (!value.startsWith('presetposno')) {
                 return;
             }
-            const id = Number(valueData[0].replace('presetposno', ''));
+            const id = Number(value.substring(11, delimiterPos));
             if (Number.isNaN(id)) {
                 return;
             }
-            const data = valueData[1].split(':');
+            const data = value.substring(delimiterPos + 1).split(':');
             const getValue = (valueName) => {
                 for (const d of data) {
                     const p = d.split('=');
@@ -304,7 +289,7 @@ class CameraVapix {
         });
         return res;
     }
-    parseCameraPtzFromReq(response) {
+    parseCameraPtzResponse(response) {
         const json = JSON.parse(response);
         const parsed = {};
         Object.keys(json).forEach((key) => {
@@ -320,7 +305,7 @@ class CameraVapix {
     }
     getPTZPresetList(channel) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield (yield this.vapixGet(`/axis-cgi/com/ptz.cgi?query=presetposcam&camera=${encodeURIComponent(channel)}`)).text();
+            const response = yield (yield this.vapixGet('/axis-cgi/com/ptz.cgi', { query: 'presetposcam', camera: channel.toString() })).text();
             const positions = [];
             const lines = response.split(/[\r\n]/);
             for (const line of lines) {
@@ -338,11 +323,11 @@ class CameraVapix {
     listPtzVideoSourceOverview() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const response = yield this.vapixGet(`/axis-cgi/com/ptz.cgi`, {
+                const response = yield this.vapixGet('/axis-cgi/com/ptz.cgi', {
                     query: 'presetposall',
                     format: 'json',
                 });
-                const data = this.parseCameraPtzFromReq(yield response.text());
+                const data = this.parseCameraPtzResponse(yield response.text());
                 const res = {};
                 Object.keys(data).forEach((camera) => {
                     res[Number(camera) - 1] = data[Number(camera)].map((_a) => {
@@ -358,40 +343,36 @@ class CameraVapix {
         });
     }
     goToPreset(channel, presetName) {
-        return this.vapixPost('/axis-cgi/com/ptz.cgi', `camera=${encodeURIComponent(channel)}&gotoserverpresetname=${encodeURIComponent(presetName)}`);
+        return this.vapixGet('/axis-cgi/com/ptz.cgi', { camera: channel.toString(), gotoserverpresetname: presetName });
     }
     getPtzPosition(camera) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const res = yield this.vapixGet(`/axis-cgi/com/ptz.cgi`, {
+                const res = yield this.vapixGet('/axis-cgi/com/ptz.cgi', {
                     query: 'position',
                     camera: camera.toString(),
                 });
-                const data = this.parseGetParametrs(yield res.text());
+                const params = this.parseParameters(yield res.text());
                 return {
-                    pan: Number(data.pan),
-                    tilt: Number(data.tilt),
-                    zoom: Number(data.zoom),
+                    pan: Number(params.pan),
+                    tilt: Number(params.tilt),
+                    zoom: Number(params.zoom),
                 };
             }
             catch (err) {
-                return {
-                    pan: 0,
-                    tilt: 0,
-                    zoom: 0,
-                };
+                return { pan: 0, tilt: 0, zoom: 0 };
             }
         });
     }
     getInputState(port) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield (yield this.vapixPost('/axis-cgi/io/port.cgi', `checkactive=${encodeURIComponent(port)}`)).text();
+            const response = yield (yield this.vapixGet('/axis-cgi/io/port.cgi', { checkactive: port.toString() })).text();
             return response.split('=')[1].indexOf('active') === 0;
         });
     }
     setOutputState(port, active) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.vapixPost('/axis-cgi/io/port.cgi', `action=${encodeURIComponent(port)}:${active ? '/' : '\\'}`);
+            return this.vapixGet('/axis-cgi/io/port.cgi', { action: active ? `${port}:/` : `${port}:\\` });
         });
     }
     getApplicationList() {

package/DefaultAgent.js

@@ -50,7 +50,7 @@ class DefaultAgent {
             path += '&';
         }
         for (const key in params) {
-            path += `${key}=${params[key]}&`;
+            path += `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}&`;
         }
         path = path.slice(0, path.length - 1);
         return {

package/README.md

@@ -2,7 +2,7 @@
 
 Node.js helper library for CamStreamer ACAP applications.
 
-The library is primarily developed for CamScripter Acap application running directly in Axis cameras.
+The library is primarily developed for the CamScripter ACAP application running directly in Axis cameras.
 Examples of CamScripter packages can be found at https://github.com/CamStreamer/CamScripterApp_examples
 
 ## Installation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "camstreamerlib",
-  "version": "3.2.4",
+  "version": "3.3.0",
   "description": "Helper library for CamStreamer ACAP applications.",
   "prettier": "@camstreamer/prettier-config",
   "dependencies": {