nodejs-audio-visualizer 5.0.0 → 5.2.0

package/dist/image.js

@@ -1,459 +1,546 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var bmp_js_1 = require("bmp-js");
-var jimp_1 = __importDefault(require("jimp"));
-exports.mixValues = function (value1, value1Opacity, value2) {
-    return Math.round(value2 * (1 - value1Opacity) + value1 * value1Opacity);
-};
-exports.mixColors = function (_a) {
-    var color = _a.color, colorOpacity = _a.colorOpacity, backgroundColor = _a.backgroundColor;
-    return {
-        red: exports.mixValues(color.red, colorOpacity, backgroundColor.red),
-        green: exports.mixValues(color.green, colorOpacity, backgroundColor.green),
-        blue: exports.mixValues(color.blue, colorOpacity, backgroundColor.blue),
-    };
-};
-var getRectPixelColor = function (params) {
-    var imageDstBuffer = params.imageDstBuffer, pixelIndex = params.pixelIndex, color = params.color, opacity = params.opacity;
-    if (opacity === 1) {
-        return color;
-    }
-    var backgroundPixelColor = {
-        blue: imageDstBuffer.data[pixelIndex],
-        green: imageDstBuffer.data[pixelIndex + 1],
-        red: imageDstBuffer.data[pixelIndex + 2],
-    };
-    var resultColor = exports.mixColors({
-        color: color,
-        colorOpacity: opacity,
-        backgroundColor: backgroundPixelColor,
-    });
-    return resultColor;
-};
-exports.drawRect = function (_a) {
-    var imageDstBuffer = _a.imageDstBuffer, position = _a.position, size = _a.size, color = _a.color, opacity = _a.opacity;
-    for (var currY = position.y; currY < position.y + size.height; currY++) {
-        for (var currX = position.x; currX < position.x + size.width; currX++) {
-            var pixelIndex = imageDstBuffer.shiftPos + currY * imageDstBuffer.rowBytes + currX * 3;
-            var pixelColor = getRectPixelColor({
-                imageDstBuffer: imageDstBuffer,
-                pixelIndex: pixelIndex,
-                color: color,
-                opacity: opacity,
-            });
-            imageDstBuffer.data[pixelIndex] = pixelColor.blue;
-            imageDstBuffer.data[pixelIndex + 1] = pixelColor.green;
-            imageDstBuffer.data[pixelIndex + 2] = pixelColor.red;
-        }
-    }
-};
-var buildQuadEdgeTable = function (points) {
-    var edges = [];
-    for (var i = 0; i < points.length; i++) {
-        var p1 = points[i];
-        var p2 = points[(i + 1) % points.length];
-        if (p1.y === p2.y)
-            continue; // Skip horizontal edges
-        var yMin = Math.min(p1.y, p2.y);
-        var yMax = Math.max(p1.y, p2.y);
-        var x = p1.y < p2.y ? p1.x : p2.x;
-        var dx = (p2.x - p1.x) / (p2.y - p1.y);
-        edges.push({ yMin: yMin, yMax: yMax, x: x, dx: dx });
-    }
-    return edges.sort(function (a, b) { return a.yMin - b.yMin; });
-};
-/**
- * Fills a quadrilateral (4-sided polygon) using scan-line algorithm
- * Only the outer edges are anti-aliased
- */
-exports.fillRect = function (_a) {
-    var imageDstBuffer = _a.imageDstBuffer, points = _a.points, color = _a.color, opacity = _a.opacity;
-    // Build edge table from all 4 vertices
-    var edgeTable = buildQuadEdgeTable(points);
-    if (edgeTable.length === 0)
-        return;
-    // Find the bounding box
-    var yMin = Math.min.apply(Math, points.map(function (p) { return p.y; }));
-    var yMax = Math.max.apply(Math, points.map(function (p) { return p.y; }));
-    // Active Edge Table for scan line algorithm
-    var activeEdges = [];
-    // Scan line algorithm: process each horizontal line
-    for (var y = Math.floor(yMin); y <= Math.ceil(yMax); y++) {
-        // Add edges that start at this scanline to AET
-        for (var _i = 0, edgeTable_1 = edgeTable; _i < edgeTable_1.length; _i++) {
-            var edge = edgeTable_1[_i];
-            if (Math.floor(edge.yMin) === y) {
-                activeEdges.push(__assign({}, edge));
-            }
-        }
-        // Remove edges that end at this scanline from AET
-        for (var i = activeEdges.length - 1; i >= 0; i--) {
-            if (Math.ceil(activeEdges[i].yMax) <= y) {
-                activeEdges.splice(i, 1);
-            }
-        }
-        // Sort active edges by x coordinate
-        activeEdges.sort(function (a, b) { return a.x - b.x; });
-        // Fill pixels between pairs of intersections
-        for (var i = 0; i < activeEdges.length; i += 2) {
-            if (i + 1 < activeEdges.length) {
-                var xStart = activeEdges[i].x;
-                var xEnd = activeEdges[i + 1].x;
-                // Anti-aliased rendering with sub-pixel precision
-                var xStartFloor = Math.floor(xStart);
-                var xEndCeil = Math.ceil(xEnd);
-                for (var x = xStartFloor; x < xEndCeil; x++) {
-                    var pixelIndex = imageDstBuffer.shiftPos + y * imageDstBuffer.rowBytes + x * 3;
-                    // Calculate coverage for anti-aliasing
-                    var coverage = 1.0;
-                    if (x === xStartFloor) {
-                        // Left edge pixel - calculate fractional coverage
-                        coverage = Math.min(1.0, 1.0 - (xStart - xStartFloor));
-                    }
-                    else if (x === xEndCeil - 1) {
-                        // Right edge pixel - calculate fractional coverage
-                        coverage = Math.min(1.0, xEnd - Math.floor(xEnd));
-                    }
-                    // Apply coverage to opacity for smooth edges
-                    var effectiveOpacity = opacity * coverage;
-                    var pixelColor = getRectPixelColor({
-                        imageDstBuffer: imageDstBuffer,
-                        pixelIndex: pixelIndex,
-                        color: color,
-                        opacity: effectiveOpacity,
-                    });
-                    imageDstBuffer.data[pixelIndex] = pixelColor.blue;
-                    imageDstBuffer.data[pixelIndex + 1] = pixelColor.green;
-                    imageDstBuffer.data[pixelIndex + 2] = pixelColor.red;
-                }
-            }
-        }
-        // Update x coordinates for next scanline (x' = x + dx)
-        for (var _b = 0, activeEdges_1 = activeEdges; _b < activeEdges_1.length; _b++) {
-            var edge = activeEdges_1[_b];
-            edge.x += edge.dx;
-        }
-    }
-};
-var getRectY = function (rotation, top, height, rectHeight) {
-    switch (rotation) {
-        case 'up':
-            return top + height - rectHeight;
-        case 'mirror':
-            return top + Math.trunc((height - rectHeight) / 2);
-        default:
-            return top;
-    }
-};
-var minRectHeight = 2;
-var getRectHeight = function (height, spectrumValue) {
-    var rectHeight = Math.trunc(height * spectrumValue);
-    if (rectHeight < minRectHeight) {
-        return minRectHeight;
-    }
-    return rectHeight;
-};
-var drawSpectrum = function (_a) {
-    var imageDstBuffer = _a.imageDstBuffer, spectrum = _a.spectrum, size = _a.size, position = _a.position, rotation = _a.rotation, margin = _a.margin, color = _a.color, opacity = _a.opacity;
-    var busWidth = Math.trunc(size.width / spectrum.length);
-    var left = Math.trunc(position.x);
-    var top = Math.trunc(position.y);
-    var height = Math.trunc(size.height);
-    for (var spectrumX = 0; spectrumX < spectrum.length; spectrumX++) {
-        var spectrumValue = spectrum[spectrumX];
-        if ((spectrumValue > 1) || (spectrumValue < 0)) {
-            throw new Error('Spectrum values must be in range from 0 to 1');
-        }
-        var rectX = left + busWidth * spectrumX;
-        var rectHeight = getRectHeight(height, spectrumValue);
-        var rectY = getRectY(rotation, top, height, rectHeight);
-        exports.drawRect({
-            imageDstBuffer: imageDstBuffer,
-            position: { x: rectX + margin, y: rectY },
-            size: { width: busWidth - margin / 2, height: rectHeight },
-            color: color,
-            opacity: opacity,
-        });
-    }
-};
-var calcCirclePoint = function (angleRadians, radius) {
-    var circleX = radius * Math.cos(angleRadians);
-    var circleY = radius * Math.sin(angleRadians);
-    return { x: circleX, y: circleY };
-};
-var lerp = function (start, end, t) {
-    return start + (end - start) * t;
-};
-var drawPolarSpectrum = function (_a) {
-    var imageDstBuffer = _a.imageDstBuffer, spectrum = _a.spectrum, centerX = _a.centerX, centerY = _a.centerY, innerRadius = _a.innerRadius, maxBarLength = _a.maxBarLength, barWidth = _a.barWidth, color = _a.color, opacity = _a.opacity;
-    var angleStep = (2 * Math.PI) / spectrum.length;
-    var innerLength = innerRadius * 2 * Math.PI;
-    var radiansPerPixel = 2 * Math.PI / innerLength;
-    var barWidthInRadians = radiansPerPixel * barWidth;
-    var spectrumAverage = spectrum.reduce(function (a, b) { return a + b; }, 0) / spectrum.length;
-    var scaleFactor = lerp(0.75, 1, spectrumAverage);
-    var scaledMaxOuterRadius = (innerRadius + maxBarLength) * scaleFactor;
-    var scaledInnerRadius = innerRadius * scaleFactor;
-    for (var i = 0; i < spectrum.length; i++) {
-        var currentSpectrumValue = spectrum[i] || 0;
-        var busRadius = lerp(scaledInnerRadius, scaledMaxOuterRadius, currentSpectrumValue);
-        var angle = i * angleStep;
-        var angleRadiansStart = angle;
-        var angleRadiansEnd = angle + barWidthInRadians;
-        var point1 = calcCirclePoint(angleRadiansStart, scaledInnerRadius);
-        var point2 = calcCirclePoint(angleRadiansStart, busRadius);
-        var point3 = calcCirclePoint(angleRadiansEnd, scaledInnerRadius);
-        var point4 = calcCirclePoint(angleRadiansEnd, busRadius);
-        exports.fillRect({
-            imageDstBuffer: imageDstBuffer,
-            points: [
-                { x: centerX + Math.round(point1.x), y: centerY + Math.round(point1.y) },
-                { x: centerX + Math.round(point2.x), y: centerY + Math.round(point2.y) },
-                { x: centerX + Math.round(point4.x), y: centerY + Math.round(point4.y) },
-                { x: centerX + Math.round(point3.x), y: centerY + Math.round(point3.y) },
-            ],
-            color: color,
-            opacity: opacity,
-        });
-    }
-};
-exports.createSpectrumVisualizerFrameGenerator = function () {
-    var prevSpectrum = null;
-    return function (_a) {
-        var backgroundImageBuffer = _a.backgroundImageBuffer, spectrum = _a.spectrum, size = _a.size, position = _a.position, rotation = _a.rotation, margin = _a.margin, color = _a.color, opacity = _a.opacity, spectrumEffect = _a.spectrumEffect;
-        var imageDstBuffer = Object.assign({}, backgroundImageBuffer);
-        imageDstBuffer.data = Buffer.from(backgroundImageBuffer.data);
-        var rgbSpectrumColor = (typeof color === 'string') ? hexToRgb(color) : color;
-        if (spectrumEffect === 'volume') {
-            drawSpectrum({
-                imageDstBuffer: imageDstBuffer,
-                spectrum: spectrum,
-                size: size,
-                position: { x: position.x + 2, y: position.y + 2 },
-                rotation: rotation,
-                margin: margin,
-                color: rgbSpectrumColor,
-                opacity: opacity * 0.5,
-            });
-        }
-        if (spectrumEffect === 'smooth' && prevSpectrum) {
-            drawSpectrum({
-                imageDstBuffer: imageDstBuffer,
-                spectrum: prevSpectrum,
-                size: size,
-                position: position,
-                rotation: rotation,
-                margin: margin,
-                color: rgbSpectrumColor,
-                opacity: opacity * 0.3,
-            });
-        }
-        drawSpectrum({
-            imageDstBuffer: imageDstBuffer,
-            spectrum: spectrum,
-            size: size,
-            position: position,
-            rotation: rotation,
-            margin: margin,
-            color: rgbSpectrumColor,
-            opacity: opacity,
-        });
-        prevSpectrum = spectrum;
-        return imageDstBuffer;
-    };
-};
-exports.createPolarVisualizerFrameGenerator = function () {
-    var prevSpectrum = null;
-    return function (_a) {
-        var backgroundImageBuffer = _a.backgroundImageBuffer, spectrum = _a.spectrum, centerX = _a.centerX, centerY = _a.centerY, innerRadius = _a.innerRadius, maxBarLength = _a.maxBarLength, barWidth = _a.barWidth, color = _a.color, opacity = _a.opacity, spectrumEffect = _a.spectrumEffect;
-        var imageDstBuffer = Object.assign({}, backgroundImageBuffer);
-        imageDstBuffer.data = Buffer.from(backgroundImageBuffer.data);
-        var rgbSpectrumColor = (typeof color === 'string') ? hexToRgb(color) : color;
-        if (spectrumEffect === 'volume') {
-            drawPolarSpectrum({
-                imageDstBuffer: imageDstBuffer,
-                spectrum: spectrum,
-                centerX: centerX + 2,
-                centerY: centerY + 2,
-                innerRadius: innerRadius,
-                maxBarLength: maxBarLength,
-                barWidth: barWidth,
-                color: rgbSpectrumColor,
-                opacity: opacity * 0.5,
-            });
-        }
-        if (spectrumEffect === 'smooth' && prevSpectrum) {
-            drawPolarSpectrum({
-                imageDstBuffer: imageDstBuffer,
-                spectrum: prevSpectrum,
-                centerX: centerX,
-                centerY: centerY,
-                innerRadius: innerRadius,
-                maxBarLength: maxBarLength,
-                barWidth: barWidth,
-                color: rgbSpectrumColor,
-                opacity: opacity * 0.3,
-            });
-        }
-        drawPolarSpectrum({
-            imageDstBuffer: imageDstBuffer,
-            spectrum: spectrum,
-            centerX: centerX,
-            centerY: centerY,
-            innerRadius: innerRadius,
-            maxBarLength: maxBarLength,
-            barWidth: barWidth,
-            color: rgbSpectrumColor,
-            opacity: opacity,
-        });
-        prevSpectrum = spectrum;
-        return imageDstBuffer;
-    };
-};
-exports.convertToBmp = function (filePath, targetWidth, targetHeight) { return __awaiter(void 0, void 0, void 0, function () {
-    return __generator(this, function (_a) {
-        return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(void 0, void 0, void 0, function () {
-                var image, sw, sh, isOrientationMismatch, targetAspect, cropW, cropH, cropX, cropY, _a;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
-                        case 0:
-                            _b.trys.push([0, 2, , 3]);
-                            return [4 /*yield*/, jimp_1.default.read(filePath)];
-                        case 1:
-                            image = _b.sent();
-                            if (targetWidth && targetHeight) {
-                                sw = image.getWidth();
-                                sh = image.getHeight();
-                                isOrientationMismatch = (sw > sh && targetWidth < targetHeight) ||
-                                    (sw < sh && targetWidth > targetHeight);
-                                if (isOrientationMismatch) {
-                                    targetAspect = targetWidth / targetHeight;
-                                    cropW = void 0, cropH = void 0, cropX = void 0, cropY = void 0;
-                                    if (sw / sh > targetAspect) {
-                                        cropW = Math.round(sh * targetAspect);
-                                        cropH = sh;
-                                        cropX = Math.round((sw - cropW) / 2);
-                                        cropY = 0;
-                                    }
-                                    else {
-                                        cropW = sw;
-                                        cropH = Math.round(sw / targetAspect);
-                                        cropX = 0;
-                                        cropY = Math.round((sh - cropH) / 2);
-                                    }
-                                    image.crop(cropX, cropY, cropW, cropH);
-                                }
-                                image.resize(targetWidth, targetHeight);
-                            }
-                            image.getBuffer("image/bmp", function (err, value) {
-                                if (err) {
-                                    reject(err);
-                                }
-                                resolve(value);
-                            });
-                            return [3 /*break*/, 3];
-                        case 2:
-                            _a = _b.sent();
-                            throw new Error("Cannot procces image file from path: " + filePath);
-                        case 3: return [2 /*return*/];
-                    }
-                });
-            }); })];
-    });
-}); };
-exports.parseImage = function (buffer) { return bmp_js_1.decode(buffer); };
-exports.getImageColor = function (image) {
-    var blueSum = 0;
-    var greenSum = 0;
-    var redSum = 0;
-    for (var currY = 0; currY < image.height; currY++) {
-        for (var currX = 0; currX < image.width; currX++) {
-            var idx = (image.width * currY + currX) << 2;
-            blueSum += image.data[idx + 1];
-            greenSum += image.data[idx + 2];
-            redSum += image.data[idx + 3];
-        }
-    }
-    var pixelsCount = image.width * image.height;
-    return {
-        red: ~~(redSum / pixelsCount),
-        green: ~~(greenSum / pixelsCount),
-        blue: ~~(blueSum / pixelsCount)
-    };
-};
-exports.getVideoFrameColor = function (bgrBuffer, width, height) {
-    var blueSum = 0;
-    var greenSum = 0;
-    var redSum = 0;
-    var pixelsCount = width * height;
-    for (var i = 0; i < bgrBuffer.length; i += 3) {
-        blueSum += bgrBuffer[i];
-        greenSum += bgrBuffer[i + 1];
-        redSum += bgrBuffer[i + 2];
-    }
-    return {
-        red: ~~(redSum / pixelsCount),
-        green: ~~(greenSum / pixelsCount),
-        blue: ~~(blueSum / pixelsCount),
-    };
-};
-exports.invertColor = function (color) {
-    return ({ red: 255 - color.red, green: 255 - color.green, blue: 255 - color.blue });
-};
-var hexToRgb = function (hex) {
-    var red = parseInt(hex.substring(1, 3), 16);
-    var green = parseInt(hex.substring(3, 5), 16);
-    var blue = parseInt(hex.substring(5, 7), 16);
-    return { red: red, green: green, blue: blue };
-};
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var bmp_js_1 = require("bmp-js");
+var jimp_1 = __importDefault(require("jimp"));
+exports.mixValues = function (value1, value1Opacity, value2) {
+    return Math.round(value2 * (1 - value1Opacity) + value1 * value1Opacity);
+};
+exports.mixColors = function (_a) {
+    var color = _a.color, colorOpacity = _a.colorOpacity, backgroundColor = _a.backgroundColor;
+    return {
+        red: exports.mixValues(color.red, colorOpacity, backgroundColor.red),
+        green: exports.mixValues(color.green, colorOpacity, backgroundColor.green),
+        blue: exports.mixValues(color.blue, colorOpacity, backgroundColor.blue),
+    };
+};
+var getRectPixelColor = function (params) {
+    var imageDstBuffer = params.imageDstBuffer, pixelIndex = params.pixelIndex, color = params.color, opacity = params.opacity;
+    if (opacity === 1) {
+        return color;
+    }
+    var backgroundPixelColor = {
+        blue: imageDstBuffer.data[pixelIndex],
+        green: imageDstBuffer.data[pixelIndex + 1],
+        red: imageDstBuffer.data[pixelIndex + 2],
+    };
+    var resultColor = exports.mixColors({
+        color: color,
+        colorOpacity: opacity,
+        backgroundColor: backgroundPixelColor,
+    });
+    return resultColor;
+};
+exports.drawRect = function (_a) {
+    var imageDstBuffer = _a.imageDstBuffer, position = _a.position, size = _a.size, color = _a.color, opacity = _a.opacity;
+    for (var currY = position.y; currY < position.y + size.height; currY++) {
+        for (var currX = position.x; currX < position.x + size.width; currX++) {
+            var pixelIndex = imageDstBuffer.shiftPos + currY * imageDstBuffer.rowBytes + currX * 3;
+            var pixelColor = getRectPixelColor({
+                imageDstBuffer: imageDstBuffer,
+                pixelIndex: pixelIndex,
+                color: color,
+                opacity: opacity,
+            });
+            imageDstBuffer.data[pixelIndex] = pixelColor.blue;
+            imageDstBuffer.data[pixelIndex + 1] = pixelColor.green;
+            imageDstBuffer.data[pixelIndex + 2] = pixelColor.red;
+        }
+    }
+};
+var buildQuadEdgeTable = function (points) {
+    var edges = [];
+    for (var i = 0; i < points.length; i++) {
+        var p1 = points[i];
+        var p2 = points[(i + 1) % points.length];
+        if (p1.y === p2.y)
+            continue; // Skip horizontal edges
+        var yMin = Math.min(p1.y, p2.y);
+        var yMax = Math.max(p1.y, p2.y);
+        var x = p1.y < p2.y ? p1.x : p2.x;
+        var dx = (p2.x - p1.x) / (p2.y - p1.y);
+        edges.push({ yMin: yMin, yMax: yMax, x: x, dx: dx });
+    }
+    return edges.sort(function (a, b) { return a.yMin - b.yMin; });
+};
+/**
+ * Fills a quadrilateral (4-sided polygon) using scan-line algorithm
+ * Only the outer edges are anti-aliased
+ */
+exports.fillRect = function (_a) {
+    var imageDstBuffer = _a.imageDstBuffer, points = _a.points, color = _a.color, opacity = _a.opacity;
+    // Build edge table from all 4 vertices
+    var edgeTable = buildQuadEdgeTable(points);
+    if (edgeTable.length === 0)
+        return;
+    // Find the bounding box
+    var yMin = Math.min.apply(Math, points.map(function (p) { return p.y; }));
+    var yMax = Math.max.apply(Math, points.map(function (p) { return p.y; }));
+    // Active Edge Table for scan line algorithm
+    var activeEdges = [];
+    // Scan line algorithm: process each horizontal line
+    for (var y = Math.floor(yMin); y <= Math.ceil(yMax); y++) {
+        // Add edges that start at this scanline to AET
+        for (var _i = 0, edgeTable_1 = edgeTable; _i < edgeTable_1.length; _i++) {
+            var edge = edgeTable_1[_i];
+            if (Math.floor(edge.yMin) === y) {
+                activeEdges.push(__assign({}, edge));
+            }
+        }
+        // Remove edges that end at this scanline from AET
+        for (var i = activeEdges.length - 1; i >= 0; i--) {
+            if (Math.ceil(activeEdges[i].yMax) <= y) {
+                activeEdges.splice(i, 1);
+            }
+        }
+        // Sort active edges by x coordinate
+        activeEdges.sort(function (a, b) { return a.x - b.x; });
+        // Fill pixels between pairs of intersections
+        for (var i = 0; i < activeEdges.length; i += 2) {
+            if (i + 1 < activeEdges.length) {
+                var xStart = activeEdges[i].x;
+                var xEnd = activeEdges[i + 1].x;
+                // Anti-aliased rendering with sub-pixel precision
+                var xStartFloor = Math.floor(xStart);
+                var xEndCeil = Math.ceil(xEnd);
+                for (var x = xStartFloor; x < xEndCeil; x++) {
+                    var pixelIndex = imageDstBuffer.shiftPos + y * imageDstBuffer.rowBytes + x * 3;
+                    // Calculate coverage for anti-aliasing
+                    var coverage = 1.0;
+                    if (x === xStartFloor) {
+                        // Left edge pixel - calculate fractional coverage
+                        coverage = Math.min(1.0, 1.0 - (xStart - xStartFloor));
+                    }
+                    else if (x === xEndCeil - 1) {
+                        // Right edge pixel - calculate fractional coverage
+                        coverage = Math.min(1.0, xEnd - Math.floor(xEnd));
+                    }
+                    // Apply coverage to opacity for smooth edges
+                    var effectiveOpacity = opacity * coverage;
+                    var pixelColor = getRectPixelColor({
+                        imageDstBuffer: imageDstBuffer,
+                        pixelIndex: pixelIndex,
+                        color: color,
+                        opacity: effectiveOpacity,
+                    });
+                    imageDstBuffer.data[pixelIndex] = pixelColor.blue;
+                    imageDstBuffer.data[pixelIndex + 1] = pixelColor.green;
+                    imageDstBuffer.data[pixelIndex + 2] = pixelColor.red;
+                }
+            }
+        }
+        // Update x coordinates for next scanline (x' = x + dx)
+        for (var _b = 0, activeEdges_1 = activeEdges; _b < activeEdges_1.length; _b++) {
+            var edge = activeEdges_1[_b];
+            edge.x += edge.dx;
+        }
+    }
+};
+var getRectY = function (rotation, top, height, rectHeight) {
+    switch (rotation) {
+        case 'up':
+            return top + height - rectHeight;
+        case 'mirror':
+            return top + Math.trunc((height - rectHeight) / 2);
+        default:
+            return top;
+    }
+};
+var minRectHeight = 2;
+var getRectHeight = function (height, spectrumValue) {
+    var rectHeight = Math.trunc(height * spectrumValue);
+    if (rectHeight < minRectHeight) {
+        return minRectHeight;
+    }
+    return rectHeight;
+};
+var drawSpectrum = function (_a) {
+    var imageDstBuffer = _a.imageDstBuffer, spectrum = _a.spectrum, size = _a.size, position = _a.position, rotation = _a.rotation, margin = _a.margin, color = _a.color, opacity = _a.opacity;
+    var busWidth = Math.trunc(size.width / spectrum.length);
+    var left = Math.trunc(position.x);
+    var top = Math.trunc(position.y);
+    var height = Math.trunc(size.height);
+    for (var spectrumX = 0; spectrumX < spectrum.length; spectrumX++) {
+        var spectrumValue = spectrum[spectrumX];
+        if ((spectrumValue > 1) || (spectrumValue < 0)) {
+            throw new Error('Spectrum values must be in range from 0 to 1');
+        }
+        var rectX = left + busWidth * spectrumX;
+        var rectHeight = getRectHeight(height, spectrumValue);
+        var rectY = getRectY(rotation, top, height, rectHeight);
+        exports.drawRect({
+            imageDstBuffer: imageDstBuffer,
+            position: { x: rectX + margin, y: rectY },
+            size: { width: busWidth - margin / 2, height: rectHeight },
+            color: color,
+            opacity: opacity,
+        });
+    }
+};
+var calcCirclePoint = function (angleRadians, radius) {
+    var circleX = radius * Math.cos(angleRadians);
+    var circleY = radius * Math.sin(angleRadians);
+    return { x: circleX, y: circleY };
+};
+var lerp = function (start, end, t) {
+    return start + (end - start) * t;
+};
+var drawPolarSpectrum = function (_a) {
+    var imageDstBuffer = _a.imageDstBuffer, spectrum = _a.spectrum, centerX = _a.centerX, centerY = _a.centerY, innerRadius = _a.innerRadius, maxBarLength = _a.maxBarLength, barWidth = _a.barWidth, color = _a.color, opacity = _a.opacity;
+    var angleStep = (2 * Math.PI) / spectrum.length;
+    var innerLength = innerRadius * 2 * Math.PI;
+    var radiansPerPixel = 2 * Math.PI / innerLength;
+    var barWidthInRadians = radiansPerPixel * barWidth;
+    var spectrumAverage = spectrum.reduce(function (a, b) { return a + b; }, 0) / spectrum.length;
+    var scaleFactor = lerp(0.75, 1, spectrumAverage);
+    var scaledMaxOuterRadius = (innerRadius + maxBarLength) * scaleFactor;
+    var scaledInnerRadius = innerRadius * scaleFactor;
+    for (var i = 0; i < spectrum.length; i++) {
+        var currentSpectrumValue = spectrum[i] || 0;
+        var busRadius = lerp(scaledInnerRadius, scaledMaxOuterRadius, currentSpectrumValue);
+        var angle = i * angleStep;
+        var angleRadiansStart = angle;
+        var angleRadiansEnd = angle + barWidthInRadians;
+        var point1 = calcCirclePoint(angleRadiansStart, scaledInnerRadius);
+        var point2 = calcCirclePoint(angleRadiansStart, busRadius);
+        var point3 = calcCirclePoint(angleRadiansEnd, scaledInnerRadius);
+        var point4 = calcCirclePoint(angleRadiansEnd, busRadius);
+        exports.fillRect({
+            imageDstBuffer: imageDstBuffer,
+            points: [
+                { x: centerX + Math.round(point1.x), y: centerY + Math.round(point1.y) },
+                { x: centerX + Math.round(point2.x), y: centerY + Math.round(point2.y) },
+                { x: centerX + Math.round(point4.x), y: centerY + Math.round(point4.y) },
+                { x: centerX + Math.round(point3.x), y: centerY + Math.round(point3.y) },
+            ],
+            color: color,
+            opacity: opacity,
+        });
+    }
+};
+exports.createSpectrumVisualizerFrameGenerator = function () {
+    var prevSpectrum = null;
+    return function (_a) {
+        var backgroundImageBuffer = _a.backgroundImageBuffer, spectrum = _a.spectrum, size = _a.size, position = _a.position, rotation = _a.rotation, margin = _a.margin, color = _a.color, opacity = _a.opacity, spectrumEffect = _a.spectrumEffect;
+        var imageDstBuffer = Object.assign({}, backgroundImageBuffer);
+        imageDstBuffer.data = Buffer.from(backgroundImageBuffer.data);
+        var rgbSpectrumColor = (typeof color === 'string') ? hexToRgb(color) : color;
+        if (spectrumEffect === 'volume') {
+            drawSpectrum({
+                imageDstBuffer: imageDstBuffer,
+                spectrum: spectrum,
+                size: size,
+                position: { x: position.x + 2, y: position.y + 2 },
+                rotation: rotation,
+                margin: margin,
+                color: rgbSpectrumColor,
+                opacity: opacity * 0.5,
+            });
+        }
+        if (spectrumEffect === 'smooth' && prevSpectrum) {
+            drawSpectrum({
+                imageDstBuffer: imageDstBuffer,
+                spectrum: prevSpectrum,
+                size: size,
+                position: position,
+                rotation: rotation,
+                margin: margin,
+                color: rgbSpectrumColor,
+                opacity: opacity * 0.3,
+            });
+        }
+        drawSpectrum({
+            imageDstBuffer: imageDstBuffer,
+            spectrum: spectrum,
+            size: size,
+            position: position,
+            rotation: rotation,
+            margin: margin,
+            color: rgbSpectrumColor,
+            opacity: opacity,
+        });
+        prevSpectrum = spectrum;
+        return imageDstBuffer;
+    };
+};
+exports.createPolarVisualizerFrameGenerator = function () {
+    var prevSpectrum = null;
+    return function (_a) {
+        var backgroundImageBuffer = _a.backgroundImageBuffer, spectrum = _a.spectrum, centerX = _a.centerX, centerY = _a.centerY, innerRadius = _a.innerRadius, maxBarLength = _a.maxBarLength, barWidth = _a.barWidth, color = _a.color, opacity = _a.opacity, spectrumEffect = _a.spectrumEffect;
+        var imageDstBuffer = Object.assign({}, backgroundImageBuffer);
+        imageDstBuffer.data = Buffer.from(backgroundImageBuffer.data);
+        var rgbSpectrumColor = (typeof color === 'string') ? hexToRgb(color) : color;
+        if (spectrumEffect === 'volume') {
+            drawPolarSpectrum({
+                imageDstBuffer: imageDstBuffer,
+                spectrum: spectrum,
+                centerX: centerX + 2,
+                centerY: centerY + 2,
+                innerRadius: innerRadius,
+                maxBarLength: maxBarLength,
+                barWidth: barWidth,
+                color: rgbSpectrumColor,
+                opacity: opacity * 0.5,
+            });
+        }
+        if (spectrumEffect === 'smooth' && prevSpectrum) {
+            drawPolarSpectrum({
+                imageDstBuffer: imageDstBuffer,
+                spectrum: prevSpectrum,
+                centerX: centerX,
+                centerY: centerY,
+                innerRadius: innerRadius,
+                maxBarLength: maxBarLength,
+                barWidth: barWidth,
+                color: rgbSpectrumColor,
+                opacity: opacity * 0.3,
+            });
+        }
+        drawPolarSpectrum({
+            imageDstBuffer: imageDstBuffer,
+            spectrum: spectrum,
+            centerX: centerX,
+            centerY: centerY,
+            innerRadius: innerRadius,
+            maxBarLength: maxBarLength,
+            barWidth: barWidth,
+            color: rgbSpectrumColor,
+            opacity: opacity,
+        });
+        prevSpectrum = spectrum;
+        return imageDstBuffer;
+    };
+};
+exports.convertToBmp = function (filePath, targetWidth, targetHeight) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, new Promise(function (resolve, reject) { return __awaiter(void 0, void 0, void 0, function () {
+                var image, sw, sh, isOrientationMismatch, targetAspect, cropW, cropH, cropX, cropY, _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _b.trys.push([0, 2, , 3]);
+                            return [4 /*yield*/, jimp_1.default.read(filePath)];
+                        case 1:
+                            image = _b.sent();
+                            if (targetWidth && targetHeight) {
+                                sw = image.getWidth();
+                                sh = image.getHeight();
+                                isOrientationMismatch = (sw > sh && targetWidth < targetHeight) ||
+                                    (sw < sh && targetWidth > targetHeight);
+                                if (isOrientationMismatch) {
+                                    targetAspect = targetWidth / targetHeight;
+                                    cropW = void 0, cropH = void 0, cropX = void 0, cropY = void 0;
+                                    if (sw / sh > targetAspect) {
+                                        cropW = Math.round(sh * targetAspect);
+                                        cropH = sh;
+                                        cropX = Math.round((sw - cropW) / 2);
+                                        cropY = 0;
+                                    }
+                                    else {
+                                        cropW = sw;
+                                        cropH = Math.round(sw / targetAspect);
+                                        cropX = 0;
+                                        cropY = Math.round((sh - cropH) / 2);
+                                    }
+                                    image.crop(cropX, cropY, cropW, cropH);
+                                }
+                                image.resize(targetWidth, targetHeight);
+                            }
+                            image.getBuffer("image/bmp", function (err, value) {
+                                if (err) {
+                                    reject(err);
+                                }
+                                resolve(value);
+                            });
+                            return [3 /*break*/, 3];
+                        case 2:
+                            _a = _b.sent();
+                            throw new Error("Cannot procces image file from path: " + filePath);
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            }); })];
+    });
+}); };
+exports.parseImage = function (buffer) { return bmp_js_1.decode(buffer); };
+exports.getImageColor = function (image) {
+    var blueSum = 0;
+    var greenSum = 0;
+    var redSum = 0;
+    for (var currY = 0; currY < image.height; currY++) {
+        for (var currX = 0; currX < image.width; currX++) {
+            var idx = (image.width * currY + currX) << 2;
+            blueSum += image.data[idx + 1];
+            greenSum += image.data[idx + 2];
+            redSum += image.data[idx + 3];
+        }
+    }
+    var pixelsCount = image.width * image.height;
+    return {
+        red: ~~(redSum / pixelsCount),
+        green: ~~(greenSum / pixelsCount),
+        blue: ~~(blueSum / pixelsCount)
+    };
+};
+exports.getVideoFrameColor = function (bgrBuffer, width, height) {
+    var blueSum = 0;
+    var greenSum = 0;
+    var redSum = 0;
+    var pixelsCount = width * height;
+    for (var i = 0; i < bgrBuffer.length; i += 3) {
+        blueSum += bgrBuffer[i];
+        greenSum += bgrBuffer[i + 1];
+        redSum += bgrBuffer[i + 2];
+    }
+    return {
+        red: ~~(redSum / pixelsCount),
+        green: ~~(greenSum / pixelsCount),
+        blue: ~~(blueSum / pixelsCount),
+    };
+};
+exports.invertColor = function (color) {
+    return ({ red: 255 - color.red, green: 255 - color.green, blue: 255 - color.blue });
+};
+/** Pixel shift strength for the cut frame and the frames after it. */
+exports.CUT_SHAKE_AMPLITUDE_BY_OFFSET = [14, 9, 5, 3, 1];
+exports.CUT_SHAKE_PEAK_AMPLITUDE = 14;
+exports.MIN_CUT_SHAKE_FRAMES = 3;
+exports.SHAKE_DURATION_BEAT_FRACTION = 1 / 3;
+/** Camera shake starts this many seconds after the cut instead of on the cut frame. */
+exports.CAMERA_SHAKE_DELAY_SECONDS = 0.1;
+/**
+ * When auto-edit produces no cuts (e.g. a single continuous-shot video with no detected
+ * scene changes), camera shake falls back to every Nth beat of the tempo grid instead.
+ */
+exports.CAMERA_SHAKE_EVERY_BEATS = 2;
+exports.buildCutShakeAmplitudes = function (periodFrames) {
+    if (!(periodFrames > 0)) {
+        return Array.from(exports.CUT_SHAKE_AMPLITUDE_BY_OFFSET);
+    }
+    var frameCount = Math.max(exports.MIN_CUT_SHAKE_FRAMES, Math.round(periodFrames * exports.SHAKE_DURATION_BEAT_FRACTION));
+    if (frameCount === 1) {
+        return [exports.CUT_SHAKE_PEAK_AMPLITUDE];
+    }
+    var decayTo = 1 / exports.CUT_SHAKE_PEAK_AMPLITUDE;
+    var amplitudes = [];
+    for (var i = 0; i < frameCount; i++) {
+        var t = i / (frameCount - 1);
+        amplitudes.push(Math.max(1, Math.round(exports.CUT_SHAKE_PEAK_AMPLITUDE * Math.pow(decayTo, t))));
+    }
+    return amplitudes;
+};
+var clampInt = function (value, min, max) {
+    if (value < min) {
+        return min;
+    }
+    if (value > max) {
+        return max;
+    }
+    return value;
+};
+exports.getCutShakeOffset = function (frameIndex, cutFrames, amplitudes, delayFrames) {
+    if (amplitudes === void 0) { amplitudes = exports.CUT_SHAKE_AMPLITUDE_BY_OFFSET; }
+    if (delayFrames === void 0) { delayFrames = 0; }
+    if (amplitudes.length === 0) {
+        return { x: 0, y: 0 };
+    }
+    var delayedFrameIndex = frameIndex - delayFrames;
+    var framesAfterCut = -1;
+    var originCut = -1;
+    for (var offset = 0; offset < amplitudes.length; offset++) {
+        var cut = delayedFrameIndex - offset;
+        if (cutFrames.has(cut) && (framesAfterCut === -1 || offset < framesAfterCut)) {
+            framesAfterCut = offset;
+            originCut = cut;
+        }
+    }
+    if (framesAfterCut === -1) {
+        return { x: 0, y: 0 };
+    }
+    var amplitude = amplitudes[framesAfterCut];
+    var angle = originCut * 2.399 + framesAfterCut * 2.1;
+    return {
+        x: Math.round(Math.cos(angle) * amplitude),
+        y: Math.round(Math.sin(angle) * amplitude),
+    };
+};
+exports.applyCameraShake = function (imageDstBuffer, width, height, offsetX, offsetY) {
+    var ox = Math.round(offsetX);
+    var oy = Math.round(offsetY);
+    if (ox === 0 && oy === 0) {
+        return;
+    }
+    var shiftPos = imageDstBuffer.shiftPos, rowBytes = imageDstBuffer.rowBytes, data = imageDstBuffer.data;
+    var pixelBytes = height * rowBytes;
+    var sourcePixels = Buffer.allocUnsafe(pixelBytes);
+    data.copy(sourcePixels, 0, shiftPos, shiftPos + pixelBytes);
+    for (var y = 0; y < height; y++) {
+        var srcY = clampInt(y - oy, 0, height - 1);
+        var dstRow = shiftPos + y * rowBytes;
+        var srcRow = srcY * rowBytes;
+        for (var x = 0; x < width; x++) {
+            var srcX = clampInt(x - ox, 0, width - 1);
+            var dstIndex = dstRow + x * 3;
+            var srcIndex = srcRow + srcX * 3;
+            data[dstIndex] = sourcePixels[srcIndex];
+            data[dstIndex + 1] = sourcePixels[srcIndex + 1];
+            data[dstIndex + 2] = sourcePixels[srcIndex + 2];
+        }
+    }
+};
+var hexToRgb = function (hex) {
+    var red = parseInt(hex.substring(1, 3), 16);
+    var green = parseInt(hex.substring(3, 5), 16);
+    var blue = parseInt(hex.substring(5, 7), 16);
+    return { red: red, green: green, blue: blue };
+};
 //# sourceMappingURL=image.js.map