imagescript 3.3.0 → 3.4.0

package/dist/codecs/av1/restoration.js

@@ -0,0 +1,193 @@
+/*!
+ * AV1 superres upscaling and loop restoration (Wiener and self guided filters), as the AV1 specification describes them
+ * (sections 7.16, 7.17) and dav1d implements them (src/looprestoration_tmpl.c, src/mc_tmpl.c), with dav1d's tables.
+ * Copyright (c) 2018-2021, VideoLAN and dav1d authors, Copyright (c) 2018, Two Orioles, LLC, BSD-2-Clause License (see
+ * THIRD_PARTY_NOTICES.md)
+ */
+import { RESTORATION_NONE, RESTORATION_WIENER } from "./obu.js";
+import { RESIZE_FILTER } from "./tables.js";
+export function superres(f, planes) {
+    const out = [], strides = [];
+    const max = f.bitdepthMax;
+    for (let p = 0; p < planes.length; p++) {
+        const subX = p ? f.ssx : 0, subY = p ? f.ssy : 0;
+        const downW = f.width + subX >> subX, upW = f.hdr.upscaledWidth + subX >> subX, h = f.height + subY >> subY;
+        const stepX = Math.floor(((downW << 14) + (upW >> 1)) / upW);
+        const err = upW * stepX - (downW << 14);
+        let initialSubpelX = Math.trunc((-((upW - downW) << 13) + (upW >> 1)) / upW) + (1 << 7) - Math.trunc(err / 2);
+        initialSubpelX &= (1 << 14) - 1;
+        const maxX = ((f.bw >> subX) * 4) - 1;
+        const src = planes[p], srcStride = f.strides[p];
+        const stride = upW + 31 & ~31;
+        const dst = new Uint16Array(stride * (h + 8));
+        for (let y = 0; y < h; y++) {
+            for (let x = 0; x < upW; x++) {
+                const srcX = -(1 << 14) + initialSubpelX + x * stepX;
+                const px = srcX >> 14, subpel = (srcX & (1 << 14) - 1) >> 8;
+                let sum = 0;
+                for (let k = 0; k < 8; k++) {
+                    const sx = Math.min(maxX, Math.max(0, px + k - 3));
+                    sum -= src[y * srcStride + sx] * RESIZE_FILTER[subpel * 8 + k];
+                }
+                const v = (sum + 64) >> 7;
+                dst[y * stride + x] = v < 0 ? 0 : v > max ? max : v;
+            }
+        }
+        out.push(dst);
+        strides.push(stride);
+    }
+    return { planes: out, strides };
+}
+const SGR = [
+    [2, 12, 1, 4], [2, 15, 1, 6], [2, 18, 1, 8], [2, 21, 1, 9], [2, 24, 1, 10], [2, 29, 1, 11], [2, 36, 1, 12],
+    [2, 45, 1, 13], [2, 56, 1, 14], [2, 68, 1, 15], [0, 0, 1, 5], [0, 0, 1, 8], [0, 0, 1, 11], [0, 0, 1, 14],
+    [2, 30, 0, 0], [2, 75, 0, 0]
+];
+export function loopRestoration(f, pre, cdef, out, strides) {
+    const hdr = f.hdr, bitdepth = f.bitdepth, max = f.bitdepthMax;
+    for (let p = 0; p < out.length; p++) {
+        if (hdr.restoration.types[p] === RESTORATION_NONE)
+            continue;
+        const subX = p ? f.ssx : 0, subY = p ? f.ssy : 0;
+        const planeW = hdr.upscaledWidth + subX >> subX, planeH = f.height + subY >> subY;
+        const unitSize = 1 << hdr.restoration.unitSizeLog2[p ? 1 : 0];
+        const unitCols = f.lrUnitsW[p], unitRows = f.lrUnitsH[p];
+        const stride = strides[p], cur = pre[p], cd = cdef[p], dst = out[p];
+        for (let stripe = 0; (-8 + stripe * 64) >> subY < planeH; stripe++) {
+            const stripeStart = (-8 + stripe * 64) >> subY, stripeEnd = stripeStart + (64 >> subY) - 1;
+            const y0 = Math.max(0, stripeStart), y1 = Math.min(planeH, stripeEnd + 1);
+            if (y0 >= y1)
+                continue;
+            const lumaRow = Math.max(0, stripe * 64 - 8) >> 2;
+            const unitRow = Math.min(unitRows - 1, Math.floor(((lumaRow * 4 + 8) >> subY) / unitSize));
+            const sample = (x, y) => {
+                x = Math.max(0, Math.min(planeW - 1, x));
+                y = Math.max(0, Math.min(planeH - 1, y));
+                if (y < stripeStart)
+                    return cur[Math.max(stripeStart - 2, y) * stride + x];
+                if (y > stripeEnd)
+                    return cur[Math.min(stripeEnd + 2, y) * stride + x];
+                return cd[y * stride + x];
+            };
+            for (let unitCol = 0; unitCol < unitCols; unitCol++) {
+                const x0 = unitCol * unitSize, x1 = unitCol === unitCols - 1 ? planeW : Math.min(planeW, x0 + unitSize);
+                const unit = f.lr[p][unitRow * unitCols + unitCol];
+                const w = x1 - x0, h = y1 - y0;
+                const ww = w + 6, win = new Int32Array(ww * (h + 6));
+                for (let y = 0; y < h + 6; y++)
+                    for (let x = 0; x < ww; x++)
+                        win[y * ww + x] = sample(x0 + x - 3, y0 + y - 3);
+                if (unit.type === RESTORATION_WIENER)
+                    wiener(win, ww, w, h, unit.filterV, unit.filterH, bitdepth, dst, y0 * stride + x0, stride);
+                else if (unit.type !== RESTORATION_NONE)
+                    selfGuided(win, ww, w, h, unit.type - 3, unit.sgrWeights, bitdepth, cd, dst, y0 * stride + x0, stride, max);
+            }
+        }
+    }
+}
+function wienerFilter(coeff) {
+    const filter = [coeff[0], coeff[1], coeff[2], 128, coeff[2], coeff[1], coeff[0]];
+    filter[3] -= 2 * (coeff[0] + coeff[1] + coeff[2]);
+    return filter;
+}
+function wiener(win, ww, w, h, v, hf, bitdepth, dst, d, stride) {
+    const round0 = bitdepth === 12 ? 5 : 3, round1 = bitdepth === 12 ? 9 : 11;
+    const vfilter = wienerFilter(v), hfilter = wienerFilter(hf);
+    const offset = 1 << (bitdepth + 7 - round0 - 1), limit = (1 << (bitdepth + 1 + 7 - round0)) - 1;
+    const max = (1 << bitdepth) - 1;
+    const inter = new Int32Array(w * (h + 6));
+    for (let r = 0; r < h + 6; r++) {
+        for (let c = 0; c < w; c++) {
+            let s = 0;
+            for (let t = 0; t < 7; t++)
+                s += hfilter[t] * win[r * ww + c + t];
+            const x = (s + (1 << (round0 - 1))) >> round0;
+            inter[r * w + c] = x < -offset ? -offset : x > limit - offset ? limit - offset : x;
+        }
+    }
+    for (let r = 0; r < h; r++) {
+        for (let c = 0; c < w; c++) {
+            let s = 0;
+            for (let t = 0; t < 7; t++)
+                s += vfilter[t] * inter[(r + t) * w + c];
+            const x = (s + (1 << (round1 - 1))) >> round1;
+            dst[d + r * stride + c] = x < 0 ? 0 : x > max ? max : x;
+        }
+    }
+}
+function boxFilter(win, ww, w, h, r, eps, pass, bitdepth, cd, d, stride) {
+    const n = (2 * r + 1) * (2 * r + 1), n2e = n * n * eps;
+    const s = Math.floor(((1 << 20) + Math.floor(n2e / 2)) / n2e);
+    const oneOverN = Math.floor(((1 << 12) + (n >> 1)) / n);
+    const shiftA = 2 * (bitdepth - 8), shiftB = bitdepth - 8;
+    const aw = w + 2, A = new Int32Array(aw * (h + 2)), B = new Int32Array(aw * (h + 2));
+    const rowSum = new Int32Array(ww), rowSq = new Float64Array(ww);
+    for (let i = -1; i < h + 1; i++) {
+        if (pass === 0 && !(i & 1))
+            continue;
+        rowSum.fill(0);
+        rowSq.fill(0);
+        for (let dy = -r; dy <= r; dy++) {
+            const o = (i + dy + 3) * ww;
+            for (let x = 0; x < ww; x++) {
+                const c = win[o + x];
+                rowSum[x] += c;
+                rowSq[x] += c * c;
+            }
+        }
+        for (let j = -1; j < w + 1; j++) {
+            let a = 0, b = 0;
+            for (let dx = -r; dx <= r; dx++) {
+                a += rowSq[j + dx + 3];
+                b += rowSum[j + dx + 3];
+            }
+            a = shiftA ? (a + (1 << (shiftA - 1))) >> shiftA : a;
+            const dd = shiftB ? (b + (1 << (shiftB - 1))) >> shiftB : b;
+            const p = Math.max(0, a * n - dd * dd);
+            const z = Math.floor((p * s + (1 << 19)) / (1 << 20));
+            const a2 = z >= 255 ? 256 : z === 0 ? 1 : Math.floor(((z << 8) + (z >> 1)) / (z + 1));
+            A[(i + 1) * aw + j + 1] = a2;
+            B[(i + 1) * aw + j + 1] = Math.floor(((256 - a2) * b * oneOverN + 2048) / 4096);
+        }
+    }
+    const F = new Int32Array(w * h);
+    for (let i = 0; i < h; i++) {
+        const shift = (pass === 0 && i & 1 ? 4 : 5) + 4, rnd = 1 << (shift - 1);
+        const up = i * aw, mid = (i + 1) * aw, down = (i + 2) * aw;
+        for (let j = 0; j < w; j++) {
+            let a, b;
+            if (pass === 0) {
+                if (i & 1) {
+                    a = 6 * A[mid + j + 1] + 5 * (A[mid + j] + A[mid + j + 2]);
+                    b = 6 * B[mid + j + 1] + 5 * (B[mid + j] + B[mid + j + 2]);
+                }
+                else {
+                    a = 6 * (A[up + j + 1] + A[down + j + 1]) + 5 * (A[up + j] + A[up + j + 2] + A[down + j] + A[down + j + 2]);
+                    b = 6 * (B[up + j + 1] + B[down + j + 1]) + 5 * (B[up + j] + B[up + j + 2] + B[down + j] + B[down + j + 2]);
+                }
+            }
+            else {
+                a = 4 * (A[up + j + 1] + A[mid + j] + A[mid + j + 1] + A[mid + j + 2] + A[down + j + 1]) + 3 * (A[up + j] + A[up + j + 2] + A[down + j] + A[down + j + 2]);
+                b = 4 * (B[up + j + 1] + B[mid + j] + B[mid + j + 1] + B[mid + j + 2] + B[down + j + 1]) + 3 * (B[up + j] + B[up + j + 2] + B[down + j] + B[down + j + 2]);
+            }
+            F[i * w + j] = (a * cd[d + i * stride + j] + b + rnd) >> shift;
+        }
+    }
+    return F;
+}
+function selfGuided(win, ww, w, h, set, weights, bitdepth, cd, dst, d, stride, max) {
+    const [r0, e0, r1, e1] = SGR[set];
+    const flt0 = r0 ? boxFilter(win, ww, w, h, r0, e0, 0, bitdepth, cd, d, stride) : null;
+    const flt1 = r1 ? boxFilter(win, ww, w, h, r1, e1, 1, bitdepth, cd, d, stride) : null;
+    const w0 = weights[0], w1 = weights[1], w2 = 128 - w0 - w1;
+    for (let i = 0; i < h; i++) {
+        for (let j = 0; j < w; j++) {
+            const u = cd[d + i * stride + j] << 4;
+            let v = w1 * u;
+            v += flt0 ? w0 * flt0[i * w + j] : w0 * u;
+            v += flt1 ? w2 * flt1[i * w + j] : w2 * u;
+            const s = (v + 1024) >> 11;
+            dst[d + i * stride + j] = s < 0 ? 0 : s > max ? max : s;
+        }
+    }
+}

package/dist/codecs/av1/tables.js

@@ -0,0 +1,160 @@
+/*!
+ * Constants and tables of the AV1 decoder, ported from dav1d (src/levels.h, src/intra_edge.c, src/qm.c, src/cdf.c).
+ * Copyright (c) 2018-2021, VideoLAN and dav1d authors, Copyright (c) 2018, Two Orioles, LLC, BSD-2-Clause License
+ * (see THIRD_PARTY_NOTICES.md)
+ */
+import * as data from "./data.js";
+import { base64 } from "../../util/bytes.js";
+import { decompress } from "../zlib.js";
+export const BL_128X128 = 0, BL_64X64 = 1, BL_8X8 = 4;
+export const BS_128x128 = 0, BS_64x64 = 3, BS_4x4 = 21;
+export const PARTITION_NONE = 0, PARTITION_H = 1, PARTITION_V = 2, PARTITION_SPLIT = 3, PARTITION_T_TOP_SPLIT = 4, PARTITION_T_BOTTOM_SPLIT = 5, PARTITION_T_LEFT_SPLIT = 6, PARTITION_T_RIGHT_SPLIT = 7, PARTITION_H4 = 8, PARTITION_V4 = 9;
+export const DC_PRED = 0, VERT_PRED = 1, HOR_PRED = 2, DIAG_DOWN_LEFT_PRED = 3, VERT_LEFT_PRED = 8, SMOOTH_PRED = 9, SMOOTH_V_PRED = 10, SMOOTH_H_PRED = 11, PAETH_PRED = 12, CFL_PRED = 13, FILTER_PRED = 13, LEFT_DC_PRED = 3, TOP_DC_PRED = 4, DC_128_PRED = 5, Z1_PRED = 6, Z2_PRED = 7, Z3_PRED = 8;
+export const TX_4X4 = 0, TX_8X8 = 1, TX_16X16 = 2, TX_32X32 = 3, TX_64X64 = 4, RTX_4X8 = 5;
+export const DCT_DCT = 0, IDTX = 9, WHT_WHT = 16;
+export const TX_CLASS_2D = 0, TX_CLASS_H = 1, TX_CLASS_V = 2;
+export const EDGE_I444_TOP_HAS_RIGHT = 1, EDGE_I422_TOP_HAS_RIGHT = 2, EDGE_I420_TOP_HAS_RIGHT = 4, EDGE_I444_LEFT_HAS_BOTTOM = 8, EDGE_I422_LEFT_HAS_BOTTOM = 16, EDGE_I420_LEFT_HAS_BOTTOM = 32, EDGE_ALL_TOP_HAS_RIGHT = 7, EDGE_ALL_LEFT_HAS_BOTTOM = 56, EDGE_ALL_TR_AND_BL = 63;
+export const { AL_PART_CTX, BLOCK_SIZES, BLOCK_DIMENSIONS, TXFM_DIMENSIONS, MAX_TXFM_SIZE_FOR_BS, TXTP_FROM_UVMODE, PARTITION_TYPE_COUNT, TX_TYPES_PER_SET, FILTER_MODE_TO_Y_MODE, LO_CTX_OFFSETS, SKIP_CTX, TX_TYPE_CLASS, INTRA_MODE_CONTEXT, CDEF_DIRECTIONS, SGR_PARAMS, SGR_X_BY_X, SM_WEIGHTS, DR_INTRA_DERIVATIVE, FILTER_INTRA_TAPS, RESIZE_FILTER, CDF, SCAN_OFFSETS } = data;
+export const CFL_ALLOWED_MASK = (1 << 7) | (1 << 8) | (1 << 9) | (1 << 11) | (1 << 12) | (1 << 13) | (1 << 14) | (1 << 15) |
+    (1 << 16) | (1 << 17) | (1 << 18) | (1 << 19) | (1 << 20) | (1 << 21);
+let tables = null;
+function load() {
+    if (tables)
+        return tables;
+    const at = data.PACKED_AT;
+    const blob = decompress(base64(data.PACKED), at.size[1]);
+    const bytes = ([offset, size]) => blob.subarray(offset, offset + size);
+    const words = ([offset, size]) => {
+        const w = new Uint16Array(size >> 1);
+        for (let i = 0; i < w.length; i++)
+            w[i] = blob[offset + i * 2] | blob[offset + i * 2 + 1] << 8;
+        return w;
+    };
+    return tables = {
+        modeCdfs: words(at.modeCdfs),
+        coefCdfs: [at.coefCdfs0, at.coefCdfs1, at.coefCdfs2, at.coefCdfs3].map(words),
+        scans: words(at.scans),
+        dq: words(at.dq),
+        qm: buildQm(bytes(at.qm)),
+        gaussianSequence: new Int16Array(words(at.gaussianSequence))
+    };
+}
+export function gaussianSequence() {
+    return load().gaussianSequence;
+}
+export function defaultCdfs(qidx) {
+    const t = load();
+    const cdf = new Uint16Array(CDF.size);
+    cdf.set(t.modeCdfs);
+    cdf.set(t.coefCdfs[(qidx > 20 ? 1 : 0) + (qidx > 60 ? 1 : 0) + (qidx > 120 ? 1 : 0)], t.modeCdfs.length);
+    return cdf;
+}
+export function scan(tx) {
+    const t = load();
+    const w = Math.min(TXFM_DIMENSIONS[tx * 8] * 4, 32), h = Math.min(TXFM_DIMENSIONS[tx * 8 + 1] * 4, 32);
+    return t.scans.subarray(SCAN_OFFSETS[tx], SCAN_OFFSETS[tx] + w * h);
+}
+export function dequant(hbd, qidx, ac) {
+    return load().dq[(hbd * 256 + qidx) * 2 + ac];
+}
+export function quantizerMatrix(level, chroma, tx) {
+    return load().qm[level][chroma][tx];
+}
+function buildQm(src) {
+    const subsample = (s, o, h, hstep, vstep) => {
+        const out = [];
+        for (let y = 0; y < h; y += vstep)
+            for (let x = 0; x < 32; x += hstep)
+                out.push(s[o + y * 32 + x]);
+        return Uint8Array.from(out);
+    };
+    const transpose = (s, w, h) => {
+        const d = new Uint8Array(w * h);
+        for (let y = 0; y < h; y++)
+            for (let x = 0; x < w; x++)
+                d[x * h + y] = s[y * w + x];
+        return d;
+    };
+    const result = [];
+    for (let i = 0; i < 15; i++) {
+        const level = [];
+        for (let j = 0; j < 2; j++) {
+            const t32x16 = src.subarray((i * 2 + j) * 512, (i * 2 + j + 1) * 512);
+            const tri = src.subarray(15 * 2 * 512 + (i * 2 + j) * 528);
+            const t32x32 = new Uint8Array(1024);
+            for (let y = 0, o = 0; y < 32; y++)
+                for (let x = 0; x <= y; x++, o++)
+                    t32x32[y * 32 + x] = t32x32[x * 32 + y] = tri[o];
+            const t4x4 = subsample(t32x32, 32 * 3 + 3, 32, 8, 8);
+            const t8x4 = subsample(t32x16, 32 + 1, 16, 4, 4);
+            const t8x8 = subsample(t32x32, 32 + 1, 32, 4, 4);
+            const t16x4 = subsample(t32x16, 32, 16, 2, 4);
+            const t16x8 = subsample(t32x16, 0, 16, 2, 2);
+            const t16x16 = subsample(t32x32, 0, 32, 2, 2);
+            const t32x8 = subsample(t32x16, 0, 16, 1, 2);
+            const t4x8 = transpose(t8x4, 8, 4), t4x16 = transpose(t16x4, 16, 4), t8x16 = transpose(t16x8, 16, 8);
+            const t8x32 = transpose(t32x8, 32, 8), t16x32 = transpose(t32x16, 32, 16);
+            const byTx = [];
+            byTx[TX_4X4] = t4x4;
+            byTx[TX_8X8] = t8x8;
+            byTx[TX_16X16] = t16x16;
+            byTx[TX_32X32] = t32x32;
+            byTx[TX_64X64] = t32x32;
+            byTx[5] = t8x4;
+            byTx[6] = t4x8;
+            byTx[7] = t16x8;
+            byTx[8] = t8x16;
+            byTx[9] = t32x16;
+            byTx[10] = t16x32;
+            byTx[11] = t32x32;
+            byTx[12] = t32x32;
+            byTx[13] = t16x4;
+            byTx[14] = t4x16;
+            byTx[15] = t32x8;
+            byTx[16] = t8x32;
+            byTx[17] = t32x16;
+            byTx[18] = t16x32;
+            level.push(byTx);
+        }
+        result.push(level);
+    }
+    return result;
+}
+function initEdges(bl, flags) {
+    const node = { o: flags, h: [flags | EDGE_ALL_LEFT_HAS_BOTTOM, 0], v: [flags | EDGE_ALL_TOP_HAS_RIGHT, 0], h4: 0, v4: 0, split: [], tip: [] };
+    if (bl === BL_8X8) {
+        node.h[1] = flags & (EDGE_ALL_LEFT_HAS_BOTTOM | EDGE_I420_TOP_HAS_RIGHT);
+        node.v[1] = flags & (EDGE_ALL_TOP_HAS_RIGHT | EDGE_I420_LEFT_HAS_BOTTOM | EDGE_I422_LEFT_HAS_BOTTOM);
+        node.tip = [
+            flags & EDGE_ALL_TOP_HAS_RIGHT | EDGE_I422_LEFT_HAS_BOTTOM,
+            flags | EDGE_I444_TOP_HAS_RIGHT,
+            flags & (EDGE_I420_TOP_HAS_RIGHT | EDGE_I420_LEFT_HAS_BOTTOM | EDGE_I422_LEFT_HAS_BOTTOM)
+        ];
+    }
+    else {
+        node.h[1] = flags & EDGE_ALL_LEFT_HAS_BOTTOM;
+        node.v[1] = flags & EDGE_ALL_TOP_HAS_RIGHT;
+        node.h4 = EDGE_ALL_LEFT_HAS_BOTTOM;
+        node.v4 = EDGE_ALL_TOP_HAS_RIGHT;
+        if (bl === 3) {
+            node.h4 |= flags & EDGE_I420_TOP_HAS_RIGHT;
+            node.v4 |= flags & (EDGE_I420_LEFT_HAS_BOTTOM | EDGE_I422_LEFT_HAS_BOTTOM);
+        }
+    }
+    return node;
+}
+function initModeNode(bl, topHasRight, leftHasBottom) {
+    const node = initEdges(bl, (topHasRight ? EDGE_ALL_TOP_HAS_RIGHT : 0) | (leftHasBottom ? EDGE_ALL_LEFT_HAS_BOTTOM : 0));
+    for (let n = 0; n < 4; n++) {
+        const tr = !(n === 3 || n === 1 && !topHasRight), lb = n === 0 || n === 2 && leftHasBottom;
+        node.split.push(bl === 3
+            ? initEdges(bl + 1, (tr ? EDGE_ALL_TOP_HAS_RIGHT : 0) | (lb ? EDGE_ALL_LEFT_HAS_BOTTOM : 0))
+            : initModeNode(bl + 1, tr, lb));
+    }
+    return node;
+}
+let edgeTrees = null;
+export function edgeTree(sb128) {
+    edgeTrees ??= [initModeNode(BL_128X128, true, false), initModeNode(BL_64X64, true, false)];
+    return edgeTrees[sb128 ? 0 : 1];
+}