imagescript 3.2.1 → 3.4.0

package/dist/codecs/av1/loopfilter.js

@@ -0,0 +1,149 @@
+/*!
+ * The AV1 deblocking filter: every transform block edge of intra frames, filtered with the filters of dav1d
+ * (src/loopfilter_tmpl.c, src/lf_mask.c). Copyright (c) 2018-2021, VideoLAN and dav1d authors, Copyright (c) 2018,
+ * Two Orioles, LLC, BSD-2-Clause License (see THIRD_PARTY_NOTICES.md)
+ */
+export function deblock(f) {
+    const lf = f.hdr.loopFilter;
+    if (!lf.levelY[0] && !lf.levelY[1])
+        return;
+    const sharp = lf.sharpness;
+    const I = new Uint8Array(64), E = new Uint8Array(64);
+    for (let level = 0; level < 64; level++) {
+        let limit = level;
+        if (sharp > 0)
+            limit = Math.min(limit >> (sharp + 3 >> 2), 9 - sharp);
+        I[level] = Math.max(limit, 1);
+        E[level] = 2 * (level + 2) + I[level];
+    }
+    const s4 = f.b4Stride;
+    for (let plane = 0; plane < f.planes.length; plane++) {
+        if (plane && !(plane === 1 ? lf.levelU : lf.levelV))
+            continue;
+        const subX = plane ? f.ssx : 0, subY = plane ? f.ssy : 0;
+        const txW = plane ? f.uvTxW : f.txW, txH = plane ? f.uvTxH : f.txH;
+        const pic = f.planes[plane], stride = f.strides[plane];
+        for (let pass = 0; pass < 2; pass++) {
+            const dx = pass ? 0 : 1, dy = pass;
+            const tx = pass ? txH : txW;
+            const level = plane ? plane + 1 : pass;
+            for (let row = 0; row < f.bh; row += 1 << subY) {
+                const y = row * 4;
+                if (y >= f.height || pass && !y)
+                    continue;
+                for (let col = 0; col < f.bw; col += 1 << subX) {
+                    const x = col * 4;
+                    if (x >= f.width || !pass && !x)
+                        continue;
+                    const r = row | subY, c = col | subX;
+                    const xP = x >> subX, yP = y >> subY;
+                    const cur = (r >> subY) * s4 + (c >> subX);
+                    const prevR = r - (dy << subY), prevC = c - (dx << subX);
+                    const prev = (prevR >> subY) * s4 + (prevC >> subX);
+                    const size = 4 << tx[cur];
+                    if ((pass ? yP : xP) % size)
+                        continue;
+                    const filterSize = Math.min(plane ? 8 : 16, size, 4 << tx[prev]);
+                    let lvl = f.lfLevels[(r * s4 + c) * 4 + level];
+                    if (!lvl)
+                        lvl = f.lfLevels[(prevR * s4 + prevC) * 4 + level];
+                    if (!lvl)
+                        continue;
+                    const wd = plane && filterSize === 8 ? 6 : filterSize;
+                    filter(pic, yP * stride + xP, E[lvl], I[lvl], lvl >> 4, pass ? 1 : stride, pass ? stride : 1, wd, f.bitdepth);
+                }
+            }
+        }
+    }
+}
+function filter(dst, d, E, I, H, stridea, strideb, wd, bitdepth) {
+    const shift = bitdepth - 8, F = 1 << shift;
+    E <<= shift;
+    I <<= shift;
+    H <<= shift;
+    const max = (1 << bitdepth) - 1;
+    const pix = (v) => v < 0 ? 0 : v > max ? max : v;
+    const diffMin = -128 * (1 << shift), diffMax = 128 * (1 << shift) - 1;
+    const clipDiff = (v) => v < diffMin ? diffMin : v > diffMax ? diffMax : v;
+    const abs = Math.abs;
+    for (let i = 0; i < 4; i++, d += stridea) {
+        let p6 = 0, p5 = 0, p4 = 0, p3 = 0, p2 = 0, q2 = 0, q3 = 0, q4 = 0, q5 = 0, q6 = 0;
+        const p1 = dst[d - 2 * strideb], p0 = dst[d - strideb], q0 = dst[d], q1 = dst[d + strideb];
+        let fm = abs(p1 - p0) <= I && abs(q1 - q0) <= I && abs(p0 - q0) * 2 + (abs(p1 - q1) >> 1) <= E;
+        if (wd > 4) {
+            p2 = dst[d - 3 * strideb];
+            q2 = dst[d + 2 * strideb];
+            fm &&= abs(p2 - p1) <= I && abs(q2 - q1) <= I;
+            if (wd > 6) {
+                p3 = dst[d - 4 * strideb];
+                q3 = dst[d + 3 * strideb];
+                fm &&= abs(p3 - p2) <= I && abs(q3 - q2) <= I;
+            }
+        }
+        if (!fm)
+            continue;
+        let flat8out = false, flat8in = false;
+        if (wd >= 16) {
+            p6 = dst[d - 7 * strideb];
+            p5 = dst[d - 6 * strideb];
+            p4 = dst[d - 5 * strideb];
+            q4 = dst[d + 4 * strideb];
+            q5 = dst[d + 5 * strideb];
+            q6 = dst[d + 6 * strideb];
+            flat8out = abs(p6 - p0) <= F && abs(p5 - p0) <= F && abs(p4 - p0) <= F && abs(q4 - q0) <= F &&
+                abs(q5 - q0) <= F && abs(q6 - q0) <= F;
+        }
+        if (wd >= 6)
+            flat8in = abs(p2 - p0) <= F && abs(p1 - p0) <= F && abs(q1 - q0) <= F && abs(q2 - q0) <= F;
+        if (wd >= 8)
+            flat8in &&= abs(p3 - p0) <= F && abs(q3 - q0) <= F;
+        if (wd >= 16 && flat8out && flat8in) {
+            dst[d - 6 * strideb] = (p6 * 7 + p5 * 2 + p4 * 2 + p3 + p2 + p1 + p0 + q0 + 8) >> 4;
+            dst[d - 5 * strideb] = (p6 * 5 + p5 * 2 + p4 * 2 + p3 * 2 + p2 + p1 + p0 + q0 + q1 + 8) >> 4;
+            dst[d - 4 * strideb] = (p6 * 4 + p5 + p4 * 2 + p3 * 2 + p2 * 2 + p1 + p0 + q0 + q1 + q2 + 8) >> 4;
+            dst[d - 3 * strideb] = (p6 * 3 + p5 + p4 + p3 * 2 + p2 * 2 + p1 * 2 + p0 + q0 + q1 + q2 + q3 + 8) >> 4;
+            dst[d - 2 * strideb] = (p6 * 2 + p5 + p4 + p3 + p2 * 2 + p1 * 2 + p0 * 2 + q0 + q1 + q2 + q3 + q4 + 8) >> 4;
+            dst[d - strideb] = (p6 + p5 + p4 + p3 + p2 + p1 * 2 + p0 * 2 + q0 * 2 + q1 + q2 + q3 + q4 + q5 + 8) >> 4;
+            dst[d] = (p5 + p4 + p3 + p2 + p1 + p0 * 2 + q0 * 2 + q1 * 2 + q2 + q3 + q4 + q5 + q6 + 8) >> 4;
+            dst[d + strideb] = (p4 + p3 + p2 + p1 + p0 + q0 * 2 + q1 * 2 + q2 * 2 + q3 + q4 + q5 + q6 * 2 + 8) >> 4;
+            dst[d + 2 * strideb] = (p3 + p2 + p1 + p0 + q0 + q1 * 2 + q2 * 2 + q3 * 2 + q4 + q5 + q6 * 3 + 8) >> 4;
+            dst[d + 3 * strideb] = (p2 + p1 + p0 + q0 + q1 + q2 * 2 + q3 * 2 + q4 * 2 + q5 + q6 * 4 + 8) >> 4;
+            dst[d + 4 * strideb] = (p1 + p0 + q0 + q1 + q2 + q3 * 2 + q4 * 2 + q5 * 2 + q6 * 5 + 8) >> 4;
+            dst[d + 5 * strideb] = (p0 + q0 + q1 + q2 + q3 + q4 * 2 + q5 * 2 + q6 * 7 + 8) >> 4;
+        }
+        else if (wd >= 8 && flat8in) {
+            dst[d - 3 * strideb] = (p3 * 3 + 2 * p2 + p1 + p0 + q0 + 4) >> 3;
+            dst[d - 2 * strideb] = (p3 * 2 + p2 + 2 * p1 + p0 + q0 + q1 + 4) >> 3;
+            dst[d - strideb] = (p3 + p2 + p1 + 2 * p0 + q0 + q1 + q2 + 4) >> 3;
+            dst[d] = (p2 + p1 + p0 + 2 * q0 + q1 + q2 + q3 + 4) >> 3;
+            dst[d + strideb] = (p1 + p0 + q0 + 2 * q1 + q2 + q3 * 2 + 4) >> 3;
+            dst[d + 2 * strideb] = (p0 + q0 + q1 + 2 * q2 + q3 * 3 + 4) >> 3;
+        }
+        else if (wd === 6 && flat8in) {
+            dst[d - 2 * strideb] = (p2 * 3 + 2 * p1 + 2 * p0 + q0 + 4) >> 3;
+            dst[d - strideb] = (p2 + 2 * p1 + 2 * p0 + 2 * q0 + q1 + 4) >> 3;
+            dst[d] = (p1 + 2 * p0 + 2 * q0 + 2 * q1 + q2 + 4) >> 3;
+            dst[d + strideb] = (p0 + 2 * q0 + 2 * q1 + q2 * 3 + 4) >> 3;
+        }
+        else {
+            const hev = abs(p1 - p0) > H || abs(q1 - q0) > H;
+            const top = (128 << shift) - 1;
+            if (hev) {
+                let f = clipDiff(p1 - q1);
+                f = clipDiff(3 * (q0 - p0) + f);
+                const f1 = Math.min(f + 4, top) >> 3, f2 = Math.min(f + 3, top) >> 3;
+                dst[d - strideb] = pix(p0 + f2);
+                dst[d] = pix(q0 - f1);
+            }
+            else {
+                const f = clipDiff(3 * (q0 - p0));
+                const f1 = Math.min(f + 4, top) >> 3, f2 = Math.min(f + 3, top) >> 3;
+                dst[d - strideb] = pix(p0 + f2);
+                dst[d] = pix(q0 - f1);
+                const g = (f1 + 1) >> 1;
+                dst[d - 2 * strideb] = pix(p1 + g);
+                dst[d + strideb] = pix(q1 - g);
+            }
+        }
+    }
+}

package/dist/codecs/av1/msac.js

@@ -0,0 +1,161 @@
+/*!
+ * The AV1 symbol decoder (a multi-symbol arithmetic decoder with adapting CDFs), ported from dav1d (src/msac.c).
+ * Copyright (c) 2018-2021, VideoLAN and dav1d authors, Copyright (c) 2018, Two Orioles, LLC, BSD-2-Clause License
+ * (see THIRD_PARTY_NOTICES.md)
+ */
+const PROB_SHIFT = 6, MIN_PROB = 4;
+const WIN = 32;
+export class SymbolDecoder {
+    data;
+    end;
+    allowUpdate;
+    pos;
+    dif = 0;
+    rng = 0x8000;
+    cnt = -15;
+    constructor(data, start, end, allowUpdate) {
+        this.data = data;
+        this.end = end;
+        this.allowUpdate = allowUpdate;
+        this.pos = start;
+        this.refill();
+    }
+    refill() {
+        let c = WIN - this.cnt - 24;
+        let dif = this.dif;
+        do {
+            if (this.pos >= this.end) {
+                dif = (dif | ~(~0xff << c)) >>> 0;
+                break;
+            }
+            dif = (dif | (this.data[this.pos++] ^ 0xff) << c) >>> 0;
+            c -= 8;
+        } while (c >= 0);
+        this.dif = dif;
+        this.cnt = WIN - c - 24;
+    }
+    norm(dif, rng) {
+        const d = 15 ^ (31 ^ Math.clz32(rng));
+        const cnt = this.cnt;
+        this.dif = (dif << d) >>> 0;
+        this.rng = rng << d;
+        this.cnt = cnt - d;
+        if (cnt >= 0 && cnt < d)
+            this.refill();
+    }
+    bool() {
+        const r = this.rng;
+        let dif = this.dif;
+        let v = (r >> 8 << 7) + MIN_PROB;
+        const vw = v * 65536;
+        const ret = dif >= vw ? 1 : 0;
+        if (ret) {
+            dif -= vw;
+            v = r - v;
+        }
+        this.norm(dif, v);
+        return ret ^ 1;
+    }
+    boolProb(f) {
+        const r = this.rng;
+        let dif = this.dif;
+        let v = ((r >> 8) * (f >> PROB_SHIFT) >> (7 - PROB_SHIFT)) + MIN_PROB;
+        const vw = v * 65536;
+        const ret = dif >= vw ? 1 : 0;
+        if (ret) {
+            dif -= vw;
+            v = r - v;
+        }
+        this.norm(dif, v);
+        return ret ^ 1;
+    }
+    bools(n) {
+        let v = 0;
+        while (n--)
+            v = v << 1 | this.bool();
+        return v;
+    }
+    uniform(n) {
+        const l = 32 - Math.clz32(n);
+        const m = (1 << l) - n;
+        const v = this.bools(l - 1);
+        return v < m ? v : (v << 1) - m + this.bool();
+    }
+    symbol(cdf, o, n) {
+        const c = this.dif >>> 16, r = this.rng >> 8;
+        let u, v = this.rng, val = -1;
+        do {
+            val++;
+            u = v;
+            v = r * (cdf[o + val] >> PROB_SHIFT) >> (7 - PROB_SHIFT);
+            v += MIN_PROB * (n - val);
+        } while (c < v);
+        this.norm(this.dif - v * 65536, u - v);
+        if (this.allowUpdate) {
+            const count = cdf[o + n];
+            const rate = 4 + (count >> 4) + (n > 2 ? 1 : 0);
+            let i = 0;
+            for (; i < val; i++)
+                cdf[o + i] += 32768 - cdf[o + i] >> rate;
+            for (; i < n; i++)
+                cdf[o + i] -= cdf[o + i] >> rate;
+            cdf[o + n] = count + (count < 32 ? 1 : 0);
+        }
+        return val;
+    }
+    boolAdapt(cdf, o) {
+        const bit = this.boolProb(cdf[o]);
+        if (this.allowUpdate) {
+            const count = cdf[o + 1];
+            const rate = 4 + (count >> 4);
+            if (bit)
+                cdf[o] += 32768 - cdf[o] >> rate;
+            else
+                cdf[o] -= cdf[o] >> rate;
+            cdf[o + 1] = count + (count < 32 ? 1 : 0);
+        }
+        return bit;
+    }
+    hiTok(cdf, o) {
+        let br = this.symbol(cdf, o, 3);
+        let tok = 3 + br;
+        if (br === 3) {
+            br = this.symbol(cdf, o, 3);
+            tok = 6 + br;
+            if (br === 3) {
+                br = this.symbol(cdf, o, 3);
+                tok = 9 + br;
+                if (br === 3)
+                    tok = 12 + this.symbol(cdf, o, 3);
+            }
+        }
+        return tok;
+    }
+    golomb() {
+        let len = 0;
+        while (!this.bool() && len < 32)
+            len++;
+        let v = 1;
+        while (len--)
+            v = v * 2 + this.bool();
+        return v - 1;
+    }
+    subexp(ref, n, k) {
+        let a = 0;
+        if (this.bool()) {
+            if (this.bool())
+                k += this.bool() + 1;
+            a = 1 << k;
+        }
+        const v = this.bools(k) + a;
+        return ref * 2 <= n ? inverseRecenter(ref, v) : n - 1 - inverseRecenter(n - 1 - ref, v);
+    }
+    get overread() {
+        return this.cnt <= -15;
+    }
+}
+function inverseRecenter(r, v) {
+    if (v > r << 1)
+        return v;
+    return v & 1 ? r - (v + 1 >> 1) : r + (v >> 1);
+}