@vpalmisano/webrtcperf 4.0.0

package/build/src/vmaf.js

@@ -0,0 +1,624 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVideo = parseVideo;
+exports.prepareVideo = prepareVideo;
+exports.convertToIvf = convertToIvf;
+exports.recognizeFrames = recognizeFrames;
+exports.fixIvfFrames = fixIvfFrames;
+exports.fixIvfFiles = fixIvfFiles;
+exports.runVmaf = runVmaf;
+exports.calculateVmafScore = calculateVmafScore;
+const fs_1 = __importDefault(require("fs"));
+const json5_1 = __importDefault(require("json5"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const utils_1 = require("./utils");
+const stats_1 = require("./stats");
+const log = (0, utils_1.logger)('webrtcperf:vmaf');
+const cpus = os_1.default.cpus().length;
+async function parseVideo(fpath) {
+    let width = 0;
+    let height = 0;
+    let frameRate = 0;
+    await (0, utils_1.ffprobe)(fpath, 'video', 'frame=pts,width,height,duration_time', '', frame => {
+        const w = parseInt(frame.width);
+        const h = parseInt(frame.height);
+        if (w > width)
+            width = w;
+        if (h > height)
+            height = h;
+        const duration = parseFloat(frame.duration_time);
+        if (duration) {
+            frameRate = Math.max(Math.round(1 / duration), frameRate);
+        }
+        return utils_1.FFProbeProcess.Skip;
+    });
+    return { width, height, frameRate };
+}
+/**
+ * It prepares a video file for VMAF evaluation applying a timestamp video overlay.
+ * @param name The input video file path with the output id (e.g `filename.flv,1`).
+ * @param crop If the video should be cropped.
+ * @param keepSourceFile If the source file should be kept.
+ */
+async function prepareVideo({ vmafPrepareVideo, vmafVideoCrop, videoWidth, videoHeight, videoFramerate, videoDuration, }, keepSourceFile = true) {
+    const [fpath, id] = vmafPrepareVideo.split(',');
+    const outputPath = path_1.default.join(path_1.default.dirname(fpath), `${id}_send.mp4`);
+    if (fs_1.default.existsSync(outputPath)) {
+        throw new Error(`Output file ${outputPath} already exists`);
+    }
+    const { width, height, frameRate } = await parseVideo(fpath);
+    log.info(`prepareVideo ${fpath} ${width}x${height}@${frameRate} -> ${outputPath} ${vmafVideoCrop && `crop: ${vmafVideoCrop}`}`);
+    const fontsize = Math.round((videoHeight || height) / 18);
+    const textHeight = Math.round(fontsize * 1.2);
+    const filter = vmafVideoCrop ? cropFilter(json5_1.default.parse(vmafVideoCrop), 0, ',') : '';
+    await (0, utils_1.runShellCommand)(`ffmpeg -hide_banner -loglevel warning -threads ${Math.min(cpus, 16)} \
+${videoDuration ? `-t ${videoDuration}` : ''} \
+-i ${fpath} \
+-filter_complex "[0:v]scale=w=${videoWidth || width}:h=${videoHeight || height},fps=${videoFramerate || frameRate},${filter}\
+drawbox=x=0:y=0:w=iw:h=${textHeight}:color=black:t=fill,\
+drawtext=fontfile=/usr/share/fonts/truetype/noto/NotoMono-Regular.ttf:text='${id || 0}-%{eif\\:t*1000\\:u}':fontcolor=white:fontsize=${fontsize}:x=(w-text_w)/2:y=(${textHeight}-text_h)/2[out]" \
+-map [out] -fps_mode vfr -c:v libx264 -crf 10 -an \
+-f mp4 -movflags +faststart ${outputPath}`, true);
+    if (!keepSourceFile) {
+        await fs_1.default.promises.unlink(fpath);
+    }
+}
+/**
+ * It converts a video file to VP8/IVF format.
+ * @param fpath The input video file path.
+ * @param crop The crop filter.
+ * @param keepSourceFile If the source file should be kept.
+ */
+async function convertToIvf(fpath, crop, keepSourceFile = true) {
+    const { width, height, frameRate } = await parseVideo(fpath);
+    const outputPath = fpath.replace(/\.[^.]+$/, '.ivf.raw');
+    log.debug(`convertToIvf ${fpath} ${width}x${height}@${frameRate} -> ${outputPath} crop:`, crop);
+    const filter = crop ? `-vf '${cropFilter(json5_1.default.parse(crop))}'` : '';
+    await (0, utils_1.runShellCommand)(`ffmpeg -y -hide_banner -y -loglevel warning -i ${fpath} -map 0:v \
+      -c:v vp8 -quality best -cpu-used 0 -crf 1 -b:v 20M -qmin 1 -qmax 10 \
+      -g 1 -threads ${Math.min(cpus, 16)} ${filter} -an \
+      -f ivf ${outputPath}`, true);
+    await fixIvfFrames(outputPath, keepSourceFile);
+}
+/**
+ * It recognizes the frames of a video file using OCR.
+ * @param fpath The input video file path.
+ * @param recover If missing frames should be recovered.
+ * @param crop If the video should be cropped.
+ * @param debug Enable debug logging.
+ */
+async function recognizeFrames(fpath, recover = false, debug = false) {
+    const { width, height, frameRate } = await parseVideo(fpath);
+    const fname = path_1.default.basename(fpath);
+    const frames = new Map();
+    let skipped = 0;
+    let failed = 0;
+    let recovered = 0;
+    let firstTimestamp = 0;
+    let lastTimestamp = 0;
+    let participantDisplayName = '';
+    const regExp = /(?<name>[0-9]{1,6})-(?<time>[0-9]{1,13})/;
+    await (0, utils_1.ffprobe)(fpath, 'video', 'frame=pts,frame_tags=lavfi.ocr.text,lavfi.ocr.confidence', `scale=w=1280:h=-1:flags=bicubic,crop=w=min(iw\\,ih):h=max((ih/15)\\,32):x=(iw-ow)/2:y=0:exact=1,ocr=whitelist=0123456789-`, frame => {
+        const pts = parseInt(frame.pts);
+        if ((!frames.has(pts) || !frames.get(pts)) && frameRate) {
+            const confidence = parseFloat(frame.tag_lavfi_ocr_confidence?.trim() || '0');
+            const textMatch = regExp.exec(frame.tag_lavfi_ocr_text?.trim() || '');
+            if (confidence > 0 && textMatch) {
+                const { name, time } = textMatch.groups;
+                participantDisplayName = `Participant-${name.padStart(6, '0')}`;
+                const recognizedTime = parseInt(time);
+                const recognizedPts = Math.round((frameRate * recognizedTime) / 1000);
+                if (debug) {
+                    log.debug(`recognized frame ${fname} confidence=${confidence} pts=${pts} name=${name} time=${time} recognized=${recognizedPts}`);
+                }
+                frames.set(pts, recognizedPts);
+                if (!firstTimestamp)
+                    firstTimestamp = recognizedPts / frameRate;
+                lastTimestamp = recognizedPts / frameRate;
+            }
+            else {
+                if (recover)
+                    frames.set(pts, 0);
+                failed++;
+            }
+        }
+        else {
+            skipped++;
+        }
+        return utils_1.FFProbeProcess.Skip;
+    });
+    if (recover) {
+        const ptsIndex = Array.from(frames.keys()).sort((a, b) => a - b);
+        for (const [i, pts] of ptsIndex.entries()) {
+            const recognizedPts = frames.get(pts);
+            if (!recognizedPts && i) {
+                const prevRecognizedPts = frames.get(ptsIndex[i - 1]);
+                if (prevRecognizedPts) {
+                    frames.set(pts, prevRecognizedPts + pts - ptsIndex[i - 1]);
+                    recovered++;
+                }
+                else {
+                    frames.delete(pts);
+                }
+            }
+        }
+    }
+    log.info(`recognizeFrames ${fname} ${width}x${height}@${frameRate} "${participantDisplayName}" frames: ${frames.size} skipped: ${skipped} recovered: ${recovered} failed: ${failed} \
+ts: ${firstTimestamp.toFixed(2)}-${lastTimestamp.toFixed(2)} (${(lastTimestamp - firstTimestamp).toFixed(2)})`);
+    return { width, height, frameRate, frames, participantDisplayName };
+}
+async function parseIvf(fpath, runRecognizer = false) {
+    const { width, height } = await parseVideo(fpath);
+    const fname = path_1.default.basename(fpath);
+    const fd = await fs_1.default.promises.open(fpath, 'r');
+    const headerData = new ArrayBuffer(32);
+    const headerView = new DataView(headerData);
+    const ret = await fd.read(headerView, 0, 32, 0);
+    if (ret.bytesRead !== 32) {
+        await fd.close();
+        throw new Error('Invalid IVF file');
+    }
+    const den = headerView.getUint32(16, true);
+    const num = headerView.getUint32(20, true);
+    const frameRate = den / num;
+    let participantDisplayName = '';
+    let skipped = 0;
+    const frameHeaderView = new DataView(new ArrayBuffer(12));
+    let index = 0;
+    let position = 32;
+    let bytesRead = 0;
+    const frames = new Map();
+    let firstTimestamp = 0;
+    let lastTimestamp = 0;
+    do {
+        const ret = await fd.read(frameHeaderView, 0, frameHeaderView.byteLength, position);
+        bytesRead = ret.bytesRead;
+        if (bytesRead !== 12) {
+            break;
+        }
+        const size = frameHeaderView.getUint32(0, true);
+        const pts = Number(frameHeaderView.getBigUint64(4, true));
+        /* if (pts <= ptsIndex[ptsIndex.length - 1]) {
+          log.warn(`IVF file ${fname}: pts ${pts} <= prev ${ptsIndex[ptsIndex.length - 1]}`)
+        } */
+        if (frames.has(pts)) {
+            /* log.debug(`IVF file ${fname}: pts ${pts} already present, skipping`) */
+            skipped++;
+        }
+        else {
+            frames.set(pts, { pts, index, position, size: size + 12 });
+            index++;
+            if (!firstTimestamp) {
+                firstTimestamp = pts / frameRate;
+            }
+            lastTimestamp = pts / frameRate;
+        }
+        position += size + 12;
+    } while (bytesRead === 12);
+    await fd.close();
+    log.debug(`parseIvf ${fname}: ${width}x${height}@${frameRate} \
+frames: ${frames.size} skipped: ${skipped} \
+ts: ${firstTimestamp.toFixed(2)}-${lastTimestamp.toFixed(2)} (${(lastTimestamp - firstTimestamp).toFixed(2)}s)`);
+    if (runRecognizer) {
+        const { frames: ptsToRecognized, participantDisplayName: name } = await recognizeFrames(fpath);
+        participantDisplayName = name;
+        for (const [pts, frame] of frames.entries()) {
+            const recognizedPts = ptsToRecognized.get(pts);
+            if (!recognizedPts)
+                continue;
+            frame.recognizedPts = recognizedPts;
+        }
+    }
+    return {
+        width,
+        height,
+        frameRate,
+        frames,
+        participantDisplayName,
+    };
+}
+async function fixIvfFrames(filePath, keepSourceFile = true) {
+    const fname = path_1.default.basename(filePath);
+    const dirPath = path_1.default.dirname(filePath);
+    if (!fname.endsWith('.ivf.raw')) {
+        throw new Error(`fixIvfFrames ${fname}: invalid file extension, expected ".ivf.raw"`);
+    }
+    const { width, height, frames, participantDisplayName } = await parseIvf(filePath, true);
+    if (!participantDisplayName) {
+        throw new Error(`fixIvfFrames ${fname}: no participant name found`);
+    }
+    if (!frames.size) {
+        throw new Error(`fixIvfFrames ${fname}: no frames found`);
+    }
+    log.debug(`fixIvfFrames ${fname} width=${width} height=${height} (${frames.size} frames)`);
+    const fd = await fs_1.default.promises.open(filePath, 'r');
+    const parts = path_1.default.basename(filePath).split('_');
+    if (!parts[1].startsWith('send') && !parts[1].startsWith('recv')) {
+        throw new Error(`fixIvfFrames ${fname}: invalid file name, expected "<name>_send" or "<name>_recv"`);
+    }
+    const outFilePath = path_1.default.join(dirPath, parts[1].startsWith('send') ? `${participantDisplayName}.ivf` : `${participantDisplayName}_recv-by_${parts[0]}.ivf`);
+    const fixedFd = await fs_1.default.promises.open(outFilePath, 'w');
+    const headerView = new DataView(new ArrayBuffer(32));
+    await fd.read(headerView, 0, headerView.byteLength, 0);
+    let position = 32;
+    let writtenFrames = 0;
+    const ptsIndex = Array.from(frames.keys())
+        .filter(pts => frames.get(pts)?.recognizedPts)
+        .sort((a, b) => {
+        if (a === b)
+            return (frames.get(a)?.recognizedPts || 0) - (frames.get(b)?.recognizedPts || 0);
+        return a - b;
+    });
+    for (const [i, pts] of ptsIndex.entries()) {
+        const frame = frames.get(pts);
+        if (!frame || !frame.recognizedPts) {
+            log.warn(`fixIvfFrames ${fname}: pts ${pts} not found, skipping`);
+            continue;
+        }
+        const prevFrame = frames.get(ptsIndex[i - 1]);
+        const nextFrame = frames.get(ptsIndex[i + 1]);
+        // Skip frames that are not in the correct order.
+        if (nextFrame?.recognizedPts && (nextFrame?.recognizedPts || 0) < frame.recognizedPts) {
+            continue;
+        }
+        // Keep duplicated frames.
+        if (prevFrame?.recognizedPts && frame.recognizedPts === prevFrame.recognizedPts) {
+            /* log.warn(
+              `${frame.index} pts=${pts}:${frame.recognizedPts} prev ${prevFrame.pts}(${pts - prevFrame.pts}):${prevFrame.recognizedPts}(${frame.recognizedPts - prevFrame.recognizedPts}) next ${nextFrame?.pts}(${(nextFrame?.pts || 0) - pts}):${nextFrame?.recognizedPts}(${(nextFrame?.recognizedPts || 0) - frame.recognizedPts})`,
+            ) */
+            frame.recognizedPts = prevFrame.recognizedPts + 1;
+        }
+        const frameView = new DataView(new ArrayBuffer(frame.size));
+        await fd.read(frameView, 0, frame.size, frame.position);
+        frameView.setBigUint64(4, BigInt(frame.recognizedPts), true);
+        await fixedFd.write(new Uint8Array(frameView.buffer), 0, frameView.byteLength, position);
+        position += frameView.byteLength;
+        writtenFrames++;
+    }
+    headerView.setUint16(12, width, true);
+    headerView.setUint16(14, height, true);
+    headerView.setUint32(24, writtenFrames, true);
+    await fixedFd.write(new Uint8Array(headerView.buffer), 0, headerView.byteLength, 0);
+    await fd.close();
+    await fixedFd.close();
+    if (!keepSourceFile) {
+        await fs_1.default.promises.unlink(filePath);
+    }
+    return { participantDisplayName, outFilePath };
+}
+async function fixIvfFiles(directory, keepSourceFiles = true) {
+    const reference = new Map();
+    const degraded = new Map();
+    const addFile = (participantDisplayName, outFilePath) => {
+        if (outFilePath.includes('_recv-by_')) {
+            if (!degraded.has(participantDisplayName)) {
+                degraded.set(participantDisplayName, []);
+            }
+            degraded.get(participantDisplayName)?.push(outFilePath);
+        }
+        else {
+            reference.set(participantDisplayName, outFilePath);
+        }
+    };
+    const ivfFiles = await (0, utils_1.getFiles)(directory, '.ivf');
+    if (ivfFiles.length) {
+        log.debug(`using existing ${ivfFiles.length} ivf files`);
+        for (const outFilePath of ivfFiles) {
+            try {
+                const participantDisplayName = path_1.default.basename(outFilePath).replace('.ivf', '').split('_')[0];
+                addFile(participantDisplayName, outFilePath);
+            }
+            catch (err) {
+                log.error(`fixIvfFrames error: ${err.stack}`);
+            }
+        }
+    }
+    const rawFiles = await (0, utils_1.getFiles)(directory, '.ivf.raw');
+    if (rawFiles.length) {
+        log.debug(`processing ${rawFiles.length} raw ivf files`);
+        const results = await (0, utils_1.chunkedPromiseAll)(rawFiles, async (filePath) => {
+            try {
+                const { participantDisplayName, outFilePath } = await fixIvfFrames(filePath, keepSourceFiles);
+                return { participantDisplayName, outFilePath };
+            }
+            catch (err) {
+                log.error(`fixIvfFrames error: ${err.stack}`);
+            }
+        }, Math.ceil(cpus / 4));
+        for (const res of results) {
+            if (!res)
+                continue;
+            const { participantDisplayName, outFilePath } = res;
+            addFile(participantDisplayName, outFilePath);
+        }
+    }
+    return { reference, degraded };
+}
+async function filterIvfFrames(fpath, frames) {
+    const outFilePath = fpath.replace('.ivf', '.filtered.ivf');
+    const fd = await fs_1.default.promises.open(fpath, 'r');
+    const fixedFd = await fs_1.default.promises.open(outFilePath, 'w');
+    const headerView = new DataView(new ArrayBuffer(32));
+    await fd.read(headerView, 0, headerView.byteLength, 0);
+    let position = 32;
+    let writtenFrames = 0;
+    for (const frame of frames.values()) {
+        const frameView = new DataView(new ArrayBuffer(frame.size));
+        await fd.read(frameView, 0, frame.size, frame.position);
+        await fixedFd.write(new Uint8Array(frameView.buffer), 0, frameView.byteLength, position);
+        position += frameView.byteLength;
+        writtenFrames++;
+    }
+    headerView.setUint32(24, writtenFrames, true);
+    await fixedFd.write(new Uint8Array(headerView.buffer), 0, headerView.byteLength, 0);
+    await fd.close();
+    await fixedFd.close();
+    return outFilePath;
+}
+async function runVmaf(referencePath, degradedPath, preview, cropConfig = {}, cropTimeOverlay = false) {
+    const comparisonDir = path_1.default.dirname(degradedPath);
+    const comparisonName = path_1.default.basename(degradedPath.replace(/\.[^.]+$/, ''));
+    const cropDest = cropConfig[comparisonName];
+    const crop = { ref: fixCrop(cropDest?.ref), deg: fixCrop(cropDest?.deg) };
+    log.info('runVmaf', { referencePath, degradedPath, preview, crop });
+    await fs_1.default.promises.mkdir(path_1.default.join(comparisonDir, comparisonName), { recursive: true });
+    const vmafLogPath = path_1.default.join(comparisonDir, comparisonName, 'vmaf-log.json');
+    const psnrLogPath = path_1.default.join(comparisonDir, comparisonName, 'psnr.log');
+    const comparisonPath = path_1.default.join(comparisonDir, comparisonName, 'comparison.mp4');
+    const sender = path_1.default.basename(referencePath).replace('.ivf', '');
+    const receiver = path_1.default.basename(degradedPath).replace('.ivf', '').split('_recv-by_')[1];
+    const { frameRate: refFrameRate, frames: refFrames } = await parseIvf(referencePath, false);
+    const { width: degWidth, height: degHeight, frameRate: degFrameRate, frames: degFrames, } = await parseIvf(degradedPath, false);
+    const textHeight = cropTimeOverlay ? '(ih/15)' : '';
+    if (textHeight) {
+        crop.ref.h = `${crop.ref.h}-${textHeight}`;
+        crop.ref.y = `${crop.ref.y}+${textHeight}`;
+        crop.deg.h = `${crop.deg.h}-${textHeight}`;
+        crop.deg.y = `${crop.deg.y}+${textHeight}`;
+    }
+    if (refFrameRate !== degFrameRate) {
+        throw new Error(`runVmaf: frame rates do not match: ref=${refFrameRate} deg=${degFrameRate}`);
+    }
+    // Find common frames.
+    const commonRefFrames = [];
+    const commonDegFrames = [];
+    let firstPts = 0;
+    let lastPts = 0;
+    for (const [pts, refFrame] of refFrames.entries()) {
+        const degFrame = degFrames.get(pts);
+        if (degFrame) {
+            commonRefFrames.push(refFrame);
+            commonDegFrames.push(degFrame);
+            if (!firstPts) {
+                firstPts = pts;
+            }
+            lastPts = pts;
+        }
+    }
+    const duration = (lastPts - firstPts) / refFrameRate;
+    referencePath = await filterIvfFrames(referencePath, commonRefFrames);
+    degradedPath = await filterIvfFrames(degradedPath, commonDegFrames);
+    log.debug(`common frames: ${commonRefFrames.length} ref: ${refFrames.size} deg: ${degFrames.size} duration: ${duration}s`, {
+        crop,
+    });
+    const ffmpegCmd = `ffmpeg -hide_banner -loglevel warning -y -threads ${Math.min(cpus, 16)} \
+-i ${degradedPath} \
+-i ${referencePath} \
+`;
+    const filter = `\
+[0:v]\
+scale=w=-1:h=${degHeight}:flags=bicubic,\
+${cropFilter(crop.deg, 0, ',')}\
+${splitFilter(['deg_vmaf', 'deg_psnr', preview ? 'deg_preview' : ''])};\
+[1:v]\
+scale=w=-1:h=${degHeight}:flags=bicubic,crop=w=${degWidth}:x=(iw-${degWidth})/2,\
+${cropFilter(crop.ref, 0, ',')}\
+${splitFilter(['ref_vmaf', 'ref_psnr', preview ? 'ref_preview' : ''])};\
+[deg_vmaf][ref_vmaf]libvmaf=model='path=/usr/share/model/vmaf_v0.6.1.json':log_fmt=json:log_path=${vmafLogPath}:n_subsample=1:n_threads=${cpus}:shortest=1[vmaf];\
+[deg_psnr][ref_psnr]psnr=stats_file=${psnrLogPath}[psnr]\
+`;
+    const cmd = preview
+        ? `${ffmpegCmd} \
+-filter_complex "${filter};[ref_preview][deg_preview]hstack[stacked]" \
+-map [vmaf] -f null - \
+-map [psnr] -f null - \
+-map [stacked] -fps_mode vfr -c:v libx264 -crf 10 -f mp4 -movflags +faststart ${comparisonPath} \
+`
+        : `${ffmpegCmd} \
+-filter_complex "${filter}" \
+-map [vmaf] -f null - \
+-map [psnr] -f null - \
+`;
+    log.debug('runVmaf', cmd);
+    try {
+        const { stdout, stderr } = await (0, utils_1.runShellCommand)(cmd);
+        const vmafLog = JSON.parse(await fs_1.default.promises.readFile(vmafLogPath, 'utf-8'));
+        log.debug('runVmaf', {
+            stdout,
+            stderr,
+        });
+        const metrics = {
+            sender,
+            receiver,
+            ...vmafLog.pooled_metrics.vmaf,
+        };
+        log.info(`VMAF metrics ${vmafLogPath}:`, metrics);
+        try {
+            await writeGraph(vmafLogPath);
+        }
+        catch (err) {
+            log.error(`writeGraph error: ${err.stack}`);
+        }
+        return metrics;
+    }
+    finally {
+        await fs_1.default.promises.unlink(degradedPath);
+        await fs_1.default.promises.unlink(referencePath);
+    }
+}
+async function writeGraph(vmafLogPath) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { ChartJSNodeCanvas } = require('chartjs-node-canvas');
+    const vmafLog = JSON.parse(await fs_1.default.promises.readFile(vmafLogPath, 'utf-8'));
+    const { min, max, mean } = vmafLog.pooled_metrics.vmaf;
+    const fpath = vmafLogPath.replace('.json', '.png');
+    const decimation = Math.ceil(vmafLog.frames.length / 500);
+    const stats = new stats_1.FastStats();
+    const data = vmafLog.frames
+        .reduce((prev, cur) => {
+        if (cur.frameNum % decimation === 0) {
+            prev.push({
+                x: cur.frameNum,
+                y: cur.metrics.vmaf,
+                count: 1,
+            });
+        }
+        else {
+            prev[prev.length - 1].y += cur.metrics.vmaf;
+            prev[prev.length - 1].count++;
+        }
+        stats.push(cur.metrics.vmaf);
+        return prev;
+    }, [])
+        .map(d => ({ x: d.x, y: d.y / d.count }));
+    const chartJSNodeCanvas = new ChartJSNodeCanvas({
+        width: 1280,
+        height: 720,
+        backgroundColour: 'white',
+    });
+    const buffer = await chartJSNodeCanvas.renderToBuffer({
+        type: 'line',
+        data: {
+            labels: data.map(d => d.x),
+            datasets: [
+                {
+                    label: `VMAF score (min: ${min.toFixed(2)}, max: ${max.toFixed(2)}, mean: ${mean.toFixed(2)}, P5: ${stats.percentile(5).toFixed(2)})`,
+                    data: data.map(d => d.y),
+                    fill: false,
+                    borderColor: 'rgb(0, 0, 0)',
+                    borderWidth: 1,
+                    pointRadius: 0,
+                },
+            ],
+        },
+        options: {
+            plugins: {
+                title: {
+                    display: true,
+                    text: path_1.default.basename(vmafLogPath).replace('.vmaf.json', '').replace(/_/g, ' '),
+                },
+            },
+            scales: {
+                y: {
+                    min: 0,
+                    max: 100,
+                },
+            },
+        },
+    });
+    await fs_1.default.promises.writeFile(fpath, buffer);
+}
+const fixCrop = (c) => {
+    return {
+        w: c?.w ?? 'iw',
+        h: c?.h ?? 'ih',
+        x: c?.x ?? '0',
+        y: c?.y ?? '0',
+    };
+};
+const cropFilter = (crop, exact = 0, suffix = '') => {
+    const { w, h, x, y } = crop;
+    if (!x && !w && !x && !y)
+        return '';
+    return `crop=w=${w}:h=${h}:x=${x}:y=${y}:exact=${exact}${suffix}`;
+};
+const splitFilter = (outputs, suffix = '') => {
+    const out = outputs
+        .filter(o => !!o)
+        .map(o => `[${o}]`)
+        .join('');
+    if (!out)
+        return '';
+    return `split=${outputs.length}${out}${suffix}`;
+};
+async function calculateVmafScore(config) {
+    const { vmafPath, vmafPreview, vmafKeepIntermediateFiles, vmafKeepSourceFiles, vmafCrop } = config;
+    if (!fs_1.default.existsSync(config.vmafPath)) {
+        throw new Error(`VMAF path ${config.vmafPath} does not exist`);
+    }
+    log.debug(`calculateVmafScore referencePath=${vmafPath}`);
+    const { reference, degraded } = await fixIvfFiles(vmafPath, vmafKeepSourceFiles);
+    const crop = vmafCrop ? json5_1.default.parse(vmafCrop) : undefined;
+    const ret = [];
+    for (const participantDisplayName of reference.keys()) {
+        const vmafReferencePath = reference.get(participantDisplayName);
+        if (!vmafReferencePath)
+            continue;
+        for (const degradedPath of degraded.get(participantDisplayName) ?? []) {
+            try {
+                const metrics = await runVmaf(vmafReferencePath, degradedPath, vmafPreview, crop);
+                ret.push(metrics);
+            }
+            catch (err) {
+                log.error(`runVmaf error: ${err.message}`);
+            }
+            finally {
+                if (!vmafKeepIntermediateFiles) {
+                    await fs_1.default.promises.unlink(degradedPath);
+                }
+            }
+        }
+        if (!vmafKeepIntermediateFiles) {
+            await fs_1.default.promises.unlink(vmafReferencePath);
+        }
+    }
+    await fs_1.default.promises.writeFile(path_1.default.join(vmafPath, 'vmaf.json'), JSON.stringify(ret, undefined, 2));
+    return ret;
+}
+if (require.main === module) {
+    ;
+    (async () => {
+        switch (process.argv[2]) {
+            case 'convert':
+                await convertToIvf(process.argv[3], process.argv[4], false);
+                break;
+            case 'parse': {
+                const { frames } = await parseIvf(process.argv[3], true);
+                console.log(frames);
+                break;
+            }
+            case 'fix':
+                await fixIvfFrames(process.argv[3], true);
+                break;
+            case 'analyze':
+                console.log(JSON.stringify(await (0, utils_1.analyzeColors)(process.argv[3]), null, 2));
+                break;
+            case 'graph':
+                await writeGraph(process.argv[3]);
+                break;
+            case 'vmaf':
+                await calculateVmafScore({
+                    vmafPath: process.argv[3],
+                    vmafPreview: true,
+                    vmafKeepIntermediateFiles: true,
+                    vmafKeepSourceFiles: true,
+                    vmafCrop: json5_1.default.stringify({
+                        'Participant-000001_recv-by_Participant-000000': {
+                            ref: { w: '', h: '', x: '', y: '' },
+                            deg: { w: '', h: '', x: '', y: '' },
+                        },
+                    }),
+                });
+                break;
+            default:
+                throw new Error(`Invalid command: ${process.argv[2]}`);
+        }
+    })()
+        .catch(err => console.error(err))
+        .finally(() => process.exit(0));
+}
+//# sourceMappingURL=vmaf.js.map