image-in-browser
Version:
Package for encoding / decoding images, transforming images, applying filters, drawing primitives on images on the client side (no need for server Node.js)
598 lines • 21.9 kB
JavaScript
var _a;
import { BitUtils } from '../../common/bit-utils.js';
import { InputBuffer } from '../../common/input-buffer.js';
import { VP8 } from './vp8.js';
export class VP8Filter {
constructor() {
_a.initTables();
}
static mul(a, b) {
const c = a * b;
return BitUtils.sshR(c, 16);
}
static store(dst, di, x, y, v) {
dst.set(di + x + y * VP8.bps, _a.clip8b(dst.get(di + x + y * VP8.bps) + BitUtils.sshR(v, 3)));
}
static store2(dst, y, dc, d, c) {
_a.store(dst, 0, 0, y, dc + d);
_a.store(dst, 0, 1, y, dc + c);
_a.store(dst, 0, 2, y, dc - c);
_a.store(dst, 0, 3, y, dc - d);
}
static initTables() {
if (!this.tablesInitialized) {
for (let i = -255; i <= 255; ++i) {
this.abs0[255 + i] = i < 0 ? -i : i;
this.abs1[255 + i] = this.abs0[255 + i] >>> 1;
}
for (let i = -1020; i <= 1020; ++i) {
this.sclip1[1020 + i] = i < -128 ? -128 : i > 127 ? 127 : i;
}
for (let i = -112; i <= 112; ++i) {
this.sclip2[112 + i] = i < -16 ? -16 : i > 15 ? 15 : i;
}
for (let i = -255; i <= 255 + 255; ++i) {
this.clip1[255 + i] = i < 0 ? 0 : i > 255 ? 255 : i;
}
this.tablesInitialized = true;
}
}
static clip8b(v) {
return (v & -256) === 0 ? v : v < 0 ? 0 : 255;
}
static avg3(a, b, c) {
return BitUtils.sshR(a + 2 * b + c + 2, 2);
}
static avg2(a, b) {
return BitUtils.sshR(a + b + 1, 1);
}
static ve4(dst) {
const top = -VP8.bps;
const values = new Uint8Array([
_a.avg3(dst.get(top - 1), dst.get(top), dst.get(top + 1)),
_a.avg3(dst.get(top), dst.get(top + 1), dst.get(top + 2)),
_a.avg3(dst.get(top + 1), dst.get(top + 2), dst.get(top + 3)),
_a.avg3(dst.get(top + 2), dst.get(top + 3), dst.get(top + 4)),
]);
for (let i = 0; i < 4; ++i) {
dst.memcpy(i * VP8.bps, 4, values);
}
}
static he4(dst) {
const a = dst.get(-1 - VP8.bps);
const b = dst.get(-1);
const c = dst.get(-1 + VP8.bps);
const d = dst.get(-1 + 2 * VP8.bps);
const e = dst.get(-1 + 3 * VP8.bps);
const d2 = InputBuffer.from(dst);
d2.toUint32Array()[0] = 0x01010101 * _a.avg3(a, b, c);
d2.offset += VP8.bps;
d2.toUint32Array()[0] = 0x01010101 * _a.avg3(b, c, d);
d2.offset += VP8.bps;
d2.toUint32Array()[0] = 0x01010101 * _a.avg3(c, d, e);
d2.offset += VP8.bps;
d2.toUint32Array()[0] = 0x01010101 * _a.avg3(d, e, e);
}
static dc4(dst) {
let dc = 4;
for (let i = 0; i < 4; ++i) {
dc += dst.get(i - VP8.bps) + dst.get(-1 + i * VP8.bps);
}
dc >>>= 3;
for (let i = 0; i < 4; ++i) {
dst.memset(i * VP8.bps, 4, dc);
}
}
static trueMotion(dst, size) {
const top = -VP8.bps;
const clip0 = 255 - dst.get(top - 1);
let di = 0;
for (let y = 0; y < size; ++y) {
const clip = clip0 + dst.get(di - 1);
for (let x = 0; x < size; ++x) {
dst.set(di + x, _a.clip1[clip + dst.get(top + x)]);
}
di += VP8.bps;
}
}
static tm4(dst) {
_a.trueMotion(dst, 4);
}
static tm8uv(dst) {
_a.trueMotion(dst, 8);
}
static tm16(dst) {
_a.trueMotion(dst, 16);
}
static dst(x, y) {
return x + y * VP8.bps;
}
static rd4(dst) {
const i = dst.get(-1 + 0 * VP8.bps);
const j = dst.get(-1 + Number(VP8.bps));
const K = dst.get(-1 + 2 * VP8.bps);
const l = dst.get(-1 + 3 * VP8.bps);
const x = dst.get(-1 - VP8.bps);
const a = dst.get(0 - VP8.bps);
const b = dst.get(1 - VP8.bps);
const c = dst.get(2 - VP8.bps);
const d = dst.get(3 - VP8.bps);
dst.set(_a.dst(0, 3), _a.avg3(j, K, l));
dst.set(_a.dst(0, 2), dst.set(_a.dst(1, 3), _a.avg3(i, j, K)));
dst.set(_a.dst(0, 1), dst.set(_a.dst(1, 2), dst.set(_a.dst(2, 3), _a.avg3(x, i, j))));
dst.set(_a.dst(0, 0), dst.set(_a.dst(1, 1), dst.set(_a.dst(2, 2), dst.set(_a.dst(3, 3), _a.avg3(a, x, i)))));
dst.set(_a.dst(1, 0), dst.set(_a.dst(2, 1), dst.set(_a.dst(3, 2), _a.avg3(b, a, x))));
dst.set(_a.dst(2, 0), dst.set(_a.dst(3, 1), _a.avg3(c, b, a)));
dst.set(_a.dst(3, 0), _a.avg3(d, c, b));
}
static ld4(dst) {
const a = dst.get(0 - VP8.bps);
const b = dst.get(1 - VP8.bps);
const c = dst.get(2 - VP8.bps);
const d = dst.get(3 - VP8.bps);
const e = dst.get(4 - VP8.bps);
const f = dst.get(5 - VP8.bps);
const g = dst.get(6 - VP8.bps);
const h = dst.get(7 - VP8.bps);
dst.set(_a.dst(0, 0), _a.avg3(a, b, c));
dst.set(_a.dst(1, 0), dst.set(_a.dst(0, 1), _a.avg3(b, c, d)));
dst.set(_a.dst(2, 0), dst.set(_a.dst(1, 1), dst.set(_a.dst(0, 2), _a.avg3(c, d, e))));
dst.set(_a.dst(3, 0), dst.set(_a.dst(2, 1), dst.set(_a.dst(1, 2), dst.set(_a.dst(0, 3), _a.avg3(d, e, f)))));
dst.set(_a.dst(3, 1), dst.set(_a.dst(2, 2), dst.set(_a.dst(1, 3), _a.avg3(e, f, g))));
dst.set(_a.dst(3, 2), dst.set(_a.dst(2, 3), _a.avg3(f, g, h)));
dst.set(_a.dst(3, 3), _a.avg3(g, h, h));
}
static vr4(dst) {
const i = dst.get(-1 + 0 * VP8.bps);
const j = dst.get(-1 + Number(VP8.bps));
const k = dst.get(-1 + 2 * VP8.bps);
const x = dst.get(-1 - VP8.bps);
const a = dst.get(0 - VP8.bps);
const b = dst.get(1 - VP8.bps);
const c = dst.get(2 - VP8.bps);
const d = dst.get(3 - VP8.bps);
dst.set(_a.dst(0, 0), dst.set(_a.dst(1, 2), _a.avg2(x, a)));
dst.set(_a.dst(1, 0), dst.set(_a.dst(2, 2), _a.avg2(a, b)));
dst.set(_a.dst(2, 0), dst.set(_a.dst(3, 2), _a.avg2(b, c)));
dst.set(_a.dst(3, 0), _a.avg2(c, d));
dst.set(_a.dst(0, 3), _a.avg3(k, j, i));
dst.set(_a.dst(0, 2), _a.avg3(j, i, x));
dst.set(_a.dst(0, 1), dst.set(_a.dst(1, 3), _a.avg3(i, x, a)));
dst.set(_a.dst(1, 1), dst.set(_a.dst(2, 3), _a.avg3(x, a, b)));
dst.set(_a.dst(2, 1), dst.set(_a.dst(3, 3), _a.avg3(a, b, c)));
dst.set(_a.dst(3, 1), _a.avg3(b, c, d));
}
static vl4(dst) {
const a = dst.get(0 - VP8.bps);
const b = dst.get(1 - VP8.bps);
const c = dst.get(2 - VP8.bps);
const d = dst.get(3 - VP8.bps);
const e = dst.get(4 - VP8.bps);
const f = dst.get(5 - VP8.bps);
const g = dst.get(6 - VP8.bps);
const h = dst.get(7 - VP8.bps);
dst.set(_a.dst(0, 0), _a.avg2(a, b));
dst.set(_a.dst(1, 0), dst.set(_a.dst(0, 2), _a.avg2(b, c)));
dst.set(_a.dst(2, 0), dst.set(_a.dst(1, 2), _a.avg2(c, d)));
dst.set(_a.dst(3, 0), dst.set(_a.dst(2, 2), _a.avg2(d, e)));
dst.set(_a.dst(0, 1), _a.avg3(a, b, c));
dst.set(_a.dst(1, 1), dst.set(_a.dst(0, 3), _a.avg3(b, c, d)));
dst.set(_a.dst(2, 1), dst.set(_a.dst(1, 3), _a.avg3(c, d, e)));
dst.set(_a.dst(3, 1), dst.set(_a.dst(2, 3), _a.avg3(d, e, f)));
dst.set(_a.dst(3, 2), _a.avg3(e, f, g));
dst.set(_a.dst(3, 3), _a.avg3(f, g, h));
}
static hu4(dst) {
const i = dst.get(-1 + 0 * VP8.bps);
const j = dst.get(-1 + Number(VP8.bps));
const k = dst.get(-1 + 2 * VP8.bps);
const l = dst.get(-1 + 3 * VP8.bps);
dst.set(_a.dst(0, 0), _a.avg2(i, j));
dst.set(_a.dst(2, 0), dst.set(_a.dst(0, 1), _a.avg2(j, k)));
dst.set(_a.dst(2, 1), dst.set(_a.dst(0, 2), _a.avg2(k, l)));
dst.set(_a.dst(1, 0), _a.avg3(i, j, k));
dst.set(_a.dst(3, 0), dst.set(_a.dst(1, 1), _a.avg3(j, k, l)));
dst.set(_a.dst(3, 1), dst.set(_a.dst(1, 2), _a.avg3(k, l, l)));
dst.set(_a.dst(3, 2), dst.set(_a.dst(2, 2), dst.set(_a.dst(0, 3), dst.set(_a.dst(1, 3), dst.set(_a.dst(2, 3), dst.set(_a.dst(3, 3), l))))));
}
static hd4(dst) {
const i = dst.get(-1 + 0 * VP8.bps);
const j = dst.get(-1 + Number(VP8.bps));
const k = dst.get(-1 + 2 * VP8.bps);
const l = dst.get(-1 + 3 * VP8.bps);
const x = dst.get(-1 - VP8.bps);
const a = dst.get(0 - VP8.bps);
const b = dst.get(1 - VP8.bps);
const c = dst.get(2 - VP8.bps);
dst.set(_a.dst(0, 0), dst.set(_a.dst(2, 1), _a.avg2(i, x)));
dst.set(_a.dst(0, 1), dst.set(_a.dst(2, 2), _a.avg2(j, i)));
dst.set(_a.dst(0, 2), dst.set(_a.dst(2, 3), _a.avg2(k, j)));
dst.set(_a.dst(0, 3), _a.avg2(l, k));
dst.set(_a.dst(3, 0), _a.avg3(a, b, c));
dst.set(_a.dst(2, 0), _a.avg3(x, a, b));
dst.set(_a.dst(1, 0), dst.set(_a.dst(3, 1), _a.avg3(i, x, a)));
dst.set(_a.dst(1, 1), dst.set(_a.dst(3, 2), _a.avg3(j, i, x)));
dst.set(_a.dst(1, 2), dst.set(_a.dst(3, 3), _a.avg3(k, j, i)));
dst.set(_a.dst(1, 3), _a.avg3(l, k, j));
}
filterLoop26(p, hstride, vstride, size, thresh, ithresh, hevThresh) {
let _size = size;
const p2 = InputBuffer.from(p);
while (_size-- > 0) {
if (this.needsFilter2(p2, hstride, thresh, ithresh)) {
if (this.hev(p2, hstride, hevThresh)) {
this.doFilter2(p2, hstride);
}
else {
this.doFilter6(p2, hstride);
}
}
p2.offset += vstride;
}
}
filterLoop24(p, hstride, vstride, size, thresh, ithresh, hevThresh) {
let _size = size;
const p2 = InputBuffer.from(p);
while (_size-- > 0) {
if (this.needsFilter2(p2, hstride, thresh, ithresh)) {
if (this.hev(p2, hstride, hevThresh)) {
this.doFilter2(p2, hstride);
}
else {
this.doFilter4(p2, hstride);
}
}
p2.offset += vstride;
}
}
doFilter2(p, step) {
const p1 = p.get(-2 * step);
const p0 = p.get(-step);
const q0 = p.get(0);
const q1 = p.get(step);
const a = 3 * (q0 - p0) + _a.sclip1[1020 + p1 - q1];
const a1 = _a.sclip2[112 + BitUtils.sshR(a + 4, 3)];
const a2 = _a.sclip2[112 + BitUtils.sshR(a + 3, 3)];
p.set(-step, _a.clip1[255 + p0 + a2]);
p.set(0, _a.clip1[255 + q0 - a1]);
}
doFilter4(p, step) {
const p1 = p.get(-2 * step);
const p0 = p.get(-step);
const q0 = p.get(0);
const q1 = p.get(step);
const a = 3 * (q0 - p0);
const a1 = _a.sclip2[112 + BitUtils.sshR(a + 4, 3)];
const a2 = _a.sclip2[112 + BitUtils.sshR(a + 3, 3)];
const a3 = BitUtils.sshR(a1 + 1, 1);
p.set(-2 * step, _a.clip1[255 + p1 + a3]);
p.set(-step, _a.clip1[255 + p0 + a2]);
p.set(0, _a.clip1[255 + q0 - a1]);
p.set(step, _a.clip1[255 + q1 - a3]);
}
doFilter6(p, step) {
const p2 = p.get(-3 * step);
const p1 = p.get(-2 * step);
const p0 = p.get(-step);
const q0 = p.get(0);
const q1 = p.get(step);
const q2 = p.get(2 * step);
const a = _a.sclip1[1020 + 3 * (q0 - p0) + _a.sclip1[1020 + p1 - q1]];
const a1 = BitUtils.sshR(27 * a + 63, 7);
const a2 = BitUtils.sshR(18 * a + 63, 7);
const a3 = BitUtils.sshR(9 * a + 63, 7);
p.set(-3 * step, _a.clip1[255 + p2 + a3]);
p.set(-2 * step, _a.clip1[255 + p1 + a2]);
p.set(-step, _a.clip1[255 + p0 + a1]);
p.set(0, _a.clip1[255 + q0 - a1]);
p.set(step, _a.clip1[255 + q1 - a2]);
p.set(2 * step, _a.clip1[255 + q2 - a3]);
}
hev(p, step, thresh) {
const p1 = p.get(-2 * step);
const p0 = p.get(-step);
const q0 = p.get(0);
const q1 = p.get(step);
return (_a.abs0[255 + p1 - p0] > thresh ||
_a.abs0[255 + q1 - q0] > thresh);
}
needsFilter(p, step, thresh) {
const p1 = p.get(-2 * step);
const p0 = p.get(-step);
const q0 = p.get(0);
const q1 = p.get(step);
return (2 * _a.abs0[255 + p0 - q0] + _a.abs1[255 + p1 - q1] <=
thresh);
}
needsFilter2(p, step, t, it) {
const p3 = p.get(-4 * step);
const p2 = p.get(-3 * step);
const p1 = p.get(-2 * step);
const p0 = p.get(-step);
const q0 = p.get(0);
const q1 = p.get(step);
const q2 = p.get(2 * step);
const q3 = p.get(3 * step);
if (2 * _a.abs0[255 + p0 - q0] + _a.abs1[255 + p1 - q1] > t) {
return false;
}
return (_a.abs0[255 + p3 - p2] <= it &&
_a.abs0[255 + p2 - p1] <= it &&
_a.abs0[255 + p1 - p0] <= it &&
_a.abs0[255 + q3 - q2] <= it &&
_a.abs0[255 + q2 - q1] <= it &&
_a.abs0[255 + q1 - q0] <= it);
}
simpleVFilter16(p, stride, threshold) {
const p2 = InputBuffer.from(p);
for (let i = 0; i < 16; ++i) {
p2.offset = p.offset + i;
if (this.needsFilter(p2, stride, threshold)) {
this.doFilter2(p2, stride);
}
}
}
simpleHFilter16(p, stride, threshold) {
const p2 = InputBuffer.from(p);
for (let i = 0; i < 16; ++i) {
p2.offset = p.offset + i * stride;
if (this.needsFilter(p2, 1, threshold)) {
this.doFilter2(p2, 1);
}
}
}
simpleVFilter16i(p, stride, threshold) {
const p2 = InputBuffer.from(p);
for (let k = 3; k > 0; --k) {
p2.offset += 4 * stride;
this.simpleVFilter16(p2, stride, threshold);
}
}
simpleHFilter16i(p, stride, threshold) {
const p2 = InputBuffer.from(p);
for (let k = 3; k > 0; --k) {
p2.offset += 4;
this.simpleHFilter16(p2, stride, threshold);
}
}
vFilter16(p, stride, thresh, iThreshold, hevThreshold) {
this.filterLoop26(p, stride, 1, 16, thresh, iThreshold, hevThreshold);
}
hFilter16(p, stride, thresh, iThreshold, hevThreshold) {
this.filterLoop26(p, 1, stride, 16, thresh, iThreshold, hevThreshold);
}
vFilter16i(p, stride, thresh, iThreshold, hevThreshold) {
const p2 = InputBuffer.from(p);
for (let k = 3; k > 0; --k) {
p2.offset += 4 * stride;
this.filterLoop24(p2, stride, 1, 16, thresh, iThreshold, hevThreshold);
}
}
hFilter16i(p, stride, thresh, iThreshold, hevThreshold) {
const p2 = InputBuffer.from(p);
for (let k = 3; k > 0; --k) {
p2.offset += 4;
this.filterLoop24(p2, 1, stride, 16, thresh, iThreshold, hevThreshold);
}
}
vFilter8(u, v, stride, thresh, iThreshold, hevThreshold) {
this.filterLoop26(u, stride, 1, 8, thresh, iThreshold, hevThreshold);
this.filterLoop26(v, stride, 1, 8, thresh, iThreshold, hevThreshold);
}
hFilter8(u, v, stride, thresh, iThreshold, hevThreshold) {
this.filterLoop26(u, 1, stride, 8, thresh, iThreshold, hevThreshold);
this.filterLoop26(v, 1, stride, 8, thresh, iThreshold, hevThreshold);
}
vFilter8i(u, v, stride, thresh, iThreshold, hevThreshold) {
const u2 = InputBuffer.from(u, 4 * stride);
const v2 = InputBuffer.from(v, 4 * stride);
this.filterLoop24(u2, stride, 1, 8, thresh, iThreshold, hevThreshold);
this.filterLoop24(v2, stride, 1, 8, thresh, iThreshold, hevThreshold);
}
hFilter8i(u, v, stride, thresh, iThreshold, hevThreshold) {
const u2 = InputBuffer.from(u, 4);
const v2 = InputBuffer.from(v, 4);
this.filterLoop24(u2, 1, stride, 8, thresh, iThreshold, hevThreshold);
this.filterLoop24(v2, 1, stride, 8, thresh, iThreshold, hevThreshold);
}
transformOne(src, dst) {
const t = new Int32Array(4 * 4);
let si = 0;
let di = 0;
let tmp = 0;
for (let i = 0; i < 4; ++i) {
const a = src.get(si) + src.get(si + 8);
const b = src.get(si) - src.get(si + 8);
const c = _a.mul(src.get(si + 4), _a.kC2) -
_a.mul(src.get(si + 12), _a.kC1);
const d = _a.mul(src.get(si + 4), _a.kC1) +
_a.mul(src.get(si + 12), _a.kC2);
t[tmp++] = a + d;
t[tmp++] = b + c;
t[tmp++] = b - c;
t[tmp++] = a - d;
si++;
}
tmp = 0;
for (let i = 0; i < 4; ++i) {
const dc = t[tmp] + 4;
const a = dc + t[tmp + 8];
const b = dc - t[tmp + 8];
const c = _a.mul(t[tmp + 4], _a.kC2) -
_a.mul(t[tmp + 12], _a.kC1);
const d = _a.mul(t[tmp + 4], _a.kC1) +
_a.mul(t[tmp + 12], _a.kC2);
_a.store(dst, di, 0, 0, a + d);
_a.store(dst, di, 1, 0, b + c);
_a.store(dst, di, 2, 0, b - c);
_a.store(dst, di, 3, 0, a - d);
tmp++;
di += VP8.bps;
}
}
transform(src, dst, doTwo) {
this.transformOne(src, dst);
if (doTwo) {
this.transformOne(InputBuffer.from(src, 16), InputBuffer.from(dst, 4));
}
}
transformUV(src, dst) {
this.transform(src, dst, true);
this.transform(InputBuffer.from(src, 2 * 16), InputBuffer.from(dst, 4 * VP8.bps), true);
}
transformDC(src, dst) {
const dc = src.get(0) + 4;
for (let j = 0; j < 4; ++j) {
for (let i = 0; i < 4; ++i) {
_a.store(dst, 0, i, j, dc);
}
}
}
transformDCUV(src, dst) {
if (src.get(0 * 16) !== 0) {
this.transformDC(src, dst);
}
if (src.get(1 * 16) !== 0) {
this.transformDC(InputBuffer.from(src, 1 * 16), InputBuffer.from(dst, 4));
}
if (src.get(2 * 16) !== 0) {
this.transformDC(InputBuffer.from(src, 2 * 16), InputBuffer.from(dst, 4 * VP8.bps));
}
if (src.get(3 * 16) !== 0) {
this.transformDC(InputBuffer.from(src, 3 * 16), InputBuffer.from(dst, 4 * VP8.bps + 4));
}
}
transformAC3(src, dst) {
const a = src.get(0) + 4;
const c4 = _a.mul(src.get(4), _a.kC2);
const d4 = _a.mul(src.get(4), _a.kC1);
const c1 = _a.mul(src.get(1), _a.kC2);
const d1 = _a.mul(src.get(1), _a.kC1);
_a.store2(dst, 0, a + d4, d1, c1);
_a.store2(dst, 1, a + c4, d1, c1);
_a.store2(dst, 2, a - c4, d1, c1);
_a.store2(dst, 3, a - d4, d1, c1);
}
static ve16(dst) {
for (let j = 0; j < 16; ++j) {
dst.memcpy(j * VP8.bps, 16, dst, -VP8.bps);
}
}
static he16(dst) {
let di = 0;
for (let j = 16; j > 0; --j) {
dst.memset(di, 16, dst.get(di - 1));
di += VP8.bps;
}
}
static put16(v, dst) {
for (let j = 0; j < 16; ++j) {
dst.memset(j * VP8.bps, 16, v);
}
}
static dc16(dst) {
let dc = 16;
for (let j = 0; j < 16; ++j) {
dc += dst.get(-1 + j * VP8.bps) + dst.get(j - VP8.bps);
}
_a.put16(dc >>> 5, dst);
}
static dc16NoTop(dst) {
let dc = 8;
for (let j = 0; j < 16; ++j) {
dc += dst.get(-1 + j * VP8.bps);
}
_a.put16(dc >>> 4, dst);
}
static dc16NoLeft(dst) {
let dc = 8;
for (let i = 0; i < 16; ++i) {
dc += dst.get(i - VP8.bps);
}
_a.put16(dc >>> 4, dst);
}
static dc16NoTopLeft(dst) {
_a.put16(0x80, dst);
}
static ve8uv(dst) {
for (let j = 0; j < 8; ++j) {
dst.memcpy(j * VP8.bps, 8, dst, -VP8.bps);
}
}
static he8uv(dst) {
let di = 0;
for (let j = 0; j < 8; ++j) {
dst.memset(di, 8, dst.get(di - 1));
di += VP8.bps;
}
}
static put8x8uv(value, dst) {
for (let j = 0; j < 8; ++j) {
dst.memset(j * VP8.bps, 8, value);
}
}
static dc8uv(dst) {
let dc0 = 8;
for (let i = 0; i < 8; ++i) {
dc0 += dst.get(i - VP8.bps) + dst.get(-1 + i * VP8.bps);
}
_a.put8x8uv(dc0 >>> 4, dst);
}
static dc8uvNoLeft(dst) {
let dc0 = 4;
for (let i = 0; i < 8; ++i) {
dc0 += dst.get(i - VP8.bps);
}
_a.put8x8uv(dc0 >>> 3, dst);
}
static dc8uvNoTop(dst) {
let dc0 = 4;
for (let i = 0; i < 8; ++i) {
dc0 += dst.get(-1 + i * VP8.bps);
}
_a.put8x8uv(dc0 >>> 3, dst);
}
static dc8uvNoTopLeft(dst) {
_a.put8x8uv(0x80, dst);
}
}
_a = VP8Filter;
VP8Filter.kC1 = 20091 + ((1 << 16) >>> 0);
VP8Filter.kC2 = 35468;
VP8Filter.abs0 = new Uint8Array(255 + 255 + 1);
VP8Filter.abs1 = new Uint8Array(255 + 255 + 1);
VP8Filter.sclip1 = new Int8Array(1020 + 1020 + 1);
VP8Filter.sclip2 = new Int8Array(112 + 112 + 1);
VP8Filter.clip1 = new Uint8Array(255 + 510 + 1);
VP8Filter.tablesInitialized = false;
VP8Filter.predLuma4 = [
_a.dc4,
_a.tm4,
_a.ve4,
_a.he4,
_a.rd4,
_a.vr4,
_a.ld4,
_a.vl4,
_a.hd4,
_a.hu4,
];
VP8Filter.predLuma16 = [
_a.dc16,
_a.tm16,
_a.ve16,
_a.he16,
_a.dc16NoTop,
_a.dc16NoLeft,
_a.dc16NoTopLeft,
];
VP8Filter.predChroma8 = [
_a.dc8uv,
_a.tm8uv,
_a.ve8uv,
_a.he8uv,
_a.dc8uvNoTop,
_a.dc8uvNoLeft,
_a.dc8uvNoTopLeft,
];
//# sourceMappingURL=vp8-filter.js.map