Telegram Web, preconfigured for usage in I2P.
http://web.telegram.i2p/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10321 lines
368 KiB
10321 lines
368 KiB
9 years ago
|
var WebPZlib = (function WebPZlib() {
|
||
|
|
var dd = (function() {
|
||
|
|
var o = 32768;
|
||
|
|
var r = 0;
|
||
|
|
var s = 1;
|
||
|
|
var t = 2;
|
||
|
|
var u = 6;
|
||
|
|
var x = true;
|
||
|
|
var y = 32768;
|
||
|
|
var z = 64;
|
||
|
|
var A = 1024 * 8;
|
||
|
|
var B = 2 * o;
|
||
|
|
var C = 3;
|
||
|
|
var D = 258;
|
||
|
|
var E = 16;
|
||
|
|
var F = 0x2000;
|
||
|
|
var G = 13;
|
||
|
|
if (F > y) alert("error: zip_INBUFSIZ is too small");
|
||
|
|
if ((o << 1) > (1 << E)) alert("error: zip_WSIZE is too large");
|
||
|
|
if (G > E - 1) alert("error: zip_HASH_BITS is too large");
|
||
|
|
if (G < 8 || D != 258) alert("error: Code too clever");
|
||
|
|
var H = F;
|
||
|
|
var I = 1 << G;
|
||
|
|
var J = I - 1;
|
||
|
|
var K = o - 1;
|
||
|
|
var L = 0;
|
||
|
|
var M = 4096;
|
||
|
|
var N = D + C + 1;
|
||
|
|
var O = o - N;
|
||
|
|
var P = 1;
|
||
|
|
var Q = 15;
|
||
|
|
var R = 7;
|
||
|
|
var S = 29;
|
||
|
|
var T = 256;
|
||
|
|
var U = 256;
|
||
|
|
var V = T + 1 + S;
|
||
|
|
var W = 30;
|
||
|
|
var X = 19;
|
||
|
|
var Y = 16;
|
||
|
|
var Z = 17;
|
||
|
|
var de = 18;
|
||
|
|
var df = 2 * V + 1;
|
||
|
|
var dg = parseInt((G + C - 1) / C, 10);
|
||
|
|
var dh;
|
||
|
|
var di, zip_qtail;
|
||
|
|
var dj;
|
||
|
|
var dk = null;
|
||
|
|
var dl, zip_outoff;
|
||
|
|
var dm;
|
||
|
|
var dn;
|
||
|
|
var dp;
|
||
|
|
var dq;
|
||
|
|
var dr;
|
||
|
|
var ds;
|
||
|
|
var dt;
|
||
|
|
var du;
|
||
|
|
var dv;
|
||
|
|
var dw;
|
||
|
|
var dx;
|
||
|
|
var dy;
|
||
|
|
var dz;
|
||
|
|
var dA;
|
||
|
|
var dB;
|
||
|
|
var dC;
|
||
|
|
var dD;
|
||
|
|
var dE;
|
||
|
|
var dF;
|
||
|
|
var dG;
|
||
|
|
var dH;
|
||
|
|
var dI;
|
||
|
|
var dJ;
|
||
|
|
var dK;
|
||
|
|
var dL;
|
||
|
|
var dM;
|
||
|
|
var dN;
|
||
|
|
var dO;
|
||
|
|
var dP;
|
||
|
|
var dQ;
|
||
|
|
var dR;
|
||
|
|
var dS;
|
||
|
|
var dT;
|
||
|
|
var dU;
|
||
|
|
var dV;
|
||
|
|
var dW;
|
||
|
|
var dX;
|
||
|
|
var dY;
|
||
|
|
var dZ;
|
||
|
|
var ea;
|
||
|
|
var eb;
|
||
|
|
var ec;
|
||
|
|
var ed;
|
||
|
|
var ee;
|
||
|
|
var ef;
|
||
|
|
var eg;
|
||
|
|
var eh;
|
||
|
|
var ei;
|
||
|
|
var ej;
|
||
|
|
var ek;
|
||
|
|
var el = function() {
|
||
|
|
this.fc = 0;
|
||
|
|
this.dl = 0
|
||
|
|
};
|
||
|
|
var em = function() {
|
||
|
|
this.dyn_tree = null;
|
||
|
|
this.static_tree = null;
|
||
|
|
this.extra_bits = null;
|
||
|
|
this.extra_base = 0;
|
||
|
|
this.elems = 0;
|
||
|
|
this.max_length = 0;
|
||
|
|
this.max_code = 0
|
||
|
|
};
|
||
|
|
var en = function(a, b, c, d) {
|
||
|
|
this.good_length = a;
|
||
|
|
this.max_lazy = b;
|
||
|
|
this.nice_length = c;
|
||
|
|
this.max_chain = d
|
||
|
|
};
|
||
|
|
var eo = function() {
|
||
|
|
this.next = null;
|
||
|
|
this.len = 0;
|
||
|
|
this.ptr = new Array(A);
|
||
|
|
this.off = 0
|
||
|
|
};
|
||
|
|
var ep = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
|
||
|
|
var eq = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
|
||
|
|
var er = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7];
|
||
|
|
var es = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
|
||
|
|
var et = [new en(0, 0, 0, 0), new en(4, 4, 8, 4), new en(4, 5, 16, 8), new en(4, 6, 32, 32), new en(4, 4, 16, 16), new en(8, 16, 32, 32), new en(8, 16, 128, 128), new en(8, 32, 128, 256), new en(32, 128, 258, 1024), new en(32, 258, 258, 4096)];
|
||
|
|
var eu = function(a) {
|
||
|
|
var i;
|
||
|
|
if (!a) a = u;
|
||
|
|
else if (a < 1) a = 1;
|
||
|
|
else if (a > 9) a = 9;
|
||
|
|
dH = a;
|
||
|
|
dj = false;
|
||
|
|
dD = false;
|
||
|
|
if (dk != null) return;
|
||
|
|
dh = di = zip_qtail = null;
|
||
|
|
dk = new Array(A);
|
||
|
|
dn = new Array(B);
|
||
|
|
dp = new Array(H);
|
||
|
|
dq = new Array(y + z);
|
||
|
|
dr = new Array(1 << E);
|
||
|
|
dK = new Array(df);
|
||
|
|
for (i = 0; i < df; i++) dK[i] = new el();
|
||
|
|
dL = new Array(2 * W + 1);
|
||
|
|
for (i = 0; i < 2 * W + 1; i++) dL[i] = new el();
|
||
|
|
dM = new Array(V + 2);
|
||
|
|
for (i = 0; i < V + 2; i++) dM[i] = new el();
|
||
|
|
dN = new Array(W);
|
||
|
|
for (i = 0; i < W; i++) dN[i] = new el();
|
||
|
|
dO = new Array(2 * X + 1);
|
||
|
|
for (i = 0; i < 2 * X + 1; i++) dO[i] = new el();
|
||
|
|
dP = new em();
|
||
|
|
dQ = new em();
|
||
|
|
dR = new em();
|
||
|
|
dS = new Array(Q + 1);
|
||
|
|
dT = new Array(2 * V + 1);
|
||
|
|
dW = new Array(2 * V + 1);
|
||
|
|
dX = new Array(D - C + 1);
|
||
|
|
dY = new Array(512);
|
||
|
|
dZ = new Array(S);
|
||
|
|
ea = new Array(W);
|
||
|
|
eb = new Array(parseInt(F / 8, 10))
|
||
|
|
};
|
||
|
|
var ev = function() {
|
||
|
|
dh = di = zip_qtail = null;
|
||
|
|
dk = null;
|
||
|
|
dn = null;
|
||
|
|
dp = null;
|
||
|
|
dq = null;
|
||
|
|
dr = null;
|
||
|
|
dK = null;
|
||
|
|
dL = null;
|
||
|
|
dM = null;
|
||
|
|
dN = null;
|
||
|
|
dO = null;
|
||
|
|
dP = null;
|
||
|
|
dQ = null;
|
||
|
|
dR = null;
|
||
|
|
dS = null;
|
||
|
|
dT = null;
|
||
|
|
dW = null;
|
||
|
|
dX = null;
|
||
|
|
dY = null;
|
||
|
|
dZ = null;
|
||
|
|
ea = null;
|
||
|
|
eb = null
|
||
|
|
};
|
||
|
|
var ew = function(p) {
|
||
|
|
p.next = dh;
|
||
|
|
dh = p
|
||
|
|
};
|
||
|
|
var ex = function() {
|
||
|
|
var p;
|
||
|
|
if (dh != null) {
|
||
|
|
p = dh;
|
||
|
|
dh = dh.next
|
||
|
|
} else p = new eo();
|
||
|
|
p.next = null;
|
||
|
|
p.len = p.off = 0;
|
||
|
|
return p
|
||
|
|
};
|
||
|
|
var ey = function(i) {
|
||
|
|
return dr[o + i]
|
||
|
|
};
|
||
|
|
var ez = function(i, a) {
|
||
|
|
return dr[o + i] = a
|
||
|
|
};
|
||
|
|
var eA = function(c) {
|
||
|
|
dk[zip_outoff + dl++] = c;
|
||
|
|
if (zip_outoff + dl == A) fg()
|
||
|
|
};
|
||
|
|
var eB = function(w) {
|
||
|
|
w &= 0xffff;
|
||
|
|
if (zip_outoff + dl < A - 2) {
|
||
|
|
dk[zip_outoff + dl++] = (w & 0xff);
|
||
|
|
dk[zip_outoff + dl++] = (w >>> 8)
|
||
|
|
} else {
|
||
|
|
eA(w & 0xff);
|
||
|
|
eA(w >>> 8)
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var eC = function() {
|
||
|
|
dv = ((dv << dg) ^ (dn[dB + C - 1] & 0xff)) & J;
|
||
|
|
dw = ey(dv);
|
||
|
|
dr[dB & K] = dw;
|
||
|
|
ez(dv, dB)
|
||
|
|
};
|
||
|
|
var eD = function(c, a) {
|
||
|
|
fd(a[c].fc, a[c].dl)
|
||
|
|
};
|
||
|
|
var eE = function(a) {
|
||
|
|
return (a < 256 ? dY[a] : dY[256 + (a >> 7)]) & 0xff
|
||
|
|
};
|
||
|
|
var eF = function(a, n, m) {
|
||
|
|
return a[n].fc < a[m].fc || (a[n].fc == a[m].fc && dW[n] <= dW[m])
|
||
|
|
};
|
||
|
|
var eG = function(a, b, n) {
|
||
|
|
var i;
|
||
|
|
var l = ej.length;
|
||
|
|
for (i = 0; i < n && ek < l; i += 1) {
|
||
|
|
a[b + i] = ej[ek++]
|
||
|
|
}
|
||
|
|
return i
|
||
|
|
};
|
||
|
|
var eH = function() {
|
||
|
|
var j;
|
||
|
|
for (j = 0; j < I; j++) dr[o + j] = 0;
|
||
|
|
dG = et[dH].max_lazy;
|
||
|
|
dI = et[dH].good_length;
|
||
|
|
if (!x) dJ = et[dH].nice_length;
|
||
|
|
dF = et[dH].max_chain;
|
||
|
|
dB = 0;
|
||
|
|
du = 0;
|
||
|
|
dE = eG(dn, 0, 2 * o);
|
||
|
|
if (dE <= 0) {
|
||
|
|
dD = true;
|
||
|
|
dE = 0;
|
||
|
|
return
|
||
|
|
}
|
||
|
|
dD = false;
|
||
|
|
while (dE < N && !dD) eJ();
|
||
|
|
dv = 0;
|
||
|
|
for (j = 0; j < C - 1; j++) {
|
||
|
|
dv = ((dv << dg) ^ (dn[j] & 0xff)) & J
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var eI = function(a) {
|
||
|
|
var b = dF;
|
||
|
|
var c = dB;
|
||
|
|
var d;
|
||
|
|
var e;
|
||
|
|
var f = dA;
|
||
|
|
var g = (dB > O ? dB - O : L);
|
||
|
|
var h = dB + D;
|
||
|
|
var i = dn[c + f - 1];
|
||
|
|
var j = dn[c + f];
|
||
|
|
if (dA >= dI) b >>= 2;
|
||
|
|
do {
|
||
|
|
d = a;
|
||
|
|
if (dn[d + f] != j || dn[d + f - 1] != i || dn[d] != dn[c] || dn[++d] != dn[c + 1]) {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
c += 2;
|
||
|
|
d++;
|
||
|
|
do {} while (dn[++c] == dn[++d] && dn[++c] == dn[++d] && dn[++c] == dn[++d] && dn[++c] == dn[++d] && dn[++c] == dn[++d] && dn[++c] == dn[++d] && dn[++c] == dn[++d] && dn[++c] == dn[++d] && c < h);
|
||
|
|
e = D - (h - c);
|
||
|
|
c = h - D;
|
||
|
|
if (e > f) {
|
||
|
|
dC = a;
|
||
|
|
f = e;
|
||
|
|
if (x) {
|
||
|
|
if (e >= D) break
|
||
|
|
} else {
|
||
|
|
if (e >= dJ) break
|
||
|
|
}
|
||
|
|
i = dn[c + f - 1];
|
||
|
|
j = dn[c + f]
|
||
|
|
}
|
||
|
|
} while ((a = dr[a & K]) > g && --b != 0);
|
||
|
|
return f
|
||
|
|
};
|
||
|
|
var eJ = function() {
|
||
|
|
var n, m;
|
||
|
|
var a = B - dE - dB;
|
||
|
|
if (a == -1) {
|
||
|
|
a--
|
||
|
|
} else if (dB >= o + O) {
|
||
|
|
for (n = 0; n < o; n++) dn[n] = dn[n + o];
|
||
|
|
dC -= o;
|
||
|
|
dB -= o;
|
||
|
|
du -= o;
|
||
|
|
for (n = 0; n < I; n++) {
|
||
|
|
m = ey(n);
|
||
|
|
ez(n, m >= o ? m - o : L)
|
||
|
|
}
|
||
|
|
for (n = 0; n < o; n++) {
|
||
|
|
m = dr[n];
|
||
|
|
dr[n] = (m >= o ? m - o : L)
|
||
|
|
}
|
||
|
|
a += o
|
||
|
|
}
|
||
|
|
if (!dD) {
|
||
|
|
n = eG(dn, dB + dE, a);
|
||
|
|
if (n <= 0) dD = true;
|
||
|
|
else dE += n
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var eK = function() {
|
||
|
|
while (dE != 0 && di == null) {
|
||
|
|
var a;
|
||
|
|
eC();
|
||
|
|
if (dw != L && dB - dw <= O) {
|
||
|
|
dz = eI(dw);
|
||
|
|
if (dz > dE) dz = dE
|
||
|
|
}
|
||
|
|
if (dz >= C) {
|
||
|
|
a = fa(dB - dC, dz - C);
|
||
|
|
dE -= dz;
|
||
|
|
if (dz <= dG) {
|
||
|
|
dz--;
|
||
|
|
do {
|
||
|
|
dB++;
|
||
|
|
eC()
|
||
|
|
} while (--dz != 0);
|
||
|
|
dB++
|
||
|
|
} else {
|
||
|
|
dB += dz;
|
||
|
|
dz = 0;
|
||
|
|
dv = dn[dB] & 0xff;
|
||
|
|
dv = ((dv << dg) ^ (dn[dB + 1] & 0xff)) & J
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
a = fa(0, dn[dB] & 0xff);
|
||
|
|
dE--;
|
||
|
|
dB++
|
||
|
|
}
|
||
|
|
if (a) {
|
||
|
|
eZ(0);
|
||
|
|
du = dB
|
||
|
|
}
|
||
|
|
while (dE < N && !dD) eJ()
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var eL = function() {
|
||
|
|
while (dE != 0 && di == null) {
|
||
|
|
eC();
|
||
|
|
dA = dz;
|
||
|
|
dx = dC;
|
||
|
|
dz = C - 1;
|
||
|
|
if (dw != L && dA < dG && dB - dw <= O) {
|
||
|
|
dz = eI(dw);
|
||
|
|
if (dz > dE) dz = dE;
|
||
|
|
if (dz == C && dB - dC > M) {
|
||
|
|
dz--
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (dA >= C && dz <= dA) {
|
||
|
|
var a;
|
||
|
|
a = fa(dB - 1 - dx, dA - C);
|
||
|
|
dE -= dA - 1;
|
||
|
|
dA -= 2;
|
||
|
|
do {
|
||
|
|
dB++;
|
||
|
|
eC()
|
||
|
|
} while (--dA != 0);
|
||
|
|
dy = 0;
|
||
|
|
dz = C - 1;
|
||
|
|
dB++;
|
||
|
|
if (a) {
|
||
|
|
eZ(0);
|
||
|
|
du = dB
|
||
|
|
}
|
||
|
|
} else if (dy != 0) {
|
||
|
|
if (fa(0, dn[dB - 1] & 0xff)) {
|
||
|
|
eZ(0);
|
||
|
|
du = dB
|
||
|
|
}
|
||
|
|
dB++;
|
||
|
|
dE--
|
||
|
|
} else {
|
||
|
|
dy = 1;
|
||
|
|
dB++;
|
||
|
|
dE--
|
||
|
|
}
|
||
|
|
while (dE < N && !dD) eJ()
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var eM = function() {
|
||
|
|
if (dD) return;
|
||
|
|
ds = 0;
|
||
|
|
dt = 0;
|
||
|
|
eP();
|
||
|
|
eH();
|
||
|
|
di = null;
|
||
|
|
dl = 0;
|
||
|
|
zip_outoff = 0;
|
||
|
|
if (dH <= 3) {
|
||
|
|
dA = C - 1;
|
||
|
|
dz = 0
|
||
|
|
} else {
|
||
|
|
dz = C - 1;
|
||
|
|
dy = 0
|
||
|
|
}
|
||
|
|
dm = false
|
||
|
|
};
|
||
|
|
var eN = function(a, b, c) {
|
||
|
|
var n;
|
||
|
|
if (!dj) {
|
||
|
|
eM();
|
||
|
|
dj = true;
|
||
|
|
if (dE == 0) {
|
||
|
|
dm = true;
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if ((n = eO(a, b, c)) == c) return c;
|
||
|
|
if (dm) return n;
|
||
|
|
if (dH <= 3) eK();
|
||
|
|
else eL();
|
||
|
|
if (dE == 0) {
|
||
|
|
if (dy != 0) {
|
||
|
|
fa(0, dn[dB - 1] & 0xff)
|
||
|
|
}
|
||
|
|
eZ(1);
|
||
|
|
dm = true
|
||
|
|
}
|
||
|
|
return n + eO(a, n + b, c - n)
|
||
|
|
};
|
||
|
|
var eO = function(a, b, c) {
|
||
|
|
var n, i, j;
|
||
|
|
n = 0;
|
||
|
|
while (di != null && n < c) {
|
||
|
|
i = c - n;
|
||
|
|
if (i > di.len) i = di.len;
|
||
|
|
for (j = 0; j < i; j++) {
|
||
|
|
a[b + n + j] = di.ptr[di.off + j]
|
||
|
|
}
|
||
|
|
di.off += i;
|
||
|
|
di.len -= i;
|
||
|
|
n += i;
|
||
|
|
if (di.len == 0) {
|
||
|
|
var p;
|
||
|
|
p = di;
|
||
|
|
di = di.next;
|
||
|
|
ew(p)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (n == c) {
|
||
|
|
return n
|
||
|
|
}
|
||
|
|
if (zip_outoff < dl) {
|
||
|
|
i = c - n;
|
||
|
|
if (i > dl - zip_outoff) {
|
||
|
|
i = dl - zip_outoff
|
||
|
|
}
|
||
|
|
for (j = 0; j < i; j++) {
|
||
|
|
a[b + n + j] = dk[zip_outoff + j]
|
||
|
|
}
|
||
|
|
zip_outoff += i;
|
||
|
|
n += i;
|
||
|
|
if (dl == zip_outoff) {
|
||
|
|
dl = zip_outoff = 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return n
|
||
|
|
};
|
||
|
|
var eP = function() {
|
||
|
|
var n;
|
||
|
|
var a;
|
||
|
|
var b;
|
||
|
|
var c;
|
||
|
|
var d;
|
||
|
|
if (dN[0].dl != 0) return;
|
||
|
|
dP.dyn_tree = dK;
|
||
|
|
dP.static_tree = dM;
|
||
|
|
dP.extra_bits = ep;
|
||
|
|
dP.extra_base = T + 1;
|
||
|
|
dP.elems = V;
|
||
|
|
dP.max_length = Q;
|
||
|
|
dP.max_code = 0;
|
||
|
|
dQ.dyn_tree = dL;
|
||
|
|
dQ.static_tree = dN;
|
||
|
|
dQ.extra_bits = eq;
|
||
|
|
dQ.extra_base = 0;
|
||
|
|
dQ.elems = W;
|
||
|
|
dQ.max_length = Q;
|
||
|
|
dQ.max_code = 0;
|
||
|
|
dR.dyn_tree = dO;
|
||
|
|
dR.static_tree = null;
|
||
|
|
dR.extra_bits = er;
|
||
|
|
dR.extra_base = 0;
|
||
|
|
dR.elems = X;
|
||
|
|
dR.max_length = R;
|
||
|
|
dR.max_code = 0;
|
||
|
|
b = 0;
|
||
|
|
for (c = 0; c < S - 1; c++) {
|
||
|
|
dZ[c] = b;
|
||
|
|
for (n = 0; n < (1 << ep[c]); n++) dX[b++] = c
|
||
|
|
}
|
||
|
|
dX[b - 1] = c;
|
||
|
|
d = 0;
|
||
|
|
for (c = 0; c < 16; c++) {
|
||
|
|
ea[c] = d;
|
||
|
|
for (n = 0; n < (1 << eq[c]); n++) {
|
||
|
|
dY[d++] = c
|
||
|
|
}
|
||
|
|
}
|
||
|
|
d >>= 7;
|
||
|
|
for (; c < W; c++) {
|
||
|
|
ea[c] = d << 7;
|
||
|
|
for (n = 0; n < (1 << (eq[c] - 7)); n++) dY[256 + d++] = c
|
||
|
|
}
|
||
|
|
for (a = 0; a <= Q; a++) dS[a] = 0;
|
||
|
|
n = 0;
|
||
|
|
while (n <= 143) {
|
||
|
|
dM[n++].dl = 8;
|
||
|
|
dS[8]++
|
||
|
|
}
|
||
|
|
while (n <= 255) {
|
||
|
|
dM[n++].dl = 9;
|
||
|
|
dS[9]++
|
||
|
|
}
|
||
|
|
while (n <= 279) {
|
||
|
|
dM[n++].dl = 7;
|
||
|
|
dS[7]++
|
||
|
|
}
|
||
|
|
while (n <= 287) {
|
||
|
|
dM[n++].dl = 8;
|
||
|
|
dS[8]++
|
||
|
|
}
|
||
|
|
eT(dM, V + 1);
|
||
|
|
for (n = 0; n < W; n++) {
|
||
|
|
dN[n].dl = 5;
|
||
|
|
dN[n].fc = fe(n, 5)
|
||
|
|
}
|
||
|
|
eQ()
|
||
|
|
};
|
||
|
|
var eQ = function() {
|
||
|
|
var n;
|
||
|
|
for (n = 0; n < V; n++) dK[n].fc = 0;
|
||
|
|
for (n = 0; n < W; n++) dL[n].fc = 0;
|
||
|
|
for (n = 0; n < X; n++) dO[n].fc = 0;
|
||
|
|
dK[U].fc = 1;
|
||
|
|
eh = ei = 0;
|
||
|
|
ec = ed = ee = 0;
|
||
|
|
ef = 0;
|
||
|
|
eg = 1
|
||
|
|
};
|
||
|
|
var eR = function(a, k) {
|
||
|
|
var v = dT[k];
|
||
|
|
var j = k << 1;
|
||
|
|
while (j <= dU) {
|
||
|
|
if (j < dU && eF(a, dT[j + 1], dT[j])) j++;
|
||
|
|
if (eF(a, v, dT[j])) break;
|
||
|
|
dT[k] = dT[j];
|
||
|
|
k = j;
|
||
|
|
j <<= 1
|
||
|
|
}
|
||
|
|
dT[k] = v
|
||
|
|
};
|
||
|
|
var eS = function(a) {
|
||
|
|
var b = a.dyn_tree;
|
||
|
|
var c = a.extra_bits;
|
||
|
|
var d = a.extra_base;
|
||
|
|
var e = a.max_code;
|
||
|
|
var g = a.max_length;
|
||
|
|
var i = a.static_tree;
|
||
|
|
var h;
|
||
|
|
var n, m;
|
||
|
|
var j;
|
||
|
|
var k;
|
||
|
|
var f;
|
||
|
|
var l = 0;
|
||
|
|
for (j = 0; j <= Q; j++) dS[j] = 0;
|
||
|
|
b[dT[dV]].dl = 0;
|
||
|
|
for (h = dV + 1; h < df; h++) {
|
||
|
|
n = dT[h];
|
||
|
|
j = b[b[n].dl].dl + 1;
|
||
|
|
if (j > g) {
|
||
|
|
j = g;
|
||
|
|
l++
|
||
|
|
}
|
||
|
|
b[n].dl = j;
|
||
|
|
if (n > e) continue;
|
||
|
|
dS[j]++;
|
||
|
|
k = 0;
|
||
|
|
if (n >= d) k = c[n - d];
|
||
|
|
f = b[n].fc;
|
||
|
|
eh += f * (j + k);
|
||
|
|
if (i != null) ei += f * (i[n].dl + k)
|
||
|
|
}
|
||
|
|
if (l == 0) return;
|
||
|
|
do {
|
||
|
|
j = g - 1;
|
||
|
|
while (dS[j] == 0) j--;
|
||
|
|
dS[j]--;
|
||
|
|
dS[j + 1] += 2;
|
||
|
|
dS[g]--;
|
||
|
|
l -= 2
|
||
|
|
} while (l > 0);
|
||
|
|
for (j = g; j != 0; j--) {
|
||
|
|
n = dS[j];
|
||
|
|
while (n != 0) {
|
||
|
|
m = dT[--h];
|
||
|
|
if (m > e) continue;
|
||
|
|
if (b[m].dl != j) {
|
||
|
|
eh += (j - b[m].dl) * b[m].fc;
|
||
|
|
b[m].fc = j
|
||
|
|
}
|
||
|
|
n--
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var eT = function(a, b) {
|
||
|
|
var c = new Array(Q + 1);
|
||
|
|
var d = 0;
|
||
|
|
var e;
|
||
|
|
var n;
|
||
|
|
for (e = 1; e <= Q; e++) {
|
||
|
|
d = ((d + dS[e - 1]) << 1);
|
||
|
|
c[e] = d
|
||
|
|
}
|
||
|
|
for (n = 0; n <= b; n++) {
|
||
|
|
var f = a[n].dl;
|
||
|
|
if (f == 0) continue;
|
||
|
|
a[n].fc = fe(c[f]++, f)
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var eU = function(a) {
|
||
|
|
var b = a.dyn_tree;
|
||
|
|
var c = a.static_tree;
|
||
|
|
var d = a.elems;
|
||
|
|
var n, m;
|
||
|
|
var e = -1;
|
||
|
|
var f = d;
|
||
|
|
dU = 0;
|
||
|
|
dV = df;
|
||
|
|
for (n = 0; n < d; n++) {
|
||
|
|
if (b[n].fc != 0) {
|
||
|
|
dT[++dU] = e = n;
|
||
|
|
dW[n] = 0
|
||
|
|
} else b[n].dl = 0
|
||
|
|
}
|
||
|
|
while (dU < 2) {
|
||
|
|
var g = dT[++dU] = (e < 2 ? ++e : 0);
|
||
|
|
b[g].fc = 1;
|
||
|
|
dW[g] = 0;
|
||
|
|
eh--;
|
||
|
|
if (c != null) ei -= c[g].dl
|
||
|
|
}
|
||
|
|
a.max_code = e;
|
||
|
|
for (n = dU >> 1; n >= 1; n--) eR(b, n);
|
||
|
|
do {
|
||
|
|
n = dT[P];
|
||
|
|
dT[P] = dT[dU--];
|
||
|
|
eR(b, P);
|
||
|
|
m = dT[P];
|
||
|
|
dT[--dV] = n;
|
||
|
|
dT[--dV] = m;
|
||
|
|
b[f].fc = b[n].fc + b[m].fc;
|
||
|
|
if (dW[n] > dW[m] + 1) dW[f] = dW[n];
|
||
|
|
else dW[f] = dW[m] + 1;
|
||
|
|
b[n].dl = b[m].dl = f;
|
||
|
|
dT[P] = f++;
|
||
|
|
eR(b, P)
|
||
|
|
} while (dU >= 2);
|
||
|
|
dT[--dV] = dT[P];
|
||
|
|
eS(a);
|
||
|
|
eT(b, e)
|
||
|
|
};
|
||
|
|
var eV = function(a, b) {
|
||
|
|
var n;
|
||
|
|
var c = -1;
|
||
|
|
var d;
|
||
|
|
var e = a[0].dl;
|
||
|
|
var f = 0;
|
||
|
|
var g = 7;
|
||
|
|
var h = 4;
|
||
|
|
if (e == 0) {
|
||
|
|
g = 138;
|
||
|
|
h = 3
|
||
|
|
}
|
||
|
|
a[b + 1].dl = 0xffff;
|
||
|
|
for (n = 0; n <= b; n++) {
|
||
|
|
d = e;
|
||
|
|
e = a[n + 1].dl;
|
||
|
|
if (++f < g && d == e) continue;
|
||
|
|
else if (f < h) dO[d].fc += f;
|
||
|
|
else if (d != 0) {
|
||
|
|
if (d != c) dO[d].fc++;
|
||
|
|
dO[Y].fc++
|
||
|
|
} else if (f <= 10) dO[Z].fc++;
|
||
|
|
else dO[de].fc++;
|
||
|
|
f = 0;
|
||
|
|
c = d;
|
||
|
|
if (e == 0) {
|
||
|
|
g = 138;
|
||
|
|
h = 3
|
||
|
|
} else if (d == e) {
|
||
|
|
g = 6;
|
||
|
|
h = 3
|
||
|
|
} else {
|
||
|
|
g = 7;
|
||
|
|
h = 4
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var eW = function(a, b) {
|
||
|
|
var n;
|
||
|
|
var c = -1;
|
||
|
|
var d;
|
||
|
|
var e = a[0].dl;
|
||
|
|
var f = 0;
|
||
|
|
var g = 7;
|
||
|
|
var h = 4;
|
||
|
|
if (e == 0) {
|
||
|
|
g = 138;
|
||
|
|
h = 3
|
||
|
|
}
|
||
|
|
for (n = 0; n <= b; n++) {
|
||
|
|
d = e;
|
||
|
|
e = a[n + 1].dl;
|
||
|
|
if (++f < g && d == e) {
|
||
|
|
continue
|
||
|
|
} else if (f < h) {
|
||
|
|
do {
|
||
|
|
eD(d, dO)
|
||
|
|
} while (--f != 0)
|
||
|
|
} else if (d != 0) {
|
||
|
|
if (d != c) {
|
||
|
|
eD(d, dO);
|
||
|
|
f--
|
||
|
|
}
|
||
|
|
eD(Y, dO);
|
||
|
|
fd(f - 3, 2)
|
||
|
|
} else if (f <= 10) {
|
||
|
|
eD(Z, dO);
|
||
|
|
fd(f - 3, 3)
|
||
|
|
} else {
|
||
|
|
eD(de, dO);
|
||
|
|
fd(f - 11, 7)
|
||
|
|
}
|
||
|
|
f = 0;
|
||
|
|
c = d;
|
||
|
|
if (e == 0) {
|
||
|
|
g = 138;
|
||
|
|
h = 3
|
||
|
|
} else if (d == e) {
|
||
|
|
g = 6;
|
||
|
|
h = 3
|
||
|
|
} else {
|
||
|
|
g = 7;
|
||
|
|
h = 4
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var eX = function() {
|
||
|
|
var a;
|
||
|
|
eV(dK, dP.max_code);
|
||
|
|
eV(dL, dQ.max_code);
|
||
|
|
eU(dR);
|
||
|
|
for (a = X - 1; a >= 3; a--) {
|
||
|
|
if (dO[es[a]].dl != 0) break
|
||
|
|
}
|
||
|
|
eh += 3 * (a + 1) + 5 + 5 + 4;
|
||
|
|
return a
|
||
|
|
};
|
||
|
|
var eY = function(a, b, c) {
|
||
|
|
var d;
|
||
|
|
fd(a - 257, 5);
|
||
|
|
fd(b - 1, 5);
|
||
|
|
fd(c - 4, 4);
|
||
|
|
for (d = 0; d < c; d++) {
|
||
|
|
fd(dO[es[d]].dl, 3)
|
||
|
|
}
|
||
|
|
eW(dK, a - 1);
|
||
|
|
eW(dL, b - 1)
|
||
|
|
};
|
||
|
|
var eZ = function(a) {
|
||
|
|
var b, static_lenb;
|
||
|
|
var c;
|
||
|
|
var d;
|
||
|
|
d = dB - du;
|
||
|
|
eb[ee] = ef;
|
||
|
|
eU(dP);
|
||
|
|
eU(dQ);
|
||
|
|
c = eX();
|
||
|
|
b = (eh + 3 + 7) >> 3;
|
||
|
|
static_lenb = (ei + 3 + 7) >> 3;
|
||
|
|
if (static_lenb <= b) b = static_lenb;
|
||
|
|
if (d + 4 <= b && du >= 0) {
|
||
|
|
var i;
|
||
|
|
fd((r << 1) + a, 3);
|
||
|
|
ff();
|
||
|
|
eB(d);
|
||
|
|
eB(~d);
|
||
|
|
for (i = 0; i < d; i++) eA(dn[du + i])
|
||
|
|
} else if (static_lenb == b) {
|
||
|
|
fd((s << 1) + a, 3);
|
||
|
|
fb(dM, dN)
|
||
|
|
} else {
|
||
|
|
fd((t << 1) + a, 3);
|
||
|
|
eY(dP.max_code + 1, dQ.max_code + 1, c + 1);
|
||
|
|
fb(dK, dL)
|
||
|
|
}
|
||
|
|
eQ();
|
||
|
|
if (a != 0) ff()
|
||
|
|
};
|
||
|
|
var fa = function(a, b) {
|
||
|
|
dq[ec++] = b;
|
||
|
|
if (a == 0) {
|
||
|
|
dK[b].fc++
|
||
|
|
} else {
|
||
|
|
a--;
|
||
|
|
dK[dX[b] + T + 1].fc++;
|
||
|
|
dL[eE(a)].fc++;
|
||
|
|
dp[ed++] = a;
|
||
|
|
ef |= eg
|
||
|
|
}
|
||
|
|
eg <<= 1;
|
||
|
|
if ((ec & 7) == 0) {
|
||
|
|
eb[ee++] = ef;
|
||
|
|
ef = 0;
|
||
|
|
eg = 1
|
||
|
|
}
|
||
|
|
if (dH > 2 && (ec & 0xfff) == 0) {
|
||
|
|
var c = ec * 8;
|
||
|
|
var d = dB - du;
|
||
|
|
var e;
|
||
|
|
for (e = 0; e < W; e++) {
|
||
|
|
c += dL[e].fc * (5 + eq[e])
|
||
|
|
}
|
||
|
|
c >>= 3;
|
||
|
|
if (ed < parseInt(ec / 2, 10) && c < parseInt(d / 2, 10)) return true
|
||
|
|
}
|
||
|
|
return (ec == F - 1 || ed == H)
|
||
|
|
};
|
||
|
|
var fb = function(a, b) {
|
||
|
|
var c;
|
||
|
|
var d;
|
||
|
|
var e = 0;
|
||
|
|
var f = 0;
|
||
|
|
var g = 0;
|
||
|
|
var h = 0;
|
||
|
|
var i;
|
||
|
|
var j;
|
||
|
|
if (ec != 0)
|
||
|
|
do {
|
||
|
|
if ((e & 7) == 0) h = eb[g++];
|
||
|
|
d = dq[e++] & 0xff;
|
||
|
|
if ((h & 1) == 0) {
|
||
|
|
eD(d, a)
|
||
|
|
} else {
|
||
|
|
i = dX[d];
|
||
|
|
eD(i + T + 1, a);
|
||
|
|
j = ep[i];
|
||
|
|
if (j != 0) {
|
||
|
|
d -= dZ[i];
|
||
|
|
fd(d, j)
|
||
|
|
}
|
||
|
|
c = dp[f++];
|
||
|
|
i = eE(c);
|
||
|
|
eD(i, b);
|
||
|
|
j = eq[i];
|
||
|
|
if (j != 0) {
|
||
|
|
c -= ea[i];
|
||
|
|
fd(c, j)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
h >>= 1
|
||
|
|
} while (e < ec);
|
||
|
|
eD(U, a)
|
||
|
|
};
|
||
|
|
var fc = 16;
|
||
|
|
var fd = function(a, b) {
|
||
|
|
if (dt > fc - b) {
|
||
|
|
ds |= (a << dt);
|
||
|
|
eB(ds);
|
||
|
|
ds = (a >> (fc - dt));
|
||
|
|
dt += b - fc
|
||
|
|
} else {
|
||
|
|
ds |= a << dt;
|
||
|
|
dt += b
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var fe = function(a, b) {
|
||
|
|
var c = 0;
|
||
|
|
do {
|
||
|
|
c |= a & 1;
|
||
|
|
a >>= 1;
|
||
|
|
c <<= 1
|
||
|
|
} while (--b > 0);
|
||
|
|
return c >> 1
|
||
|
|
};
|
||
|
|
var ff = function() {
|
||
|
|
if (dt > 8) {
|
||
|
|
eB(ds)
|
||
|
|
} else if (dt > 0) {
|
||
|
|
eA(ds)
|
||
|
|
}
|
||
|
|
ds = 0;
|
||
|
|
dt = 0
|
||
|
|
};
|
||
|
|
var fg = function() {
|
||
|
|
if (dl != 0) {
|
||
|
|
var q, i;
|
||
|
|
q = ex();
|
||
|
|
if (di == null) di = zip_qtail = q;
|
||
|
|
else zip_qtail = zip_qtail.next = q;
|
||
|
|
q.len = dl - zip_outoff;
|
||
|
|
for (i = 0; i < q.len; i++) q.ptr[i] = dk[zip_outoff + i];
|
||
|
|
dl = zip_outoff = 0
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var fh = function(a, b) {
|
||
|
|
var i, j;
|
||
|
|
ej = a;
|
||
|
|
ek = 0;
|
||
|
|
if (typeof b == "undefined") {
|
||
|
|
b = u
|
||
|
|
}
|
||
|
|
eu(b);
|
||
|
|
var c = [0];
|
||
|
|
var d = [];
|
||
|
|
while ((i = eN(c, 0, c.length)) > 0) {
|
||
|
|
d.push(c[0])
|
||
|
|
}
|
||
|
|
ej = null;
|
||
|
|
return d
|
||
|
|
};
|
||
|
|
return fh
|
||
|
|
})();
|
||
|
|
var fi = (function() {
|
||
|
|
var D = 32768;
|
||
|
|
var E = 0;
|
||
|
|
var F = 1;
|
||
|
|
var G = 2;
|
||
|
|
var H = 9;
|
||
|
|
var I = 6;
|
||
|
|
var J = 32768;
|
||
|
|
var K = 64;
|
||
|
|
var L;
|
||
|
|
var M;
|
||
|
|
var N = null;
|
||
|
|
var O;
|
||
|
|
var P, fixed_bd;
|
||
|
|
var Q;
|
||
|
|
var R;
|
||
|
|
var S;
|
||
|
|
var T;
|
||
|
|
var U;
|
||
|
|
var V;
|
||
|
|
var W, zip_td;
|
||
|
|
var X, zip_bd;
|
||
|
|
var Y;
|
||
|
|
var Z;
|
||
|
|
var de = new Array(0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff);
|
||
|
|
var df = new Array(3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0);
|
||
|
|
var dg = new Array(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99);
|
||
|
|
var dh = new Array(1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577);
|
||
|
|
var di = new Array(0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13);
|
||
|
|
var dj = new Array(16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15);
|
||
|
|
var dk = function() {
|
||
|
|
this.next = null;
|
||
|
|
this.list = null
|
||
|
|
};
|
||
|
|
var dl = function() {
|
||
|
|
this.e = 0;
|
||
|
|
this.b = 0;
|
||
|
|
this.n = 0;
|
||
|
|
this.t = null
|
||
|
|
};
|
||
|
|
var dm = function(b, n, s, d, e, l) {
|
||
|
|
this.BMAX = 16;
|
||
|
|
this.N_MAX = 288;
|
||
|
|
this.status = 0;
|
||
|
|
this.root = null;
|
||
|
|
this.m = 0; {
|
||
|
|
var a;
|
||
|
|
var c = new Array(this.BMAX + 1);
|
||
|
|
var m;
|
||
|
|
var f;
|
||
|
|
var g;
|
||
|
|
var h;
|
||
|
|
var i;
|
||
|
|
var j;
|
||
|
|
var k;
|
||
|
|
var t = new Array(this.BMAX + 1);
|
||
|
|
var p;
|
||
|
|
var A;
|
||
|
|
var q;
|
||
|
|
var r = new dl();
|
||
|
|
var u = new Array(this.BMAX);
|
||
|
|
var v = new Array(this.N_MAX);
|
||
|
|
var w;
|
||
|
|
var x = new Array(this.BMAX + 1);
|
||
|
|
var B;
|
||
|
|
var y;
|
||
|
|
var z;
|
||
|
|
var o;
|
||
|
|
var C;
|
||
|
|
C = this.root = null;
|
||
|
|
for (i = 0; i < c.length; i++) c[i] = 0;
|
||
|
|
for (i = 0; i < t.length; i++) t[i] = 0;
|
||
|
|
for (i = 0; i < u.length; i++) u[i] = null;
|
||
|
|
for (i = 0; i < v.length; i++) v[i] = 0;
|
||
|
|
for (i = 0; i < x.length; i++) x[i] = 0;
|
||
|
|
m = n > 256 ? b[256] : this.BMAX;
|
||
|
|
p = b;
|
||
|
|
A = 0;
|
||
|
|
i = n;
|
||
|
|
do {
|
||
|
|
c[p[A]]++;
|
||
|
|
A++
|
||
|
|
} while (--i > 0);
|
||
|
|
if (c[0] == n) {
|
||
|
|
this.root = null;
|
||
|
|
this.m = 0;
|
||
|
|
this.status = 0;
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for (j = 1; j <= this.BMAX; j++)
|
||
|
|
if (c[j] != 0) break;
|
||
|
|
k = j;
|
||
|
|
if (l < j) l = j;
|
||
|
|
for (i = this.BMAX; i != 0; i--)
|
||
|
|
if (c[i] != 0) break;
|
||
|
|
g = i;
|
||
|
|
if (l > i) l = i;
|
||
|
|
for (y = 1 << j; j < i; j++, y <<= 1)
|
||
|
|
if ((y -= c[j]) < 0) {
|
||
|
|
this.status = 2;
|
||
|
|
this.m = l;
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if ((y -= c[i]) < 0) {
|
||
|
|
this.status = 2;
|
||
|
|
this.m = l;
|
||
|
|
return
|
||
|
|
}
|
||
|
|
c[i] += y;
|
||
|
|
x[1] = j = 0;
|
||
|
|
p = c;
|
||
|
|
A = 1;
|
||
|
|
B = 2;
|
||
|
|
while (--i > 0) x[B++] = (j += p[A++]);
|
||
|
|
p = b;
|
||
|
|
A = 0;
|
||
|
|
i = 0;
|
||
|
|
do {
|
||
|
|
if ((j = p[A++]) != 0) v[x[j]++] = i
|
||
|
|
} while (++i < n);
|
||
|
|
n = x[g];
|
||
|
|
x[0] = i = 0;
|
||
|
|
p = v;
|
||
|
|
A = 0;
|
||
|
|
h = -1;
|
||
|
|
w = t[0] = 0;
|
||
|
|
q = null;
|
||
|
|
z = 0;
|
||
|
|
for (; k <= g; k++) {
|
||
|
|
a = c[k];
|
||
|
|
while (a-- > 0) {
|
||
|
|
while (k > w + t[1 + h]) {
|
||
|
|
w += t[1 + h];
|
||
|
|
h++;
|
||
|
|
z = (z = g - w) > l ? l : z;
|
||
|
|
if ((f = 1 << (j = k - w)) > a + 1) {
|
||
|
|
f -= a + 1;
|
||
|
|
B = k;
|
||
|
|
while (++j < z) {
|
||
|
|
if ((f <<= 1) <= c[++B]) break;
|
||
|
|
f -= c[B]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (w + j > m && w < m) j = m - w;
|
||
|
|
z = 1 << j;
|
||
|
|
t[1 + h] = j;
|
||
|
|
q = new Array(z);
|
||
|
|
for (o = 0; o < z; o++) {
|
||
|
|
q[o] = new dl()
|
||
|
|
}
|
||
|
|
if (C == null) C = this.root = new dk();
|
||
|
|
else C = C.next = new dk();
|
||
|
|
C.next = null;
|
||
|
|
C.list = q;
|
||
|
|
u[h] = q;
|
||
|
|
if (h > 0) {
|
||
|
|
x[h] = i;
|
||
|
|
r.b = t[h];
|
||
|
|
r.e = 16 + j;
|
||
|
|
r.t = q;
|
||
|
|
j = (i & ((1 << w) - 1)) >> (w - t[h]);
|
||
|
|
u[h - 1][j].e = r.e;
|
||
|
|
u[h - 1][j].b = r.b;
|
||
|
|
u[h - 1][j].n = r.n;
|
||
|
|
u[h - 1][j].t = r.t
|
||
|
|
}
|
||
|
|
}
|
||
|
|
r.b = k - w;
|
||
|
|
if (A >= n) r.e = 99;
|
||
|
|
else if (p[A] < s) {
|
||
|
|
r.e = (p[A] < 256 ? 16 : 15);
|
||
|
|
r.n = p[A++]
|
||
|
|
} else {
|
||
|
|
r.e = e[p[A] - s];
|
||
|
|
r.n = d[p[A++] - s]
|
||
|
|
}
|
||
|
|
f = 1 << (k - w);
|
||
|
|
for (j = i >> w; j < z; j += f) {
|
||
|
|
q[j].e = r.e;
|
||
|
|
q[j].b = r.b;
|
||
|
|
q[j].n = r.n;
|
||
|
|
q[j].t = r.t
|
||
|
|
}
|
||
|
|
for (j = 1 << (k - 1);
|
||
|
|
(i & j) != 0; j >>= 1) i ^= j;
|
||
|
|
i ^= j;
|
||
|
|
while ((i & ((1 << w) - 1)) != x[h]) {
|
||
|
|
w -= t[h];
|
||
|
|
h--
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
this.m = t[1];
|
||
|
|
this.status = ((y != 0 && g != 1) ? 1 : 0)
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var dn = function() {
|
||
|
|
if (Y.length == Z) return -1;
|
||
|
|
return Y[Z++]
|
||
|
|
};
|
||
|
|
var dp = function(n) {
|
||
|
|
while (R < n) {
|
||
|
|
Q |= dn() << R;
|
||
|
|
R += 8
|
||
|
|
}
|
||
|
|
};
|
||
|
|
var dq = function(n) {
|
||
|
|
return Q & de[n]
|
||
|
|
};
|
||
|
|
var dr = function(n) {
|
||
|
|
Q >>= n;
|
||
|
|
R -= n
|
||
|
|
};
|
||
|
|
var ds = function(a, b, c) {
|
||
|
|
var e;
|
||
|
|
var t;
|
||
|
|
var n;
|
||
|
|
if (c == 0) return 0;
|
||
|
|
n = 0;
|
||
|
|
for (;;) {
|
||
|
|
dp(X);
|
||
|
|
t = W.list[dq(X)];
|
||
|
|
e = t.e;
|
||
|
|
while (e > 16) {
|
||
|
|
if (e == 99) return -1;
|
||
|
|
dr(t.b);
|
||
|
|
e -= 16;
|
||
|
|
dp(e);
|
||
|
|
t = t.t[dq(e)];
|
||
|
|
e = t.e
|
||
|
|
}
|
||
|
|
dr(t.b);
|
||
|
|
if (e == 16) {
|
||
|
|
M &= D - 1;
|
||
|
|
a[b + n++] = L[M++] = t.n;
|
||
|
|
if (n == c) return c;
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if (e == 15) break;
|
||
|
|
dp(e);
|
||
|
|
U = t.n + dq(e);
|
||
|
|
dr(e);
|
||
|
|
dp(zip_bd);
|
||
|
|
t = zip_td.list[dq(zip_bd)];
|
||
|
|
e = t.e;
|
||
|
|
while (e > 16) {
|
||
|
|
if (e == 99) return -1;
|
||
|
|
dr(t.b);
|
||
|
|
e -= 16;
|
||
|
|
dp(e);
|
||
|
|
t = t.t[dq(e)];
|
||
|
|
e = t.e
|
||
|
|
}
|
||
|
|
dr(t.b);
|
||
|
|
dp(e);
|
||
|
|
V = M - t.n - dq(e);
|
||
|
|
dr(e);
|
||
|
|
while (U > 0 && n < c) {
|
||
|
|
U--;
|
||
|
|
V &= D - 1;
|
||
|
|
M &= D - 1;
|
||
|
|
a[b + n++] = L[M++] = L[V++]
|
||
|
|
}
|
||
|
|
if (n == c) return c
|
||
|
|
}
|
||
|
|
S = -1;
|
||
|
|
return n
|
||
|
|
};
|
||
|
|
var dt = function(a, b, c) {
|
||
|
|
var n;
|
||
|
|
n = R & 7;
|
||
|
|
dr(n);
|
||
|
|
dp(16);
|
||
|
|
n = dq(16);
|
||
|
|
dr(16);
|
||
|
|
dp(16);
|
||
|
|
if (n != ((~Q) & 0xffff)) return -1;
|
||
|
|
dr(16);
|
||
|
|
U = n;
|
||
|
|
n = 0;
|
||
|
|
while (U > 0 && n < c) {
|
||
|
|
U--;
|
||
|
|
M &= D - 1;
|
||
|
|
dp(8);
|
||
|
|
a[b + n++] = L[M++] = dq(8);
|
||
|
|
dr(8)
|
||
|
|
}
|
||
|
|
if (U == 0) S = -1;
|
||
|
|
return n
|
||
|
|
};
|
||
|
|
var du = function(a, b, c) {
|
||
|
|
if (N == null) {
|
||
|
|
var i;
|
||
|
|
var l = new Array(288);
|
||
|
|
var h;
|
||
|
|
for (i = 0; i < 144; i++) l[i] = 8;
|
||
|
|
for (; i < 256; i++) l[i] = 9;
|
||
|
|
for (; i < 280; i++) l[i] = 7;
|
||
|
|
for (; i < 288; i++) l[i] = 8;
|
||
|
|
P = 7;
|
||
|
|
h = new dm(l, 288, 257, df, dg, P);
|
||
|
|
if (h.status != 0) {
|
||
|
|
alert("HufBuild error: " + h.status);
|
||
|
|
return -1
|
||
|
|
}
|
||
|
|
N = h.root;
|
||
|
|
P = h.m;
|
||
|
|
for (i = 0; i < 30; i++) l[i] = 5;
|
||
|
|
var d = 5;
|
||
|
|
h = new dm(l, 30, 0, dh, di, d);
|
||
|
|
if (h.status > 1) {
|
||
|
|
N = null;
|
||
|
|
alert("HufBuild error: " + h.status);
|
||
|
|
return -1
|
||
|
|
}
|
||
|
|
O = h.root;
|
||
|
|
d = h.m
|
||
|
|
}
|
||
|
|
W = N;
|
||
|
|
zip_td = O;
|
||
|
|
X = P;
|
||
|
|
zip_bd = d;
|
||
|
|
return ds(a, b, c)
|
||
|
|
};
|
||
|
|
var dv = function(a, b, c) {
|
||
|
|
var i;
|
||
|
|
var j;
|
||
|
|
var l;
|
||
|
|
var n;
|
||
|
|
var t;
|
||
|
|
var d;
|
||
|
|
var e;
|
||
|
|
var f;
|
||
|
|
var g = new Array(286 + 30);
|
||
|
|
var h;
|
||
|
|
for (i = 0; i < g.length; i++) g[i] = 0;
|
||
|
|
dp(5);
|
||
|
|
e = 257 + dq(5);
|
||
|
|
dr(5);
|
||
|
|
dp(5);
|
||
|
|
f = 1 + dq(5);
|
||
|
|
dr(5);
|
||
|
|
dp(4);
|
||
|
|
d = 4 + dq(4);
|
||
|
|
dr(4);
|
||
|
|
if (e > 286 || f > 30) return -1;
|
||
|
|
for (j = 0; j < d; j++) {
|
||
|
|
dp(3);
|
||
|
|
g[dj[j]] = dq(3);
|
||
|
|
dr(3)
|
||
|
|
}
|
||
|
|
for (; j < 19; j++) g[dj[j]] = 0;
|
||
|
|
X = 7;
|
||
|
|
h = new dm(g, 19, 19, null, null, X);
|
||
|
|
if (h.status != 0) return -1;
|
||
|
|
W = h.root;
|
||
|
|
X = h.m;
|
||
|
|
n = e + f;
|
||
|
|
i = l = 0;
|
||
|
|
while (i < n) {
|
||
|
|
dp(X);
|
||
|
|
t = W.list[dq(X)];
|
||
|
|
j = t.b;
|
||
|
|
dr(j);
|
||
|
|
j = t.n;
|
||
|
|
if (j < 16) g[i++] = l = j;
|
||
|
|
else if (j == 16) {
|
||
|
|
dp(2);
|
||
|
|
j = 3 + dq(2);
|
||
|
|
dr(2);
|
||
|
|
if (i + j > n) return -1;
|
||
|
|
while (j-- > 0) g[i++] = l
|
||
|
|
} else if (j == 17) {
|
||
|
|
dp(3);
|
||
|
|
j = 3 + dq(3);
|
||
|
|
dr(3);
|
||
|
|
if (i + j > n) return -1;
|
||
|
|
while (j-- > 0) g[i++] = 0;
|
||
|
|
l = 0
|
||
|
|
} else {
|
||
|
|
dp(7);
|
||
|
|
j = 11 + dq(7);
|
||
|
|
dr(7);
|
||
|
|
if (i + j > n) return -1;
|
||
|
|
while (j-- > 0) g[i++] = 0;
|
||
|
|
l = 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
X = H;
|
||
|
|
h = new dm(g, e, 257, df, dg, X);
|
||
|
|
if (X == 0) h.status = 1;
|
||
|
|
if (h.status != 0) {
|
||
|
|
if (h.status == 1);
|
||
|
|
return -1
|
||
|
|
}
|
||
|
|
W = h.root;
|
||
|
|
X = h.m;
|
||
|
|
for (i = 0; i < f; i++) g[i] = g[i + e];
|
||
|
|
zip_bd = I;
|
||
|
|
h = new dm(g, f, 0, dh, di, zip_bd);
|
||
|
|
zip_td = h.root;
|
||
|
|
zip_bd = h.m;
|
||
|
|
if (zip_bd == 0 && e > 257) {
|
||
|
|
return -1
|
||
|
|
}
|
||
|
|
if (h.status == 1) {}
|
||
|
|
if (h.status != 0) return -1;
|
||
|
|
return ds(a, b, c)
|
||
|
|
};
|
||
|
|
var dw = function() {
|
||
|
|
var i;
|
||
|
|
if (L == null) L = new Array(2 * D);
|
||
|
|
M = 0;
|
||
|
|
Q = 0;
|
||
|
|
R = 0;
|
||
|
|
S = -1;
|
||
|
|
T = false;
|
||
|
|
U = V = 0;
|
||
|
|
W = null
|
||
|
|
};
|
||
|
|
var dx = function(a, b, c) {
|
||
|
|
var n, i;
|
||
|
|
n = 0;
|
||
|
|
while (n < c) {
|
||
|
|
if (T && S == -1) return n;
|
||
|
|
if (U > 0) {
|
||
|
|
if (S != E) {
|
||
|
|
while (U > 0 && n < c) {
|
||
|
|
U--;
|
||
|
|
V &= D - 1;
|
||
|
|
M &= D - 1;
|
||
|
|
a[b + n++] = L[M++] = L[V++]
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
while (U > 0 && n < c) {
|
||
|
|
U--;
|
||
|
|
M &= D - 1;
|
||
|
|
dp(8);
|
||
|
|
a[b + n++] = L[M++] = dq(8);
|
||
|
|
dr(8)
|
||
|
|
}
|
||
|
|
if (U == 0) S = -1
|
||
|
|
}
|
||
|
|
if (n == c) return n
|
||
|
|
}
|
||
|
|
if (S == -1) {
|
||
|
|
if (T) break;
|
||
|
|
dp(1);
|
||
|
|
if (dq(1) != 0) T = true;
|
||
|
|
dr(1);
|
||
|
|
dp(2);
|
||
|
|
S = dq(2);
|
||
|
|
dr(2);
|
||
|
|
W = null;
|
||
|
|
U = 0
|
||
|
|
}
|
||
|
|
switch (S) {
|
||
|
|
case 0:
|
||
|
|
i = dt(a, b + n, c - n);
|
||
|
|
break;
|
||
|
|
case 1:
|
||
|
|
if (W != null) i = ds(a, b + n, c - n);
|
||
|
|
else i = du(a, b + n, c - n);
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
if (W != null) i = ds(a, b + n, c - n);
|
||
|
|
else i = dv(a, b + n, c - n);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
i = -1;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if (i == -1) {
|
||
|
|
if (T) return 0;
|
||
|
|
return -1
|
||
|
|
}
|
||
|
|
n += i
|
||
|
|
}
|
||
|
|
return n
|
||
|
|
};
|
||
|
|
var dy = function(a) {
|
||
|
|
var i, j;
|
||
|
|
dw();
|
||
|
|
Y = a;
|
||
|
|
Z = 0;
|
||
|
|
var b = [0];
|
||
|
|
var c = [];
|
||
|
|
while ((i = dx(b, 0, b.length)) > 0) {
|
||
|
|
c.push(b[0])
|
||
|
|
}
|
||
|
|
Y = null;
|
||
|
|
return c
|
||
|
|
};
|
||
|
|
return dy
|
||
|
|
})();
|
||
|
|
var fj = function(c) {
|
||
|
|
var a = 1,
|
||
|
|
b = 0;
|
||
|
|
var i;
|
||
|
|
var d = c.length;
|
||
|
|
var e = 65521;
|
||
|
|
for (i = 0; i < d; i += 1) {
|
||
|
|
a = (a + c[i]) % e;
|
||
|
|
b = (b + a) % e
|
||
|
|
}
|
||
|
|
return (b << 16) | a
|
||
|
|
};
|
||
|
|
var fk = function(a, b) {
|
||
|
|
var i;
|
||
|
|
var c = fj(a);
|
||
|
|
var d = dd(a, b);
|
||
|
|
a = d;
|
||
|
|
a.unshift(0x78, 0xDA);
|
||
|
|
for (i = 0; i < 4; ++i) a.push(c >> i * 8 & 25);
|
||
|
|
return a
|
||
|
|
};
|
||
|
|
var fl = function(a) {
|
||
|
|
if (a.length < 6) {
|
||
|
|
throw "DataError: Not enough input";
|
||
|
|
}
|
||
|
|
var b = fi(a.slice(2, a.length - 4));
|
||
|
|
if (a.length > 6 && b.length === 0) {
|
||
|
|
throw "DataError: Unable to inflate the data";
|
||
|
|
}
|
||
|
|
return b
|
||
|
|
};
|
||
|
|
return {
|
||
|
|
'deflate': dd,
|
||
|
|
'inflate': fi,
|
||
|
|
'compress': fk,
|
||
|
|
'uncompress': fl
|
||
|
|
}
|
||
|
|
})();
|
||
|
|
var char = 0,
|
||
|
|
short = 0,
|
||
|
|
int = 0,
|
||
|
|
long = 0,
|
||
|
|
void_ = 0;
|
||
|
|
var int8_t = char;
|
||
|
|
var uint8_t = char;
|
||
|
|
var int16_t = short;
|
||
|
|
var uint16_t = short;
|
||
|
|
var int32_t = int;
|
||
|
|
var uint32_t = int;
|
||
|
|
var uint64_t = long;
|
||
|
|
var int64_t = long;
|
||
|
|
var float = 0.00;
|
||
|
|
var size_t = 0;
|
||
|
|
var double = 0;
|
||
|
|
var score_t = int64_t;
|
||
|
|
|
||
|
|
function cloneObjAttr(a) {
|
||
|
|
if (a instanceof Array) {
|
||
|
|
return a
|
||
|
|
}
|
||
|
|
if (a instanceof Object) {
|
||
|
|
var b = {};
|
||
|
|
for (var c in a) {
|
||
|
|
if (a.hasOwnProperty(c) && !(a instanceof Array)) b[c] = (a[c])
|
||
|
|
}
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
throw new alert("Unable to copy obj! Its type isn't supported.");
|
||
|
|
}
|
||
|
|
|
||
|
|
function newObjectIt(a) {
|
||
|
|
return JSON.parse(JSON.stringify(a))
|
||
|
|
}
|
||
|
|
|
||
|
|
function convertBinaryToArray(a) {
|
||
|
|
var b = new Array();
|
||
|
|
var c = a.length;
|
||
|
|
for (i = 0; i < c; ++i) b.push(a.charCodeAt(i));
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
|
||
|
|
function int64BitLeft(a, b) {
|
||
|
|
var c = new Array();
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < b; ++i) c[i] = '0';
|
||
|
|
bits = (a.toString(2) + '' + c.join(""));
|
||
|
|
return parseInt(bits, 2)
|
||
|
|
}
|
||
|
|
|
||
|
|
function write32BitIn4Bytes(a, b, c) {
|
||
|
|
var i;
|
||
|
|
for (i = 3; i >= 0; --i) a[b + (3 - i)] = (c >> (8 * i)) & 0xff
|
||
|
|
}
|
||
|
|
|
||
|
|
function write4BytesIn32Bit(a, b) {
|
||
|
|
return ((a[b + 0] << 24) | (a[b + 1] << 16) | (a[b + 2] << 8) | a[b + 3])
|
||
|
|
}
|
||
|
|
|
||
|
|
function alert32BitIn4Bytes(a) {
|
||
|
|
var i, str = '';
|
||
|
|
for (i = 3; i >= 0; --i) str += ' ' + ((a >> (8 * i)) & 0xff);
|
||
|
|
alert(str)
|
||
|
|
}
|
||
|
|
|
||
|
|
function Byte2Hex(a) {
|
||
|
|
return '0x' + a.toString(16)
|
||
|
|
}
|
||
|
|
|
||
|
|
function memcpy(a, b, c, d, e) {
|
||
|
|
if (typeof a != 'string') {
|
||
|
|
for (i = 0; i < e; ++i) a[b + i] = c[d + i]
|
||
|
|
} else {
|
||
|
|
if (b > 0) alert('string offset is over 0');
|
||
|
|
a = c.slice(d, e);
|
||
|
|
return a
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function memcpy2(a, b, c, d, e) {
|
||
|
|
var f = c.slice(0, d);
|
||
|
|
var g = c.slice(d, d + e);
|
||
|
|
var h = c.slice(d + e);
|
||
|
|
a.splice(0);
|
||
|
|
a.concat(f, g, h)
|
||
|
|
}
|
||
|
|
|
||
|
|
function memcpyArrM(b, c, d, e, f) {
|
||
|
|
for (i = 0; i < f; ++i) {
|
||
|
|
var g = b[c + i].length;
|
||
|
|
for (var a = 0; a < g; ++a) b[c + i][a] = d[e + i][a]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function ArrCopy(a) {
|
||
|
|
var b = new Array();
|
||
|
|
var c = a.length;
|
||
|
|
for (i = 0; i < c; ++i) {
|
||
|
|
b.push(a[i])
|
||
|
|
}
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
|
||
|
|
function memset_wl(a, b) {
|
||
|
|
var c = new Array();
|
||
|
|
c.push(newObjectIt(a));
|
||
|
|
for (i = 0; i < b; ++i) c.push(newObjectIt(a));
|
||
|
|
c.push(0);
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function memset(a, b) {
|
||
|
|
var c = new Array();
|
||
|
|
for (i = 0; i < b; ++i) c.push(a);
|
||
|
|
c.push(0);
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function membuild_wl(a, b) {
|
||
|
|
var c = new Array();
|
||
|
|
c.push(newObjectIt(a));
|
||
|
|
for (i = 0; i < b; ++i) c.push(newObjectIt(a));
|
||
|
|
c.push(0);
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function membuild(a, b) {
|
||
|
|
var c = new Array();
|
||
|
|
for (i = 0; i < b; ++i) c.push(a);
|
||
|
|
c.push(0);
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function memset_(a, b, c, d) {
|
||
|
|
for (i = 0; i < d; ++i) a[b + i] = c
|
||
|
|
}
|
||
|
|
|
||
|
|
function malloc(a, b) {
|
||
|
|
var c = new Array();
|
||
|
|
for (i = 0; i < a; ++i) c.push(b);
|
||
|
|
c.push(0);
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function mallocStr(a, b) {
|
||
|
|
var c = new Array();
|
||
|
|
for (i = 0; i < a; ++i) c.push(' ');
|
||
|
|
return c.join("")
|
||
|
|
}
|
||
|
|
|
||
|
|
function sizeof(a) {
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function memcmp(a, b, s, c) {
|
||
|
|
var w = '';
|
||
|
|
for (i = 0; i < c; ++i) w += String.fromCharCode(a[b + i]);
|
||
|
|
if (s == w) return 0;
|
||
|
|
else return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function Arr(a, b) {
|
||
|
|
var c = new Array();
|
||
|
|
for (i = 0; i < a; ++i) c.push(b);
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function Arr_nOI(a, b) {
|
||
|
|
var c = new Array();
|
||
|
|
for (i = 0; i < a; ++i) c.push(newObjectIt(b));
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function ArrM(b, c) {
|
||
|
|
var d, resStr = new Array();
|
||
|
|
for (a = (b.length - 1); a >= 0; --a) c = newObjectIt(Arr(b[a], c));
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function assert(a) {
|
||
|
|
if (!a) {
|
||
|
|
throw new Error('assert :P');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPDecoder() {
|
||
|
|
var N = 0x0002;
|
||
|
|
var O = 0,
|
||
|
|
MODE_RGBA = 1,
|
||
|
|
MODE_BGR = 2,
|
||
|
|
MODE_BGRA = 3,
|
||
|
|
MODE_ARGB = 4,
|
||
|
|
MODE_RGBA_4444 = 5,
|
||
|
|
MODE_RGB_565 = 6,
|
||
|
|
MODE_YUV = 7,
|
||
|
|
MODE_YUVA = 8,
|
||
|
|
MODE_LAST = 9;
|
||
|
|
this.WEBP_CSP_MODE = {
|
||
|
|
MODE_RGB: 0,
|
||
|
|
MODE_RGBA: 1,
|
||
|
|
MODE_BGR: 2,
|
||
|
|
MODE_BGRA: 3,
|
||
|
|
MODE_ARGB: 4,
|
||
|
|
MODE_RGBA_4444: 5,
|
||
|
|
MODE_RGB_565: 6,
|
||
|
|
MODE_YUV: 7,
|
||
|
|
MODE_YUVA: 8,
|
||
|
|
MODE_LAST: 9
|
||
|
|
};
|
||
|
|
var P = {
|
||
|
|
rgba: uint8_t,
|
||
|
|
rgba_off: 0,
|
||
|
|
stride: int,
|
||
|
|
size: int
|
||
|
|
};
|
||
|
|
var Q = {
|
||
|
|
y: uint8_t,
|
||
|
|
u: uint8_t,
|
||
|
|
v: uint8_t,
|
||
|
|
a: uint8_t,
|
||
|
|
y_off: uint8_t,
|
||
|
|
u_off: uint8_t,
|
||
|
|
v_off: uint8_t,
|
||
|
|
a_off: uint8_t,
|
||
|
|
y_stride: int,
|
||
|
|
u_stride: int,
|
||
|
|
v_stride: int,
|
||
|
|
a_stride: int,
|
||
|
|
y_size: int,
|
||
|
|
u_size: int,
|
||
|
|
v_size: int,
|
||
|
|
a_size: int
|
||
|
|
};
|
||
|
|
var R = {
|
||
|
|
colorspace: 'WEBP_CSP_MODE',
|
||
|
|
width: int,
|
||
|
|
height: int,
|
||
|
|
is_external_memory: int,
|
||
|
|
u: {
|
||
|
|
RGBA: P,
|
||
|
|
YUVA: Q
|
||
|
|
},
|
||
|
|
private_memory: null,
|
||
|
|
private_memory_off: uint8_t
|
||
|
|
};
|
||
|
|
|
||
|
|
function WebPInitDecBuffer(a) {
|
||
|
|
return WebPInitDecBufferInternal(a, N)
|
||
|
|
}
|
||
|
|
var T = 0,
|
||
|
|
VP8_STATUS_OUT_OF_MEMORY = 1,
|
||
|
|
VP8_STATUS_INVALID_PARAM = 2,
|
||
|
|
VP8_STATUS_BITSTREAM_ERROR = 3,
|
||
|
|
VP8_STATUS_UNSUPPORTED_FEATURE = 4,
|
||
|
|
VP8_STATUS_SUSPENDED = 5,
|
||
|
|
VP8_STATUS_USER_ABORT = 6,
|
||
|
|
VP8_STATUS_NOT_ENOUGH_DATA = 7;
|
||
|
|
this.VP8StatusCode = {
|
||
|
|
VP8_STATUS_OK: 0,
|
||
|
|
VP8_STATUS_OUT_OF_MEMORY: 1,
|
||
|
|
VP8_STATUS_INVALID_PARAM: 2,
|
||
|
|
VP8_STATUS_BITSTREAM_ERROR: 3,
|
||
|
|
VP8_STATUS_UNSUPPORTED_FEATURE: 4,
|
||
|
|
VP8_STATUS_SUSPENDED: 5,
|
||
|
|
VP8_STATUS_USER_ABORT: 6,
|
||
|
|
VP8_STATUS_NOT_ENOUGH_DATA: 7
|
||
|
|
};
|
||
|
|
var U = {
|
||
|
|
width: {
|
||
|
|
value: int
|
||
|
|
},
|
||
|
|
height: {
|
||
|
|
value: int
|
||
|
|
},
|
||
|
|
has_alpha: {
|
||
|
|
value: int
|
||
|
|
},
|
||
|
|
no_incremental_decoding: int,
|
||
|
|
rotate: int,
|
||
|
|
uv_sampling: int,
|
||
|
|
bitstream_version: int
|
||
|
|
};
|
||
|
|
this.WebPGetFeatures = function(a, b, c) {
|
||
|
|
return WebPGetFeaturesInternal(a, b, c, N)
|
||
|
|
};
|
||
|
|
var V = {
|
||
|
|
bypass_filtering: int,
|
||
|
|
no_fancy_upsampling: int,
|
||
|
|
use_cropping: int,
|
||
|
|
crop_left: int,
|
||
|
|
crop_top: int,
|
||
|
|
crop_width: int,
|
||
|
|
crop_height: int,
|
||
|
|
use_scaling: int,
|
||
|
|
scaled_width: int,
|
||
|
|
scaled_height: int,
|
||
|
|
force_rotation: int,
|
||
|
|
no_enhancement: int,
|
||
|
|
use_threads: int
|
||
|
|
};
|
||
|
|
this.WebPDecoderConfig = {
|
||
|
|
input: newObjectIt(U),
|
||
|
|
output: newObjectIt(R),
|
||
|
|
options: newObjectIt(V)
|
||
|
|
};
|
||
|
|
this.WebPInitDecoderConfig = function(a) {
|
||
|
|
return WebPInitDecoderConfigInternal(a, N)
|
||
|
|
};
|
||
|
|
var Y = {
|
||
|
|
width: int,
|
||
|
|
height: int,
|
||
|
|
mb_y: int,
|
||
|
|
mb_w: int,
|
||
|
|
mb_h: int,
|
||
|
|
y: uint8_t,
|
||
|
|
u: uint8_t,
|
||
|
|
v: uint8_t,
|
||
|
|
y_off: 0,
|
||
|
|
u_off: 0,
|
||
|
|
v_off: 0,
|
||
|
|
y_stride: int,
|
||
|
|
uv_stride: int,
|
||
|
|
opaque: void_,
|
||
|
|
put: 0,
|
||
|
|
setup: 0,
|
||
|
|
teardown: 0,
|
||
|
|
fancy_upsampling: int,
|
||
|
|
data_size: uint32_t,
|
||
|
|
data: uint8_t,
|
||
|
|
data_off: 0,
|
||
|
|
bypass_filtering: int,
|
||
|
|
use_cropping: int,
|
||
|
|
crop_left: int,
|
||
|
|
crop_right: int,
|
||
|
|
crop_top: int,
|
||
|
|
crop_bottom: int,
|
||
|
|
use_scaling: int,
|
||
|
|
scaled_width: int,
|
||
|
|
scaled_height: int,
|
||
|
|
a: uint8_t,
|
||
|
|
a_off: 0
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8InitIo(a) {
|
||
|
|
return VP8InitIoInternal(a, N)
|
||
|
|
};
|
||
|
|
var Z = {
|
||
|
|
x_expand: int,
|
||
|
|
fy_scale: int,
|
||
|
|
fx_scale: int,
|
||
|
|
fxy_scale: int64_t,
|
||
|
|
y_accum: int,
|
||
|
|
y_add: int,
|
||
|
|
y_sub: int,
|
||
|
|
x_add: int,
|
||
|
|
x_sub: int,
|
||
|
|
src_width: int,
|
||
|
|
src_height: int,
|
||
|
|
dst_width: int,
|
||
|
|
dst_height: int,
|
||
|
|
dst: uint8_t,
|
||
|
|
dst_off: 0,
|
||
|
|
dst_stride: int,
|
||
|
|
irow: int32_t,
|
||
|
|
irow_off: 0,
|
||
|
|
frow: int32_t,
|
||
|
|
frow_off: 0
|
||
|
|
};
|
||
|
|
var ba = {
|
||
|
|
output: newObjectIt(R),
|
||
|
|
tmp_y: uint8_t,
|
||
|
|
tmp_u: uint8_t,
|
||
|
|
tmp_v: uint8_t,
|
||
|
|
tmp_y_off: 0,
|
||
|
|
tmp_u_off: 0,
|
||
|
|
tmp_v_off: 0,
|
||
|
|
last_y: int,
|
||
|
|
options_: newObjectIt(V),
|
||
|
|
scaler_y: newObjectIt(Z),
|
||
|
|
scaler_u: newObjectIt(Z),
|
||
|
|
scaler_v: newObjectIt(Z),
|
||
|
|
scaler_a: newObjectIt(Z),
|
||
|
|
memory: void_,
|
||
|
|
emit: '(OutputFunc)',
|
||
|
|
emit_alpha: '(OutputFunc)'
|
||
|
|
};
|
||
|
|
var bb = {
|
||
|
|
buf_: uint8_t,
|
||
|
|
buf_off: null,
|
||
|
|
buf_end_: uint8_t,
|
||
|
|
eof_: int,
|
||
|
|
range_: uint32_t,
|
||
|
|
value_: uint32_t,
|
||
|
|
missing_: int
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8Get(a) {
|
||
|
|
return VP8GetValue(a, 1)
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8GetByte(a) {
|
||
|
|
assert(a);
|
||
|
|
if (a.buf_off < a.buf_end_) {
|
||
|
|
assert(a.buf_);
|
||
|
|
return (a.buf_[a.buf_off++])
|
||
|
|
}
|
||
|
|
a.eof_ = 1;
|
||
|
|
return 0xff
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8BitUpdate(a, b) {
|
||
|
|
var c = uint32_t;
|
||
|
|
var d = (b + 1) << 8;
|
||
|
|
if (a.missing_ > 0) {
|
||
|
|
a.value_ |= VP8GetByte(a) << a.missing_;
|
||
|
|
a.missing_ -= 8
|
||
|
|
}
|
||
|
|
c = (a.value_ >= d) + 0;
|
||
|
|
if (c) {
|
||
|
|
a.range_ -= b + 1;
|
||
|
|
a.value_ -= d
|
||
|
|
} else {
|
||
|
|
a.range_ = b
|
||
|
|
}
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8Shift(a) {
|
||
|
|
var b = bc[a.range_];
|
||
|
|
a.range_ = bd[a.range_];
|
||
|
|
a.value_ <<= b;
|
||
|
|
a.missing_ += b
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8GetBit(a, b) {
|
||
|
|
var c = (a.range_ * b) >> 8;
|
||
|
|
var d = VP8BitUpdate(a, c);
|
||
|
|
if (a.range_ < 0x7f) {
|
||
|
|
VP8Shift(a)
|
||
|
|
}
|
||
|
|
return d
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8GetSigned(a, v) {
|
||
|
|
var b = a.range_ >> 1;
|
||
|
|
var c = VP8BitUpdate(a, b);
|
||
|
|
VP8Shift(a);
|
||
|
|
return c ? -v : v
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8InitBitReader(a, b, c, d) {
|
||
|
|
assert(a);
|
||
|
|
assert(b);
|
||
|
|
assert(d);
|
||
|
|
a.range_ = 255 - 1;
|
||
|
|
a.buf_ = b;
|
||
|
|
a.buf_off = c;
|
||
|
|
a.buf_end_ = d;
|
||
|
|
a.value_ = 0;
|
||
|
|
a.missing_ = 8;
|
||
|
|
a.eof_ = 0
|
||
|
|
};
|
||
|
|
var bc = new Array(7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0);
|
||
|
|
var bd = new Array(127, 127, 191, 127, 159, 191, 223, 127, 143, 159, 175, 191, 207, 223, 239, 127, 135, 143, 151, 159, 167, 175, 183, 191, 199, 207, 215, 223, 231, 239, 247, 127, 131, 135, 139, 143, 147, 151, 155, 159, 163, 167, 171, 175, 179, 183, 187, 191, 195, 199, 203, 207, 211, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251, 127, 129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 171, 173, 175, 177, 179, 181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, 213, 215, 217, 219, 221, 223, 225, 227, 229, 231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 127);
|
||
|
|
|
||
|
|
function VP8GetValue(a, b) {
|
||
|
|
var v = 0;
|
||
|
|
while (b-- > 0) {
|
||
|
|
v |= VP8GetBit(a, 0x80) << b
|
||
|
|
}
|
||
|
|
return v
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8GetSignedValue(a, b) {
|
||
|
|
var c = VP8GetValue(a, b);
|
||
|
|
return VP8Get(a) ? -c : c
|
||
|
|
};
|
||
|
|
var be = 0;
|
||
|
|
var bf = 1;
|
||
|
|
var bg = 2;
|
||
|
|
var bh = 0,
|
||
|
|
B_TM_PRED = 1,
|
||
|
|
B_VE_PRED = 2,
|
||
|
|
B_HE_PRED = 3,
|
||
|
|
B_RD_PRED = 4,
|
||
|
|
B_VR_PRED = 5,
|
||
|
|
B_LD_PRED = 6,
|
||
|
|
B_VL_PRED = 7,
|
||
|
|
B_HD_PRED = 8,
|
||
|
|
B_HU_PRED = 9,
|
||
|
|
NUM_BMODES = B_HU_PRED + 1 - bh,
|
||
|
|
DC_PRED = bh,
|
||
|
|
V_PRED = B_VE_PRED,
|
||
|
|
H_PRED = B_HE_PRED,
|
||
|
|
TM_PRED = B_TM_PRED,
|
||
|
|
B_PRED = NUM_BMODES,
|
||
|
|
B_DC_PRED_NOTOP = 4,
|
||
|
|
B_DC_PRED_NOLEFT = 5,
|
||
|
|
B_DC_PRED_NOTOPLEFT = 6,
|
||
|
|
NUM_B_DC_MODES = 7;
|
||
|
|
var bi = 3,
|
||
|
|
NUM_MB_SEGMENTS = 4,
|
||
|
|
NUM_REF_LF_DELTAS = 4,
|
||
|
|
NUM_MODE_LF_DELTAS = 4,
|
||
|
|
MAX_NUM_PARTITIONS = 8,
|
||
|
|
NUM_TYPES = 4,
|
||
|
|
NUM_BANDS = 8,
|
||
|
|
NUM_CTX = 3,
|
||
|
|
NUM_PROBAS = 11,
|
||
|
|
NUM_MV_PROBAS = 19;
|
||
|
|
var bj = 32;
|
||
|
|
var bk = (bj * 17 + bj * 9);
|
||
|
|
var bl = (bj * 17);
|
||
|
|
var bm = (bj * 1 + 8);
|
||
|
|
var bn = (bm + bj * 16 + bj);
|
||
|
|
var bo = (bn + 16);
|
||
|
|
var bp = {
|
||
|
|
key_frame_: uint8_t,
|
||
|
|
profile_: uint8_t,
|
||
|
|
show_: uint8_t,
|
||
|
|
partition_length_: uint32_t
|
||
|
|
};
|
||
|
|
var bq = {
|
||
|
|
width_: uint16_t,
|
||
|
|
height_: uint16_t,
|
||
|
|
xscale_: uint8_t,
|
||
|
|
yscale_: uint8_t,
|
||
|
|
colorspace_: uint8_t,
|
||
|
|
clamp_type_: uint8_t
|
||
|
|
};
|
||
|
|
var bs = {
|
||
|
|
use_segment_: int,
|
||
|
|
update_map_: int,
|
||
|
|
absolute_delta_: int,
|
||
|
|
quantizer_: Arr(NUM_MB_SEGMENTS, int8_t),
|
||
|
|
filter_strength_: Arr(NUM_MB_SEGMENTS, int8_t)
|
||
|
|
};
|
||
|
|
var bt = {
|
||
|
|
segments_: Arr(bi, uint8_t),
|
||
|
|
coeffs_: ArrM(new Array(NUM_TYPES, NUM_BANDS, NUM_CTX, NUM_PROBAS), uint8_t)
|
||
|
|
};
|
||
|
|
var bu = {
|
||
|
|
simple_: int,
|
||
|
|
level_: int,
|
||
|
|
sharpness_: int,
|
||
|
|
use_lf_delta_: int,
|
||
|
|
ref_lf_delta_: Arr(NUM_REF_LF_DELTAS, int),
|
||
|
|
mode_lf_delta_: Arr(NUM_REF_LF_DELTAS, int)
|
||
|
|
};
|
||
|
|
var bv = {
|
||
|
|
f_level_: int,
|
||
|
|
f_ilevel_: int,
|
||
|
|
f_inner_: int
|
||
|
|
};
|
||
|
|
var bw = {
|
||
|
|
nz_: int,
|
||
|
|
dc_nz_: int,
|
||
|
|
skip_: int
|
||
|
|
};
|
||
|
|
var bx = {
|
||
|
|
y1_mat_: Arr(2, uint16_t),
|
||
|
|
y2_mat_: Arr(2, uint16_t),
|
||
|
|
uv_mat_: Arr(2, uint16_t)
|
||
|
|
};
|
||
|
|
var by = {
|
||
|
|
id_: int,
|
||
|
|
mb_y_: int,
|
||
|
|
filter_row_: int,
|
||
|
|
f_info_: bv,
|
||
|
|
io_: Y
|
||
|
|
};
|
||
|
|
var bz = {
|
||
|
|
status_: 'VP8StatusCode',
|
||
|
|
ready_: int,
|
||
|
|
error_msg_: char,
|
||
|
|
br_: newObjectIt(bb),
|
||
|
|
frm_hdr_: newObjectIt(bp),
|
||
|
|
pic_hdr_: newObjectIt(bq),
|
||
|
|
filter_hdr_: newObjectIt(bu),
|
||
|
|
segment_hdr_: newObjectIt(bs),
|
||
|
|
worker_: 'WebPWorker',
|
||
|
|
use_threads_: int,
|
||
|
|
cache_id_: int,
|
||
|
|
num_caches_: int,
|
||
|
|
thread_ctx_: by,
|
||
|
|
mb_w_: int,
|
||
|
|
mb_h_: int,
|
||
|
|
tl_mb_x_: int,
|
||
|
|
tl_mb_y_: int,
|
||
|
|
br_mb_x_: int,
|
||
|
|
br_mb_y_: int,
|
||
|
|
num_parts_: int,
|
||
|
|
parts_: Arr_nOI(MAX_NUM_PARTITIONS, bb),
|
||
|
|
buffer_flags_: uint32_t,
|
||
|
|
dqm_: Arr_nOI(NUM_MB_SEGMENTS, bx),
|
||
|
|
proba_: newObjectIt(bt),
|
||
|
|
use_skip_proba_: int,
|
||
|
|
skip_p_: uint8_t,
|
||
|
|
intra_t_: uint8_t,
|
||
|
|
intra_l_: Arr(4, uint8_t),
|
||
|
|
y_t_: uint8_t,
|
||
|
|
u_t_: uint8_t,
|
||
|
|
v_t_: uint8_t,
|
||
|
|
mb_info_: newObjectIt(bw),
|
||
|
|
f_info_: newObjectIt(bv),
|
||
|
|
yuv_b_: uint8_t,
|
||
|
|
coeffs_: int16_t,
|
||
|
|
cache_y_: uint8_t,
|
||
|
|
cache_u_: uint8_t,
|
||
|
|
cache_v_: uint8_t,
|
||
|
|
cache_y_off: int,
|
||
|
|
cache_u_off: int,
|
||
|
|
cache_v_off: int,
|
||
|
|
cache_y_stride_: int,
|
||
|
|
cache_uv_stride_: int,
|
||
|
|
mem_: void_,
|
||
|
|
mem_size_: int,
|
||
|
|
mb_x_: int,
|
||
|
|
mb_y_: int,
|
||
|
|
is_i4x4_: uint8_t,
|
||
|
|
imodes_: Arr(16, uint8_t),
|
||
|
|
imodes_offset_: 0,
|
||
|
|
uvmode_: uint8_t,
|
||
|
|
segment_: uint8_t,
|
||
|
|
non_zero_: uint32_t,
|
||
|
|
non_zero_ac_: uint32_t,
|
||
|
|
filter_type_: int,
|
||
|
|
filter_row_: int,
|
||
|
|
filter_levels_: Arr(NUM_MB_SEGMENTS, uint8_t),
|
||
|
|
alpha_data_: uint8_t,
|
||
|
|
alpha_data_off: 0,
|
||
|
|
alpha_data_size_: size_t,
|
||
|
|
alpha_plane_: uint8_t,
|
||
|
|
alpha_plane_off: 0,
|
||
|
|
layer_colorspace_: int,
|
||
|
|
layer_data_: uint8_t,
|
||
|
|
layer_data_off: 0,
|
||
|
|
layer_data_size_: size_t
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8DecompressAlphaRows(a, b, c) {
|
||
|
|
var d = a.alpha_plane_;
|
||
|
|
var e = a.pic_hdr_.width_;
|
||
|
|
if (b < 0 || b + c > a.pic_hdr_.height_) {
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
if (b == 0) {
|
||
|
|
var f = a.alpha_data_;
|
||
|
|
var g = a.alpha_data_off;
|
||
|
|
var h = a.alpha_data_size_;
|
||
|
|
var i = e * a.pic_hdr_.height_;
|
||
|
|
d = WebPZlib.uncompress(f.slice(g, g + h))
|
||
|
|
}
|
||
|
|
return (b == 0 ? d : (+b * e))
|
||
|
|
}
|
||
|
|
var bA = new Array(3, 4, 3, 4, 4, 2, 2, 1, 1);
|
||
|
|
|
||
|
|
function CheckDecBuffer(a) {
|
||
|
|
var b = 1;
|
||
|
|
var c = a.colorspace;
|
||
|
|
var d = a.width;
|
||
|
|
var e = a.height;
|
||
|
|
if (c >= MODE_YUV) {
|
||
|
|
var f = a.u.YUVA;
|
||
|
|
var g = f.y_stride * e;
|
||
|
|
var h = f.u_stride * parseInt((e + 1) / 2);
|
||
|
|
var i = f.v_stride * parseInt((e + 1) / 2);
|
||
|
|
var j = f.a_stride * e;
|
||
|
|
b &= (g <= f.y_size);
|
||
|
|
b &= (h <= f.u_size);
|
||
|
|
b &= (i <= f.v_size);
|
||
|
|
b &= (j <= f.a_size);
|
||
|
|
b &= (f.y_stride >= d);
|
||
|
|
b &= (f.u_stride >= parseInt(d + 1) / 2);
|
||
|
|
b &= (f.v_stride >= parseInt(d + 1) / 2);
|
||
|
|
if (f.a) {
|
||
|
|
b &= (f.a_stride >= d)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var f = a.u.RGBA;
|
||
|
|
b &= (f.stride * e <= f.size);
|
||
|
|
b &= (f.stride >= d * bA[c])
|
||
|
|
}
|
||
|
|
return b ? T : VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
|
||
|
|
function AllocateBuffer(a) {
|
||
|
|
var w = a.width;
|
||
|
|
var h = a.height;
|
||
|
|
if (w <= 0 || h <= 0) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
if (!a.is_external_memory && a.private_memory == null) {
|
||
|
|
var b = uint8_t;
|
||
|
|
var c = 0;
|
||
|
|
var d = a.colorspace;
|
||
|
|
var e = int;
|
||
|
|
var f = 0,
|
||
|
|
a_stride = 0;
|
||
|
|
var g = 0;
|
||
|
|
var i = uint64_t,
|
||
|
|
a_size = 0,
|
||
|
|
total_size = uint64_t;
|
||
|
|
e = w * bA[d];
|
||
|
|
i = e * h;
|
||
|
|
if (d >= MODE_YUV) {
|
||
|
|
f = parseInt((w + 1) / 2);
|
||
|
|
g = f * parseInt((h + 1) / 2);
|
||
|
|
if (d == MODE_YUVA) {
|
||
|
|
a_stride = w;
|
||
|
|
a_size = a_stride * h
|
||
|
|
}
|
||
|
|
}
|
||
|
|
total_size = i + 2 * g + a_size;
|
||
|
|
if ((total_size != total_size)) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
a.private_memory = b = malloc(total_size, size_t);
|
||
|
|
a.private_memory_off = c = 0;
|
||
|
|
if (b == null) {
|
||
|
|
return VP8_STATUS_OUT_OF_MEMORY
|
||
|
|
}
|
||
|
|
if (d >= MODE_YUV) {
|
||
|
|
var j = a.u.YUVA;
|
||
|
|
j.y = b;
|
||
|
|
j.y_off = c;
|
||
|
|
j.y_stride = e;
|
||
|
|
j.y_size = i;
|
||
|
|
j.u = b;
|
||
|
|
j.u_off = c + i;
|
||
|
|
j.u_stride = f;
|
||
|
|
j.u_size = g;
|
||
|
|
j.v = b;
|
||
|
|
j.v_off = c + i + g;
|
||
|
|
j.v_stride = f;
|
||
|
|
j.v_size = g;
|
||
|
|
if (d == MODE_YUVA) {
|
||
|
|
j.a = b;
|
||
|
|
j.a_off = c + i + 2 * g
|
||
|
|
}
|
||
|
|
j.a_size = a_size;
|
||
|
|
j.a_stride = a_stride
|
||
|
|
} else {
|
||
|
|
var j = a.u.RGBA;
|
||
|
|
j.rgba = b;
|
||
|
|
j.rgba_off = c;
|
||
|
|
j.stride = e;
|
||
|
|
j.size = i
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return CheckDecBuffer(a)
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPAllocateDecBuffer(w, h, a, b) {
|
||
|
|
if (b == null || w <= 0 || h <= 0) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
if (a != null) {
|
||
|
|
if (a.use_cropping) {
|
||
|
|
var c = a.crop_width;
|
||
|
|
var d = a.crop_height;
|
||
|
|
var x = a.crop_left & ~1;
|
||
|
|
var y = a.crop_top & ~1;
|
||
|
|
if (x < 0 || y < 0 || c <= 0 || d <= 0 || x + c > w || y + d > h) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
w = c;
|
||
|
|
h = d
|
||
|
|
}
|
||
|
|
if (a.use_scaling) {
|
||
|
|
if (a.scaled_width <= 0 || a.scaled_height <= 0) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
w = a.scaled_width;
|
||
|
|
h = a.scaled_height
|
||
|
|
}
|
||
|
|
}
|
||
|
|
b.width = w;
|
||
|
|
b.height = h;
|
||
|
|
return AllocateBuffer(b)
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPInitDecBufferInternal(a, b) {
|
||
|
|
if (b != N) return 0;
|
||
|
|
if (!a) return 0;
|
||
|
|
memset_(a, 0, 0, sizeof(a) * a.length);
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
this.WebPFreeDecBuffer = function(a) {
|
||
|
|
if (a) {
|
||
|
|
if (!a.is_external_memory) a.private_memory = '';
|
||
|
|
a.private_memory_off = 0;
|
||
|
|
a.private_memory = a.private_memory_off = null
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function WebPCopyDecBuffer(a, b) {
|
||
|
|
alert('todo: WebPCopyDecBuffer')
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPGrabDecBuffer(a, b) {
|
||
|
|
alert('todo: WebPGrabDecBuffer')
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8DecodeLayer(a) {
|
||
|
|
assert(a);
|
||
|
|
assert(a.layer_data_size_ > 0);
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
var bB = Arr((255 + 255 + 1), uint8_t);
|
||
|
|
var bC = Arr((255 + 255 + 1), uint8_t);
|
||
|
|
var bD = Arr((1020 + 1020 + 1), int8_t);
|
||
|
|
var bE = Arr((112 + 112 + 1), int8_t);
|
||
|
|
var bF = Arr((255 + 510 + 1), uint8_t);
|
||
|
|
var bG = 0;
|
||
|
|
|
||
|
|
function VP8DspInitTables(a) {
|
||
|
|
if (!bG) {
|
||
|
|
var i;
|
||
|
|
for (i = -255; i <= 255; ++i) {
|
||
|
|
bB[255 + i] = (i < 0) ? -i : i;
|
||
|
|
bC[255 + i] = bB[255 + i] >> 1
|
||
|
|
}
|
||
|
|
for (i = -1020; i <= 1020; ++i) {
|
||
|
|
bD[1020 + i] = (i < -128) ? -128 : (i > 127) ? 127 : i
|
||
|
|
}
|
||
|
|
for (i = -112; i <= 112; ++i) {
|
||
|
|
bE[112 + i] = (i < -16) ? -16 : (i > 15) ? 15 : i
|
||
|
|
}
|
||
|
|
for (i = -255; i <= 255 + 255; ++i) {
|
||
|
|
bF[255 + i] = (i < 0) ? 0 : (i > 255) ? 255 : i
|
||
|
|
}
|
||
|
|
bG = 1
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function clip_8b(v) {
|
||
|
|
return (!(v & ~0xff)) ? v : (v < 0) ? 0 : 255
|
||
|
|
};
|
||
|
|
|
||
|
|
function STORE(x, y, v) {
|
||
|
|
dst[dst_off + x + y * bj] = clip_8b(dst_off + dst[x + y * bj] + ((v) >> 3))
|
||
|
|
};
|
||
|
|
var bH = 20091 + (1 << 16);
|
||
|
|
var bI = 35468;
|
||
|
|
|
||
|
|
function MUL(a, b) {
|
||
|
|
return (((a) * (b)) >> 16)
|
||
|
|
}
|
||
|
|
|
||
|
|
function TransformOne(e, f, g, h) {
|
||
|
|
var C = Arr(4 * 4, 0),
|
||
|
|
tmp, tmp_off;
|
||
|
|
tmp_off = 0;
|
||
|
|
var i;
|
||
|
|
tmp = C;
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var a = e[f + 0] + e[f + 8];
|
||
|
|
var b = e[f + 0] - e[f + 8];
|
||
|
|
var c = MUL(e[f + 4], bI) - MUL(e[f + 12], bH);
|
||
|
|
var d = MUL(e[f + 4], bH) + MUL(e[f + 12], bI);
|
||
|
|
tmp[tmp_off + 0] = a + d;
|
||
|
|
tmp[tmp_off + 1] = b + c;
|
||
|
|
tmp[tmp_off + 2] = b - c;
|
||
|
|
tmp[tmp_off + 3] = a - d;
|
||
|
|
tmp_off += 4;
|
||
|
|
f++
|
||
|
|
}
|
||
|
|
tmp_off = 0;
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var j = tmp[tmp_off + 0] + 4;
|
||
|
|
var a = j + tmp[tmp_off + 8];
|
||
|
|
var b = j - tmp[tmp_off + 8];
|
||
|
|
var c = MUL(tmp[tmp_off + 4], bI) - MUL(tmp[tmp_off + 12], bH);
|
||
|
|
var d = MUL(tmp[tmp_off + 4], bH) + MUL(tmp[tmp_off + 12], bI);
|
||
|
|
g[h + 0 + 0 * bj] = clip_8b(g[h + 0 + 0 * bj] + ((a + d) >> 3));
|
||
|
|
g[h + 1 + 0 * bj] = clip_8b(g[h + 1 + 0 * bj] + ((b + c) >> 3));
|
||
|
|
g[h + 2 + 0 * bj] = clip_8b(g[h + 2 + 0 * bj] + ((b - c) >> 3));
|
||
|
|
g[h + 3 + 0 * bj] = clip_8b(g[h + 3 + 0 * bj] + ((a - d) >> 3));
|
||
|
|
tmp_off++;
|
||
|
|
h += bj
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function TransformTwo(a, b, c, d, e) {
|
||
|
|
TransformOne(a, b, c, d);
|
||
|
|
if (e) {
|
||
|
|
TransformOne(a, b + 16, c, d + 4)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function TransformUV(a, b, c, d) {
|
||
|
|
bM(a, b + 0 * 16, c, d + 0, 1);
|
||
|
|
bM(a, b + 2 * 16, c, d + 4 * bj, 1)
|
||
|
|
}
|
||
|
|
|
||
|
|
function TransformDC(a, b, c, d) {
|
||
|
|
var e = a[b + 0] + 4;
|
||
|
|
var i, j;
|
||
|
|
for (j = 0; j < 4; ++j) {
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var f = c[d + i + j * bj];
|
||
|
|
c[d + i + j * bj] = clip_8b(c[d + i + j * bj] + ((e) >> 3))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function TransformDCUV(a, b, c, d) {
|
||
|
|
if (a[b + 0 * 16]) TransformDC(a, b + 0 * 16, c, d + 0);
|
||
|
|
if (a[b + 1 * 16]) TransformDC(a, b + 1 * 16, c, d + 4);
|
||
|
|
if (a[b + 2 * 16]) TransformDC(a, b + 2 * 16, c, d + 4 * bj);
|
||
|
|
if (a[b + 3 * 16]) TransformDC(a, b + 3 * 16, c, d + 4 * bj + 4)
|
||
|
|
};
|
||
|
|
|
||
|
|
function TransformWHT(a, b) {
|
||
|
|
var c = Arr(16, int);
|
||
|
|
var i = int;
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var d = a[0 + i] + a[12 + i];
|
||
|
|
var e = a[4 + i] + a[8 + i];
|
||
|
|
var f = a[4 + i] - a[8 + i];
|
||
|
|
var g = a[0 + i] - a[12 + i];
|
||
|
|
c[0 + i] = d + e;
|
||
|
|
c[8 + i] = d - e;
|
||
|
|
c[4 + i] = g + f;
|
||
|
|
c[12 + i] = g - f
|
||
|
|
}
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var h = b[b.length - 1];
|
||
|
|
var j = c[0 + i * 4] + 3;
|
||
|
|
var d = j + c[3 + i * 4];
|
||
|
|
var e = c[1 + i * 4] + c[2 + i * 4];
|
||
|
|
var f = c[1 + i * 4] - c[2 + i * 4];
|
||
|
|
var g = j - c[3 + i * 4];
|
||
|
|
b[h + 0] = (d + e) >> 3;
|
||
|
|
b[h + 16] = (g + f) >> 3;
|
||
|
|
b[h + 32] = (d - e) >> 3;
|
||
|
|
b[h + 48] = (g - f) >> 3;
|
||
|
|
b[b.length - 1] += 64
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8TransformWHT(a, b) {
|
||
|
|
TransformWHT(a, b)
|
||
|
|
};
|
||
|
|
|
||
|
|
function OUT(x, y) {
|
||
|
|
dst[(x) + (y) * bj]
|
||
|
|
}
|
||
|
|
|
||
|
|
function TrueMotion(a, b, c) {
|
||
|
|
var d = a;
|
||
|
|
var e = b - bj;
|
||
|
|
var f = bF;
|
||
|
|
var g = +255 - d[e - 1];
|
||
|
|
var y;
|
||
|
|
for (y = 0; y < c; ++y) {
|
||
|
|
var h = f;
|
||
|
|
var i = g + a[b - 1];
|
||
|
|
var x;
|
||
|
|
for (x = 0; x < c; ++x) {
|
||
|
|
a[b + x] = h[i + d[e + x]]
|
||
|
|
}
|
||
|
|
b += bj
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function TM4(a, b) {
|
||
|
|
TrueMotion(a, b, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function TM8uv(a, b) {
|
||
|
|
TrueMotion(a, b, 8)
|
||
|
|
}
|
||
|
|
|
||
|
|
function TM16(a, b) {
|
||
|
|
TrueMotion(a, b, 16)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VE16(a, b) {
|
||
|
|
var j;
|
||
|
|
for (j = 0; j < 16; ++j) {
|
||
|
|
memcpy(a, b + j * bj, a, b - bj, 16)
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function HE16(a, b) {
|
||
|
|
var j;
|
||
|
|
for (j = 16; j > 0; --j) {
|
||
|
|
memset_(a, b + 0, a[b - 1], 16);
|
||
|
|
b += bj
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function Put16(v, a, b) {
|
||
|
|
var j;
|
||
|
|
for (j = 0; j < 16; ++j) {
|
||
|
|
for (i = 0; i < (16); ++i) a[b + j * bj + i] = v
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function DC16(a, b) {
|
||
|
|
var c = 16;
|
||
|
|
var j;
|
||
|
|
for (j = 0; j < 16; ++j) {
|
||
|
|
c += a[b - 1 + j * bj] + a[b + j - bj]
|
||
|
|
}
|
||
|
|
Put16(c >> 5, a, b)
|
||
|
|
};
|
||
|
|
|
||
|
|
function DC16NoTop(a, b) {
|
||
|
|
var c = 8;
|
||
|
|
var j;
|
||
|
|
for (j = 0; j < 16; ++j) {
|
||
|
|
c += a[b - 1 + j * bj]
|
||
|
|
}
|
||
|
|
Put16(c >> 4, a, b)
|
||
|
|
};
|
||
|
|
|
||
|
|
function DC16NoLeft(a, b) {
|
||
|
|
var c = 8;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 16; ++i) {
|
||
|
|
c += a[b + i - bj]
|
||
|
|
}
|
||
|
|
Put16(c >> 4, a, b)
|
||
|
|
};
|
||
|
|
|
||
|
|
function DC16NoTopLeft(a, b) {
|
||
|
|
Put16(0x80, a, b)
|
||
|
|
};
|
||
|
|
|
||
|
|
function AVG3(a, b, c) {
|
||
|
|
return (((a) + 2 * (b) + (c) + 2) >> 2)
|
||
|
|
};
|
||
|
|
|
||
|
|
function AVG2(a, b) {
|
||
|
|
return (((a) + (b) + 1) >> 1)
|
||
|
|
};
|
||
|
|
|
||
|
|
function VE4(a, b) {
|
||
|
|
var c = a;
|
||
|
|
var d = b - bj;
|
||
|
|
var e = new Array();
|
||
|
|
e.push(AVG3(c[d - 1], c[d + 0], c[d + 1]));
|
||
|
|
e.push(AVG3(c[d + 0], c[d + 1], c[d + 2]));
|
||
|
|
e.push(AVG3(c[d + 1], c[d + 2], c[d + 3]));
|
||
|
|
e.push(AVG3(c[d + 2], c[d + 3], c[d + 4]));
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
memcpy(a, b + i * bj, e, 0, 4 * sizeof(e))
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function HE4(a, b) {
|
||
|
|
var A = a[b - 1 - bj];
|
||
|
|
var B = a[b - 1];
|
||
|
|
var C = a[b - 1 + bj];
|
||
|
|
var D = a[b - 1 + 2 * bj];
|
||
|
|
var E = a[b - 1 + 3 * bj];
|
||
|
|
a[b + 0 + 0 * bj] = a[b + 1 + 0 * bj] = a[b + 2 + 0 * bj] = a[b + 3 + 0 * bj] = AVG3(A, B, C);
|
||
|
|
a[b + 0 + 1 * bj] = a[b + 1 + 1 * bj] = a[b + 2 + 1 * bj] = a[b + 3 + 1 * bj] = AVG3(B, C, D);
|
||
|
|
a[b + 0 + 2 * bj] = a[b + 1 + 2 * bj] = a[b + 2 + 2 * bj] = a[b + 3 + 2 * bj] = AVG3(C, D, E);
|
||
|
|
a[b + 0 + 3 * bj] = a[b + 1 + 3 * bj] = a[b + 2 + 3 * bj] = a[b + 3 + 3 * bj] = AVG3(D, E, E)
|
||
|
|
};
|
||
|
|
|
||
|
|
function DC4(a, b) {
|
||
|
|
var c = 4;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 4; ++i) c += a[b + i - bj] + a[b - 1 + i * bj];
|
||
|
|
c >>= 3;
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
memset_(a, b + i * bj, c, 4)
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function RD4(a, b) {
|
||
|
|
var I = a[b - 1 + 0 * bj];
|
||
|
|
var J = a[b - 1 + 1 * bj];
|
||
|
|
var K = a[b - 1 + 2 * bj];
|
||
|
|
var L = a[b - 1 + 3 * bj];
|
||
|
|
var X = a[b - 1 - bj];
|
||
|
|
var A = a[b + 0 - bj];
|
||
|
|
var B = a[b + 1 - bj];
|
||
|
|
var C = a[b + 2 - bj];
|
||
|
|
var D = a[b + 3 - bj];
|
||
|
|
a[b + (0) + (3) * bj] = AVG3(J, K, L);
|
||
|
|
a[b + (0) + (2) * bj] = a[b + (1) + (3) * bj] = AVG3(I, J, K);
|
||
|
|
a[b + (0) + (1) * bj] = a[b + (1) + (2) * bj] = a[b + (2) + (3) * bj] = AVG3(X, I, J);
|
||
|
|
a[b + (0) + (0) * bj] = a[b + (1) + (1) * bj] = a[b + (2) + (2) * bj] = a[b + (3) + (3) * bj] = AVG3(A, X, I);
|
||
|
|
a[b + (1) + (0) * bj] = a[b + (2) + (1) * bj] = a[b + (3) + (2) * bj] = AVG3(B, A, X);
|
||
|
|
a[b + (2) + (0) * bj] = a[b + (3) + (1) * bj] = AVG3(C, B, A);
|
||
|
|
a[b + (3) + (0) * bj] = AVG3(D, C, B)
|
||
|
|
};
|
||
|
|
|
||
|
|
function LD4(a, b) {
|
||
|
|
var A = a[b + 0 - bj];
|
||
|
|
var B = a[b + 1 - bj];
|
||
|
|
var C = a[b + 2 - bj];
|
||
|
|
var D = a[b + 3 - bj];
|
||
|
|
var E = a[b + 4 - bj];
|
||
|
|
var F = a[b + 5 - bj];
|
||
|
|
var G = a[b + 6 - bj];
|
||
|
|
var H = a[b + 7 - bj];
|
||
|
|
a[b + (0) + (0) * bj] = AVG3(A, B, C);
|
||
|
|
a[b + (1) + (0) * bj] = a[b + (0) + (1) * bj] = AVG3(B, C, D);
|
||
|
|
a[b + (2) + (0) * bj] = a[b + (1) + (1) * bj] = a[b + (0) + (2) * bj] = AVG3(C, D, E);
|
||
|
|
a[b + (3) + (0) * bj] = a[b + (2) + (1) * bj] = a[b + (1) + (2) * bj] = a[b + (0) + (3) * bj] = AVG3(D, E, F);
|
||
|
|
a[b + (3) + (1) * bj] = a[b + (2) + (2) * bj] = a[b + (1) + (3) * bj] = AVG3(E, F, G);
|
||
|
|
a[b + (3) + (2) * bj] = a[b + (2) + (3) * bj] = AVG3(F, G, H);
|
||
|
|
a[b + (3) + (3) * bj] = AVG3(G, H, H)
|
||
|
|
};
|
||
|
|
|
||
|
|
function VR4(a, b) {
|
||
|
|
var I = a[b - 1 + 0 * bj];
|
||
|
|
var J = a[b - 1 + 1 * bj];
|
||
|
|
var K = a[b - 1 + 2 * bj];
|
||
|
|
var X = a[b - 1 - bj];
|
||
|
|
var A = a[b + 0 - bj];
|
||
|
|
var B = a[b + 1 - bj];
|
||
|
|
var C = a[b + 2 - bj];
|
||
|
|
var D = a[b + 3 - bj];
|
||
|
|
a[b + (0) + (0) * bj] = a[b + (1) + (2) * bj] = AVG2(X, A);
|
||
|
|
a[b + (1) + (0) * bj] = a[b + (2) + (2) * bj] = AVG2(A, B);
|
||
|
|
a[b + (2) + (0) * bj] = a[b + (3) + (2) * bj] = AVG2(B, C);
|
||
|
|
a[b + (3) + (0) * bj] = AVG2(C, D);
|
||
|
|
a[b + (0) + (3) * bj] = AVG3(K, J, I);
|
||
|
|
a[b + (0) + (2) * bj] = AVG3(J, I, X);
|
||
|
|
a[b + (0) + (1) * bj] = a[b + (1) + (3) * bj] = AVG3(I, X, A);
|
||
|
|
a[b + (1) + (1) * bj] = a[b + (2) + (3) * bj] = AVG3(X, A, B);
|
||
|
|
a[b + (2) + (1) * bj] = a[b + (3) + (3) * bj] = AVG3(A, B, C);
|
||
|
|
a[b + (3) + (1) * bj] = AVG3(B, C, D)
|
||
|
|
};
|
||
|
|
|
||
|
|
function VL4(a, b) {
|
||
|
|
var A = a[b + 0 - bj];
|
||
|
|
var B = a[b + 1 - bj];
|
||
|
|
var C = a[b + 2 - bj];
|
||
|
|
var D = a[b + 3 - bj];
|
||
|
|
var E = a[b + 4 - bj];
|
||
|
|
var F = a[b + 5 - bj];
|
||
|
|
var G = a[b + 6 - bj];
|
||
|
|
var H = a[b + 7 - bj];
|
||
|
|
a[b + (0) + (0) * bj] = AVG2(A, B);
|
||
|
|
a[b + (1) + (0) * bj] = a[b + (0) + (2) * bj] = AVG2(B, C);
|
||
|
|
a[b + (2) + (0) * bj] = a[b + (1) + (2) * bj] = AVG2(C, D);
|
||
|
|
a[b + (3) + (0) * bj] = a[b + (2) + (2) * bj] = AVG2(D, E);
|
||
|
|
a[b + (0) + (1) * bj] = AVG3(A, B, C);
|
||
|
|
a[b + (1) + (1) * bj] = a[b + (0) + (3) * bj] = AVG3(B, C, D);
|
||
|
|
a[b + (2) + (1) * bj] = a[b + (1) + (3) * bj] = AVG3(C, D, E);
|
||
|
|
a[b + (3) + (1) * bj] = a[b + (2) + (3) * bj] = AVG3(D, E, F);
|
||
|
|
a[b + (3) + (2) * bj] = AVG3(E, F, G);
|
||
|
|
a[b + (3) + (3) * bj] = AVG3(F, G, H)
|
||
|
|
};
|
||
|
|
|
||
|
|
function HU4(a, b) {
|
||
|
|
var I = a[b - 1 + 0 * bj];
|
||
|
|
var J = a[b - 1 + 1 * bj];
|
||
|
|
var K = a[b - 1 + 2 * bj];
|
||
|
|
var L = a[b - 1 + 3 * bj];
|
||
|
|
a[b + (0) + (0) * bj] = AVG2(I, J);
|
||
|
|
a[b + (2) + (0) * bj] = a[b + (0) + (1) * bj] = AVG2(J, K);
|
||
|
|
a[b + (2) + (1) * bj] = a[b + (0) + (2) * bj] = AVG2(K, L);
|
||
|
|
a[b + (1) + (0) * bj] = AVG3(I, J, K);
|
||
|
|
a[b + (3) + (0) * bj] = a[b + (1) + (1) * bj] = AVG3(J, K, L);
|
||
|
|
a[b + (3) + (1) * bj] = a[b + (1) + (2) * bj] = AVG3(K, L, L);
|
||
|
|
a[b + (3) + (2) * bj] = a[b + (2) + (2) * bj] = a[b + (0) + (3) * bj] = a[b + (1) + (3) * bj] = a[b + (2) + (3) * bj] = a[b + (3) + (3) * bj] = L
|
||
|
|
};
|
||
|
|
|
||
|
|
function HD4(a, b) {
|
||
|
|
var I = a[b - 1 + 0 * bj];
|
||
|
|
var J = a[b - 1 + 1 * bj];
|
||
|
|
var K = a[b - 1 + 2 * bj];
|
||
|
|
var L = a[b - 1 + 3 * bj];
|
||
|
|
var X = a[b - 1 - bj];
|
||
|
|
var A = a[b + 0 - bj];
|
||
|
|
var B = a[b + 1 - bj];
|
||
|
|
var C = a[b + 2 - bj];
|
||
|
|
a[b + (0) + (0) * bj] = a[b + (2) + (1) * bj] = AVG2(I, X);
|
||
|
|
a[b + (0) + (1) * bj] = a[b + (2) + (2) * bj] = AVG2(J, I);
|
||
|
|
a[b + (0) + (2) * bj] = a[b + (2) + (3) * bj] = AVG2(K, J);
|
||
|
|
a[b + (0) + (3) * bj] = AVG2(L, K);
|
||
|
|
a[b + (3) + (0) * bj] = AVG3(A, B, C);
|
||
|
|
a[b + (2) + (0) * bj] = AVG3(X, A, B);
|
||
|
|
a[b + (1) + (0) * bj] = a[b + (3) + (1) * bj] = AVG3(I, X, A);
|
||
|
|
a[b + (1) + (1) * bj] = a[b + (3) + (2) * bj] = AVG3(J, I, X);
|
||
|
|
a[b + (1) + (2) * bj] = a[b + (3) + (3) * bj] = AVG3(K, J, I);
|
||
|
|
a[b + (1) + (3) * bj] = AVG3(L, K, J)
|
||
|
|
};
|
||
|
|
|
||
|
|
function VE8uv(a, b) {
|
||
|
|
var j;
|
||
|
|
for (j = 0; j < 8; ++j) {
|
||
|
|
memcpy(a, b + j * bj, a, b - bj, 8)
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function HE8uv(a, b) {
|
||
|
|
var j;
|
||
|
|
for (j = 0; j < 8; ++j) {
|
||
|
|
memset_(a, b + 0, a[b - 1], 8);
|
||
|
|
b += bj
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function Put8x8uv(v, a, b) {
|
||
|
|
var j, k;
|
||
|
|
for (j = 0; j < 8; ++j) {
|
||
|
|
for (k = 0; k < 8; ++k) a[b + k + j * bj] = v
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function DC8uv(a, b) {
|
||
|
|
var c = 8;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 8; ++i) {
|
||
|
|
c += a[b + i - bj] + a[b - 1 + i * bj]
|
||
|
|
}
|
||
|
|
Put8x8uv(((c >> 4) * 0x01), a, b)
|
||
|
|
};
|
||
|
|
|
||
|
|
function DC8uvNoLeft(a, b) {
|
||
|
|
var c = 4;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 8; ++i) {
|
||
|
|
c += a[b + i - bj]
|
||
|
|
}
|
||
|
|
Put8x8uv(((c >> 3) * 0x01), a, b)
|
||
|
|
};
|
||
|
|
|
||
|
|
function DC8uvNoTop(a, b) {
|
||
|
|
var c = 4;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 8; ++i) {
|
||
|
|
c += a[b - 1 + i * bj]
|
||
|
|
}
|
||
|
|
Put8x8uv(((c >> 3) * 0x01), a, b)
|
||
|
|
};
|
||
|
|
|
||
|
|
function DC8uvNoTopLeft(a, b) {
|
||
|
|
Put8x8uv(0x80, a, b)
|
||
|
|
};
|
||
|
|
var bJ = new Array(function(v, o) {
|
||
|
|
DC4(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
TM4(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
VE4(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
HE4(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
RD4(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
VR4(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
LD4(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
VL4(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
HD4(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
HU4(v, o)
|
||
|
|
});
|
||
|
|
var bK = new Array(function(v, o) {
|
||
|
|
DC16(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
TM16(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
VE16(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
HE16(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
DC16NoTop(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
DC16NoLeft(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
DC16NoTopLeft(v, o)
|
||
|
|
});
|
||
|
|
var bL = new Array(function(v, o) {
|
||
|
|
DC8uv(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
TM8uv(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
VE8uv(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
HE8uv(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
DC8uvNoTop(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
DC8uvNoLeft(v, o)
|
||
|
|
}, function(v, o) {
|
||
|
|
DC8uvNoTopLeft(v, o)
|
||
|
|
});
|
||
|
|
|
||
|
|
function do_filter2(p, b, c) {
|
||
|
|
var d = p[b - 2 * c],
|
||
|
|
p0 = p[b - c],
|
||
|
|
q0 = p[b + 0],
|
||
|
|
q1 = p[b + c];
|
||
|
|
var a = 3 * (q0 - p0) + bD[1020 + d - q1];
|
||
|
|
var e = bE[112 + ((a + 4) >> 3)];
|
||
|
|
var f = bE[112 + ((a + 3) >> 3)];
|
||
|
|
p[b - c] = bF[255 + p0 + f];
|
||
|
|
p[b + 0] = bF[255 + q0 - e]
|
||
|
|
};
|
||
|
|
|
||
|
|
function do_filter4(p, b, c) {
|
||
|
|
var d = p[b - 2 * c],
|
||
|
|
p0 = p[b - c],
|
||
|
|
q0 = p[b + 0],
|
||
|
|
q1 = p[b + c];
|
||
|
|
var a = 3 * (q0 - p0);
|
||
|
|
var e = bE[112 + ((a + 4) >> 3)];
|
||
|
|
var f = bE[112 + ((a + 3) >> 3)];
|
||
|
|
var g = (e + 1) >> 1;
|
||
|
|
p[b - 2 * c] = bF[255 + d + g];
|
||
|
|
p[b - c] = bF[255 + p0 + f];
|
||
|
|
p[b + 0] = bF[255 + q0 - e];
|
||
|
|
p[b + c] = bF[255 + q1 - g]
|
||
|
|
};
|
||
|
|
|
||
|
|
function do_filter6(p, b, c) {
|
||
|
|
var d = p[b - 3 * c],
|
||
|
|
p1 = p[b - 2 * c],
|
||
|
|
p0 = p[b - c];
|
||
|
|
var e = p[b + 0],
|
||
|
|
q1 = p[b + c],
|
||
|
|
q2 = p[b + 2 * c];
|
||
|
|
var a = bD[1020 + 3 * (e - p0) + bD[1020 + p1 - q1]];
|
||
|
|
var f = (27 * a + 63) >> 7;
|
||
|
|
var g = (18 * a + 63) >> 7;
|
||
|
|
var h = (9 * a + 63) >> 7;
|
||
|
|
p[b - 3 * c] = bF[255 + d + h];
|
||
|
|
p[b - 2 * c] = bF[255 + p1 + g];
|
||
|
|
p[b - c] = bF[255 + p0 + f];
|
||
|
|
p[b + 0] = bF[255 + e - f];
|
||
|
|
p[b + c] = bF[255 + q1 - g];
|
||
|
|
p[b + 2 * c] = bF[255 + q2 - h]
|
||
|
|
};
|
||
|
|
|
||
|
|
function hev(p, a, b, c) {
|
||
|
|
var d = p[a - 2 * b],
|
||
|
|
p0 = p[a - b],
|
||
|
|
q0 = p[a + 0],
|
||
|
|
q1 = p[a + b];
|
||
|
|
return (bB[255 + d - p0] > c) || (bB[255 + q1 - q0] > c)
|
||
|
|
};
|
||
|
|
|
||
|
|
function needs_filter(p, a, b, c) {
|
||
|
|
var d = p[a - 2 * b],
|
||
|
|
p0 = p[a - b],
|
||
|
|
q0 = p[a + 0],
|
||
|
|
q1 = p[a + b];
|
||
|
|
return (2 * bB[255 + p0 - q0] + bC[255 + d - q1]) <= c
|
||
|
|
};
|
||
|
|
|
||
|
|
function needs_filter2(p, a, b, t, c) {
|
||
|
|
var d = p[a - 4 * b],
|
||
|
|
p2 = p[a - 3 * b],
|
||
|
|
p1 = p[a - 2 * b],
|
||
|
|
p0 = p[a - b];
|
||
|
|
var e = p[a + 0],
|
||
|
|
q1 = p[a + b],
|
||
|
|
q2 = p[a + 2 * b],
|
||
|
|
q3 = p[a + 3 * b];
|
||
|
|
if ((2 * bB[255 + p0 - e] + bC[255 + p1 - q1]) > t) return 0;
|
||
|
|
return bB[255 + d - p2] <= c && bB[255 + p2 - p1] <= c && bB[255 + p1 - p0] <= c && bB[255 + q3 - q2] <= c && bB[255 + q2 - q1] <= c && bB[255 + q1 - e] <= c
|
||
|
|
};
|
||
|
|
|
||
|
|
function SimpleVFilter16(p, a, b, c) {
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 16; ++i) {
|
||
|
|
if (needs_filter(p, a + i, b, c)) {
|
||
|
|
do_filter2(p, a + i, b)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function SimpleHFilter16(p, a, b, c) {
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 16; ++i) {
|
||
|
|
if (needs_filter(p, a + i * b, 1, c)) {
|
||
|
|
do_filter2(p, a + i * b, 1)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function SimpleVFilter16i(p, a, b, c) {
|
||
|
|
var k;
|
||
|
|
for (k = 3; k > 0; --k) {
|
||
|
|
a += 4 * b;
|
||
|
|
SimpleVFilter16(p, a + 0, b, c)
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function SimpleHFilter16i(p, a, b, c) {
|
||
|
|
var k;
|
||
|
|
for (k = 3; k > 0; --k) {
|
||
|
|
a += 4;
|
||
|
|
SimpleHFilter16(p, a + 0, b, c)
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function FilterLoop26(p, a, b, c, d, e, f, g) {
|
||
|
|
while (d-- > 0) {
|
||
|
|
if (needs_filter2(p, a + 0, b, e, f)) {
|
||
|
|
if (hev(p, a + 0, b, g)) {
|
||
|
|
do_filter2(p, a + 0, b)
|
||
|
|
} else {
|
||
|
|
do_filter6(p, a + 0, b)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
a += c
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function FilterLoop24(p, a, b, c, d, e, f, g) {
|
||
|
|
while (d-- > 0) {
|
||
|
|
if (needs_filter2(p, a + 0, b, e, f)) {
|
||
|
|
if (hev(p, a + 0, b, g)) {
|
||
|
|
do_filter2(p, a + 0, b)
|
||
|
|
} else {
|
||
|
|
do_filter4(p, a + 0, b)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
a += c
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function VFilter16(p, a, b, c, d, e) {
|
||
|
|
FilterLoop26(p, a + 0, b, 1, 16, c, d, e)
|
||
|
|
}
|
||
|
|
|
||
|
|
function HFilter16(p, a, b, c, d, e) {
|
||
|
|
FilterLoop26(p, a + 0, 1, b, 16, c, d, e)
|
||
|
|
};
|
||
|
|
|
||
|
|
function VFilter16i(p, a, b, c, d, e) {
|
||
|
|
var k;
|
||
|
|
for (k = 3; k > 0; --k) {
|
||
|
|
a += 4 * b;
|
||
|
|
FilterLoop24(p, a + 0, b, 1, 16, c, d, e)
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function HFilter16i(p, a, b, c, d, e) {
|
||
|
|
var k;
|
||
|
|
for (k = 3; k > 0; --k) {
|
||
|
|
a += 4;
|
||
|
|
FilterLoop24(p, a + 0, 1, b, 16, c, d, e)
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
function VFilter8(u, a, v, b, c, d, e, f) {
|
||
|
|
FilterLoop26(u, a, c, 1, 8, d, e, f);
|
||
|
|
FilterLoop26(v, b, c, 1, 8, d, e, f)
|
||
|
|
};
|
||
|
|
|
||
|
|
function HFilter8(u, a, v, b, c, d, e, f) {
|
||
|
|
FilterLoop26(u, a, 1, c, 8, d, e, f);
|
||
|
|
FilterLoop26(v, b, 1, c, 8, d, e, f)
|
||
|
|
};
|
||
|
|
|
||
|
|
function VFilter8i(u, a, v, b, c, d, e, f) {
|
||
|
|
FilterLoop24(u, a + 4 * c, c, 1, 8, d, e, f);
|
||
|
|
FilterLoop24(v, b + 4 * c, c, 1, 8, d, e, f)
|
||
|
|
};
|
||
|
|
|
||
|
|
function HFilter8i(u, a, v, b, c, d, e, f) {
|
||
|
|
FilterLoop24(u, a + 4, 1, c, 8, d, e, f);
|
||
|
|
FilterLoop24(v, b + 4, 1, c, 8, d, e, f)
|
||
|
|
};
|
||
|
|
var bM;
|
||
|
|
var bN;
|
||
|
|
var bO;
|
||
|
|
var bP;
|
||
|
|
var bQ;
|
||
|
|
var bR;
|
||
|
|
var bS;
|
||
|
|
var bT;
|
||
|
|
var bU;
|
||
|
|
var bV;
|
||
|
|
var bW;
|
||
|
|
var bX;
|
||
|
|
var bY;
|
||
|
|
var bZ;
|
||
|
|
var ca;
|
||
|
|
var cb;
|
||
|
|
|
||
|
|
function VP8DspInit(a) {
|
||
|
|
bM = TransformTwo;
|
||
|
|
bN = TransformUV;
|
||
|
|
bO = TransformDC;
|
||
|
|
bP = TransformDCUV;
|
||
|
|
bQ = VFilter16;
|
||
|
|
bR = HFilter16;
|
||
|
|
bS = VFilter8;
|
||
|
|
bT = HFilter8;
|
||
|
|
bU = VFilter16i;
|
||
|
|
bV = HFilter16i;
|
||
|
|
bW = VFilter8i;
|
||
|
|
bX = HFilter8i;
|
||
|
|
bY = SimpleVFilter16;
|
||
|
|
bZ = SimpleHFilter16;
|
||
|
|
ca = SimpleVFilter16i;
|
||
|
|
cb = SimpleHFilter16i
|
||
|
|
};
|
||
|
|
var cc = (32 - 1);
|
||
|
|
var cd = 3;
|
||
|
|
var ce = 1;
|
||
|
|
|
||
|
|
function InitThreadContext(a) {
|
||
|
|
a.cache_id_ = 0;
|
||
|
|
if (a.use_threads_) {
|
||
|
|
var b = a.worker_;
|
||
|
|
if (!WebPWorkerReset(b)) {
|
||
|
|
return VP8SetError(a, VP8_STATUS_OUT_OF_MEMORY, "thread initialization failed.")
|
||
|
|
}
|
||
|
|
b.data1 = a;
|
||
|
|
b.data2 = a.thread_ctx_.io_;
|
||
|
|
b.hook = VP8FinishRow;
|
||
|
|
a.num_caches_ = (a.filter_type_ > 0) ? cd : cd - 1
|
||
|
|
} else {
|
||
|
|
a.num_caches_ = ce
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
var cf = new Array(0, 2, 8);
|
||
|
|
|
||
|
|
function AllocateMemory(a) {
|
||
|
|
var b = a.num_caches_;
|
||
|
|
var c = a.mb_w_;
|
||
|
|
var d = 4 * c * sizeof(uint8_t);
|
||
|
|
var e = (16 + 8 + 8) * c;
|
||
|
|
var f = (c + 1) * sizeof(bw);
|
||
|
|
var g = (a.filter_type_ > 0) ? c * (a.use_threads_ ? 2 : 1) * sizeof(bv) : 0;
|
||
|
|
var h = bk * sizeof(a.yuv_b_);
|
||
|
|
var i = 384 * sizeof(a.coeffs_);
|
||
|
|
var j = (16 * b + parseInt(cf[a.filter_type_]) * 3 / 2);
|
||
|
|
var k = e * j;
|
||
|
|
var l = a.alpha_data_ ? (a.pic_hdr_.width_ * a.pic_hdr_.height_) : 0;
|
||
|
|
var m = d + e + f + g + h + i + k + l + cc;
|
||
|
|
var n = uint8_t,
|
||
|
|
mem_offset = 0;
|
||
|
|
if (m > a.mem_size_) {
|
||
|
|
a.mem_ = 0;
|
||
|
|
a.mem_size_ = 0;
|
||
|
|
if (a.mem_ == null) {
|
||
|
|
return VP8SetError(a, 'VP8_STATUS_OUT_OF_MEMORY', "no memory during frame initialization.")
|
||
|
|
}
|
||
|
|
a.mem_size_ = m
|
||
|
|
}
|
||
|
|
n = a.mem_;
|
||
|
|
a.intra_t_ = 205;
|
||
|
|
a.y_t_ = memset(205, (16 * c) * sizeof(a.y_t_));
|
||
|
|
a.u_t_ = memset(205, (8 * c) * sizeof(a.u_t_));
|
||
|
|
a.v_t_ = memset(205, (8 * c) * sizeof(a.v_t_));
|
||
|
|
a.f_info_ = g ? memset_wl(bv, g) : null;
|
||
|
|
a.f_info_off = g ? 0 : null;
|
||
|
|
a.thread_ctx_.id_ = 0;
|
||
|
|
a.thread_ctx_.f_info_ = a.f_info_;
|
||
|
|
if (a.use_threads_) {
|
||
|
|
a.thread_ctx_.f_info_off += c
|
||
|
|
}
|
||
|
|
assert((h & cc) == 0);
|
||
|
|
a.yuv_b_ = memset(205, h * sizeof(a.yuv_b_));
|
||
|
|
a.coeffs_ = -12851;
|
||
|
|
a.cache_y_stride_ = 16 * c;
|
||
|
|
a.cache_uv_stride_ = 8 * c; {
|
||
|
|
var o = cf[a.filter_type_];
|
||
|
|
var p = o * a.cache_y_stride_;
|
||
|
|
var q = (o / 2) * a.cache_uv_stride_;
|
||
|
|
a.cache_y_ = Arr(k, 205);
|
||
|
|
a.cache_y_off = +p;
|
||
|
|
a.cache_u_ = a.cache_y_;
|
||
|
|
a.cache_u_off = a.cache_y_off + 16 * b * a.cache_y_stride_ + q;
|
||
|
|
a.cache_v_ = a.cache_u_;
|
||
|
|
a.cache_v_off = a.cache_u_off + 8 * b * a.cache_uv_stride_ + q
|
||
|
|
}
|
||
|
|
a.alpha_plane_ = l ? Arr(l, uint8_t) : null;
|
||
|
|
a.mb_info_ = memset_wl(bw, f);
|
||
|
|
a.intra_t_ = memset(bh, d);
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function InitIo(a, b) {
|
||
|
|
b.width = a.pic_hdr_.width_;
|
||
|
|
b.height = a.pic_hdr_.height_;
|
||
|
|
b.mb_y = 0;
|
||
|
|
b.y = a.cache_y_;
|
||
|
|
b.y_off = a.cache_y_off;
|
||
|
|
b.u = a.cache_u_;
|
||
|
|
b.u_off = a.cache_u_off;
|
||
|
|
b.v = a.cache_v_;
|
||
|
|
b.v_off = a.cache_v_off;
|
||
|
|
b.y_stride = a.cache_y_stride_;
|
||
|
|
b.uv_stride = a.cache_uv_stride_;
|
||
|
|
b.fancy_upsampling = 0;
|
||
|
|
b.a = null;
|
||
|
|
b.a_off = null
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8InitFrame(a, b) {
|
||
|
|
if (!InitThreadContext(a)) return 0;
|
||
|
|
if (!AllocateMemory(a)) return 0;
|
||
|
|
InitIo(a, b);
|
||
|
|
VP8DspInitTables();
|
||
|
|
VP8DspInit();
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function hev_thresh_from_level(a, b) {
|
||
|
|
if (b) {
|
||
|
|
return (a >= 40) ? 2 : (a >= 15) ? 1 : 0
|
||
|
|
} else {
|
||
|
|
return (a >= 40) ? 3 : (a >= 20) ? 2 : (a >= 15) ? 1 : 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function DoFilter(a, b, c) {
|
||
|
|
var d = a.thread_ctx_;
|
||
|
|
var e = a.cache_y_stride_;
|
||
|
|
var f = d.f_info_[1 + b];
|
||
|
|
var g = a.cache_y_;
|
||
|
|
var h = a.cache_y_off + d.id_ * 16 * e + b * 16;
|
||
|
|
var i = f.f_level_;
|
||
|
|
var j = f.f_ilevel_;
|
||
|
|
var k = 2 * i + j;
|
||
|
|
if (i == 0) {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if (a.filter_type_ == 1) {
|
||
|
|
if (b > 0) {
|
||
|
|
bZ(g, h, e, k + 4)
|
||
|
|
}
|
||
|
|
if (f.f_inner_) {
|
||
|
|
cb(g, h, e, k)
|
||
|
|
}
|
||
|
|
if (c > 0) {
|
||
|
|
bY(g, h, e, k + 4)
|
||
|
|
}
|
||
|
|
if (f.f_inner_) {
|
||
|
|
ca(g, h, e, k)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var l = a.cache_uv_stride_;
|
||
|
|
var m = a.cache_u_;
|
||
|
|
var n = a.cache_u_off + d.id_ * 8 * l + b * 8;
|
||
|
|
var o = a.cache_v_;
|
||
|
|
var p = a.cache_v_off + d.id_ * 8 * l + b * 8;
|
||
|
|
var q = hev_thresh_from_level(i, a.frm_hdr_.key_frame_);
|
||
|
|
if (b > 0) {
|
||
|
|
bR(g, h, e, k + 4, j, q);
|
||
|
|
bT(m, n, o, p, l, k + 4, j, q)
|
||
|
|
}
|
||
|
|
if (f.f_inner_) {
|
||
|
|
bV(g, h, e, k, j, q);
|
||
|
|
bX(m, n, o, p, l, k, j, q)
|
||
|
|
}
|
||
|
|
if (c > 0) {
|
||
|
|
bQ(g, h, e, k + 4, j, q);
|
||
|
|
bS(m, n, o, p, l, k + 4, j, q)
|
||
|
|
}
|
||
|
|
if (f.f_inner_) {
|
||
|
|
bU(g, h, e, k, j, q);
|
||
|
|
bW(m, n, o, p, l, k, j, q)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function FilterRow(a) {
|
||
|
|
var b = int;
|
||
|
|
var c = a.thread_ctx_.mb_y_;
|
||
|
|
assert(a.thread_ctx_.filter_row_);
|
||
|
|
for (b = a.tl_mb_x_; b < a.br_mb_x_; ++b) {
|
||
|
|
DoFilter(a, b, c)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8StoreBlock(a) {
|
||
|
|
if (a.filter_type_ > 0) {
|
||
|
|
var b = a.f_info_[1 + a.mb_x_];
|
||
|
|
var c = a.mb_info_[1 + a.mb_x_].skip_;
|
||
|
|
var d = a.filter_levels_[a.segment_];
|
||
|
|
if (a.filter_hdr_.use_lf_delta_) {
|
||
|
|
d += a.filter_hdr_.ref_lf_delta_[0];
|
||
|
|
if (a.is_i4x4_) {
|
||
|
|
d += a.filter_hdr_.mode_lf_delta_[0]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
d = (d < 0) ? 0 : (d > 63) ? 63 : d;
|
||
|
|
b.f_level_ = d;
|
||
|
|
if (a.filter_hdr_.sharpness_ > 0) {
|
||
|
|
if (a.filter_hdr_.sharpness_ > 4) {
|
||
|
|
d >>= 2
|
||
|
|
} else {
|
||
|
|
d >>= 1
|
||
|
|
}
|
||
|
|
if (d > 9 - a.filter_hdr_.sharpness_) {
|
||
|
|
d = 9 - a.filter_hdr_.sharpness_
|
||
|
|
}
|
||
|
|
}
|
||
|
|
b.f_ilevel_ = (d < 1) ? 1 : d;
|
||
|
|
b.f_inner_ = (!c || a.is_i4x4_) + 0
|
||
|
|
} {
|
||
|
|
var y;
|
||
|
|
var e = a.cache_id_ * 16 * a.cache_y_stride_;
|
||
|
|
var f = a.cache_id_ * 8 * a.cache_uv_stride_;
|
||
|
|
var g = a.cache_y_;
|
||
|
|
var h = a.cache_y_off + a.mb_x_ * 16 + e;
|
||
|
|
var i = a.cache_u_;
|
||
|
|
var j = a.cache_u_off + a.mb_x_ * 8 + f;
|
||
|
|
var k = a.cache_v_;
|
||
|
|
var l = a.cache_v_off + a.mb_x_ * 8 + f;
|
||
|
|
for (y = 0; y < 16; ++y) {
|
||
|
|
memcpy(g, h + y * a.cache_y_stride_, a.yuv_b_, +bm + y * bj, 16)
|
||
|
|
}
|
||
|
|
for (y = 0; y < 8; ++y) {
|
||
|
|
memcpy(i, j + y * a.cache_uv_stride_, a.yuv_b_, +bn + y * bj, 8);
|
||
|
|
memcpy(k, l + y * a.cache_uv_stride_, a.yuv_b_, +bo + y * bj, 8)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function MACROBLOCK_VPOS(a) {
|
||
|
|
return ((a) * 16)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8FinishRow(a, b) {
|
||
|
|
var c = 1;
|
||
|
|
var d = a.thread_ctx_;
|
||
|
|
var e = cf[a.filter_type_];
|
||
|
|
var f = e * a.cache_y_stride_;
|
||
|
|
var g = parseInt(e / 2) * a.cache_uv_stride_;
|
||
|
|
var h = d.id_ * 16 * a.cache_y_stride_;
|
||
|
|
var i = d.id_ * 8 * a.cache_uv_stride_;
|
||
|
|
var j = a.cache_y_;
|
||
|
|
var k = a.cache_y_off - f + h;
|
||
|
|
var l = a.cache_u_;
|
||
|
|
var m = a.cache_u_off - g + i;
|
||
|
|
var n = a.cache_v_;
|
||
|
|
var o = a.cache_v_off - g + i;
|
||
|
|
var p = (d.mb_y_ == 0);
|
||
|
|
var q = (d.mb_y_ >= a.mb_h_ - 1) + 0;
|
||
|
|
var r = MACROBLOCK_VPOS(d.mb_y_);
|
||
|
|
var s = MACROBLOCK_VPOS(d.mb_y_ + 1);
|
||
|
|
if (d.filter_row_) {
|
||
|
|
FilterRow(a)
|
||
|
|
}
|
||
|
|
if (b.put) {
|
||
|
|
if (!p) {
|
||
|
|
r -= e;
|
||
|
|
b.y = j;
|
||
|
|
b.y_off = k;
|
||
|
|
b.u = l;
|
||
|
|
b.u_off = m;
|
||
|
|
b.v = n;
|
||
|
|
b.v_off = o
|
||
|
|
} else {
|
||
|
|
b.y = a.cache_y_;
|
||
|
|
b.y_off = a.cache_y_off + h;
|
||
|
|
b.u = a.cache_u_;
|
||
|
|
b.u_off = a.cache_u_off + i;
|
||
|
|
b.v = a.cache_v_;
|
||
|
|
b.v_off = a.cache_v_off + i
|
||
|
|
}
|
||
|
|
if (!q) {
|
||
|
|
s -= e
|
||
|
|
}
|
||
|
|
if (s > b.crop_bottom) {
|
||
|
|
s = b.crop_bottom
|
||
|
|
}
|
||
|
|
if (a.alpha_data_) {
|
||
|
|
if (r == 0) {
|
||
|
|
b.a = VP8DecompressAlphaRows(a, r, s - r);
|
||
|
|
b.a_off = 0
|
||
|
|
} else {
|
||
|
|
b.a_off = VP8DecompressAlphaRows(a, r, s - r)
|
||
|
|
}
|
||
|
|
if (b.a == null) {
|
||
|
|
return VP8SetError(a, VP8_STATUS_BITSTREAM_ERROR, "Could not decode alpha data.")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (r < b.crop_top) {
|
||
|
|
var t = b.crop_top - r;
|
||
|
|
r = b.crop_top;
|
||
|
|
assert(!(t & 1));
|
||
|
|
b.y_off += a.cache_y_stride_ * t;
|
||
|
|
b.u_off += a.cache_uv_stride_ * (t >> 1);
|
||
|
|
b.v_off += a.cache_uv_stride_ * (t >> 1);
|
||
|
|
if (b.a) {
|
||
|
|
b.a_off += b.width * t
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (r < s) {
|
||
|
|
b.y_off += b.crop_left;
|
||
|
|
b.u_off += b.crop_left >> 1;
|
||
|
|
b.v_off += b.crop_left >> 1;
|
||
|
|
if (b.a) {
|
||
|
|
b.a_off += b.crop_left
|
||
|
|
}
|
||
|
|
b.mb_y = r - b.crop_top;
|
||
|
|
b.mb_w = b.crop_right - b.crop_left;
|
||
|
|
b.mb_h = s - r;
|
||
|
|
c = b.put(b)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (d.id_ + 1 == a.num_caches_) {
|
||
|
|
if (!q) {
|
||
|
|
memcpy(a.cache_y_, a.cache_y_off - f, j, k + 16 * a.cache_y_stride_, f);
|
||
|
|
memcpy(a.cache_u_, a.cache_u_off - g, l, m + 8 * a.cache_uv_stride_, g);
|
||
|
|
memcpy(a.cache_v_, a.cache_v_off - g, n, o + 8 * a.cache_uv_stride_, g)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8ProcessRow(a, b) {
|
||
|
|
var c = 1;
|
||
|
|
var d = a.thread_ctx_;
|
||
|
|
if (!a.use_threads_) {
|
||
|
|
d.mb_y_ = a.mb_y_;
|
||
|
|
d.filter_row_ = a.filter_row_;
|
||
|
|
c = VP8FinishRow(a, b)
|
||
|
|
} else {
|
||
|
|
var e = a.worker_;
|
||
|
|
c &= WebPWorkerSync(e);
|
||
|
|
assert(e.status_ == OK);
|
||
|
|
if (c) {
|
||
|
|
d.io_ = b;
|
||
|
|
d.id_ = a.cache_id_;
|
||
|
|
d.mb_y_ = a.mb_y_;
|
||
|
|
d.filter_row_ = a.filter_row_;
|
||
|
|
if (d.filter_row_) {
|
||
|
|
var f = d.f_info_;
|
||
|
|
d.f_info_ = a.f_info_;
|
||
|
|
a.f_info_ = f
|
||
|
|
}
|
||
|
|
WebPWorkerLaunch(e);
|
||
|
|
if (++a.cache_id_ == a.num_caches_) {
|
||
|
|
a.cache_id_ = 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8EnterCritical(a, b) {
|
||
|
|
if (b.setup && !b.setup(b)) {
|
||
|
|
VP8SetError(a, VP8_STATUS_USER_ABORT, "Frame setup failed");
|
||
|
|
return a.status_
|
||
|
|
}
|
||
|
|
if (b.bypass_filtering) {
|
||
|
|
a.filter_type_ = 0
|
||
|
|
} {
|
||
|
|
var c = cf[a.filter_type_];
|
||
|
|
if (a.filter_type_ == 2) {
|
||
|
|
a.tl_mb_x_ = 0;
|
||
|
|
a.tl_mb_y_ = 0
|
||
|
|
} else {
|
||
|
|
a.tl_mb_y_ = b.crop_top >> 4;
|
||
|
|
a.tl_mb_x_ = b.crop_left >> 4
|
||
|
|
}
|
||
|
|
a.br_mb_y_ = (b.crop_bottom + 15 + c) >> 4;
|
||
|
|
a.br_mb_x_ = (b.crop_right + 15 + c) >> 4;
|
||
|
|
if (a.br_mb_x_ > a.mb_w_) {
|
||
|
|
a.br_mb_x_ = a.mb_w_
|
||
|
|
}
|
||
|
|
if (a.br_mb_y_ > a.mb_h_) {
|
||
|
|
a.br_mb_y_ = a.mb_h_
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return T
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8ExitCritical(a, b) {
|
||
|
|
var c = 1;
|
||
|
|
if (a.use_threads_) {
|
||
|
|
c = WebPWorkerSync(a.worker_)
|
||
|
|
}
|
||
|
|
if (b.teardown) {
|
||
|
|
b.teardown(b)
|
||
|
|
}
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
var cg = new Array(0 + 0 * bj, 4 + 0 * bj, 8 + 0 * bj, 12 + 0 * bj, 0 + 4 * bj, 4 + 4 * bj, 8 + 4 * bj, 12 + 4 * bj, 0 + 8 * bj, 4 + 8 * bj, 8 + 8 * bj, 12 + 8 * bj, 0 + 12 * bj, 4 + 12 * bj, 8 + 12 * bj, 12 + 12 * bj);
|
||
|
|
|
||
|
|
function CheckMode(a, b) {
|
||
|
|
if (b == bh) {
|
||
|
|
if (a.mb_x_ == 0) {
|
||
|
|
return (a.mb_y_ == 0) ? B_DC_PRED_NOTOPLEFT : B_DC_PRED_NOLEFT
|
||
|
|
} else {
|
||
|
|
return (a.mb_y_ == 0) ? B_DC_PRED_NOTOP : bh
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
|
||
|
|
function Copy32b(a, b, c, d) {
|
||
|
|
for (i = 0; i < 4; ++i) a[b + i] = c[d + i]
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8ReconstructBlock(a) {
|
||
|
|
var b = a.yuv_b_;
|
||
|
|
var c = bm;
|
||
|
|
var d = a.yuv_b_;
|
||
|
|
var e = bn;
|
||
|
|
var f = a.yuv_b_;
|
||
|
|
var g = bo;
|
||
|
|
if (a.mb_x_ > 0) {
|
||
|
|
var j;
|
||
|
|
for (j = -1; j < 16; ++j) {
|
||
|
|
Copy32b(b, (c + j * bj - 4), b, (c + j * bj + 12))
|
||
|
|
}
|
||
|
|
for (j = -1; j < 8; ++j) {
|
||
|
|
Copy32b(d, (e + j * bj - 4), d, (e + j * bj + 4));
|
||
|
|
Copy32b(f, (g + j * bj - 4), f, (g + j * bj + 4))
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var j;
|
||
|
|
for (j = 0; j < 16; ++j) {
|
||
|
|
b[c + j * bj - 1] = 129
|
||
|
|
}
|
||
|
|
for (j = 0; j < 8; ++j) {
|
||
|
|
d[e + j * bj - 1] = 129;
|
||
|
|
f[g + j * bj - 1] = 129
|
||
|
|
}
|
||
|
|
if (a.mb_y_ > 0) {
|
||
|
|
b[c - 1 - bj] = d[e - 1 - bj] = f[g - 1 - bj] = 129
|
||
|
|
}
|
||
|
|
} {
|
||
|
|
var h = a.y_t_;
|
||
|
|
var k = +a.mb_x_ * 16;
|
||
|
|
var l = a.u_t_;
|
||
|
|
var m = +a.mb_x_ * 8;
|
||
|
|
var o = a.v_t_;
|
||
|
|
var p = +a.mb_x_ * 8;
|
||
|
|
var q = a.coeffs_;
|
||
|
|
var n;
|
||
|
|
if (a.mb_y_ > 0) {
|
||
|
|
memcpy(b, c - bj, h, k, 16);
|
||
|
|
memcpy(d, e - bj, l, m, 8);
|
||
|
|
memcpy(f, g - bj, o, p, 8)
|
||
|
|
} else if (a.mb_x_ == 0) {
|
||
|
|
for (i = 0; i < (16 + 4 + 1); ++i) b[c - bj - 1 + i] = 127;
|
||
|
|
for (i = 0; i < (8 + 1); ++i) d[e - bj - 1 + i] = 127;
|
||
|
|
for (i = 0; i < (8 + 1); ++i) f[g - bj - 1 + i] = 127
|
||
|
|
}
|
||
|
|
if (a.is_i4x4_) {
|
||
|
|
var r = b;
|
||
|
|
var s = c - bj + 16;
|
||
|
|
if (a.mb_y_ > 0) {
|
||
|
|
if (a.mb_x_ >= a.mb_w_ - 1) {
|
||
|
|
r[s + 0] = r[s + 1] = r[s + 2] = r[s + 3] = h[k + 15]
|
||
|
|
} else {
|
||
|
|
memcpy(r, s + 0, h, k + 16, 4)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (ii = 0; ii < 4; ++ii) r[ii + s + bj * 4] = r[ii + s + 1 * bj * 4] = r[ii + s + 2 * bj * 4] = r[ii + s + 3 * bj * 4] = r[ii + s + 0 * 4];
|
||
|
|
for (n = 0; n < 16; n++) {
|
||
|
|
var t = b;
|
||
|
|
var u = c + cg[n];
|
||
|
|
bJ[a.imodes_[n]](t, u);
|
||
|
|
if (a.non_zero_ac_ & (1 << n)) {
|
||
|
|
bM(q, +n * 16, t, u, 0)
|
||
|
|
} else if (a.non_zero_ & (1 << n)) {
|
||
|
|
bO(q, +n * 16, t, u)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var v = CheckMode(a, a.imodes_[0]);
|
||
|
|
bK[v](b, c);
|
||
|
|
if (a.non_zero_) {
|
||
|
|
for (n = 0; n < 16; n++) {
|
||
|
|
var t = b;
|
||
|
|
var u = c + cg[n];
|
||
|
|
if (a.non_zero_ac_ & (1 << n)) {
|
||
|
|
bM(q, +n * 16, t, u, 0)
|
||
|
|
} else if (a.non_zero_ & (1 << n)) {
|
||
|
|
bO(q, +n * 16, t, u)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} {
|
||
|
|
var v = CheckMode(a, a.uvmode_);
|
||
|
|
bL[v](d, e);
|
||
|
|
bL[v](f, g);
|
||
|
|
if (a.non_zero_ & 0x0f0000) {
|
||
|
|
var w = a.coeffs_;
|
||
|
|
var x = 16 * 16;
|
||
|
|
if (a.non_zero_ac_ & 0x0f0000) {
|
||
|
|
bN(w, x, d, e)
|
||
|
|
} else {
|
||
|
|
bP(w, x, d, e)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (a.non_zero_ & 0xf00000) {
|
||
|
|
var y = a.coeffs_;
|
||
|
|
var x = 20 * 16;
|
||
|
|
if (a.non_zero_ac_ & 0xf00000) {
|
||
|
|
bN(y, x, f, g)
|
||
|
|
} else {
|
||
|
|
bP(y, x, f, g)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (a.mb_y_ < (a.mb_h_ - 1)) {
|
||
|
|
memcpy(h, k, b, c + 15 * bj, 16);
|
||
|
|
memcpy(l, m, d, e + 7 * bj, 8);
|
||
|
|
memcpy(o, p, f, g + 7 * bj, 8)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function clip(v, M) {
|
||
|
|
return v < 0 ? 0 : v > M ? M : v
|
||
|
|
}
|
||
|
|
var ci = new Array(4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 17, 18, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 25, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 91, 93, 95, 96, 98, 100, 101, 102, 104, 106, 108, 110, 112, 114, 116, 118, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 143, 145, 148, 151, 154, 157);
|
||
|
|
var cj = new Array(4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 119, 122, 125, 128, 131, 134, 137, 140, 143, 146, 149, 152, 155, 158, 161, 164, 167, 170, 173, 177, 181, 185, 189, 193, 197, 201, 205, 209, 213, 217, 221, 225, 229, 234, 239, 245, 249, 254, 259, 264, 269, 274, 279, 284);
|
||
|
|
|
||
|
|
function VP8ParseQuant(a) {
|
||
|
|
var b = a.br_;
|
||
|
|
var c = VP8GetValue(b, 7);
|
||
|
|
var d = VP8Get(b) ? VP8GetSignedValue(b, 4) : 0;
|
||
|
|
var e = VP8Get(b) ? VP8GetSignedValue(b, 4) : 0;
|
||
|
|
var f = VP8Get(b) ? VP8GetSignedValue(b, 4) : 0;
|
||
|
|
var g = VP8Get(b) ? VP8GetSignedValue(b, 4) : 0;
|
||
|
|
var h = VP8Get(b) ? VP8GetSignedValue(b, 4) : 0;
|
||
|
|
var j = a.segment_hdr_;
|
||
|
|
var i = int;
|
||
|
|
for (i = 0; i < NUM_MB_SEGMENTS; ++i) {
|
||
|
|
var q = int;
|
||
|
|
if (j.use_segment_) {
|
||
|
|
q = j.quantizer_[i];
|
||
|
|
if (!j.absolute_delta_) {
|
||
|
|
q += c
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (i > 0) {
|
||
|
|
a.dqm_[i] = a.dqm_[0];
|
||
|
|
continue
|
||
|
|
} else {
|
||
|
|
q = c
|
||
|
|
}
|
||
|
|
} {
|
||
|
|
var m = a.dqm_[i];
|
||
|
|
m.y1_mat_[0] = ci[clip(q + d, 127)];
|
||
|
|
m.y1_mat_[1] = cj[clip(q + 0, 127)];
|
||
|
|
m.y2_mat_[0] = ci[clip(q + e, 127)] * 2;
|
||
|
|
m.y2_mat_[1] = parseInt(cj[clip(q + f, 127)] * 155 / 100);
|
||
|
|
if (m.y2_mat_[1] < 8) m.y2_mat_[1] = 8;
|
||
|
|
m.uv_mat_[0] = ci[clip(q + g, 117)];
|
||
|
|
m.uv_mat_[1] = cj[clip(q + h, 127)]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var ck = new Array(-bh, 1, -B_TM_PRED, 2, -B_VE_PRED, 3, 4, 6, -B_HE_PRED, 5, -B_RD_PRED, -B_VR_PRED, -B_LD_PRED, 7, -B_VL_PRED, 8, -B_HD_PRED, -B_HU_PRED);
|
||
|
|
var cl = new Array(new Array(new Array(new Array(128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128), new Array(128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128), new Array(128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128)), new Array(new Array(253, 136, 254, 255, 228, 219, 128, 128, 128, 128, 128), new Array(189, 129, 242, 255, 227, 213, 255, 219, 128, 128, 128), new Array(106, 126, 227, 252, 214, 209, 255, 255, 128, 128, 128)), new Array(new Array(1, 98, 248, 255, 236, 226, 255, 255, 128, 128, 128), new Array(181, 133, 238, 254, 221, 234, 255, 154, 128, 128, 128), new Array(78, 134, 202, 247, 198, 180, 255, 219, 128, 128, 128)), new Array(new Array(1, 185, 249, 255, 243, 255, 128, 128, 128, 128, 128), new Array(184, 150, 247, 255, 236, 224, 128, 128, 128, 128, 128), new Array(77, 110, 216, 255, 236, 230, 128, 128, 128, 128, 128)), new Array(new Array(1, 101, 251, 255, 241, 255, 128, 128, 128, 128, 128), new Array(170, 139, 241, 252, 236, 209, 255, 255, 128, 128, 128), new Array(37, 116, 196, 243, 228, 255, 255, 255, 128, 128, 128)), new Array(new Array(1, 204, 254, 255, 245, 255, 128, 128, 128, 128, 128), new Array(207, 160, 250, 255, 238, 128, 128, 128, 128, 128, 128), new Array(102, 103, 231, 255, 211, 171, 128, 128, 128, 128, 128)), new Array(new Array(1, 152, 252, 255, 240, 255, 128, 128, 128, 128, 128), new Array(177, 135, 243, 255, 234, 225, 128, 128, 128, 128, 128), new Array(80, 129, 211, 255, 194, 224, 128, 128, 128, 128, 128)), new Array(new Array(1, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128), new Array(246, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128), new Array(255, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128))), new Array(new Array(new Array(198, 35, 237, 223, 193, 187, 162, 160, 145, 155, 62), new Array(131, 45, 198, 221, 172, 176, 220, 157, 252, 221, 1), new Array(68, 47, 146, 208, 149, 167, 221, 162, 255, 223, 128)), new Array(new Array(1, 149, 241, 255, 221, 224, 255, 255, 128, 128, 128), new Array(184, 141, 234, 253, 222, 220, 255, 199, 128, 128, 128), new Array(81, 99, 181, 242, 176, 190, 249, 202, 255, 255, 128)), new Array(new Array(1, 129, 232, 253, 214, 197, 242, 196, 255, 255, 128), new Array(99, 121, 210, 250, 201, 198, 255, 202, 128, 128, 128), new Array(23, 91, 163, 242, 170, 187, 247, 210, 255, 255, 128)), new Array(new Array(1, 200, 246, 255, 234, 255, 128, 128, 128, 128, 128), new Array(109, 178, 241, 255, 231, 245, 255, 255, 128, 128, 128), new Array(44, 130, 201, 253, 205, 192, 255, 255, 128, 128, 128)), new Array(new Array(1, 132, 239, 251, 219, 209, 255, 165, 128, 128, 128), new Array(94, 136, 225, 251, 218, 190, 255, 255, 128, 128, 128), new Array(22, 100, 174, 245, 186, 161, 255, 199, 128, 128, 128)), new Array(new Array(1, 182, 249, 255, 232, 235, 128, 128, 128, 128, 128), new Array(124, 143, 241, 255, 227, 234, 128, 128, 128, 128, 128), new Array(35, 77, 181, 251, 193, 211, 255, 205, 128, 128, 128)), new Array(new Array(1, 157, 247, 255, 236, 231, 255, 255, 128, 128, 128), new Array(121, 141, 235, 255, 225, 227, 255, 255, 128, 128, 128), new Array(45, 99, 188, 251, 195, 217, 255, 224, 128, 128, 128)), new Array(new Array(1, 1, 251, 255, 213, 255, 128, 128, 128, 128, 128), new Array(203, 1, 248, 255, 255, 128, 128, 128, 128, 128, 128), new Array(137, 1, 177, 255, 224, 255, 128, 128, 128, 128, 128))), new Array(new Array(new Array(253, 9, 248, 251, 207, 208, 255, 192, 128, 128, 128), new Array(175, 13, 224, 243, 193, 185, 249, 198, 255, 255, 128), new Array(73, 17, 171, 221, 161, 179, 236, 167, 255, 234, 128)), new Array(new Array(1, 95, 247, 253, 212, 183, 255, 255, 128, 128, 128), new Array(239, 90, 244, 250, 211, 209, 255, 255, 128, 128, 128), new Array(155, 77, 195, 248, 188, 195, 255, 255, 128, 128, 128)), new Array(new Array(1, 24, 239, 251, 218, 219, 255, 205, 128, 128, 128), new Array(201, 51, 219, 255, 196, 186, 128, 128, 128, 128, 128), new Array(69, 46, 190, 239, 201, 218, 255, 228, 128, 128, 128)), new Array(new Array(1, 191, 251, 255, 255, 128, 128, 128, 128, 128, 128), new Array(223, 165, 249, 255, 213, 255, 128, 128, 128, 128, 128), new A
|
||
|
|
var cm = new Array(new Array(new Array(231, 120, 48, 89, 115, 113, 120, 152, 112), new Array(152, 179, 64, 126, 170, 118, 46, 70, 95), new Array(175, 69, 143, 80, 85, 82, 72, 155, 103), new Array(56, 58, 10, 171, 218, 189, 17, 13, 152), new Array(114, 26, 17, 163, 44, 195, 21, 10, 173), new Array(121, 24, 80, 195, 26, 62, 44, 64, 85), new Array(144, 71, 10, 38, 171, 213, 144, 34, 26), new Array(170, 46, 55, 19, 136, 160, 33, 206, 71), new Array(63, 20, 8, 114, 114, 208, 12, 9, 226), new Array(81, 40, 11, 96, 182, 84, 29, 16, 36)), new Array(new Array(134, 183, 89, 137, 98, 101, 106, 165, 148), new Array(72, 187, 100, 130, 157, 111, 32, 75, 80), new Array(66, 102, 167, 99, 74, 62, 40, 234, 128), new Array(41, 53, 9, 178, 241, 141, 26, 8, 107), new Array(74, 43, 26, 146, 73, 166, 49, 23, 157), new Array(65, 38, 105, 160, 51, 52, 31, 115, 128), new Array(104, 79, 12, 27, 217, 255, 87, 17, 7), new Array(87, 68, 71, 44, 114, 51, 15, 186, 23), new Array(47, 41, 14, 110, 182, 183, 21, 17, 194), new Array(66, 45, 25, 102, 197, 189, 23, 18, 22)), new Array(new Array(88, 88, 147, 150, 42, 46, 45, 196, 205), new Array(43, 97, 183, 117, 85, 38, 35, 179, 61), new Array(39, 53, 200, 87, 26, 21, 43, 232, 171), new Array(56, 34, 51, 104, 114, 102, 29, 93, 77), new Array(39, 28, 85, 171, 58, 165, 90, 98, 64), new Array(34, 22, 116, 206, 23, 34, 43, 166, 73), new Array(107, 54, 32, 26, 51, 1, 81, 43, 31), new Array(68, 25, 106, 22, 64, 171, 36, 225, 114), new Array(34, 19, 21, 102, 132, 188, 16, 76, 124), new Array(62, 18, 78, 95, 85, 57, 50, 48, 51)), new Array(new Array(193, 101, 35, 159, 215, 111, 89, 46, 111), new Array(60, 148, 31, 172, 219, 228, 21, 18, 111), new Array(112, 113, 77, 85, 179, 255, 38, 120, 114), new Array(40, 42, 1, 196, 245, 209, 10, 25, 109), new Array(88, 43, 29, 140, 166, 213, 37, 43, 154), new Array(61, 63, 30, 155, 67, 45, 68, 1, 209), new Array(100, 80, 8, 43, 154, 1, 51, 26, 71), new Array(142, 78, 78, 16, 255, 128, 34, 197, 171), new Array(41, 40, 5, 102, 211, 183, 4, 1, 221), new Array(51, 50, 17, 168, 209, 192, 23, 25, 82)), new Array(new Array(138, 31, 36, 171, 27, 166, 38, 44, 229), new Array(67, 87, 58, 169, 82, 115, 26, 59, 179), new Array(63, 59, 90, 180, 59, 166, 93, 73, 154), new Array(40, 40, 21, 116, 143, 209, 34, 39, 175), new Array(47, 15, 16, 183, 34, 223, 49, 45, 183), new Array(46, 17, 33, 183, 6, 98, 15, 32, 183), new Array(57, 46, 22, 24, 128, 1, 54, 17, 37), new Array(65, 32, 73, 115, 28, 128, 23, 128, 205), new Array(40, 3, 9, 115, 51, 192, 18, 6, 223), new Array(87, 37, 9, 115, 59, 77, 64, 21, 47)), new Array(new Array(104, 55, 44, 218, 9, 54, 53, 130, 226), new Array(64, 90, 70, 205, 40, 41, 23, 26, 57), new Array(54, 57, 112, 184, 5, 41, 38, 166, 213), new Array(30, 34, 26, 133, 152, 116, 10, 32, 134), new Array(39, 19, 53, 221, 26, 114, 32, 73, 255), new Array(31, 9, 65, 234, 2, 15, 1, 118, 73), new Array(75, 32, 12, 51, 192, 255, 160, 43, 51), new Array(88, 31, 35, 67, 102, 85, 55, 186, 85), new Array(56, 21, 23, 111, 59, 205, 45, 37, 192), new Array(55, 38, 70, 124, 73, 102, 1, 34, 98)), new Array(new Array(125, 98, 42, 88, 104, 85, 117, 175, 82), new Array(95, 84, 53, 89, 128, 100, 113, 101, 45), new Array(75, 79, 123, 47, 51, 128, 81, 171, 1), new Array(57, 17, 5, 71, 102, 57, 53, 41, 49), new Array(38, 33, 13, 121, 57, 73, 26, 1, 85), new Array(41, 10, 67, 138, 77, 110, 90, 47, 114), new Array(115, 21, 2, 10, 102, 255, 166, 23, 6), new Array(101, 29, 16, 10, 85, 128, 101, 196, 26), new Array(57, 18, 10, 102, 102, 213, 34, 20, 43), new Array(117, 20, 15, 36, 163, 128, 68, 1, 26)), new Array(new Array(102, 61, 71, 37, 34, 53, 31, 243, 192), new Array(69, 60, 71, 38, 73, 119, 28, 222, 37), new Array(68, 45, 128, 34, 1, 47, 11, 245, 171), new Array(62, 17, 19, 70, 146, 85, 55, 62, 70), new Array(37, 43, 37, 154, 100, 163, 85, 160, 1), new Array(63, 9, 92, 136, 28, 64, 32, 201, 85), new Array(75, 15, 9, 9, 64, 255, 184, 119, 16), new Array(86, 6, 28, 5, 64, 255, 25, 248, 1), new Array(56, 8, 17, 132, 137, 255, 55, 116, 128), new Array(58, 15, 20, 82, 135, 57, 26, 121, 40)), new A
|
||
|
|
|
||
|
|
function VP8ResetProba(a) {
|
||
|
|
for (i = 0; i < a.segments_.length; ++i) a.segments_[i] = 255;
|
||
|
|
a.coeffs_ = newObjectIt(cl)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8ParseIntraMode(a, b) {
|
||
|
|
var c = b.intra_t_;
|
||
|
|
c[c.length - 1] = 0 + 4 * b.mb_x_;
|
||
|
|
var d = b.intra_l_;
|
||
|
|
b.is_i4x4_ = !VP8GetBit(a, 145);
|
||
|
|
if (!b.is_i4x4_) {
|
||
|
|
var e = VP8GetBit(a, 156) ? (VP8GetBit(a, 128) ? TM_PRED : H_PRED) : (VP8GetBit(a, 163) ? V_PRED : DC_PRED);
|
||
|
|
b.imodes_[0] = e;
|
||
|
|
for (i = 0; i < 4; ++i) c[i + c[c.length - 1]] = e;
|
||
|
|
for (i = 0; i < 4; ++i) d[i] = e
|
||
|
|
} else {
|
||
|
|
var f = b.imodes_;
|
||
|
|
var g = 0;
|
||
|
|
var y;
|
||
|
|
for (y = 0; y < 4; ++y) {
|
||
|
|
var e = d[y];
|
||
|
|
var x;
|
||
|
|
for (x = 0; x < 4; ++x) {
|
||
|
|
var h = cm[c[c[c.length - 1] + x]][e];
|
||
|
|
var i = 0;
|
||
|
|
do {
|
||
|
|
i = ck[2 * i + VP8GetBit(a, h[i])]
|
||
|
|
} while (i > 0);
|
||
|
|
e = -i;
|
||
|
|
c[c[c.length - 1] + x] = e;
|
||
|
|
f[g] = e;
|
||
|
|
g++
|
||
|
|
}
|
||
|
|
d[y] = e
|
||
|
|
}
|
||
|
|
}
|
||
|
|
b.uvmode_ = !VP8GetBit(a, 142) ? DC_PRED : !VP8GetBit(a, 114) ? V_PRED : VP8GetBit(a, 183) ? TM_PRED : H_PRED
|
||
|
|
}
|
||
|
|
var cn = new Array(new Array(new Array(new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(176, 246, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(223, 241, 252, 255, 255, 255, 255, 255, 255, 255, 255), new Array(249, 253, 253, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 244, 252, 255, 255, 255, 255, 255, 255, 255, 255), new Array(234, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 246, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(239, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(254, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 248, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(251, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(251, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(254, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 254, 253, 255, 254, 255, 255, 255, 255, 255, 255), new Array(250, 255, 254, 255, 254, 255, 255, 255, 255, 255, 255), new Array(254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255))), new Array(new Array(new Array(217, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(225, 252, 241, 253, 255, 255, 254, 255, 255, 255, 255), new Array(234, 250, 241, 250, 253, 255, 253, 254, 255, 255, 255)), new Array(new Array(255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(223, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(238, 253, 254, 254, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 248, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(249, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(247, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 254, 253, 255, 255, 255, 255, 255, 255, 255, 255), new Array(250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255))), new Array(new Array(new Array(186, 251, 250, 255, 255, 255, 255, 255, 255, 255, 255), new Array(234, 251, 244, 254, 255, 255, 255, 255, 255, 255, 255), new Array(251, 251, 243, 253, 254, 255, 254, 255, 255, 255, 255)), new Array(new Array(255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(236, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(251, 253, 253, 254, 254, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 254, 255, 255, 255, 255, 255, 255, 255, 255,
|
||
|
|
|
||
|
|
function VP8ParseProba(a, d) {
|
||
|
|
var e = d.proba_;
|
||
|
|
var t, b, c, p;
|
||
|
|
for (t = 0; t < NUM_TYPES; ++t) {
|
||
|
|
for (b = 0; b < NUM_BANDS; ++b) {
|
||
|
|
for (c = 0; c < NUM_CTX; ++c) {
|
||
|
|
for (p = 0; p < NUM_PROBAS; ++p) {
|
||
|
|
if (VP8GetBit(a, cn[t][b][c][p])) {
|
||
|
|
e.coeffs_[t][b][c][p] = VP8GetValue(a, 8)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
d.use_skip_proba_ = VP8Get(a);
|
||
|
|
if (d.use_skip_proba_) {
|
||
|
|
d.skip_p_ = VP8GetValue(a, 8)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var co = 12;
|
||
|
|
var cp = 20;
|
||
|
|
this.WebPGetDecoderVersion = function(a) {
|
||
|
|
return (be << 16) | (bf << 8) | bg
|
||
|
|
};
|
||
|
|
|
||
|
|
function SetOk(a) {
|
||
|
|
a.status_ = 'VP8_STATUS_OK';
|
||
|
|
a.error_msg_ = "OK"
|
||
|
|
}
|
||
|
|
var cq;
|
||
|
|
|
||
|
|
function VP8InitIoInternal(a, b) {
|
||
|
|
if (b != N) {
|
||
|
|
alert('mismatch error');
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (a) {}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
var cr;
|
||
|
|
|
||
|
|
function VP8New(a) {
|
||
|
|
var b = newObjectIt(bz);
|
||
|
|
if (b) {
|
||
|
|
SetOk(b);
|
||
|
|
b.ready_ = 0
|
||
|
|
}
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8Delete(a) {
|
||
|
|
if (a) {
|
||
|
|
VP8Clear(a);
|
||
|
|
a = 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8SetError(a, b, c) {
|
||
|
|
a.status_ = b;
|
||
|
|
a.error_msg_ = c;
|
||
|
|
a.ready_ = 0;
|
||
|
|
alert(b + ': ' + c);
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function get_le32(a, b) {
|
||
|
|
return a[b + 0] | (a[b + 1] << 8) | (a[b + 2] << 16) | (a[b + 3] << 24)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8CheckAndSkipHeader(a, b, c, d, e, f) {
|
||
|
|
if (!a || !c || !d || !e) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (c.value >= 8) {
|
||
|
|
if (!memcmp(a, b.value, "VP8 ", 4)) {
|
||
|
|
d.value = 1;
|
||
|
|
e.value = get_le32(a, b.value + 4);
|
||
|
|
if ((f.value >= co) && (e.value > f.value - co)) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
b.value += 8;
|
||
|
|
c.value -= 8
|
||
|
|
} else {
|
||
|
|
d.value = 0;
|
||
|
|
e.value = 0
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
d.value = -1;
|
||
|
|
e.value = 0
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8GetInfo(a, b, c, d, e, f, g) {
|
||
|
|
if (c.value < 10) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (a[b.value + 3] != 0x9d || a[b.value + 4] != 0x01 || a[b.value + 5] != 0x2a) {
|
||
|
|
return 0
|
||
|
|
} else {
|
||
|
|
var i = a[b.value + 0] | (a[b.value + 1] << 8) | (a[b.value + 2] << 16);
|
||
|
|
var j = !(i & 1) + 0;
|
||
|
|
var w = ((a[b.value + 7] << 8) | a[b.value + 6]) & 0x3fff;
|
||
|
|
var h = ((a[b.value + 9] << 8) | a[b.value + 8]) & 0x3fff;
|
||
|
|
if (g) {
|
||
|
|
if (c.value < 11) return 0;
|
||
|
|
g.value = !!(a[b.value + 10] & 0x80)
|
||
|
|
}
|
||
|
|
if (!j) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (((i >> 1) & 7) > 3) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (!((i >> 4) & 1)) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (((i >> 5)) >= d) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (e) {
|
||
|
|
e.value = w
|
||
|
|
}
|
||
|
|
if (f) {
|
||
|
|
f.value = h
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8XGetInfo(a, b, c, d, e, f, g) {
|
||
|
|
if (!a || !c || !d) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (c.value >= cp) {
|
||
|
|
if (!memcmp(a, b.value, "VP8X", 4)) {
|
||
|
|
var h = get_le32(a, b.value + 4);
|
||
|
|
d.value = 1;
|
||
|
|
if (h.value != (cp - 8)) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (g) {
|
||
|
|
g.value = get_le32(a, b.value + 8)
|
||
|
|
}
|
||
|
|
if (e) {
|
||
|
|
e.value = get_le32(a, b.value + 12)
|
||
|
|
}
|
||
|
|
if (f) {
|
||
|
|
f.value = get_le32(a, b.value + 16)
|
||
|
|
}
|
||
|
|
b.value += cp;
|
||
|
|
c.value -= cp
|
||
|
|
} else {
|
||
|
|
d.value = 0
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
d.value = -1
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function ResetSegmentHeader(a) {
|
||
|
|
assert(a);
|
||
|
|
a.use_segment_ = 0;
|
||
|
|
a.update_map_ = 0;
|
||
|
|
a.absolute_delta_ = 1;
|
||
|
|
for (i = 0; i < a.quantizer_.length; ++i) a.quantizer_[i] = 0;
|
||
|
|
for (i = 0; i < a.filter_strength_.length; ++i) a.filter_strength_[i] = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function ParseSegmentHeader(a, b, c) {
|
||
|
|
assert(a);
|
||
|
|
assert(b);
|
||
|
|
b.use_segment_ = VP8Get(a);
|
||
|
|
if (b.use_segment_) {
|
||
|
|
b.update_map_ = VP8Get(a);
|
||
|
|
if (VP8Get(a)) {
|
||
|
|
var s;
|
||
|
|
b.absolute_delta_ = VP8Get(a);
|
||
|
|
for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
|
||
|
|
b.quantizer_[s] = VP8Get(a) ? VP8GetSignedValue(a, 7) : 0
|
||
|
|
}
|
||
|
|
for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
|
||
|
|
b.filter_strength_[s] = VP8Get(a) ? VP8GetSignedValue(a, 6) : 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (b.update_map_) {
|
||
|
|
var s;
|
||
|
|
for (s = 0; s < bi; ++s) {
|
||
|
|
c.segments_[s] = VP8Get(a) ? VP8GetValue(a, 8) : 255
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
b.update_map_ = 0
|
||
|
|
}
|
||
|
|
return !a.eof_
|
||
|
|
}
|
||
|
|
|
||
|
|
function ParsePartitions(a, b, c, d) {
|
||
|
|
var e = a.br_;
|
||
|
|
var f = b;
|
||
|
|
var g = c;
|
||
|
|
var h = b,
|
||
|
|
buf_end_off = c + d;
|
||
|
|
var i;
|
||
|
|
var j = 0;
|
||
|
|
var k = int;
|
||
|
|
var p = int;
|
||
|
|
a.num_parts_ = 1 << VP8GetValue(e, 2);
|
||
|
|
k = a.num_parts_ - 1;
|
||
|
|
i = b;
|
||
|
|
var j = c + k * 3;
|
||
|
|
if (buf_end_off < j) {
|
||
|
|
return 'VP8_STATUS_NOT_ENOUGH_DATA'
|
||
|
|
}
|
||
|
|
for (p = 0; p < k; ++p) {
|
||
|
|
var l = f[g + 0] | (f[g + 1] << 8) | (f[g + 2] << 16);
|
||
|
|
var m = i;
|
||
|
|
var n = j + l;
|
||
|
|
if (n > buf_end_off) m = h;
|
||
|
|
VP8InitBitReader(a.parts_[+p], i, j, n);
|
||
|
|
i = m;
|
||
|
|
j = n;
|
||
|
|
g += 3
|
||
|
|
}
|
||
|
|
VP8InitBitReader(a.parts_[+k], i, j, buf_end_off);
|
||
|
|
return (j < buf_end_off) ? 'VP8_STATUS_OK' : 'VP8_STATUS_SUSPENDED'
|
||
|
|
}
|
||
|
|
|
||
|
|
function ParseFilterHeader(a, b) {
|
||
|
|
var c = b.filter_hdr_;
|
||
|
|
c.simple_ = VP8Get(a);
|
||
|
|
c.level_ = VP8GetValue(a, 6);
|
||
|
|
c.sharpness_ = VP8GetValue(a, 3);
|
||
|
|
c.use_lf_delta_ = VP8Get(a);
|
||
|
|
if (c.use_lf_delta_) {
|
||
|
|
if (VP8Get(a)) {
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < NUM_REF_LF_DELTAS; ++i) {
|
||
|
|
if (VP8Get(a)) {
|
||
|
|
c.ref_lf_delta_[i] = VP8GetSignedValue(a, 6)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (i = 0; i < NUM_MODE_LF_DELTAS; ++i) {
|
||
|
|
if (VP8Get(a)) {
|
||
|
|
c.mode_lf_delta_[i] = VP8GetSignedValue(a, 6)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
b.filter_type_ = (c.level_ == 0) ? 0 : c.simple_ ? 1 : 2;
|
||
|
|
if (b.filter_type_ > 0) {
|
||
|
|
if (b.segment_hdr_.use_segment_) {
|
||
|
|
var s;
|
||
|
|
for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
|
||
|
|
var d = b.segment_hdr_.filter_strength_[s];
|
||
|
|
if (!b.segment_hdr_.absolute_delta_) {
|
||
|
|
d += c.level_
|
||
|
|
}
|
||
|
|
b.filter_levels_[s] = d
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
b.filter_levels_[0] = c.level_
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return !a.eof_
|
||
|
|
}
|
||
|
|
var cs, buf, buf_size;
|
||
|
|
var ct;
|
||
|
|
|
||
|
|
function VP8GetHeaders(a, b) {
|
||
|
|
var c = {
|
||
|
|
value: 0
|
||
|
|
};
|
||
|
|
var d = uint8_t;
|
||
|
|
var e = {
|
||
|
|
value: uint32_t
|
||
|
|
};
|
||
|
|
var f = {
|
||
|
|
value: uint32_t
|
||
|
|
};
|
||
|
|
var g = {
|
||
|
|
value: uint32_t
|
||
|
|
};
|
||
|
|
var h = {
|
||
|
|
value: 0
|
||
|
|
};
|
||
|
|
var i = {
|
||
|
|
value: 0
|
||
|
|
};
|
||
|
|
var j = newObjectIt(bp);
|
||
|
|
var k = newObjectIt(bq);
|
||
|
|
var l = newObjectIt(bb);
|
||
|
|
var m = 'VP8StatusCode';
|
||
|
|
if (a == null) {
|
||
|
|
alert('(dec == null)');
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
SetOk(a);
|
||
|
|
if (b == null) {
|
||
|
|
return VP8SetError(a, 'VP8_STATUS_INVALID_PARAM', "null VP8Io passed to VP8GetHeaders()")
|
||
|
|
}
|
||
|
|
d = b.data;
|
||
|
|
c.value = b.data_off;
|
||
|
|
e.value = b.data_size;
|
||
|
|
if (d == null || e.value <= 4) {
|
||
|
|
return VP8SetError(a, 'VP8_STATUS_NOT_ENOUGH_DATA', "Not enough data to parse frame header")
|
||
|
|
}
|
||
|
|
if (!WebPCheckAndSkipRIFFHeader(d, c, e, f)) {
|
||
|
|
return VP8SetError(a, VP8_STATUS_BITSTREAM_ERROR, "RIFF: Invalid RIFF container")
|
||
|
|
}
|
||
|
|
if (!VP8XGetInfo(d, c, e, h, null, null, null)) {
|
||
|
|
return VP8SetError(a, VP8_STATUS_BITSTREAM_ERROR, "RIFF: Invalid VP8X container")
|
||
|
|
}
|
||
|
|
if (!VP8CheckAndSkipHeader(d, c, e, i, g, f)) {
|
||
|
|
return VP8SetError(a, VP8_STATUS_BITSTREAM_ERROR, "RIFF: Inconsistent size information.")
|
||
|
|
}
|
||
|
|
if (i.value == -1) {
|
||
|
|
return VP8SetError(a, 'VP8_STATUS_BITSTREAM_ERROR', "RIFF: Inconsistent size information.")
|
||
|
|
}
|
||
|
|
if (e.value < 4) {
|
||
|
|
return VP8SetError(a, VP8_STATUS_NOT_ENOUGH_DATA, "RIFF: Truncated header.")
|
||
|
|
}
|
||
|
|
c = c.value;
|
||
|
|
e = e.value; {
|
||
|
|
var n = d[c + 0] | (d[c + 1] << 8) | (d[c + 2] << 16);
|
||
|
|
j = a.frm_hdr_;
|
||
|
|
j.key_frame_ = !(n & 1) + 0;
|
||
|
|
j.profile_ = (n >> 1) & 7;
|
||
|
|
j.show_ = (n >> 4) & 1;
|
||
|
|
j.partition_length_ = (n >> 5);
|
||
|
|
if (j.profile_ > 3) return VP8SetError(a, 'VP8_STATUS_BITSTREAM_ERROR', "Incorrect keyframe parameters.");
|
||
|
|
if (!j.show_) return VP8SetError(a, 'VP8_STATUS_UNSUPPORTED_FEATURE', "Frame not displayable.");
|
||
|
|
c += 3;
|
||
|
|
e -= 3
|
||
|
|
}
|
||
|
|
k = a.pic_hdr_;
|
||
|
|
if (j.key_frame_) {
|
||
|
|
if (e < 7) {
|
||
|
|
return VP8SetError(a, 'VP8_STATUS_NOT_ENOUGH_DATA', "cannot parse picture header")
|
||
|
|
}
|
||
|
|
if (Byte2Hex(d[c + 0]) != 0x9d || Byte2Hex(d[c + 1]) != 0x01 || Byte2Hex(d[c + 2]) != 0x2a) {
|
||
|
|
return VP8SetError(a, 'VP8_STATUS_BITSTREAM_ERROR', "Bad code word")
|
||
|
|
}
|
||
|
|
k.width_ = ((d[c + 4] << 8) | d[c + 3]) & 0x3fff;
|
||
|
|
k.xscale_ = d[c + 4] >> 6;
|
||
|
|
k.height_ = ((d[c + 6] << 8) | d[c + 5]) & 0x3fff;
|
||
|
|
k.yscale_ = d[c + 6] >> 6;
|
||
|
|
c += 7;
|
||
|
|
e -= 7;
|
||
|
|
a.mb_w_ = (k.width_ + 15) >> 4;
|
||
|
|
a.mb_h_ = (k.height_ + 15) >> 4;
|
||
|
|
b.width = k.width_;
|
||
|
|
b.height = k.height_;
|
||
|
|
b.use_scaling = 0;
|
||
|
|
b.use_cropping = 0;
|
||
|
|
b.crop_top = 0;
|
||
|
|
b.crop_left = 0;
|
||
|
|
b.crop_right = b.width;
|
||
|
|
b.crop_bottom = b.height;
|
||
|
|
b.mb_w = b.width;
|
||
|
|
b.mb_h = b.height;
|
||
|
|
VP8ResetProba(a.proba_);
|
||
|
|
ResetSegmentHeader(a.segment_hdr_);
|
||
|
|
a.segment_ = 0
|
||
|
|
}
|
||
|
|
if (j.partition_length_ > e) {
|
||
|
|
return VP8SetError(a, 'VP8_STATUS_NOT_ENOUGH_DATA', "bad partition length")
|
||
|
|
}
|
||
|
|
a.alpha_data_ = null;
|
||
|
|
a.alpha_data_size_ = 0;
|
||
|
|
var l = a.br_;
|
||
|
|
VP8InitBitReader(l, d, c, c + j.partition_length_);
|
||
|
|
c += j.partition_length_;
|
||
|
|
e -= j.partition_length_;
|
||
|
|
if (j.key_frame_) {
|
||
|
|
k.colorspace_ = VP8Get(l);
|
||
|
|
k.clamp_type_ = VP8Get(l)
|
||
|
|
}
|
||
|
|
if (!ParseSegmentHeader(l, a.segment_hdr_, a.proba_)) {
|
||
|
|
return VP8SetError(a, 'VP8_STATUS_BITSTREAM_ERROR', "cannot parse segment header")
|
||
|
|
}
|
||
|
|
if (!ParseFilterHeader(l, a)) {
|
||
|
|
return VP8SetError(a, 'VP8_STATUS_BITSTREAM_ERROR', "cannot parse filter header")
|
||
|
|
}
|
||
|
|
m = ParsePartitions(a, d, c, e);
|
||
|
|
if (m != 'VP8_STATUS_OK') {
|
||
|
|
return VP8SetError(a, 'VP8_STATUS_BITSTREAM_ERROR', "cannot parse partitions")
|
||
|
|
}
|
||
|
|
VP8ParseQuant(a);
|
||
|
|
if (!j.key_frame_) {
|
||
|
|
return VP8SetError(a, VP8_STATUS_UNSUPPORTED_FEATURE, "Not a key frame.")
|
||
|
|
} else {
|
||
|
|
a.buffer_flags_ = 0x003 | 0x100
|
||
|
|
}
|
||
|
|
VP8Get(l);
|
||
|
|
VP8ParseProba(l, a);
|
||
|
|
if (a.pic_hdr_.colorspace_) {
|
||
|
|
var o = 8;
|
||
|
|
var p = 0x01;
|
||
|
|
var q = d;
|
||
|
|
ext_buf_off = c - o;
|
||
|
|
var r = size_t;
|
||
|
|
if (j.partition_length_ < o || q[ext_buf_off + o - 1] != p) {}
|
||
|
|
r = (q[ext_buf_off + 4] << 0) | (q[ext_buf_off + 5] << 8) | (q[ext_buf_off + 6] << 16);
|
||
|
|
if (j.partition_length_ < r + o) {
|
||
|
|
return VP8SetError(a, VP8_STATUS_BITSTREAM_ERROR, "RIFF: Inconsistent extra information.")
|
||
|
|
}
|
||
|
|
a.alpha_data_ = (r > 0) ? q : null;
|
||
|
|
a.alpha_data_off = (r > 0) ? ext_buf_off - r : null;
|
||
|
|
a.alpha_data_size_ = r;
|
||
|
|
r = (q[ext_buf_off + 0] << 0) | (q[ext_buf_off + 1] << 8) | (q[ext_buf_off + 2] << 16);
|
||
|
|
a.layer_data_size_ = r;
|
||
|
|
a.layer_data_ = null;
|
||
|
|
a.layer_colorspace_ = q[ext_buf_off + 3]
|
||
|
|
}
|
||
|
|
a.ready_ = 1;
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
var cu = new Array(0, 1, 2, 3, 6, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 0);
|
||
|
|
var cv = new Array(173, 148, 140, 0);
|
||
|
|
var cw = new Array(176, 155, 140, 135, 0);
|
||
|
|
var cx = new Array(180, 157, 141, 134, 130, 0);
|
||
|
|
var cy = new Array(254, 254, 243, 230, 196, 177, 153, 140, 133, 130, 129, 0);
|
||
|
|
var cz = new Array(cv, cw, cx, cy);
|
||
|
|
var cA = new Array(0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15);
|
||
|
|
var cB = ArrM(new Array(NUM_CTX, NUM_PROBAS), '');
|
||
|
|
|
||
|
|
function GetCoeffs(a, b, c, d, n, e) {
|
||
|
|
var p = b[cu[n]][c];
|
||
|
|
if (!VP8GetBit(a, p[0])) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
while (1) {
|
||
|
|
++n;
|
||
|
|
if (!VP8GetBit(a, p[1])) {
|
||
|
|
p = b[cu[n]][0]
|
||
|
|
} else {
|
||
|
|
var v, j;
|
||
|
|
if (!VP8GetBit(a, p[2])) {
|
||
|
|
p = b[cu[n]][1];
|
||
|
|
v = 1
|
||
|
|
} else {
|
||
|
|
if (!VP8GetBit(a, p[3])) {
|
||
|
|
if (!VP8GetBit(a, p[4])) {
|
||
|
|
v = 2
|
||
|
|
} else {
|
||
|
|
v = 3 + VP8GetBit(a, p[5])
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (!VP8GetBit(a, p[6])) {
|
||
|
|
if (!VP8GetBit(a, p[7])) {
|
||
|
|
v = 5 + VP8GetBit(a, 159)
|
||
|
|
} else {
|
||
|
|
v = 7 + 2 * VP8GetBit(a, 165);
|
||
|
|
v += VP8GetBit(a, 145)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var f = uint8_t;
|
||
|
|
var g = VP8GetBit(a, p[8]);
|
||
|
|
var h = VP8GetBit(a, p[9 + g]);
|
||
|
|
var k = 2 * g + h;
|
||
|
|
v = 0;
|
||
|
|
f = cz[k];
|
||
|
|
var l;
|
||
|
|
for (i = 0; i < (f.length - 1); ++i) {
|
||
|
|
v += v + VP8GetBit(a, f[i])
|
||
|
|
}
|
||
|
|
v += 3 + (8 << k)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
p = b[cu[n]][2]
|
||
|
|
}
|
||
|
|
j = cA[n - 1];
|
||
|
|
e[e[e.length - 1] + j] = VP8GetSigned(a, v) * d[((j > 0) + 0)];
|
||
|
|
if (n == 16 || !VP8GetBit(a, p[0])) {
|
||
|
|
return n
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (n == 16) {
|
||
|
|
return 16
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var cC = {
|
||
|
|
i8: Arr(4, uint8_t),
|
||
|
|
i32: uint32_t
|
||
|
|
};
|
||
|
|
var cD = new Array(new Array(0, 0, 0, 0), new Array(1, 0, 0, 0), new Array(0, 1, 0, 0), new Array(1, 1, 0, 0), new Array(0, 0, 1, 0), new Array(1, 0, 1, 0), new Array(0, 1, 1, 0), new Array(1, 1, 1, 0), new Array(0, 0, 0, 1), new Array(1, 0, 0, 1), new Array(0, 1, 0, 1), new Array(1, 1, 0, 1), new Array(0, 0, 1, 1), new Array(1, 0, 1, 1), new Array(0, 1, 1, 1), new Array(1, 1, 1, 1));
|
||
|
|
var cE = 0x08040201;
|
||
|
|
|
||
|
|
function PACK(X, S) {
|
||
|
|
return ((((X[0] * 0x1000000 + X[1] * 0x10000 + X[2] * 0x100 + X[3] * 0x1) * cE) & 0xff000000) >> (S))
|
||
|
|
}
|
||
|
|
|
||
|
|
function ParseResiduals(a, b, c) {
|
||
|
|
var d, out_l_nz, first;
|
||
|
|
var e = cB;
|
||
|
|
var q = a.dqm_[a.segment_];
|
||
|
|
var f = a.coeffs_;
|
||
|
|
var g = a.mb_info_[1 - 1];
|
||
|
|
var h = Arr(4, 0),
|
||
|
|
nz_dc = Arr(4, 0);
|
||
|
|
var i = Arr(4, 0),
|
||
|
|
lnz = Arr(4, 0);
|
||
|
|
var j = 0;
|
||
|
|
var k = 0;
|
||
|
|
var x, y, ch;
|
||
|
|
f = memset(0, 384 * sizeof(f));
|
||
|
|
if (!a.is_i4x4_) {
|
||
|
|
var m = Arr(16, 0);
|
||
|
|
var n = b.dc_nz_ + g.dc_nz_;
|
||
|
|
b.dc_nz_ = g.dc_nz_ = (GetCoeffs(c, a.proba_.coeffs_[1], n, q.y2_mat_, 0, m) > 0) + 0;
|
||
|
|
first = 1;
|
||
|
|
e = a.proba_.coeffs_[0];
|
||
|
|
VP8TransformWHT(m, f);
|
||
|
|
f[f.length - 1] = 0
|
||
|
|
} else {
|
||
|
|
first = 0;
|
||
|
|
e = a.proba_.coeffs_[3]
|
||
|
|
}
|
||
|
|
i = ArrCopy(cD[b.nz_ & 0xf]);
|
||
|
|
lnz = ArrCopy(cD[g.nz_ & 0xf]);
|
||
|
|
for (y = 0; y < 4; ++y) {
|
||
|
|
var l = lnz[y];
|
||
|
|
for (x = 0; x < 4; ++x) {
|
||
|
|
var n = l + i[x];
|
||
|
|
var o = GetCoeffs(c, e, n, q.y1_mat_, first, f);
|
||
|
|
i[x] = l = (o > 0) + 0;
|
||
|
|
nz_dc[x] = ((f[f[f.length - 1] + 0] != 0) + 0);
|
||
|
|
h[x] = (o > 1) + 0;
|
||
|
|
f[f.length - 1] += 16
|
||
|
|
}
|
||
|
|
lnz[y] = l;
|
||
|
|
k |= PACK(nz_dc, 24 - y * 4);
|
||
|
|
j |= PACK(h, 24 - y * 4)
|
||
|
|
}
|
||
|
|
d = PACK(i, 24);
|
||
|
|
out_l_nz = PACK(lnz, 24);
|
||
|
|
i = ArrCopy(cD[b.nz_ >> 4]);
|
||
|
|
lnz = ArrCopy(cD[g.nz_ >> 4]);
|
||
|
|
for (ch = 0; ch < 4; ch += 2) {
|
||
|
|
for (y = 0; y < 2; ++y) {
|
||
|
|
var l = lnz[ch + y];
|
||
|
|
for (x = 0; x < 2; ++x) {
|
||
|
|
var n = l + i[ch + x];
|
||
|
|
var o = GetCoeffs(c, a.proba_.coeffs_[2], n, q.uv_mat_, 0, f);
|
||
|
|
i[ch + x] = l = (o > 0) + 0;
|
||
|
|
nz_dc[y * 2 + x] = ((f[f[f.length - 1] + 0] != 0) + 0);
|
||
|
|
h[y * 2 + x] = (o > 1) + 0;
|
||
|
|
f[f.length - 1] += 16
|
||
|
|
}
|
||
|
|
lnz[ch + y] = l
|
||
|
|
}
|
||
|
|
k |= PACK(nz_dc, 8 - ch * 2);
|
||
|
|
j |= PACK(h, 8 - ch * 2)
|
||
|
|
}
|
||
|
|
d |= PACK(i, 20);
|
||
|
|
out_l_nz |= PACK(lnz, 20);
|
||
|
|
b.nz_ = d;
|
||
|
|
g.nz_ = out_l_nz;
|
||
|
|
a.coeffs_ = f;
|
||
|
|
a.non_zero_ac_ = j + 0;
|
||
|
|
a.non_zero_ = j | k;
|
||
|
|
b.skip_ = (!a.non_zero_) + 0
|
||
|
|
}
|
||
|
|
var cF;
|
||
|
|
|
||
|
|
function VP8DecodeMB(a, b) {
|
||
|
|
var c = a.br_;
|
||
|
|
var d = a.mb_info_[1 - 1];
|
||
|
|
var e = a.mb_info_[1 + a.mb_x_];
|
||
|
|
if (a.segment_hdr_.update_map_) {
|
||
|
|
a.segment_ = !VP8GetBit(c, a.proba_.segments_[0]) ? 0 + VP8GetBit(c, a.proba_.segments_[1]) : 2 + VP8GetBit(c, a.proba_.segments_[2])
|
||
|
|
}
|
||
|
|
e.skip_ = a.use_skip_proba_ ? VP8GetBit(c, a.skip_p_) : 0;
|
||
|
|
VP8ParseIntraMode(c, a);
|
||
|
|
if (c.eof_) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (!e.skip_) {
|
||
|
|
ParseResiduals(a, e, b)
|
||
|
|
} else {
|
||
|
|
d.nz_ = e.nz_ = 0;
|
||
|
|
if (!a.is_i4x4_) {
|
||
|
|
d.dc_nz_ = e.dc_nz_ = 0
|
||
|
|
}
|
||
|
|
a.non_zero_ = 0;
|
||
|
|
a.non_zero_ac_ = 0
|
||
|
|
}
|
||
|
|
return (!b.eof_)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8InitScanline(a) {
|
||
|
|
var b = a.mb_info_[1 - 1];
|
||
|
|
b.nz_ = 0;
|
||
|
|
b.dc_nz_ = 0;
|
||
|
|
memset_(a.intra_l_, 0, bh, a.intra_l_.length);
|
||
|
|
a.filter_row_ = ((a.filter_type_ > 0) && (a.mb_y_ >= a.tl_mb_y_) && (a.mb_y_ <= a.br_mb_y_)) + 0
|
||
|
|
}
|
||
|
|
var cG;
|
||
|
|
|
||
|
|
function ParseFrame(a, b) {
|
||
|
|
for (a.mb_y_ = 0; a.mb_y_ < a.br_mb_y_; ++a.mb_y_) {
|
||
|
|
cG = a.parts_[a.mb_y_ & (a.num_parts_ - 1)];
|
||
|
|
VP8InitScanline(a);
|
||
|
|
for (a.mb_x_ = 0; a.mb_x_ < a.mb_w_; a.mb_x_++) {
|
||
|
|
if (!VP8DecodeMB(a, cG)) {
|
||
|
|
return VP8SetError(a, 'VP8_STATUS_NOT_ENOUGH_DATA', "Premature end-of-file encountered." + a.mb_x_ + ' ' + a.mb_y_)
|
||
|
|
}
|
||
|
|
VP8ReconstructBlock(a);
|
||
|
|
VP8StoreBlock(a)
|
||
|
|
}
|
||
|
|
if (!VP8ProcessRow(a, b)) {
|
||
|
|
return VP8SetError(a, 'VP8_STATUS_USER_ABORT', "Output aborted.")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (a.use_threads_ && !WebPWorkerSync(a.worker_)) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (a.layer_data_size_ > 0) {
|
||
|
|
if (!VP8DecodeLayer(a)) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8Decode(a, b) {
|
||
|
|
var c = 0;
|
||
|
|
if (a == null) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (b == null) {
|
||
|
|
return VP8SetError(a, 'VP8_STATUS_INVALID_PARAM', "NULL VP8Io parameter in VP8Decode().")
|
||
|
|
}
|
||
|
|
if (!a.ready_) {
|
||
|
|
if (!VP8GetHeaders(a, b)) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
assert(a.ready_);
|
||
|
|
c = (VP8EnterCritical(a, b) == T);
|
||
|
|
if (c) {
|
||
|
|
if (c) c = VP8InitFrame(a, b);
|
||
|
|
if (c) c = ParseFrame(a, b);
|
||
|
|
c &= VP8ExitCritical(a, b)
|
||
|
|
}
|
||
|
|
if (!c) {
|
||
|
|
VP8Clear(a);
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
a.ready_ = 0;
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8Clear(a) {
|
||
|
|
if (a == null) {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if (a.use_threads_) {
|
||
|
|
WebPWorkerEnd(a.worker_)
|
||
|
|
}
|
||
|
|
if (a.mem_) {
|
||
|
|
a.mem_ = 0
|
||
|
|
}
|
||
|
|
a.mem_ = null;
|
||
|
|
a.mem_size_ = 0;
|
||
|
|
a.ready_ = 0
|
||
|
|
}
|
||
|
|
var cH = 16,
|
||
|
|
YUV_RANGE_MIN = -227,
|
||
|
|
YUV_RANGE_MAX = 256 + 226;
|
||
|
|
|
||
|
|
function VP8YuvToRgb(y, u, v, a, b) {
|
||
|
|
var c = cJ[v];
|
||
|
|
var d = (cK[v] + VP8kUToG[u]) >> cH;
|
||
|
|
var e = VP8kUToB[u];
|
||
|
|
a[b + 0] = cL[y + c - YUV_RANGE_MIN];
|
||
|
|
a[b + 1] = cL[y + d - YUV_RANGE_MIN];
|
||
|
|
a[b + 2] = cL[y + e - YUV_RANGE_MIN]
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8YuvToRgb565(y, u, v, a, b) {
|
||
|
|
var c = cJ[v];
|
||
|
|
var d = (cK[v] + VP8kUToG[u]) >> cH;
|
||
|
|
var e = VP8kUToB[u];
|
||
|
|
a[b + 0] = ((cL[y + c - YUV_RANGE_MIN] & 0xf8) | (cL[y + d - YUV_RANGE_MIN] >> 5));
|
||
|
|
a[b + 1] = (((cL[y + d - YUV_RANGE_MIN] << 3) & 0xe0) | (cL[y + e - YUV_RANGE_MIN] >> 3))
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8YuvToArgbKeepA(y, u, v, a, b) {
|
||
|
|
VP8YuvToRgb(y, u, v, a, b + 1)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8YuvToArgb(y, u, v, a, b) {
|
||
|
|
a[b + 0] = 0xff;
|
||
|
|
VP8YuvToArgbKeepA(y, u, v, a, b)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8YuvToRgba4444KeepA(y, u, v, a, b) {
|
||
|
|
var c = cJ[v];
|
||
|
|
var d = (cK[v] + VP8kUToG[u]) >> cH;
|
||
|
|
var e = VP8kUToB[u];
|
||
|
|
a[b + 0] = ((cM[y + c - YUV_RANGE_MIN] << 4) | cM[y + d - YUV_RANGE_MIN]);
|
||
|
|
a[b + 1] = ((a[b + 1] << 44) | (cM[y + e - YUV_RANGE_MIN] << 4))
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8YuvToRgba4444(y, u, v, a, b) {
|
||
|
|
a[b + 1] = 0x0f;
|
||
|
|
VP8YuvToRgba4444KeepA(y, u, v, a, b)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8YuvToBgr(y, u, v, a, b) {
|
||
|
|
var c = cJ[v];
|
||
|
|
var d = (cK[v] + VP8kUToG[u]) >> cH;
|
||
|
|
var e = VP8kUToB[u];
|
||
|
|
a[b + 0] = cL[y + e - YUV_RANGE_MIN];
|
||
|
|
a[b + 1] = cL[y + d - YUV_RANGE_MIN];
|
||
|
|
a[b + 2] = cL[y + c - YUV_RANGE_MIN]
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8YuvToBgra(y, u, v, a, b) {
|
||
|
|
VP8YuvToBgr(y, u, v, a, b);
|
||
|
|
a[b + 3] = 0xff
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8YuvToRgba(y, u, v, a, b) {
|
||
|
|
VP8YuvToRgb(y, u, v, a, b);
|
||
|
|
a[b + 3] = 0xff
|
||
|
|
}
|
||
|
|
var cI = (1 << (cH - 1));
|
||
|
|
var cJ = Arr(256, int16_t),
|
||
|
|
VP8kUToB = Arr(256, int16_t);
|
||
|
|
var cK = Arr(256, int32_t),
|
||
|
|
VP8kUToG = Arr(256, int32_t);
|
||
|
|
var cL = Arr(YUV_RANGE_MAX - YUV_RANGE_MIN, uint8_t);
|
||
|
|
var cM = Arr(YUV_RANGE_MAX - YUV_RANGE_MIN, uint8_t);
|
||
|
|
var cN = 0;
|
||
|
|
|
||
|
|
function clip(v, a) {
|
||
|
|
return v < 0 ? 0 : v > a ? a : v
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8YUVInit(a) {
|
||
|
|
var i;
|
||
|
|
if (cN) {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for (i = 0; i < 256; ++i) {
|
||
|
|
cJ[i] = (89858 * (i - 128) + cI) >> cH;
|
||
|
|
VP8kUToG[i] = -22014 * (i - 128) + cI;
|
||
|
|
cK[i] = -45773 * (i - 128);
|
||
|
|
VP8kUToB[i] = (113618 * (i - 128) + cI) >> cH
|
||
|
|
}
|
||
|
|
for (i = YUV_RANGE_MIN; i < YUV_RANGE_MAX; ++i) {
|
||
|
|
var k = ((i - 16) * 76283 + cI) >> cH;
|
||
|
|
cL[i - YUV_RANGE_MIN] = clip(k, 255);
|
||
|
|
cM[i - YUV_RANGE_MIN] = clip((k + 8) >> 4, 15)
|
||
|
|
}
|
||
|
|
cN = 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function LOAD_UV(u, v) {
|
||
|
|
return ((u) | ((v) << 16))
|
||
|
|
}
|
||
|
|
|
||
|
|
function FUNC_NAME(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) {
|
||
|
|
var x;
|
||
|
|
var t = (q - 1) >> 1;
|
||
|
|
var u = LOAD_UV(e[f + 0], g[h + 0]);
|
||
|
|
var v = LOAD_UV(i[j + 0], k[l + 0]);
|
||
|
|
if (a) {
|
||
|
|
var w = (3 * u + v + 0x00020002) >> 2;
|
||
|
|
r(a[b + 0], w & 0xff, (w >> 16), m, n)
|
||
|
|
}
|
||
|
|
if (c) {
|
||
|
|
var w = (3 * v + u + 0x00020002) >> 2;
|
||
|
|
r(c[d + 0], w & 0xff, (w >> 16), o, p)
|
||
|
|
}
|
||
|
|
for (x = 1; x <= t; ++x) {
|
||
|
|
var y = LOAD_UV(e[f + x], g[h + x]);
|
||
|
|
var z = LOAD_UV(i[j + x], k[l + x]);
|
||
|
|
var A = u + y + v + z + 0x00080008;
|
||
|
|
var B = (A + 2 * (y + v)) >> 3;
|
||
|
|
var C = (A + 2 * (u + z)) >> 3;
|
||
|
|
if (a) {
|
||
|
|
var w = (B + u) >> 1;
|
||
|
|
var D = (C + y) >> 1;
|
||
|
|
r(a[b + 2 * x - 1], w & 0xff, (w >> 16), m, n + (2 * x - 1) * s);
|
||
|
|
r(a[b + 2 * x - 0], D & 0xff, (D >> 16), m, n + (2 * x - 0) * s)
|
||
|
|
}
|
||
|
|
if (c) {
|
||
|
|
var w = (C + v) >> 1;
|
||
|
|
var D = (B + z) >> 1;
|
||
|
|
r(c[d + 2 * x - 1], w & 0xff, (w >> 16), o, p + (2 * x - 1) * s);
|
||
|
|
r(c[d + 2 * x + 0], D & 0xff, (D >> 16), o, p + (2 * x + 0) * s)
|
||
|
|
}
|
||
|
|
u = y;
|
||
|
|
v = z
|
||
|
|
}
|
||
|
|
if (!(q & 1)) {
|
||
|
|
if (a) {
|
||
|
|
var w = (3 * u + v + 0x00020002) >> 2;
|
||
|
|
r(a[b + q - 1], w & 0xff, (w >> 16), m, n + (q - 1) * s)
|
||
|
|
}
|
||
|
|
if (c) {
|
||
|
|
var w = (3 * v + u + 0x00020002) >> 2;
|
||
|
|
r(c[d + q - 1], w & 0xff, (w >> 16), o, p + (q - 1) * s)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function UpsampleRgbLinePair(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l) {
|
||
|
|
FUNC_NAME(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l, VP8YuvToRgb, 3)
|
||
|
|
}
|
||
|
|
|
||
|
|
function UpsampleBgrLinePair(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l) {
|
||
|
|
FUNC_NAME(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l, VP8YuvToBgr, 3)
|
||
|
|
}
|
||
|
|
|
||
|
|
function UpsampleRgbaLinePair(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l) {
|
||
|
|
FUNC_NAME(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l, VP8YuvToRgba, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function UpsampleBgraLinePair(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l) {
|
||
|
|
FUNC_NAME(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l, VP8YuvToBgra, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function UpsampleArgbLinePair(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l) {
|
||
|
|
FUNC_NAME(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l, VP8YuvToArgb, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function UpsampleRgba4444LinePair(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l) {
|
||
|
|
FUNC_NAME(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l, VP8YuvToRgba4444, 2)
|
||
|
|
}
|
||
|
|
|
||
|
|
function UpsampleRgb565LinePair(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l) {
|
||
|
|
FUNC_NAME(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l, VP8YuvToRgb565, 2)
|
||
|
|
}
|
||
|
|
|
||
|
|
function UpsampleRgbKeepAlphaLinePair(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l) {
|
||
|
|
FUNC_NAME(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l, VP8YuvToRgb, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function UpsampleBgrKeepAlphaLinePair(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l) {
|
||
|
|
FUNC_NAME(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l, VP8YuvToBgr, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function UpsampleArgbKeepAlphaLinePair(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l) {
|
||
|
|
FUNC_NAME(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l, VP8YuvToArgbKeepA, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function UpsampleRgba4444KeepAlphaLinePair(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l) {
|
||
|
|
FUNC_NAME(A, a, B, b, C, c, D, d, E, e, F, f, G, g, H, h, l, VP8YuvToRgba4444KeepA, 2)
|
||
|
|
}
|
||
|
|
var cO = new Array(MODE_LAST);
|
||
|
|
var cP = new Array(MODE_LAST);
|
||
|
|
|
||
|
|
function InitUpsamplers(a) {
|
||
|
|
cO[O] = UpsampleRgbLinePair;
|
||
|
|
cO[MODE_RGBA] = UpsampleRgbaLinePair;
|
||
|
|
cO[MODE_BGR] = UpsampleBgrLinePair;
|
||
|
|
cO[MODE_BGRA] = UpsampleBgraLinePair;
|
||
|
|
cO[MODE_ARGB] = UpsampleArgbLinePair;
|
||
|
|
cO[MODE_RGBA_4444] = UpsampleRgba4444LinePair;
|
||
|
|
cO[MODE_RGB_565] = UpsampleRgb565LinePair;
|
||
|
|
cP[O] = UpsampleRgbLinePair;
|
||
|
|
cP[MODE_RGBA] = UpsampleRgbKeepAlphaLinePair;
|
||
|
|
cP[MODE_BGR] = UpsampleBgrLinePair;
|
||
|
|
cP[MODE_BGRA] = UpsampleBgrKeepAlphaLinePair;
|
||
|
|
cP[MODE_ARGB] = UpsampleArgbKeepAlphaLinePair;
|
||
|
|
cP[MODE_RGBA_4444] = UpsampleRgba4444KeepAlphaLinePair;
|
||
|
|
cP[MODE_RGB_565] = UpsampleRgb565LinePair
|
||
|
|
}
|
||
|
|
|
||
|
|
function FUNC_NAME_SAMPLE(a, b, c, d, u, e, v, f, g, h, j, k, l, m, n) {
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < l - 1; i += 2) {
|
||
|
|
m(a[b + 0], u[e + 0], v[f + 0], g, h);
|
||
|
|
m(a[b + 1], u[e + 0], v[f + 0], g, h + n);
|
||
|
|
m(c[d + 0], u[e + 0], v[f + 0], j, k);
|
||
|
|
m(c[d + 1], u[e + 0], v[f + 0], j, k + n);
|
||
|
|
b += 2;
|
||
|
|
d += 2;
|
||
|
|
e++;
|
||
|
|
f++;
|
||
|
|
h += 2 * n;
|
||
|
|
k += 2 * n
|
||
|
|
}
|
||
|
|
if (i == l - 1) {
|
||
|
|
m(a[b + 0], u[e + 0], v[f + 0], g, h);
|
||
|
|
m(c[d + 0], u[e + 0], v[f + 0], j, k)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function SampleRgbLinePair(A, a, B, b, C, c, D, d, E, e, F, f, l) {
|
||
|
|
FUNC_NAME_SAMPLE(A, a, B, b, C, c, D, d, E, e, F, f, l, VP8YuvToRgb, 3)
|
||
|
|
}
|
||
|
|
|
||
|
|
function SampleBgrLinePair(A, a, B, b, C, c, D, d, E, e, F, f, l) {
|
||
|
|
FUNC_NAME_SAMPLE(A, a, B, b, C, c, D, d, E, e, F, f, l, VP8YuvToBgr, 3)
|
||
|
|
}
|
||
|
|
|
||
|
|
function SampleRgbaLinePair(A, a, B, b, C, c, D, d, E, e, F, f, l) {
|
||
|
|
FUNC_NAME_SAMPLE(A, a, B, b, C, c, D, d, E, e, F, f, l, VP8YuvToRgba, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function SampleBgraLinePair(A, a, B, b, C, c, D, d, E, e, F, f, l) {
|
||
|
|
FUNC_NAME_SAMPLE(A, a, B, b, C, c, D, d, E, e, F, f, l, VP8YuvToBgra, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function SampleArgbLinePair(A, a, B, b, C, c, D, d, E, e, F, f, l) {
|
||
|
|
FUNC_NAME_SAMPLE(A, a, B, b, C, c, D, d, E, e, F, f, l, VP8YuvToArgb, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function SampleRgba4444LinePair(A, a, B, b, C, c, D, d, E, e, F, f, l) {
|
||
|
|
FUNC_NAME_SAMPLE(A, a, B, b, C, c, D, d, E, e, F, f, l, VP8YuvToRgba4444, 2)
|
||
|
|
}
|
||
|
|
|
||
|
|
function SampleRgb565LinePair(A, a, B, b, C, c, D, d, E, e, F, f, l) {
|
||
|
|
FUNC_NAME_SAMPLE(A, a, B, b, C, c, D, d, E, e, F, f, l, VP8YuvToRgb565, 2)
|
||
|
|
}
|
||
|
|
var cQ = new Array(SampleRgbLinePair, SampleRgbaLinePair, SampleBgrLinePair, SampleBgraLinePair, SampleArgbLinePair, SampleRgba4444LinePair, SampleRgb565LinePair);
|
||
|
|
|
||
|
|
function FUNC_NAME_YUV444(y, a, u, b, v, c, d, e, f, g, h) {
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < f; ++i) g(y[a + i], u[b + i], v[c + i], d[e + i * h], 0)
|
||
|
|
}
|
||
|
|
|
||
|
|
function Yuv444ToRgb(A, a, B, b, C, c, D, d, l) {
|
||
|
|
FUNC_NAME_YUV444(A, a, B, b, C, c, D, d, l, VP8YuvToRgb, 3)
|
||
|
|
}
|
||
|
|
|
||
|
|
function Yuv444ToBgr(A, a, B, b, C, c, D, d, l) {
|
||
|
|
FUNC_NAME_YUV444(A, a, B, b, C, c, D, d, l, VP8YuvToBgr, 3)
|
||
|
|
}
|
||
|
|
|
||
|
|
function Yuv444ToRgba(A, a, B, b, C, c, D, d, l) {
|
||
|
|
FUNC_NAME_YUV444(A, a, B, b, C, c, D, d, l, VP8YuvToRgba, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function Yuv444ToBgra(A, a, B, b, C, c, D, d, l) {
|
||
|
|
FUNC_NAME_YUV444(A, a, B, b, C, c, D, d, l, VP8YuvToBgra, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function Yuv444ToArgb(A, a, B, b, C, c, D, d, l) {
|
||
|
|
FUNC_NAME_YUV444(A, a, B, b, C, c, D, d, l, VP8YuvToArgb, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function Yuv444ToRgba4444(A, a, B, b, C, c, D, d, l) {
|
||
|
|
FUNC_NAME_YUV444(A, a, B, b, C, c, D, d, l, VP8YuvToRgba4444, 2)
|
||
|
|
}
|
||
|
|
|
||
|
|
function Yuv444ToRgb565(A, a, B, b, C, c, D, d, l) {
|
||
|
|
FUNC_NAME_YUV444(A, a, B, b, C, c, D, d, l, VP8YuvToRgb565, 2)
|
||
|
|
}
|
||
|
|
var cR = new Array(Yuv444ToRgb, Yuv444ToRgba, Yuv444ToBgr, Yuv444ToBgra, Yuv444ToArgb, Yuv444ToRgba4444, Yuv444ToRgb565);
|
||
|
|
|
||
|
|
function EmitYUV(a, p) {
|
||
|
|
var b = p.output;
|
||
|
|
var c = b.u.YUVA;
|
||
|
|
var d = c.y;
|
||
|
|
var e = c.y_off + a.mb_y * c.y_stride;
|
||
|
|
var f = c.u;
|
||
|
|
var g = c.u_off + (a.mb_y >> 1) * c.u_stride;
|
||
|
|
var h = c.v;
|
||
|
|
var i = c.v_off + (a.mb_y >> 1) * c.v_stride;
|
||
|
|
var k = a.mb_w;
|
||
|
|
var l = a.mb_h;
|
||
|
|
var m = parseInt((k + 1) / 2);
|
||
|
|
var j;
|
||
|
|
for (j = 0; j < l; ++j) {
|
||
|
|
memcpy(d, e + j * c.y_stride, a.y, a.y_off + j * a.y_stride, k)
|
||
|
|
}
|
||
|
|
for (j = 0; j < (l + 1) / 2; ++j) {
|
||
|
|
memcpy(f, g + j * c.u_stride, a.u, a.u_off + j * a.uv_stride, m);
|
||
|
|
memcpy(h, i + j * c.v_stride, a.v, a.v_off + j * a.uv_stride, m)
|
||
|
|
}
|
||
|
|
return a.mb_h
|
||
|
|
}
|
||
|
|
|
||
|
|
function EmitSampledRGB(a, p) {
|
||
|
|
var b = p.output;
|
||
|
|
var c = b.u.RGBA;
|
||
|
|
var d = c.rgba;
|
||
|
|
var e = c.rgba_off + a.mb_y * c.stride;
|
||
|
|
var f = a.y;
|
||
|
|
var g = a.y_off;
|
||
|
|
var h = a.u;
|
||
|
|
var i = a.u_off;
|
||
|
|
var k = a.v;
|
||
|
|
var l = a.v_off;
|
||
|
|
var m = cQ[b.colorspace];
|
||
|
|
var n = a.mb_w;
|
||
|
|
var o = a.mb_h - 1;
|
||
|
|
var j;
|
||
|
|
for (j = 0; j < o; j += 2) {
|
||
|
|
m(f, g, f, g + a.y_stride, h, i, k, l, d, e, d, e + c.stride, n);
|
||
|
|
g += 2 * a.y_stride;
|
||
|
|
i += a.uv_stride;
|
||
|
|
l += a.uv_stride;
|
||
|
|
e += 2 * c.stride
|
||
|
|
}
|
||
|
|
if (j == o) {
|
||
|
|
m(f, g, f, g, h, i, k, l, d, e, d, e, n)
|
||
|
|
}
|
||
|
|
return a.mb_h
|
||
|
|
}
|
||
|
|
|
||
|
|
function EmitFancyRGB(a, p) {
|
||
|
|
var b = a.mb_h;
|
||
|
|
var c = p.output.u.RGBA;
|
||
|
|
var d = c.rgba;
|
||
|
|
var e = c.rgba_off + a.mb_y * c.stride;
|
||
|
|
var f = a.a ? cP[p.output.colorspace] : cO[p.output.colorspace];
|
||
|
|
var g = a.y;
|
||
|
|
var h = a.y_off;
|
||
|
|
var i = a.u;
|
||
|
|
var j = a.u_off;
|
||
|
|
var k = a.v;
|
||
|
|
var l = a.v_off;
|
||
|
|
var m = p.tmp_u;
|
||
|
|
var n = p.tmp_u_off;
|
||
|
|
var o = p.tmp_v;
|
||
|
|
var q = p.tmp_v_off;
|
||
|
|
var y = a.mb_y;
|
||
|
|
var r = a.mb_y + a.mb_h;
|
||
|
|
var s = a.mb_w;
|
||
|
|
var t = parseInt((s + 1) / 2);
|
||
|
|
if (y == 0) {
|
||
|
|
f(null, null, g, h, i, j, k, l, i, j, k, l, null, null, d, e, s)
|
||
|
|
} else {
|
||
|
|
f(p.tmp_y, p.tmp_y_off, g, h, m, n, o, q, i, j, k, l, d, e - c.stride, d, e, s);
|
||
|
|
b++
|
||
|
|
}
|
||
|
|
for (; y + 2 < r; y += 2) {
|
||
|
|
m = i;
|
||
|
|
n = j;
|
||
|
|
o = k;
|
||
|
|
q = l;
|
||
|
|
j += a.uv_stride;
|
||
|
|
l += a.uv_stride;
|
||
|
|
e += 2 * c.stride;
|
||
|
|
h += 2 * a.y_stride;
|
||
|
|
f(g, h - a.y_stride, g, h, m, n, o, q, i, j, k, l, d, e - c.stride, d, e, s)
|
||
|
|
}
|
||
|
|
h += a.y_stride;
|
||
|
|
if (a.crop_top + r < a.crop_bottom) {
|
||
|
|
memcpy(p.tmp_y, p.tmp_y_off, g, h, s * sizeof(p.tmp_y));
|
||
|
|
memcpy(p.tmp_u, p.tmp_u_off, i, j, t * sizeof(p.tmp_u));
|
||
|
|
memcpy(p.tmp_v, p.tmp_v_off, k, l, t * sizeof(p.tmp_v));
|
||
|
|
b--
|
||
|
|
} else {
|
||
|
|
if (!(r & 1)) {
|
||
|
|
f(g, h, null, null, i, j, k, l, i, j, k, l, d, e + c.stride, null, null, s)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
|
||
|
|
function EmitAlphaYUV(a, p) {
|
||
|
|
var b = a.mb_w;
|
||
|
|
var c = a.mb_h;
|
||
|
|
var j;
|
||
|
|
var d = p.output.u.YUVA;
|
||
|
|
var e = d.a;
|
||
|
|
var f = d.a_off + a.mb_y * d.a_stride;
|
||
|
|
var g = a.a;
|
||
|
|
var h = a.a_off;
|
||
|
|
if (g != null) {
|
||
|
|
for (j = 0; j < c; ++j) {
|
||
|
|
memcpy(e, f, g, h, b * sizeof(e));
|
||
|
|
h += a.width;
|
||
|
|
f += d.a_stride
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function EmitAlphaRGB(a, p) {
|
||
|
|
var b = p.output.colorspace;
|
||
|
|
var c = b == MODE_ARGB ? 0 : (b == MODE_RGBA_4444 ? 1 : 3);
|
||
|
|
var d = b == MODE_RGBA_4444 ? 2 : 4;
|
||
|
|
var e = a.mb_w;
|
||
|
|
var f = a.mb_h;
|
||
|
|
var i, j;
|
||
|
|
var g = p.output.u.RGBA;
|
||
|
|
var h = g.rgba;
|
||
|
|
var k = g.rgba_off + a.mb_y * g.stride;
|
||
|
|
var l = a.a;
|
||
|
|
var m = a.a_off;
|
||
|
|
if (l != null) {
|
||
|
|
for (j = 0; j < f; ++j) {
|
||
|
|
for (i = 0; i < e; ++i) {
|
||
|
|
h[k + d * i + c] = l[m + i]
|
||
|
|
}
|
||
|
|
m += a.width;
|
||
|
|
k += g.stride
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
var cS = 30;
|
||
|
|
|
||
|
|
function MULT(x, y) {
|
||
|
|
return (((x) * (y) + (1 << (cS - 1))) >> cS)
|
||
|
|
}
|
||
|
|
|
||
|
|
function InitRescaler(a, b, c, d, e, f, g, h, i, j, k, l, m, n) {
|
||
|
|
a.x_expand = (b < f) + 0;
|
||
|
|
a.src_width = b;
|
||
|
|
a.src_height = c;
|
||
|
|
a.dst_width = f;
|
||
|
|
a.dst_height = g;
|
||
|
|
a.dst = d;
|
||
|
|
a.dst_off = e;
|
||
|
|
a.dst_stride = h;
|
||
|
|
a.x_add = a.x_expand ? (j - 1) : i - j;
|
||
|
|
a.x_sub = a.x_expand ? (i - 1) : j;
|
||
|
|
a.y_accum = k;
|
||
|
|
a.y_add = k;
|
||
|
|
a.y_sub = l;
|
||
|
|
a.fx_scale = parseInt((1 << cS) / j);
|
||
|
|
a.fy_scale = parseInt((1 << cS) / l);
|
||
|
|
a.fxy_scale = a.x_expand ? parseInt(int64BitLeft(g, cS)) / (j * c) : parseInt(int64BitLeft(g, cS)) / (i * c);
|
||
|
|
a.irow = m;
|
||
|
|
a.irow_off = 0 * 4;
|
||
|
|
a.frow = m;
|
||
|
|
a.frow_off = n + f * 4
|
||
|
|
}
|
||
|
|
|
||
|
|
function ImportRow(a, b, c) {
|
||
|
|
var d = 0;
|
||
|
|
var e = int;
|
||
|
|
var f = 0;
|
||
|
|
if (!c.x_expand) {
|
||
|
|
var g = 0;
|
||
|
|
for (e = 0; e < c.dst_width; ++e) {
|
||
|
|
f += c.x_add;
|
||
|
|
for (; f > 0; f -= c.x_sub) {
|
||
|
|
g += a[b + (d++)]
|
||
|
|
} {
|
||
|
|
var h = a[b + (d++)];
|
||
|
|
var i = h * (-f);
|
||
|
|
write32BitIn4Bytes(c.frow, c.frow_off + e * 4, ((g + h) * c.x_sub - i));
|
||
|
|
g = MULT(i, c.fx_scale)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var j = a[b + 0],
|
||
|
|
right = a[b + 0];
|
||
|
|
for (e = 0; e < c.dst_width; ++e) {
|
||
|
|
if (f < 0) {
|
||
|
|
j = right;
|
||
|
|
right = a[b + (++d)];
|
||
|
|
f += c.x_add
|
||
|
|
}
|
||
|
|
write32BitIn4Bytes(c.frow, c.frow_off + e * 4, (right * c.x_add + (j - right) * f));
|
||
|
|
f -= c.x_sub
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (e = 0; e < c.dst_width; ++e) {
|
||
|
|
write32BitIn4Bytes(c.irow, c.irow_off + e * 4, (write4BytesIn32Bit(c.frow, c.frow_off + e * 4) + write4BytesIn32Bit(c.irow, c.irow_off + e * 4)))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function ExportRow(a) {
|
||
|
|
var b = int;
|
||
|
|
var c = a.fy_scale * (-a.y_accum);
|
||
|
|
assert(a.y_accum <= 0);
|
||
|
|
for (b = 0; b < a.dst_width; ++b) {
|
||
|
|
var d = MULT(write4BytesIn32Bit(a.frow, a.frow_off + b * 4), c);
|
||
|
|
var v = MULT(write4BytesIn32Bit(a.irow, a.irow_off + b * 4) - d, a.fxy_scale);
|
||
|
|
a.dst[a.dst_off + b] = (!(v & ~0xff)) ? v : (v < 0) ? 0 : 255;
|
||
|
|
write32BitIn4Bytes(a.irow, a.irow_off + b * 4, d)
|
||
|
|
}
|
||
|
|
a.y_accum += a.y_add;
|
||
|
|
a.dst_off += a.dst_stride
|
||
|
|
}
|
||
|
|
|
||
|
|
function Rescale(a, b, c, d, e) {
|
||
|
|
var f = 0;
|
||
|
|
while (d-- > 0) {
|
||
|
|
ImportRow(a, e);
|
||
|
|
b += c;
|
||
|
|
e.y_accum -= e.y_sub;
|
||
|
|
while (e.y_accum <= 0) {
|
||
|
|
ExportRow(e);
|
||
|
|
f++
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return f
|
||
|
|
}
|
||
|
|
|
||
|
|
function EmitRescaledYUV(a, p) {
|
||
|
|
var b = a.mb_h;
|
||
|
|
var c = (b + 1) >> 1;
|
||
|
|
var d = Rescale(a.y, a.y_off, a.y_stride, b, p.scaler_y);
|
||
|
|
Rescale(a.u, a.u_off, a.uv_stride, c, p.scaler_u);
|
||
|
|
Rescale(a.v, a.v_off, a.uv_stride, c, p.scaler_v);
|
||
|
|
return d
|
||
|
|
}
|
||
|
|
|
||
|
|
function EmitRescaledAlphaYUV(a, p) {
|
||
|
|
if (a.a != null) {
|
||
|
|
Rescale(a.a, a.a_off, a.width, a.mb_h, p.scaler_a)
|
||
|
|
}
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function IsAlphaMode(a) {
|
||
|
|
return (a == MODE_RGBA || a == MODE_BGRA || a == MODE_ARGB || a == MODE_RGBA_4444 || a == MODE_YUVA)
|
||
|
|
}
|
||
|
|
|
||
|
|
function InitYUVRescaler(a, p) {
|
||
|
|
var b = IsAlphaMode(p.output.colorspace);
|
||
|
|
var c = p.output.u.YUVA;
|
||
|
|
var d = a.scaled_width;
|
||
|
|
var e = a.scaled_height;
|
||
|
|
var f = (d + 1) >> 1;
|
||
|
|
var g = (e + 1) >> 1;
|
||
|
|
var h = (a.mb_w + 1) >> 1;
|
||
|
|
var i = (a.mb_h + 1) >> 1;
|
||
|
|
var j = 2 * d;
|
||
|
|
var k = 2 * f;
|
||
|
|
var l = size_t;
|
||
|
|
var m = int32_t;
|
||
|
|
var n = 0;
|
||
|
|
l = j + 2 * k;
|
||
|
|
if (b) {
|
||
|
|
l += j
|
||
|
|
}
|
||
|
|
p.memory = malloc(l * sizeof(m) * 4, 0);
|
||
|
|
if (p.memory == null) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
m = p.memory;
|
||
|
|
n = 0;
|
||
|
|
InitRescaler(p.scaler_y, a.mb_w, a.mb_h, c.y, c.y_off, d, e, c.y_stride, a.mb_w, d, a.mb_h, e, m, n);
|
||
|
|
InitRescaler(p.scaler_u, h, i, c.u, c.u_off, f, g, c.u_stride, h, f, i, g, m, n + j);
|
||
|
|
InitRescaler(p.scaler_v, h, i, c.v, c.v_off, f, g, c.v_stride, h, f, i, g, m, n + j + k);
|
||
|
|
p.emit = EmitRescaledYUV;
|
||
|
|
if (b) {
|
||
|
|
InitRescaler(p.scaler_a, a.mb_w, a.mb_h, c.a, c.a_off, d, e, c.a_stride, a.mb_w, d, a.mb_h, e, m, n + j + 2 * k);
|
||
|
|
p.emit_alpha = EmitRescaledAlphaYUV
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function Import(a, b, c, d, e) {
|
||
|
|
var f = 0;
|
||
|
|
while (f < d && e.y_accum > 0) {
|
||
|
|
ImportRow(a, b, e);
|
||
|
|
b += c;
|
||
|
|
++f;
|
||
|
|
e.y_accum -= e.y_sub
|
||
|
|
}
|
||
|
|
return f
|
||
|
|
}
|
||
|
|
|
||
|
|
function ExportRGB(p, a) {
|
||
|
|
var b = cR[p.output.colorspace];
|
||
|
|
var c = p.output.u.RGBA;
|
||
|
|
var d = c.rgba;
|
||
|
|
var e = c.rgba_off + (p.last_y + a) * c.stride;
|
||
|
|
var f = 0;
|
||
|
|
while (p.scaler_y.y_accum <= 0 && p.scaler_u.y_accum <= 0) {
|
||
|
|
assert(p.last_y + a + f < p.output.height);
|
||
|
|
assert(p.scaler_u.y_accum == p.scaler_v.y_accum);
|
||
|
|
ExportRow(p.scaler_y);
|
||
|
|
ExportRow(p.scaler_u);
|
||
|
|
ExportRow(p.scaler_v);
|
||
|
|
b(p.scaler_y.dst, p.scaler_y.dst_off, p.scaler_u.dst, p.scaler_u.dst_off, p.scaler_v.dst, p.scaler_v.dst_off, d, e, p.scaler_y.dst_width);
|
||
|
|
e += c.stride;
|
||
|
|
f++
|
||
|
|
}
|
||
|
|
return f
|
||
|
|
}
|
||
|
|
|
||
|
|
function EmitRescaledRGB(a, p) {
|
||
|
|
var b = a.mb_h;
|
||
|
|
var c = (b + 1) >> 1;
|
||
|
|
var j = 0,
|
||
|
|
uv_j = 0;
|
||
|
|
var d = 0;
|
||
|
|
while (j < b) {
|
||
|
|
var e = Import(a.y, a.y_off + j * a.y_stride, a.y_stride, b - j, p.scaler_y);
|
||
|
|
var f = Import(a.u, a.u_off + uv_j * a.uv_stride, a.uv_stride, c - uv_j, p.scaler_u);
|
||
|
|
var g = Import(a.v, a.v_off + uv_j * a.uv_stride, a.uv_stride, c - uv_j, p.scaler_v);
|
||
|
|
assert(f == g);
|
||
|
|
j += e;
|
||
|
|
uv_j += f;
|
||
|
|
d += ExportRGB(p, d)
|
||
|
|
}
|
||
|
|
return d
|
||
|
|
}
|
||
|
|
|
||
|
|
function ExportAlpha(p, a) {
|
||
|
|
var b = p.output.u.RGBA;
|
||
|
|
var c = b.rgba;
|
||
|
|
var d = b.rgba_off + (p.last_y + a) * b.stride;
|
||
|
|
var e = 0;
|
||
|
|
while (p.scaler_a.y_accum <= 0) {
|
||
|
|
var i;
|
||
|
|
assert(p.last_y + a + e < p.output.height);
|
||
|
|
ExportRow(p.scaler_a);
|
||
|
|
for (i = 0; i < p.scaler_a.dst_width; ++i) {
|
||
|
|
c[d + 4 * i + 3] = p.scaler_a.dst[p.scaler_a.dst_off + i]
|
||
|
|
}
|
||
|
|
d += b.stride;
|
||
|
|
e++
|
||
|
|
}
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
function EmitRescaledAlphaRGB(a, p) {
|
||
|
|
if (a.a != null) {
|
||
|
|
var j = 0,
|
||
|
|
pos = 0;
|
||
|
|
while (j < a.mb_h) {
|
||
|
|
j += Import(a.a, a.a_off + j * a.width, a.width, a.mb_h - j, p.scaler_a);
|
||
|
|
pos += ExportAlpha(p, pos)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function InitRGBRescaler(a, p) {
|
||
|
|
var b = IsAlphaMode(p.output.colorspace);
|
||
|
|
var c = a.scaled_width;
|
||
|
|
var d = a.scaled_height;
|
||
|
|
var e = (a.mb_w + 1) >> 1;
|
||
|
|
var f = (a.mb_h + 1) >> 1;
|
||
|
|
var g = 2 * c;
|
||
|
|
var h = int32_t;
|
||
|
|
var i = 0;
|
||
|
|
var j = uint8_t;
|
||
|
|
var k = 0;
|
||
|
|
var l = size_t,
|
||
|
|
tmp_size2 = size_t;
|
||
|
|
l = 3 * g;
|
||
|
|
tmp_size2 = 3 * c;
|
||
|
|
if (b) {
|
||
|
|
l += g;
|
||
|
|
tmp_size2 += c
|
||
|
|
}
|
||
|
|
p.memory = malloc(l * sizeof(h) * 4 + tmp_size2 * sizeof(j) * 1, 0);
|
||
|
|
p.memory_off = 0;
|
||
|
|
if (p.memory == null) {
|
||
|
|
slert('memory error');
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
h = p.memory;
|
||
|
|
i = p.memory_off;
|
||
|
|
j = h;
|
||
|
|
k = i + l * 1;
|
||
|
|
InitRescaler(p.scaler_y, a.mb_w, a.mb_h, j, k + 0 * c * 1, c, d, 0, a.mb_w, c, a.mb_h, d, h, i + 0 * g * 4);
|
||
|
|
InitRescaler(p.scaler_u, e, f, j, k + 1 * c * 1, c, d, 0, a.mb_w, 2 * c, a.mb_h, 2 * d, h, i + 1 * g * 4);
|
||
|
|
InitRescaler(p.scaler_v, e, f, j, k + 2 * c * 1, c, d, 0, a.mb_w, 2 * c, a.mb_h, 2 * d, h, i + 2 * g * 4);
|
||
|
|
p.emit = EmitRescaledRGB;
|
||
|
|
if (b) {
|
||
|
|
InitRescaler(p.scaler_a, a.mb_w, a.mb_h, j, k + 3 * c * 1, c, d, 0, a.mb_w, c, a.mb_h, d, h, i + 3 * g * 4);
|
||
|
|
p.emit_alpha = EmitRescaledAlphaRGB
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function InitFromOptions(a, b) {
|
||
|
|
var W = b.width;
|
||
|
|
var H = b.height;
|
||
|
|
var x = 0,
|
||
|
|
y = 0,
|
||
|
|
w = W,
|
||
|
|
h = H;
|
||
|
|
b.use_cropping = (a != null) && (a.use_cropping > 0);
|
||
|
|
if (b.use_cropping) {
|
||
|
|
w = a.crop_width;
|
||
|
|
h = a.crop_height;
|
||
|
|
x = a.crop_left & ~1;
|
||
|
|
y = a.crop_top & ~1;
|
||
|
|
if (x < 0 || y < 0 || w <= 0 || h <= 0 || x + w > W || y + h > H) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
b.crop_left = x;
|
||
|
|
b.crop_top = y;
|
||
|
|
b.crop_right = x + w;
|
||
|
|
b.crop_bottom = y + h;
|
||
|
|
b.mb_w = w;
|
||
|
|
b.mb_h = h;
|
||
|
|
b.use_scaling = ((a != null) && (a.use_scaling > 0)) + 0;
|
||
|
|
if (b.use_scaling) {
|
||
|
|
if (a.scaled_width <= 0 || a.scaled_height <= 0) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
b.scaled_width = a.scaled_width;
|
||
|
|
b.scaled_height = a.scaled_height
|
||
|
|
}
|
||
|
|
b.bypass_filtering = a && a.bypass_filtering;
|
||
|
|
b.fancy_upsampling = ((a == null) || (!a.no_fancy_upsampling)) + 0;
|
||
|
|
if (b.use_scaling) {
|
||
|
|
b.bypass_filtering = (b.scaled_width < parseInt(W * 3 / 4)) + 0 && (b.scaled_height < parseInt(H * 3 / 4)) + 0;
|
||
|
|
b.fancy_upsampling = 0
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function CustomSetup(a) {
|
||
|
|
var p = a.opaque;
|
||
|
|
var b = (p.output.colorspace < MODE_YUV);
|
||
|
|
p.memory = null;
|
||
|
|
p.emit = null;
|
||
|
|
p.emit_alpha = null;
|
||
|
|
if (!InitFromOptions(p.options_, a)) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (a.use_scaling) {
|
||
|
|
var c = b ? InitRGBRescaler(a, p) : InitYUVRescaler(a, p);
|
||
|
|
if (!c) {
|
||
|
|
alert('memory error #1');
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (b) {
|
||
|
|
p.emit = EmitSampledRGB;
|
||
|
|
if (a.fancy_upsampling) {
|
||
|
|
var d = (a.mb_w + 1) >> 1;
|
||
|
|
p.memory = malloc(a.mb_w + 2 * d, 205);
|
||
|
|
if (p.memory == null) {
|
||
|
|
alert('memory error #2');
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
p.tmp_y = p.memory;
|
||
|
|
p.tmp_y_off = 0;
|
||
|
|
p.tmp_u = p.tmp_y;
|
||
|
|
p.tmp_u_off = p.tmp_y_off + a.mb_w;
|
||
|
|
p.tmp_v = p.tmp_u;
|
||
|
|
p.tmp_v_off = p.tmp_u_off + d;
|
||
|
|
p.emit = EmitFancyRGB;
|
||
|
|
InitUpsamplers()
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
p.emit = EmitYUV
|
||
|
|
}
|
||
|
|
if (IsAlphaMode(p.output.colorspace)) {
|
||
|
|
p.emit_alpha = b ? EmitAlphaRGB : EmitAlphaYUV
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (b) {
|
||
|
|
VP8YUVInit()
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function CustomPut(a) {
|
||
|
|
var p = a.opaque;
|
||
|
|
var b = a.mb_w;
|
||
|
|
var c = a.mb_h;
|
||
|
|
var d;
|
||
|
|
assert(!(a.mb_y & 1));
|
||
|
|
if (b <= 0 || c <= 0) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
d = p.emit(a, p);
|
||
|
|
p.last_y += d;
|
||
|
|
if (p.emit_alpha) {
|
||
|
|
p.emit_alpha(a, p)
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function CustomTeardown(a) {
|
||
|
|
var p = a.opaque;
|
||
|
|
p.memory = '';
|
||
|
|
p.memory = null
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPInitCustomIo(b, c) {
|
||
|
|
c.put = function(a) {
|
||
|
|
return CustomPut(a)
|
||
|
|
};
|
||
|
|
c.setup = function(a) {
|
||
|
|
return CustomSetup(a)
|
||
|
|
};
|
||
|
|
c.teardown = function(a) {
|
||
|
|
return CustomTeardown(a)
|
||
|
|
};
|
||
|
|
c.opaque = b
|
||
|
|
}
|
||
|
|
var co = 12;
|
||
|
|
var cT = 10;
|
||
|
|
var cU = 4096;
|
||
|
|
var cV = 4096;
|
||
|
|
var cW = 0,
|
||
|
|
STATE_PARTS0 = 1,
|
||
|
|
STATE_DATA = 2,
|
||
|
|
STATE_DONE = 3,
|
||
|
|
STATE_ERROR = 4;
|
||
|
|
var cX = 0,
|
||
|
|
MEM_MODE_APPEND = 1,
|
||
|
|
MEM_MODE_MAP = 2;
|
||
|
|
var cY = {
|
||
|
|
mode_: 'MemBufferMode',
|
||
|
|
start_: uint32_t,
|
||
|
|
end_: uint32_t,
|
||
|
|
buf_size_: size_t,
|
||
|
|
buf_: uint8_t,
|
||
|
|
buf_off: 0,
|
||
|
|
part0_size_: size_t,
|
||
|
|
part0_buf_: uint8_t,
|
||
|
|
part0_buf_off: 0
|
||
|
|
};
|
||
|
|
var cZ = {
|
||
|
|
state_: "DecState",
|
||
|
|
params_: newObjectIt(ba),
|
||
|
|
dec_: newObjectIt(bz),
|
||
|
|
io_: newObjectIt(Y),
|
||
|
|
mem_: newObjectIt(cY),
|
||
|
|
output_: newObjectIt(R)
|
||
|
|
};
|
||
|
|
var da = {
|
||
|
|
left_: newObjectIt(bw),
|
||
|
|
info_: newObjectIt(bw),
|
||
|
|
intra_t_: Arr(4, uint8_t),
|
||
|
|
intra_l_: Arr(4, uint8_t),
|
||
|
|
br_: newObjectIt(bb),
|
||
|
|
token_br_: newObjectIt(bb)
|
||
|
|
};
|
||
|
|
|
||
|
|
function MemDataSize(a) {
|
||
|
|
return (a.end_ - a.start_)
|
||
|
|
}
|
||
|
|
|
||
|
|
function AppendToMemBuffer(a, b, c) {
|
||
|
|
var d = a.mem_;
|
||
|
|
var e = a.dec_;
|
||
|
|
var f = e.num_parts_ - 1;
|
||
|
|
assert(d.mode_ == MEM_MODE_APPEND);
|
||
|
|
if (d.end_ + c > d.buf_size_) {
|
||
|
|
var p;
|
||
|
|
var g = null;
|
||
|
|
var h = 0;
|
||
|
|
var i = parseInt((MemDataSize(d) + c + cU - 1) / cU);
|
||
|
|
var j = i * cU;
|
||
|
|
var k = d.buf_;
|
||
|
|
var l = d.buf_off + d.start_;
|
||
|
|
var g = malloc(j - 1, 205);
|
||
|
|
var h = 0;
|
||
|
|
if (!g) return 0;
|
||
|
|
memcpy(g, h, k, l, MemDataSize(d));
|
||
|
|
for (p = 0; p <= f; ++p) {
|
||
|
|
if (e.parts_[p].buf_off != null) {
|
||
|
|
e.parts_[p].buf_ = g;
|
||
|
|
e.parts_[p].buf_off = h + ((e.parts_[p].buf_off) - l);
|
||
|
|
e.parts_[p].buf_end_ = h + ((e.parts_[p].buf_end_) - l)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
d.buf_ = '';
|
||
|
|
d.buf_ = g;
|
||
|
|
d.buf_off = h;
|
||
|
|
d.buf_size_ = j;
|
||
|
|
d.end_ = MemDataSize(d);
|
||
|
|
d.start_ = 0
|
||
|
|
}
|
||
|
|
memcpy(d.buf_, d.buf_off + d.end_, b, 0, c);
|
||
|
|
d.end_ += c;
|
||
|
|
assert(d.end_ <= d.buf_size_);
|
||
|
|
if (f >= 0) {
|
||
|
|
e.parts_[f].buf_end_ = d.buf_off + d.end_
|
||
|
|
}
|
||
|
|
a.io_.data = d.buf_;
|
||
|
|
a.io_.data_off = d.buf_off;
|
||
|
|
a.io_.data_size = MemDataSize(d);
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function RemapMemBuffer(a, b, c, d) {
|
||
|
|
var p;
|
||
|
|
var e = a.mem_;
|
||
|
|
var f = a.dec_;
|
||
|
|
var g = f.num_parts_ - 1;
|
||
|
|
var h = e.buf_;
|
||
|
|
var i = e.buf_off;
|
||
|
|
assert(e.mode_ == MEM_MODE_MAP);
|
||
|
|
if (d < e.buf_size_) {
|
||
|
|
alert('we cannot remap to a shorter buffer!');
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
for (p = 0; p <= g; ++p) {
|
||
|
|
if (f.parts_[p].buf_off != null) {
|
||
|
|
f.parts_[p].buf_ = b;
|
||
|
|
f.parts_[p].buf_off = c + ((f.parts_[p].buf_off) - i);
|
||
|
|
f.parts_[p].buf_end_ = c + ((f.parts_[p].buf_end_) - i)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (g >= 0) {
|
||
|
|
f.parts_[g].buf_end_ = c + d
|
||
|
|
}
|
||
|
|
if (f.br_.buf_) {
|
||
|
|
f.br_.buf_ = b;
|
||
|
|
f.br_.buf_off = c + ((f.br_.buf_off) - i);
|
||
|
|
f.br_.buf_end_ = c + ((f.br_.buf_end_) - i)
|
||
|
|
}
|
||
|
|
e.buf_ = b;
|
||
|
|
e.buf_off = c;
|
||
|
|
e.end_ = e.buf_size_ = d;
|
||
|
|
a.io_.data = b;
|
||
|
|
a.io_.data_off = c;
|
||
|
|
a.io_.data_size = d;
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function InitMemBuffer(a) {
|
||
|
|
a.mode_ = cX;
|
||
|
|
a.buf_ = 0;
|
||
|
|
a.buf_size_ = 0;
|
||
|
|
a.part0_buf_ = 0;
|
||
|
|
a.part0_size_ = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function ClearMemBuffer(a) {
|
||
|
|
assert(a);
|
||
|
|
if (a.mode_ == MEM_MODE_APPEND) {
|
||
|
|
a.buf_ = '';
|
||
|
|
a.buf_off = 0;
|
||
|
|
a.part0_buf_ = '';
|
||
|
|
a.part0_buf_off = ''
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function CheckMemBufferMode(a, b) {
|
||
|
|
if (a.mode_ == cX) {
|
||
|
|
a.mode_ = b
|
||
|
|
} else if (a.mode_ != b) {
|
||
|
|
alert('we mixed the modes => error');
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
assert(a.mode_ == b);
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function SaveContext(a, b, c) {
|
||
|
|
var d = a.br_;
|
||
|
|
var e = a.mb_info_[1 - 1];
|
||
|
|
var f = a.mb_info_[1 + a.mb_x_];
|
||
|
|
c.left_ = newObjectIt(e);
|
||
|
|
c.info_ = newObjectIt(f);
|
||
|
|
c.br_ = newObjectIt(d);
|
||
|
|
c.token_br_ = newObjectIt(b);
|
||
|
|
memcpy(c.intra_t_, 0, a.intra_t_, +4 * a.mb_x_, 4);
|
||
|
|
memcpy(c.intra_l_, 0, a.intra_l_, 0, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function RestoreContext(a, b, c) {
|
||
|
|
var d = b.br_;
|
||
|
|
var e = b.mb_info_[1 - 1];
|
||
|
|
var f = b.mb_info_[1 + b.mb_x_];
|
||
|
|
e.dc_nz_ = a.left_.dc_nz_;
|
||
|
|
e.f_ilevel_ = a.left_.f_ilevel_;
|
||
|
|
e.f_inner_ = a.left_.f_inner_;
|
||
|
|
e.f_level_ = a.left_.f_level_;
|
||
|
|
e.nz_ = a.left_.nz_;
|
||
|
|
e.skip_ = a.left_.skip_;
|
||
|
|
f.dc_nz_ = a.info_.dc_nz_;
|
||
|
|
f.f_ilevel_ = a.info_.f_ilevel_;
|
||
|
|
f.f_inner_ = a.info_.f_inner_;
|
||
|
|
f.f_level_ = a.info_.f_level_;
|
||
|
|
f.nz_ = a.info_.nz_;
|
||
|
|
f.skip_ = a.info_.skip_;
|
||
|
|
b.br_.buf_end_ = a.br_.buf_end_;
|
||
|
|
b.br_.buf_off = a.br_.buf_off;
|
||
|
|
b.br_.eof_ = a.br_.eof_;
|
||
|
|
b.br_.missing_ = a.br_.missing_;
|
||
|
|
b.br_.range_ = a.br_.range_;
|
||
|
|
b.br_.value_ = a.br_.value_;
|
||
|
|
c.buf_end_ = (a.token_br_.buf_end_);
|
||
|
|
c.buf_off = (a.token_br_.buf_off);
|
||
|
|
c.eof_ = (a.token_br_.eof_);
|
||
|
|
c.missing_ = (a.token_br_.missing_);
|
||
|
|
c.range_ = (a.token_br_.range_);
|
||
|
|
c.value_ = (a.token_br_.value_);
|
||
|
|
memcpy(b.intra_t_, +4 * b.mb_x_, a.intra_t_, 0, 4);
|
||
|
|
memcpy(b.intra_l_, 0, a.intra_l_, 0, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function IDecError(a, b) {
|
||
|
|
if (a.state_ == STATE_DATA) {
|
||
|
|
var c = a.io_;
|
||
|
|
if (c.teardown) {
|
||
|
|
c.teardown(c)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
a.state_ = STATE_ERROR;
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
|
||
|
|
function DecodeHeader(a) {
|
||
|
|
var b = uint32_t,
|
||
|
|
bits = uint32_t;
|
||
|
|
var c = a.mem_.buf_;
|
||
|
|
var d = {
|
||
|
|
value: (a.mem_.buf_off + a.mem_.start_)
|
||
|
|
};
|
||
|
|
var e = {
|
||
|
|
value: MemDataSize(a.mem_)
|
||
|
|
};
|
||
|
|
var f = {
|
||
|
|
value: uint32_t
|
||
|
|
};
|
||
|
|
var g = {
|
||
|
|
value: uint32_t
|
||
|
|
};
|
||
|
|
var h = {
|
||
|
|
value: 0
|
||
|
|
};
|
||
|
|
var i = {
|
||
|
|
value: 0
|
||
|
|
};
|
||
|
|
if (e.value < co) {
|
||
|
|
return VP8_STATUS_SUSPENDED
|
||
|
|
}
|
||
|
|
if (!WebPCheckAndSkipRIFFHeader(c, d, e, g)) {
|
||
|
|
return IDecError(a, VP8_STATUS_BITSTREAM_ERROR)
|
||
|
|
}
|
||
|
|
if (!VP8XGetInfo(c, d, e, h, null, null, null)) {
|
||
|
|
return IDecError(a, VP8_STATUS_BITSTREAM_ERROR)
|
||
|
|
}
|
||
|
|
if (h.value == -1) {
|
||
|
|
return VP8_STATUS_SUSPENDED
|
||
|
|
}
|
||
|
|
if (!VP8CheckAndSkipHeader(c, d, e, i, f, g)) {
|
||
|
|
return IDecError(a, VP8_STATUS_BITSTREAM_ERROR)
|
||
|
|
}
|
||
|
|
if ((i.value == -1) && (f.value == 0)) {
|
||
|
|
return VP8_STATUS_SUSPENDED
|
||
|
|
}
|
||
|
|
if (e.value < cT) {
|
||
|
|
return VP8_STATUS_SUSPENDED
|
||
|
|
}
|
||
|
|
if (!VP8GetInfo(c, d, e, f, null, null, null)) {
|
||
|
|
return IDecError(a, VP8_STATUS_BITSTREAM_ERROR)
|
||
|
|
}
|
||
|
|
e = e.value;
|
||
|
|
d = d.value;
|
||
|
|
b = a.mem_.end_ - e;
|
||
|
|
bits = c[d + 0] | (c[d + 1] << 8) | (c[d + 2] << 16);
|
||
|
|
a.mem_.part0_size_ = (bits >> 5) + cT;
|
||
|
|
a.mem_.start_ += b;
|
||
|
|
assert(a.mem_.start_ <= a.mem_.end_);
|
||
|
|
a.io_.data_size -= b;
|
||
|
|
a.io_.data = c;
|
||
|
|
a.io_.data_off = d;
|
||
|
|
a.state_ = STATE_PARTS0;
|
||
|
|
return T
|
||
|
|
}
|
||
|
|
|
||
|
|
function CopyParts0Data(a) {
|
||
|
|
var b = a.dec_.br_;
|
||
|
|
var c = b.buf_end_ - b.buf_off;
|
||
|
|
var d = a.mem_;
|
||
|
|
assert(c > 0);
|
||
|
|
assert(c <= d.part0_size_);
|
||
|
|
if (d.mode_ == MEM_MODE_APPEND) {
|
||
|
|
var e = malloc(c, uint8_t);
|
||
|
|
var f = 0;
|
||
|
|
if (!e) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
memcpy(e, f, b.buf_, b.buf_off, c);
|
||
|
|
d.part0_buf_ = e;
|
||
|
|
d.part0_buf_off = f;
|
||
|
|
d.start_ += c;
|
||
|
|
b.buf_ = e;
|
||
|
|
b.buf_off = f;
|
||
|
|
b.buf_end_ = f + c
|
||
|
|
} else {}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function DecodePartition0(a) {
|
||
|
|
var b = a.dec_;
|
||
|
|
var c = a.io_;
|
||
|
|
var d = a.params_;
|
||
|
|
var e = d.output;
|
||
|
|
if (MemDataSize(a.mem_) < a.mem_.part0_size_) {
|
||
|
|
return VP8_STATUS_SUSPENDED
|
||
|
|
}
|
||
|
|
if (!VP8GetHeaders(b, c)) {
|
||
|
|
var f = b.status_;
|
||
|
|
if (f == VP8_STATUS_SUSPENDED || f == VP8_STATUS_NOT_ENOUGH_DATA) {
|
||
|
|
return VP8_STATUS_SUSPENDED
|
||
|
|
}
|
||
|
|
return IDecError(a, f)
|
||
|
|
}
|
||
|
|
b.status_ = WebPAllocateDecBuffer(c.width, c.height, d.options_, e);
|
||
|
|
if (b.status_ != T) {
|
||
|
|
return IDecError(a, b.status_)
|
||
|
|
}
|
||
|
|
if (!CopyParts0Data(a)) {
|
||
|
|
return IDecError(a, VP8_STATUS_OUT_OF_MEMORY)
|
||
|
|
}
|
||
|
|
if (VP8EnterCritical(b, c) != T) {
|
||
|
|
return IDecError(a, b.status_)
|
||
|
|
}
|
||
|
|
a.state_ = STATE_DATA;
|
||
|
|
if (!VP8InitFrame(b, c)) {
|
||
|
|
return IDecError(a, b.status_)
|
||
|
|
}
|
||
|
|
return T
|
||
|
|
}
|
||
|
|
|
||
|
|
function DecodeRemaining(a) {
|
||
|
|
var b = newObjectIt(bb);
|
||
|
|
var c = a.dec_;
|
||
|
|
var d = a.io_;
|
||
|
|
assert(c.ready_);
|
||
|
|
b = c.br_;
|
||
|
|
for (; c.mb_y_ < c.mb_h_; ++c.mb_y_) {
|
||
|
|
var e = c.parts_[c.mb_y_ & (c.num_parts_ - 1)];
|
||
|
|
if (c.mb_x_ == 0) {
|
||
|
|
VP8InitScanline(c)
|
||
|
|
}
|
||
|
|
for (; c.mb_x_ < c.mb_w_; c.mb_x_++) {
|
||
|
|
var f = (da);
|
||
|
|
SaveContext(c, e, f);
|
||
|
|
if (!VP8DecodeMB(c, e)) {
|
||
|
|
RestoreContext(f, c, e);
|
||
|
|
if (c.num_parts_ == 1 && MemDataSize(a.mem_) > cV) {
|
||
|
|
return IDecError(a, VP8_STATUS_BITSTREAM_ERROR)
|
||
|
|
}
|
||
|
|
return VP8_STATUS_SUSPENDED
|
||
|
|
}
|
||
|
|
VP8ReconstructBlock(c);
|
||
|
|
VP8StoreBlock(c);
|
||
|
|
if (c.num_parts_ == 1) {
|
||
|
|
a.mem_.start_ = e.buf_off - a.mem_.buf_off;
|
||
|
|
assert(a.mem_.start_ <= a.mem_.end_)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!VP8ProcessRow(c, d)) {
|
||
|
|
return IDecError(a, VP8_STATUS_USER_ABORT)
|
||
|
|
}
|
||
|
|
c.mb_x_ = 0
|
||
|
|
}
|
||
|
|
if (!VP8ExitCritical(c, d)) {
|
||
|
|
return IDecError(a, VP8_STATUS_USER_ABORT)
|
||
|
|
}
|
||
|
|
c.ready_ = 0;
|
||
|
|
a.state_ = STATE_DONE;
|
||
|
|
return T
|
||
|
|
}
|
||
|
|
|
||
|
|
function IDecode(a) {
|
||
|
|
var b = VP8_STATUS_SUSPENDED;
|
||
|
|
assert(a.dec_);
|
||
|
|
if (a.state_ == cW) {
|
||
|
|
b = DecodeHeader(a)
|
||
|
|
}
|
||
|
|
if (a.state_ == STATE_PARTS0) {
|
||
|
|
b = DecodePartition0(a)
|
||
|
|
}
|
||
|
|
if (a.state_ == STATE_DATA) {
|
||
|
|
b = DecodeRemaining(a)
|
||
|
|
}
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPINewDecoder(a) {
|
||
|
|
var b = newObjectIt(cZ);
|
||
|
|
if (b == null) {
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
b.dec_ = VP8New();
|
||
|
|
if (b.dec_ == null) {
|
||
|
|
b = '';
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
b.state_ = cW;
|
||
|
|
InitMemBuffer(b.mem_);
|
||
|
|
WebPInitDecBuffer(b.output_);
|
||
|
|
VP8InitIo(b.io_);
|
||
|
|
WebPResetDecParams(b.params_);
|
||
|
|
b.params_.output = a ? a : b.output_;
|
||
|
|
WebPInitCustomIo(b.params_, b.io_);
|
||
|
|
b.dec_.use_threads_ = 0;
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
this.WebPIDecode = function(a, b, c) {
|
||
|
|
var d = newObjectIt(cZ);
|
||
|
|
if (a != null && b > 0 && c != null) {
|
||
|
|
if (this.WebPGetFeatures(a, b, c.input) != T) {
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
}
|
||
|
|
d = WebPINewDecoder(c ? c.output : null);
|
||
|
|
if (!d) {
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
if (c != null) {
|
||
|
|
d.params_.options_ = c.options_
|
||
|
|
}
|
||
|
|
return d
|
||
|
|
};
|
||
|
|
this.WebPIDelete = function(a) {
|
||
|
|
if (!a) return;
|
||
|
|
VP8Delete(a.dec_);
|
||
|
|
ClearMemBuffer(a.mem_);
|
||
|
|
this.WebPFreeDecBuffer(a.output_);
|
||
|
|
a = ''
|
||
|
|
};
|
||
|
|
this.WebPINew = function(a) {
|
||
|
|
a = a == 'MODE_RGB' ? O : a;
|
||
|
|
a = a == 'MODE_RGBA' ? MODE_RGBA : a;
|
||
|
|
a = a == 'MODE_BGR' ? MODE_BGR : a;
|
||
|
|
a = a == 'MODE_BGRA' ? MODE_BGRA : a;
|
||
|
|
a = a == 'MODE_YUV' ? MODE_YUV : a;
|
||
|
|
var b = WebPINewDecoder(null);
|
||
|
|
if (!b) return null;
|
||
|
|
b.output_.colorspace = a;
|
||
|
|
return b
|
||
|
|
};
|
||
|
|
this.WebPINewRGB = function(a, b, c, d) {
|
||
|
|
var e = newObjectIt(cZ);
|
||
|
|
if (a >= MODE_YUV) return null;
|
||
|
|
e = WebPINewDecoder(null);
|
||
|
|
if (e) return null;
|
||
|
|
e.output_.colorspace = a;
|
||
|
|
e.output_.is_external_memory = 1;
|
||
|
|
e.output_.u.RGBA.rgba = b;
|
||
|
|
e.output_.u.RGBA.stride = d;
|
||
|
|
e.output_.u.RGBA.size = c;
|
||
|
|
return e
|
||
|
|
};
|
||
|
|
this.WebPINewYUV = function(a, b, c, d, u, e, f, g, v, h, i, j) {
|
||
|
|
var k = WebPINewDecoder(null);
|
||
|
|
if (k) return null;
|
||
|
|
k.output_.colorspace = MODE_YUV;
|
||
|
|
k.output_.is_external_memory = 1;
|
||
|
|
k.output_.u.YUVA.y = a;
|
||
|
|
k.output_.u.YUVA.y = b;
|
||
|
|
k.output_.u.YUVA.y_stride = d;
|
||
|
|
k.output_.u.YUVA.y_size = c;
|
||
|
|
k.output_.u.YUVA.u = u;
|
||
|
|
k.output_.u.YUVA.u = e;
|
||
|
|
k.output_.u.YUVA.u_stride = g;
|
||
|
|
k.output_.u.YUVA.u_size = f;
|
||
|
|
k.output_.u.YUVA.v = v;
|
||
|
|
k.output_.u.YUVA.v = h;
|
||
|
|
k.output_.u.YUVA.v_stride = j;
|
||
|
|
k.output_.u.YUVA.v_size = i;
|
||
|
|
return k
|
||
|
|
};
|
||
|
|
|
||
|
|
function IDecCheckStatus(a) {
|
||
|
|
assert(a);
|
||
|
|
if (a.dec_ == null) {
|
||
|
|
return VP8_STATUS_USER_ABORT
|
||
|
|
}
|
||
|
|
if (a.state_ == STATE_ERROR) {
|
||
|
|
return VP8_STATUS_BITSTREAM_ERROR
|
||
|
|
}
|
||
|
|
if (a.state_ == STATE_DONE) {
|
||
|
|
return T
|
||
|
|
}
|
||
|
|
return VP8_STATUS_SUSPENDED
|
||
|
|
}
|
||
|
|
this.WebPIAppend = function(a, b, c) {
|
||
|
|
var d = 0;
|
||
|
|
if (a == null || b == null) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
d = IDecCheckStatus(a);
|
||
|
|
if (d != VP8_STATUS_SUSPENDED) {
|
||
|
|
return d
|
||
|
|
}
|
||
|
|
if (!CheckMemBufferMode(a.mem_, MEM_MODE_APPEND)) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
if (!AppendToMemBuffer(a, b, c)) {
|
||
|
|
return VP8_STATUS_OUT_OF_MEMORY
|
||
|
|
}
|
||
|
|
return IDecode(a)
|
||
|
|
};
|
||
|
|
this.WebPIUpdate = function(a, b, c) {
|
||
|
|
var d = 0;
|
||
|
|
if (a == null || b == null) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
d = IDecCheckStatus(a);
|
||
|
|
if (d != VP8_STATUS_SUSPENDED) {
|
||
|
|
return d
|
||
|
|
}
|
||
|
|
if (!CheckMemBufferMode(a.mem_, MEM_MODE_MAP)) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
if (!RemapMemBuffer(a, b, 0, c)) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
return IDecode(a)
|
||
|
|
};
|
||
|
|
|
||
|
|
function GetOutputBuffer(a) {
|
||
|
|
if (!a || !a.dec_ || a.state_ <= STATE_PARTS0) {
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
return a.params_.output
|
||
|
|
}
|
||
|
|
this.WebPIDecodedArea = function(a, b, c, d, e) {
|
||
|
|
var f = GetOutputBuffer(a);
|
||
|
|
if (b) b.value = 0;
|
||
|
|
if (c) c.value = 0;
|
||
|
|
if (f) {
|
||
|
|
if (d) d.value = f.width;
|
||
|
|
if (e) e.value = a.params_.last_y
|
||
|
|
} else {
|
||
|
|
if (d) d.value = 0;
|
||
|
|
if (e) e.value = 0
|
||
|
|
}
|
||
|
|
return f
|
||
|
|
};
|
||
|
|
this.WebPIDecGetRGB = function(a, b, c, d, e) {
|
||
|
|
var f = GetOutputBuffer(a);
|
||
|
|
if (!f) return null;
|
||
|
|
if (f.colorspace >= MODE_YUV) {
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
if (typeof b.value !== "undefined") b.value = a.params_.last_y;
|
||
|
|
if (typeof c.value !== "undefined") c.value = f.width;
|
||
|
|
if (typeof d.value !== "undefined") d.value = f.height;
|
||
|
|
if (typeof e.value !== "undefined") e.value = f.u.RGBA.stride;
|
||
|
|
return f.u.RGBA.rgba
|
||
|
|
};
|
||
|
|
this.WebPIDecGetYUV = function(a, b, u, v, c, d, e, f) {
|
||
|
|
var g = GetOutputBuffer(a);
|
||
|
|
if (!g) return null;
|
||
|
|
if (g.colorspace < MODE_YUV) {
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
if (typeof b.value !== "undefined") b.value = g.u.YUVA.u;
|
||
|
|
if (typeof u.value !== "undefined") u.value = g.u.YUVA.u;
|
||
|
|
if (typeof v.value !== "undefined") v.value = g.u.YUVA.v;
|
||
|
|
if (typeof c.value !== "undefined") c.value = g.width;
|
||
|
|
if (typeof d.value !== "undefined") d.value = g.height;
|
||
|
|
if (typeof e.value !== "undefined") e.value = g.u.YUVA.y_stride;
|
||
|
|
if (typeof f.value !== "undefined") f.value = g.u.YUVA.u_stride;
|
||
|
|
return g.u.YUVA.y
|
||
|
|
};
|
||
|
|
|
||
|
|
function WebPISetIOHooks(a, b, c, d, e) {
|
||
|
|
if (!a || !a.dec_ || a.state_ > cW) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
a.io_.put = b;
|
||
|
|
a.io_.setup = c;
|
||
|
|
a.io_.teardown = d;
|
||
|
|
a.io_.opaque = e;
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
var co = 12;
|
||
|
|
|
||
|
|
function WebPCheckAndSkipRIFFHeader(a, b, c, d) {
|
||
|
|
if (c.value >= co && !memcmp(a, b.value, "RIFF", 4)) {
|
||
|
|
if (memcmp(a, b.value + 8, "WEBP", 4)) {
|
||
|
|
return 0
|
||
|
|
} else {
|
||
|
|
d.value = get_le32(a, b.value + 4);
|
||
|
|
if (d.value < co) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
b.value += co;
|
||
|
|
c.value -= co
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
d.value = 0
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPResetDecParams(a) {
|
||
|
|
if (a) {}
|
||
|
|
}
|
||
|
|
var cq = '',
|
||
|
|
cr = '';
|
||
|
|
|
||
|
|
function DecodeInto(a, b, c, d) {
|
||
|
|
cr = new VP8New();
|
||
|
|
var e = T;
|
||
|
|
cq = newObjectIt(Y);
|
||
|
|
var f = 1;
|
||
|
|
assert(d);
|
||
|
|
if (cr == null) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
VP8InitIo(cq);
|
||
|
|
cq.data = a;
|
||
|
|
cq.data_off = b;
|
||
|
|
cq.data_size = c;
|
||
|
|
WebPInitCustomIo(d, cq);
|
||
|
|
cr.use_threads_ = 0;
|
||
|
|
if (!VP8GetHeaders(cr, cq)) {
|
||
|
|
e = VP8_STATUS_BITSTREAM_ERROR
|
||
|
|
} else {
|
||
|
|
e = WebPAllocateDecBuffer(cq.width, cq.height, d.options_, d.output);
|
||
|
|
if (e == T) {
|
||
|
|
if (!VP8Decode(cr, cq)) {
|
||
|
|
e = cr.status_
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
VP8Delete(cr);
|
||
|
|
if (e != T) {
|
||
|
|
this.WebPFreeDecBuffer(d.output)
|
||
|
|
}
|
||
|
|
return e
|
||
|
|
};
|
||
|
|
|
||
|
|
function DecodeIntoRGBABuffer(a, b, c, d, e, f) {
|
||
|
|
var g = newObjectIt(ba);
|
||
|
|
var h = newObjectIt(R);
|
||
|
|
if (d == null) {
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
WebPInitDecBuffer(h);
|
||
|
|
WebPResetDecParams(g);
|
||
|
|
g.output = h;
|
||
|
|
h.colorspace = a;
|
||
|
|
h.u.RGBA.rgba = d;
|
||
|
|
h.u.RGBA.rgba_off = 0;
|
||
|
|
h.u.RGBA.stride = e;
|
||
|
|
h.u.RGBA.size = f;
|
||
|
|
h.is_external_memory = 1;
|
||
|
|
if (DecodeInto(b, 0, c, g) != T) {
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
return d
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPDecodeRGBInto(a, b, c, d, e) {
|
||
|
|
return DecodeIntoRGBABuffer(O, a, b, c, e, d)
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPDecodeRGBAInto(a, b, c, d, e) {
|
||
|
|
return DecodeIntoRGBABuffer(MODE_RGBA, a, b, c, e, d)
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPDecodeARGBInto(a, b, c, d, e) {
|
||
|
|
return DecodeIntoRGBABuffer(MODE_ARGB, a, b, c, e, d)
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPDecodeBGRInto(a, b, c, d, e) {
|
||
|
|
return DecodeIntoRGBABuffer(MODE_BGR, a, b, c, e, d)
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPDecodeBGRAInto(a, b, c, d, e) {
|
||
|
|
return DecodeIntoRGBABuffer(MODE_BGRA, a, b, c, e, d)
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPDecodeYUVInto(a, b, c, d, e, f, u, g, h, i, v, j, k, l) {
|
||
|
|
var m = newObjectIt(ba);
|
||
|
|
var n = newObjectIt(R);
|
||
|
|
if (c == null) return null;
|
||
|
|
WebPInitDecBuffer(n);
|
||
|
|
WebPResetDecParams(m);
|
||
|
|
m.output = n;
|
||
|
|
n.colorspace = MODE_YUV;
|
||
|
|
n.u.YUVA.y = c;
|
||
|
|
n.u.YUVA.y_off = d;
|
||
|
|
n.u.YUVA.y_stride = f;
|
||
|
|
n.u.YUVA.y_size = e;
|
||
|
|
n.u.YUVA.u = u;
|
||
|
|
n.u.YUVA.u_off = g;
|
||
|
|
n.u.YUVA.u_stride = i;
|
||
|
|
n.u.YUVA.u_size = h;
|
||
|
|
n.u.YUVA.v = v;
|
||
|
|
n.u.YUVA.v_off = j;
|
||
|
|
n.u.YUVA.v_stride = l;
|
||
|
|
n.u.YUVA.v_size = k;
|
||
|
|
n.is_external_memory = 1;
|
||
|
|
if (DecodeInto(a, 0, b, m) != T) {
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
var db = -1,
|
||
|
|
data_size = -1,
|
||
|
|
params_out = -1;
|
||
|
|
var dc = -1;
|
||
|
|
|
||
|
|
function Decode(a, b, c, d, e, f) {
|
||
|
|
data_off = {
|
||
|
|
value: 0
|
||
|
|
};
|
||
|
|
c = {
|
||
|
|
value: c
|
||
|
|
};
|
||
|
|
var g = newObjectIt(ba);
|
||
|
|
var h = newObjectIt(R);
|
||
|
|
WebPInitDecBuffer(h);
|
||
|
|
WebPResetDecParams(g);
|
||
|
|
g.output = h;
|
||
|
|
h.colorspace = a;
|
||
|
|
var o = {
|
||
|
|
data_off: {
|
||
|
|
value: 0
|
||
|
|
},
|
||
|
|
width: {
|
||
|
|
value: h.width
|
||
|
|
},
|
||
|
|
height: {
|
||
|
|
value: h.height
|
||
|
|
}
|
||
|
|
};
|
||
|
|
if (!WebPGetInfo(b, data_off, c, o.width, o.height)) {
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
h.width = o.width.value;
|
||
|
|
h.height = o.height.value;
|
||
|
|
if (d) d.value = h.width.value;
|
||
|
|
if (e) e.value = h.height.value;
|
||
|
|
if (DecodeInto(b, data_off.value, c.value, g) != T) {
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
if (f) {
|
||
|
|
WebPCopyDecBuffer(h, f)
|
||
|
|
}
|
||
|
|
return (a >= MODE_YUV) ? h.u.YUVA.y : h.u.RGBA.rgba
|
||
|
|
}
|
||
|
|
this.WebPDecodeRGB = function(a, b, c, d) {
|
||
|
|
return Decode(O, a, b, c, d, null)
|
||
|
|
};
|
||
|
|
this.WebPDecodeRGBA = function(a, b, c, d) {
|
||
|
|
return Decode(MODE_RGBA, a, b, c, d, null)
|
||
|
|
};
|
||
|
|
this.WebPDecodeRGBA_4444 = function(a, b, c, d) {
|
||
|
|
return Decode(MODE_RGBA_4444, a, b, c, d, null)
|
||
|
|
};
|
||
|
|
this.WebPDecodeARGB = function(a, b, c, d) {
|
||
|
|
return Decode(MODE_ARGB, a, b, c, d, null)
|
||
|
|
};
|
||
|
|
this.WebPDecodeBGR = function(a, b, c, d) {
|
||
|
|
return Decode(MODE_BGR, a, b, c, d, null)
|
||
|
|
};
|
||
|
|
this.WebPDecodeBGRA = function(a, b, c, d) {
|
||
|
|
return Decode(MODE_BGRA, a, b, c, d, null)
|
||
|
|
};
|
||
|
|
|
||
|
|
function DefaultFeatures(a) {
|
||
|
|
assert(a);
|
||
|
|
a.bitstream_version = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function GetFeatures(a, b, c, d) {
|
||
|
|
var e = {
|
||
|
|
value: 0
|
||
|
|
};
|
||
|
|
var f = {
|
||
|
|
value: 0
|
||
|
|
};
|
||
|
|
var g = {
|
||
|
|
value: 0
|
||
|
|
};
|
||
|
|
var h = {
|
||
|
|
value: 0
|
||
|
|
};
|
||
|
|
var i = {
|
||
|
|
value: 0
|
||
|
|
};
|
||
|
|
if (d == null) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
DefaultFeatures(d);
|
||
|
|
if (a == null || b == null || c.value == 0) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
if (!WebPCheckAndSkipRIFFHeader(a, b, c, f)) {
|
||
|
|
return VP8_STATUS_BITSTREAM_ERROR
|
||
|
|
}
|
||
|
|
if (!VP8XGetInfo(a, b, c, h, d.width, d.height, g)) {
|
||
|
|
return VP8_STATUS_BITSTREAM_ERROR
|
||
|
|
}
|
||
|
|
if (h.value > 0) {
|
||
|
|
return T
|
||
|
|
}
|
||
|
|
if (!VP8CheckAndSkipHeader(a, b, c, i, e, f)) {
|
||
|
|
return VP8_STATUS_BITSTREAM_ERROR
|
||
|
|
}
|
||
|
|
if (i.value == -1) {
|
||
|
|
return VP8_STATUS_BITSTREAM_ERROR
|
||
|
|
}
|
||
|
|
if (!i.value) {
|
||
|
|
e.value = c.value
|
||
|
|
}
|
||
|
|
if (!VP8GetInfo(a, b, c, e, d.width, d.height, d.has_alpha)) {
|
||
|
|
return VP8_STATUS_BITSTREAM_ERROR
|
||
|
|
}
|
||
|
|
return T
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPGetInfo(a, b, c, d, e) {
|
||
|
|
var f = newObjectIt(U);
|
||
|
|
if (GetFeatures(a, b, c, f) != T) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (d) {
|
||
|
|
d.value = f.width
|
||
|
|
}
|
||
|
|
if (e) {
|
||
|
|
e.value = f.height
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPInitDecoderConfigInternal(a, b) {
|
||
|
|
if (b != N) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (a == null) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
DefaultFeatures(a.input);
|
||
|
|
WebPInitDecBuffer(a.output);
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPGetFeaturesInternal(a, b, c, d) {
|
||
|
|
if (d != N) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
if (c == null) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
var e = {
|
||
|
|
value: 0
|
||
|
|
};
|
||
|
|
var b = {
|
||
|
|
value: b
|
||
|
|
};
|
||
|
|
return GetFeatures(a, e, b, c)
|
||
|
|
}
|
||
|
|
this.WebPDecode = function(a, b, c) {
|
||
|
|
var d = newObjectIt(ba);
|
||
|
|
var e = 'VP8StatusCode';
|
||
|
|
if (!c) {
|
||
|
|
return VP8_STATUS_INVALID_PARAM
|
||
|
|
}
|
||
|
|
var f = {
|
||
|
|
value: 0
|
||
|
|
};
|
||
|
|
b = {
|
||
|
|
value: b
|
||
|
|
};
|
||
|
|
e = GetFeatures(a, f, b, c.input);
|
||
|
|
if (e != T) {
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
WebPResetDecParams(d);
|
||
|
|
d.output = c.output;
|
||
|
|
d.options_ = c.options;
|
||
|
|
e = DecodeInto(a, f.value, b.value, d);
|
||
|
|
return e
|
||
|
|
};
|
||
|
|
var dd, height;
|
||
|
|
var db = -1,
|
||
|
|
data_size = -1,
|
||
|
|
dd = -1,
|
||
|
|
height = -1,
|
||
|
|
params_out = -1;
|
||
|
|
var dc = -1
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPEncoder() {
|
||
|
|
var N = 0x0002;
|
||
|
|
var O = {
|
||
|
|
quality: float,
|
||
|
|
target_size: int,
|
||
|
|
target_PSNR: float,
|
||
|
|
method: int,
|
||
|
|
segments: int,
|
||
|
|
sns_strength: int,
|
||
|
|
filter_strength: int,
|
||
|
|
filter_sharpness: int,
|
||
|
|
filter_type: int,
|
||
|
|
autofilter: int,
|
||
|
|
pass: int,
|
||
|
|
show_compressed: int,
|
||
|
|
preprocessing: int,
|
||
|
|
partitions: int,
|
||
|
|
partition_limit: int,
|
||
|
|
alpha_compression: int
|
||
|
|
};
|
||
|
|
var P = {
|
||
|
|
WEBP_PRESET_DEFAULT: 0,
|
||
|
|
WEBP_PRESET_PICTURE: 1,
|
||
|
|
WEBP_PRESET_PHOTO: 2,
|
||
|
|
WEBP_PRESET_DRAWING: 3,
|
||
|
|
WEBP_PRESET_ICON: 4,
|
||
|
|
WEBP_PRESET_TEXT: 5
|
||
|
|
};
|
||
|
|
|
||
|
|
function WebPConfigPreset(a, b, c) {
|
||
|
|
return WebPConfigInitInternal(a, b, c, N)
|
||
|
|
}
|
||
|
|
var S = {
|
||
|
|
PSNR: Arr(4, float),
|
||
|
|
coded_size: int,
|
||
|
|
block_count: Arr(3, int),
|
||
|
|
header_bytes: Arr(2, int),
|
||
|
|
residual_bytes: ArrM(new Array(3, 4), int),
|
||
|
|
segment_size: Arr(4, int),
|
||
|
|
segment_quant: Arr(4, int),
|
||
|
|
segment_level: Arr(4, int),
|
||
|
|
alpha_data_size: int,
|
||
|
|
layer_data_size: int
|
||
|
|
};
|
||
|
|
var T = 0,
|
||
|
|
WEBP_YUV422 = 1,
|
||
|
|
WEBP_YUV444 = 2,
|
||
|
|
WEBP_YUV400 = 3,
|
||
|
|
WEBP_CSP_UV_MASK = 3,
|
||
|
|
WEBP_YUV420A = 4,
|
||
|
|
WEBP_YUV422A = 5,
|
||
|
|
WEBP_YUV444A = 6,
|
||
|
|
WEBP_YUV400A = 7,
|
||
|
|
WEBP_CSP_ALPHA_BIT = 4;
|
||
|
|
var U = 0,
|
||
|
|
VP8_ENC_ERROR_OUT_OF_MEMORY = 1,
|
||
|
|
VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY = 2,
|
||
|
|
VP8_ENC_ERROR_NULL_PARAMETER = 3,
|
||
|
|
VP8_ENC_ERROR_INVALID_CONFIGURATION = 4,
|
||
|
|
VP8_ENC_ERROR_BAD_DIMENSION = 5,
|
||
|
|
VP8_ENC_ERROR_PARTITION0_OVERFLOW = 6,
|
||
|
|
VP8_ENC_ERROR_PARTITION_OVERFLOW = 7,
|
||
|
|
VP8_ENC_ERROR_BAD_WRITE = 8;
|
||
|
|
var V = {
|
||
|
|
colorspace: 'WebPEncCSP',
|
||
|
|
width: int,
|
||
|
|
height: int,
|
||
|
|
y: uint8_t,
|
||
|
|
u: uint8_t,
|
||
|
|
v: uint8_t,
|
||
|
|
y_off: 0,
|
||
|
|
u_off: 0,
|
||
|
|
v_off: 0,
|
||
|
|
y_stride: int,
|
||
|
|
uv_stride: int,
|
||
|
|
a: uint8_t,
|
||
|
|
a_off: 0,
|
||
|
|
a_stride: int,
|
||
|
|
writer: function WebPWriterFunction() {},
|
||
|
|
custom_ptr: void_,
|
||
|
|
extra_info_type: int,
|
||
|
|
extra_info: uint8_t,
|
||
|
|
stats: newObjectIt(S),
|
||
|
|
stats_nozero: 1,
|
||
|
|
u0: uint8_t,
|
||
|
|
v0: uint8_t,
|
||
|
|
u0_off: 0,
|
||
|
|
v0_off: 0,
|
||
|
|
uv0_stride: int,
|
||
|
|
error_code: 'WebPEncodingError'
|
||
|
|
};
|
||
|
|
|
||
|
|
function WebPPictureInit(a) {
|
||
|
|
return WebPPictureInitInternal(a, N)
|
||
|
|
}
|
||
|
|
var Y = {
|
||
|
|
range_: int32_t,
|
||
|
|
value_: int32_t,
|
||
|
|
run_: int,
|
||
|
|
nb_bits_: int,
|
||
|
|
buf_: uint8_t,
|
||
|
|
buf_off: 0,
|
||
|
|
pos_: size_t,
|
||
|
|
max_pos_: size_t,
|
||
|
|
error_: int
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8BitWriterPos(a) {
|
||
|
|
return (a.pos_ + a.run_) * 8 + 8 + a.nb_bits_
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8BitWriterBuf(a) {
|
||
|
|
return a.buf_
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8BitWriterSize(a) {
|
||
|
|
return a.pos_
|
||
|
|
}
|
||
|
|
var Z = 0;
|
||
|
|
var ba = 1;
|
||
|
|
var bb = 2;
|
||
|
|
var bc = 64;
|
||
|
|
var bd = 0,
|
||
|
|
B_TM_PRED = 1,
|
||
|
|
B_VE_PRED = 2,
|
||
|
|
B_HE_PRED = 3,
|
||
|
|
B_RD_PRED = 4,
|
||
|
|
B_VR_PRED = 5,
|
||
|
|
B_LD_PRED = 6,
|
||
|
|
B_VL_PRED = 7,
|
||
|
|
B_HD_PRED = 8,
|
||
|
|
B_HU_PRED = 9,
|
||
|
|
NUM_BMODES = (B_HU_PRED + 1 - bd),
|
||
|
|
DC_PRED = bd,
|
||
|
|
V_PRED = B_VE_PRED,
|
||
|
|
H_PRED = B_HE_PRED,
|
||
|
|
TM_PRED = B_TM_PRED;
|
||
|
|
var be = 4,
|
||
|
|
MAX_NUM_PARTITIONS = 8,
|
||
|
|
NUM_TYPES = 4,
|
||
|
|
NUM_BANDS = 8,
|
||
|
|
NUM_CTX = 3,
|
||
|
|
NUM_PROBAS = 11,
|
||
|
|
MAX_LF_LEVELS = 64,
|
||
|
|
MAX_VARIABLE_LEVEL = 67;
|
||
|
|
var bf = 16;
|
||
|
|
var bg = (bf * 16);
|
||
|
|
var bh = (bf * 8);
|
||
|
|
var bi = (bg + bh);
|
||
|
|
var bj = (6 * 16 * bf + 12 * bf);
|
||
|
|
var bk = (0);
|
||
|
|
var bl = (bg);
|
||
|
|
var bm = (bl + 8);
|
||
|
|
var bn = 15;
|
||
|
|
var bo = (0 * 16 * bf);
|
||
|
|
var bp = (1 * 16 * bf);
|
||
|
|
var bq = (2 * 16 * bf);
|
||
|
|
var br = (3 * 16 * bf);
|
||
|
|
var bs = (4 * 16 * bf);
|
||
|
|
var bt = (4 * 16 * bf + 8 * bf);
|
||
|
|
var bu = (5 * 16 * bf);
|
||
|
|
var bv = (5 * 16 * bf + 8 * bf);
|
||
|
|
var bw = (6 * 16 * bf + 0);
|
||
|
|
var bx = (6 * 16 * bf + 4);
|
||
|
|
var by = (6 * 16 * bf + 8);
|
||
|
|
var bz = (6 * 16 * bf + 12);
|
||
|
|
var bA = (6 * 16 * bf + 4 * bf + 0);
|
||
|
|
var bB = (6 * 16 * bf + 4 * bf + 4);
|
||
|
|
var bC = (6 * 16 * bf + 4 * bf + 8);
|
||
|
|
var bD = (6 * 16 * bf + 4 * bf + 12);
|
||
|
|
var bE = (6 * 16 * bf + 8 * bf + 0);
|
||
|
|
var bF = (6 * 16 * bf + 8 * bf + 4);
|
||
|
|
var bG = (6 * 16 * bf + 8 * bf + 8);
|
||
|
|
var bH = 0x7fffffffffffff;
|
||
|
|
var bI = 17;
|
||
|
|
|
||
|
|
function BIAS(b) {
|
||
|
|
return ((b) << (bI - 8))
|
||
|
|
}
|
||
|
|
|
||
|
|
function QUANTDIV(n, a, B) {
|
||
|
|
return ((n * a + B) >> bI)
|
||
|
|
}
|
||
|
|
var bJ = ArrM(new Array(NUM_CTX, NUM_PROBAS), uint8_t);
|
||
|
|
var bK = ArrM(new Array(NUM_CTX, NUM_PROBAS, 2), uint64_t);
|
||
|
|
var bL = ArrM(new Array(NUM_CTX, (MAX_VARIABLE_LEVEL + 1)), uint16_t);
|
||
|
|
var bM = ArrM(new Array(be, MAX_LF_LEVELS), double);
|
||
|
|
var bN = {
|
||
|
|
num_segments_: int,
|
||
|
|
update_map_: int,
|
||
|
|
size_: int
|
||
|
|
};
|
||
|
|
var bO = {
|
||
|
|
segments_: Arr(3, uint8_t),
|
||
|
|
skip_proba_: uint8_t,
|
||
|
|
coeffs_: ArrM(new Array(NUM_TYPES, NUM_BANDS), bJ),
|
||
|
|
stats_: ArrM(new Array(NUM_TYPES, NUM_BANDS), bK),
|
||
|
|
level_cost_: ArrM(new Array(NUM_TYPES, NUM_BANDS), bL),
|
||
|
|
use_skip_proba_: int,
|
||
|
|
nb_skip_: int
|
||
|
|
};
|
||
|
|
var bP = {
|
||
|
|
simple_: int,
|
||
|
|
level_: int,
|
||
|
|
sharpness_: int,
|
||
|
|
i4x4_lf_delta_: int
|
||
|
|
};
|
||
|
|
var bQ = {
|
||
|
|
type_: 0,
|
||
|
|
uv_mode_: 0,
|
||
|
|
skip_: 0,
|
||
|
|
segment_: 0,
|
||
|
|
alpha_: uint8_t
|
||
|
|
};
|
||
|
|
var bR = {
|
||
|
|
q_: Arr(16, uint16_t),
|
||
|
|
iq_: Arr(16, uint16_t),
|
||
|
|
bias_: Arr(16, uint16_t),
|
||
|
|
zthresh_: Arr(16, uint16_t),
|
||
|
|
sharpen_: Arr(16, uint16_t)
|
||
|
|
};
|
||
|
|
var bS = {
|
||
|
|
y1_: newObjectIt(bR),
|
||
|
|
y2_: newObjectIt(bR),
|
||
|
|
uv_: newObjectIt(bR),
|
||
|
|
alpha_: int,
|
||
|
|
beta_: int,
|
||
|
|
quant_: int,
|
||
|
|
fstrength_: int,
|
||
|
|
lambda_i16_: int,
|
||
|
|
lambda_i4_: int,
|
||
|
|
lambda_uv_: int,
|
||
|
|
lambda_mode_: int,
|
||
|
|
lambda_trellis_: int,
|
||
|
|
tlambda_: int,
|
||
|
|
lambda_trellis_i16_: int,
|
||
|
|
lambda_trellis_i4_: int,
|
||
|
|
lambda_trellis_uv_: int
|
||
|
|
};
|
||
|
|
var bT = {
|
||
|
|
config_: newObjectIt(O),
|
||
|
|
pic_: newObjectIt(V),
|
||
|
|
filter_hdr_: newObjectIt(bP),
|
||
|
|
segment_hdr_: newObjectIt(bN),
|
||
|
|
profile_: int,
|
||
|
|
mb_w_: int,
|
||
|
|
mb_h_: int,
|
||
|
|
preds_w_: int,
|
||
|
|
num_parts_: int,
|
||
|
|
bw_: newObjectIt(Y),
|
||
|
|
parts_: Arr_nOI(MAX_NUM_PARTITIONS, Y),
|
||
|
|
has_alpha_: int,
|
||
|
|
alpha_data_: uint8_t,
|
||
|
|
alpha_data_off: 0,
|
||
|
|
alpha_data_size_: size_t,
|
||
|
|
use_layer_: int,
|
||
|
|
layer_bw_: Y,
|
||
|
|
layer_data_: uint8_t,
|
||
|
|
layer_data_off: 0,
|
||
|
|
layer_data_size_: size_t,
|
||
|
|
dqm_: Arr_nOI(be, bS),
|
||
|
|
base_quant_: int,
|
||
|
|
uv_alpha_: int,
|
||
|
|
dq_y1_dc_: int,
|
||
|
|
dq_y2_dc_: int,
|
||
|
|
dq_y2_ac_: int,
|
||
|
|
dq_uv_dc_: int,
|
||
|
|
dq_uv_ac_: int,
|
||
|
|
proba_: newObjectIt(bO),
|
||
|
|
proba_off: 0,
|
||
|
|
sse_: Arr(3, uint64_t),
|
||
|
|
sse_count_: uint64_t,
|
||
|
|
coded_size_: int,
|
||
|
|
residual_bytes_: ArrM(new Array(3, 4), int),
|
||
|
|
block_count_: Arr(3, int),
|
||
|
|
method_: int,
|
||
|
|
rd_opt_level_: int,
|
||
|
|
max_i4_header_bits_: int,
|
||
|
|
mb_info_: newObjectIt(bQ),
|
||
|
|
mb_info_off: 0,
|
||
|
|
preds_: uint8_t,
|
||
|
|
preds_off: 0,
|
||
|
|
nz_: uint32_t,
|
||
|
|
nz_off: 0,
|
||
|
|
yuv_in_: uint8_t,
|
||
|
|
yuv_in_off: 0,
|
||
|
|
yuv_out_: uint8_t,
|
||
|
|
yuv_out_off: 0,
|
||
|
|
yuv_out2_: uint8_t,
|
||
|
|
yuv_out2_off: 0,
|
||
|
|
yuv_p_: uint8_t,
|
||
|
|
yuv_p_off: 0,
|
||
|
|
y_top_: uint8_t,
|
||
|
|
y_top_off: 0,
|
||
|
|
uv_top_: uint8_t,
|
||
|
|
uv_top_off: 0,
|
||
|
|
y_left_: uint8_t,
|
||
|
|
y_left_off: 0,
|
||
|
|
u_left_: uint8_t,
|
||
|
|
u_left_off: 0,
|
||
|
|
v_left_: uint8_t,
|
||
|
|
v_left_off: 0,
|
||
|
|
lf_stats_: newObjectIt(bM)
|
||
|
|
};
|
||
|
|
var bU = {
|
||
|
|
D: score_t,
|
||
|
|
SD: score_t,
|
||
|
|
R: score_t,
|
||
|
|
score: score_t,
|
||
|
|
y_dc_levels: Arr(16, int16_t),
|
||
|
|
y_ac_levels: ArrM(new Array(16, 16), int16_t),
|
||
|
|
uv_levels: ArrM(new Array(4 + 4, 16), int16_t),
|
||
|
|
mode_i16: int,
|
||
|
|
modes_i4: Arr(16, int),
|
||
|
|
mode_uv: int,
|
||
|
|
nz: uint32_t
|
||
|
|
};
|
||
|
|
var bV = {
|
||
|
|
x_: int,
|
||
|
|
y_: int,
|
||
|
|
y_offset_: int,
|
||
|
|
uv_offset_: int,
|
||
|
|
y_stride_: int,
|
||
|
|
uv_stride_: int,
|
||
|
|
yuv_in_: uint8_t,
|
||
|
|
yuv_in_off: 0,
|
||
|
|
yuv_out_: uint8_t,
|
||
|
|
yuv_out_off: 0,
|
||
|
|
yuv_out2_: uint8_t,
|
||
|
|
yuv_out2_off: 0,
|
||
|
|
yuv_p_: uint8_t,
|
||
|
|
yuv_p_off: 0,
|
||
|
|
enc_: newObjectIt(bT),
|
||
|
|
mb_: newObjectIt(bQ),
|
||
|
|
mb_off: 0,
|
||
|
|
bw_: newObjectIt(Y),
|
||
|
|
preds_: uint8_t,
|
||
|
|
preds_off: 0,
|
||
|
|
nz_: uint32_t,
|
||
|
|
nz_off: 0,
|
||
|
|
i4_boundary_: Arr(37, uint8_t),
|
||
|
|
i4_boundary_off: 0,
|
||
|
|
i4_top_: uint8_t,
|
||
|
|
i4_top_off: 0,
|
||
|
|
i4_: int,
|
||
|
|
top_nz_: Arr(9, int),
|
||
|
|
left_nz_: Arr(9, int),
|
||
|
|
bit_count_: ArrM(Array(4, 3), uint64_t),
|
||
|
|
luma_bits_: uint64_t,
|
||
|
|
uv_bits_: uint64_t,
|
||
|
|
lf_stats_: newObjectIt(bM),
|
||
|
|
do_trellis_: int,
|
||
|
|
done_: int
|
||
|
|
};
|
||
|
|
var bW = 8192;
|
||
|
|
|
||
|
|
function CompressAlpha(a, b, c, d, e, f) {
|
||
|
|
var g = WebPZlib.compress(a.slice(b, b + c), (f ? 3 : 6));
|
||
|
|
d.val = g;
|
||
|
|
e.val = g.length;
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8EncInitAlpha(a) {
|
||
|
|
a.has_alpha_ = (a.pic_.a != null) + 0;
|
||
|
|
a.alpha_data_ = null;
|
||
|
|
a.alpha_data_size_ = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8EncCodeAlphaBlock(a) {}
|
||
|
|
|
||
|
|
function VP8EncFinishAlpha(a) {
|
||
|
|
if (a.has_alpha_) {
|
||
|
|
var b = a.pic_;
|
||
|
|
assert(b.a);
|
||
|
|
a.alpha_data_ = {
|
||
|
|
val: a.alpha_data_
|
||
|
|
};
|
||
|
|
a.alpha_data_size_ = {
|
||
|
|
val: a.alpha_data_size
|
||
|
|
};
|
||
|
|
if (!CompressAlpha(b.a, 0, b.width * b.height, a.alpha_data_, a.alpha_data_size_, a.config_.alpha_compression)) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
a.alpha_data_ = a.alpha_data_.val;
|
||
|
|
a.alpha_data_size_ = a.alpha_data_size_.val
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8EncDeleteAlpha(a) {
|
||
|
|
a.alpha_data_ = '';
|
||
|
|
a.alpha_data_ = null;
|
||
|
|
a.alpha_data_size_ = 0;
|
||
|
|
a.has_alpha_ = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8EncInitLayer(a) {
|
||
|
|
a.use_layer_ = (a.pic_.u0 != null) + 0;
|
||
|
|
a.layer_data_size_ = 0;
|
||
|
|
a.layer_data_ = null;
|
||
|
|
if (a.use_layer_) {
|
||
|
|
VP8BitWriterInit(a.layer_bw_, a.mb_w_ * a.mb_h_ * 3)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8EncCodeLayerBlock(a) {}
|
||
|
|
|
||
|
|
function VP8EncFinishLayer(a) {
|
||
|
|
if (a.use_layer_) {
|
||
|
|
a.layer_data_ = VP8BitWriterFinish(a.layer_bw_);
|
||
|
|
a.layer_data_size_ = VP8BitWriterSize(a.layer_bw_)
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8EncDeleteLayer(a) {
|
||
|
|
a.layer_data_ = ''
|
||
|
|
}
|
||
|
|
var bX = 0x9d012a;
|
||
|
|
var bY = 10;
|
||
|
|
var bZ = 20;
|
||
|
|
var ca = (bZ - 8);
|
||
|
|
var cb = (1 << 19);
|
||
|
|
var cc = (1 << 24);
|
||
|
|
|
||
|
|
function PutLE32(a, b, c) {
|
||
|
|
a[b + 0] = (c >> 0) & 0xff;
|
||
|
|
a[b + 1] = (c >> 8) & 0xff;
|
||
|
|
a[b + 2] = (c >> 16) & 0xff;
|
||
|
|
a[b + 3] = (c >> 24) & 0xff
|
||
|
|
}
|
||
|
|
|
||
|
|
function PutHeader(a, b, c, d) {
|
||
|
|
var e = Arr(bY, uint8_t);
|
||
|
|
var f = new Array('R', 'I', 'F', 'F', 0, 0, 0, 0, 'W', 'E', 'B', 'P', 'V', 'P', '8', ' ');
|
||
|
|
var g = uint32_t;
|
||
|
|
if (b >= cb) {
|
||
|
|
return WebPEncodingSetError(d, VP8_ENC_ERROR_PARTITION0_OVERFLOW)
|
||
|
|
}
|
||
|
|
for (var i = 0; i < f.length; ++i) {
|
||
|
|
f[i] = f[i] != '0' ? String(f[i]).charCodeAt(0) : 0
|
||
|
|
}
|
||
|
|
PutLE32(f, +4, c + ca);
|
||
|
|
PutLE32(f, +16, c);
|
||
|
|
if (!d.writer(f, sizeof(f) * f.length, d)) {
|
||
|
|
return WebPEncodingSetError(d, VP8_ENC_ERROR_BAD_WRITE)
|
||
|
|
}
|
||
|
|
g = 0 | (a << 1) | (1 << 4) | (b << 5);
|
||
|
|
e[0] = g & 0xff;
|
||
|
|
e[1] = (g >> 8) & 0xff;
|
||
|
|
e[2] = (g >> 16) & 0xff;
|
||
|
|
e[3] = (bX >> 16) & 0xff;
|
||
|
|
e[4] = (bX >> 8) & 0xff;
|
||
|
|
e[5] = (bX >> 0) & 0xff;
|
||
|
|
e[6] = d.width & 0xff;
|
||
|
|
e[7] = d.width >> 8;
|
||
|
|
e[8] = d.height & 0xff;
|
||
|
|
e[9] = d.height >> 8;
|
||
|
|
return d.writer(e, sizeof(e) * e.length, d)
|
||
|
|
}
|
||
|
|
|
||
|
|
function PutSegmentHeader(a, b) {
|
||
|
|
var c = b.segment_hdr_;
|
||
|
|
var d = b.proba_;
|
||
|
|
if (VP8PutBitUniform(a, (c.num_segments_ > 1))) {
|
||
|
|
var e = 1;
|
||
|
|
var s;
|
||
|
|
VP8PutBitUniform(a, c.update_map_);
|
||
|
|
if (VP8PutBitUniform(a, e)) {
|
||
|
|
VP8PutBitUniform(a, 1);
|
||
|
|
for (s = 0; s < be; ++s) {
|
||
|
|
VP8PutSignedValue(a, b.dqm_[s].quant_, 7)
|
||
|
|
}
|
||
|
|
for (s = 0; s < be; ++s) {
|
||
|
|
VP8PutSignedValue(a, b.dqm_[s].fstrength_, 6)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (c.update_map_) {
|
||
|
|
for (s = 0; s < 3; ++s) {
|
||
|
|
if (VP8PutBitUniform(a, (d.segments_[s] != 255))) {
|
||
|
|
VP8PutValue(a, d.segments_[s], 8)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function PutFilterHeader(a, b) {
|
||
|
|
var c = (b.i4x4_lf_delta_ != 0) + 0;
|
||
|
|
VP8PutBitUniform(a, b.simple_);
|
||
|
|
VP8PutValue(a, b.level_, 6);
|
||
|
|
VP8PutValue(a, b.sharpness_, 3);
|
||
|
|
if (VP8PutBitUniform(a, c)) {
|
||
|
|
var d = (b.i4x4_lf_delta_ != 0);
|
||
|
|
if (VP8PutBitUniform(a, d)) {
|
||
|
|
VP8PutValue(a, 0, 4);
|
||
|
|
VP8PutSignedValue(a, b.i4x4_lf_delta_, 6);
|
||
|
|
VP8PutValue(a, 0, 3)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function PutQuant(a, b) {
|
||
|
|
VP8PutValue(a, b.base_quant_, 7);
|
||
|
|
VP8PutSignedValue(a, b.dq_y1_dc_, 4);
|
||
|
|
VP8PutSignedValue(a, b.dq_y2_dc_, 4);
|
||
|
|
VP8PutSignedValue(a, b.dq_y2_ac_, 4);
|
||
|
|
VP8PutSignedValue(a, b.dq_uv_dc_, 4);
|
||
|
|
VP8PutSignedValue(a, b.dq_uv_ac_, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function EmitPartitionsSize(a, b) {
|
||
|
|
var c = Arr(3 * (MAX_NUM_PARTITIONS - 1), uint8_t);
|
||
|
|
var p;
|
||
|
|
for (p = 0; p < a.num_parts_ - 1; ++p) {
|
||
|
|
var d = VP8BitWriterSize(a.parts_[p]);
|
||
|
|
if (d >= cc) {
|
||
|
|
return WebPEncodingSetError(b, VP8_ENC_ERROR_PARTITION_OVERFLOW)
|
||
|
|
}
|
||
|
|
c[3 * p + 0] = (d >> 0) & 0xff;
|
||
|
|
c[3 * p + 1] = (d >> 8) & 0xff;
|
||
|
|
c[3 * p + 2] = (d >> 16) & 0xff
|
||
|
|
}
|
||
|
|
return p ? b.writer(c, 3 * p, b) : 1
|
||
|
|
}
|
||
|
|
var cd = 8;
|
||
|
|
|
||
|
|
function PutLE24(a, b, c) {
|
||
|
|
a[b + 0] = (c >> 0) & 0xff;
|
||
|
|
a[b + 1] = (c >> 8) & 0xff;
|
||
|
|
a[b + 2] = (c >> 16) & 0xff
|
||
|
|
}
|
||
|
|
|
||
|
|
function WriteExtensions(a) {
|
||
|
|
var b = Arr(cd, uint8_t);
|
||
|
|
var c = a.bw_;
|
||
|
|
var d = a.pic_;
|
||
|
|
PutLE24(b, +0, a.layer_data_size_);
|
||
|
|
b[3] = a.pic_.colorspace & WEBP_CSP_UV_MASK;
|
||
|
|
if (a.layer_data_size_ > 0) {
|
||
|
|
assert(a.use_layer_);
|
||
|
|
if (!VP8BitWriterAppend(a.parts_[a.num_parts_ - 1], a.layer_data_, a.layer_data_off, a.layer_data_size_)) {
|
||
|
|
return WebPEncodingSetError(d, VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
PutLE24(b, +4, a.alpha_data_size_);
|
||
|
|
if (a.alpha_data_size_ > 0) {
|
||
|
|
assert(a.has_alpha_);
|
||
|
|
if (!VP8BitWriterAppend(c, a.alpha_data_, a.alpha_data_off, a.alpha_data_size_)) {
|
||
|
|
return WebPEncodingSetError(d, VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
b[cd - 1] = 0x01;
|
||
|
|
if (!VP8BitWriterAppend(c, b, 0, cd)) {
|
||
|
|
return WebPEncodingSetError(d, VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY)
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function GeneratePartition0(a) {
|
||
|
|
var b = a.bw_;
|
||
|
|
var c = a.mb_w_ * a.mb_h_;
|
||
|
|
var d = uint64_t,
|
||
|
|
pos2 = uint64_t,
|
||
|
|
pos3 = uint64_t;
|
||
|
|
var e = a.has_alpha_ || a.use_layer_;
|
||
|
|
d = VP8BitWriterPos(b);
|
||
|
|
VP8BitWriterInit(b, parseInt(c * 7 / 8));
|
||
|
|
VP8PutBitUniform(b, e);
|
||
|
|
VP8PutBitUniform(b, 0);
|
||
|
|
PutSegmentHeader(b, a);
|
||
|
|
PutFilterHeader(b, a.filter_hdr_);
|
||
|
|
VP8PutValue(b, a.config_.partitions, 2);
|
||
|
|
PutQuant(b, a);
|
||
|
|
VP8PutBitUniform(b, 0);
|
||
|
|
VP8WriteProbas(b, a.proba_);
|
||
|
|
pos2 = VP8BitWriterPos(b);
|
||
|
|
VP8CodeIntraModes(a);
|
||
|
|
VP8BitWriterFinish(b);
|
||
|
|
if (e && !WriteExtensions(a)) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
pos3 = VP8BitWriterPos(b);
|
||
|
|
if (a.pic_.stats_nozero) {
|
||
|
|
a.pic_.stats.header_bytes[0] = parseInt((pos2 - d + 7) >> 3);
|
||
|
|
a.pic_.stats.header_bytes[1] = parseInt((pos3 - pos2 + 7) >> 3);
|
||
|
|
a.pic_.stats.alpha_data_size = a.alpha_data_size_;
|
||
|
|
a.pic_.stats.layer_data_size = a.layer_data_size_
|
||
|
|
}
|
||
|
|
return !b.error_
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8EncWrite(a) {
|
||
|
|
var b = a.pic_;
|
||
|
|
var c = a.bw_;
|
||
|
|
var d = 0;
|
||
|
|
var e = size_t,
|
||
|
|
pad = size_t;
|
||
|
|
var p;
|
||
|
|
d = GeneratePartition0(a);
|
||
|
|
e = bY + VP8BitWriterSize(c) + 3 * (a.num_parts_ - 1);
|
||
|
|
for (p = 0; p < a.num_parts_; ++p) {
|
||
|
|
e += VP8BitWriterSize(a.parts_[p])
|
||
|
|
}
|
||
|
|
pad = e & 1;
|
||
|
|
e += pad; {
|
||
|
|
var f = VP8BitWriterBuf(c);
|
||
|
|
var g = VP8BitWriterSize(c);
|
||
|
|
d = d && PutHeader(a.profile_, g, e, b) && b.writer(f, g, b) && EmitPartitionsSize(a, b);
|
||
|
|
f = ''
|
||
|
|
}
|
||
|
|
for (p = 0; p < a.num_parts_; ++p) {
|
||
|
|
var h = VP8BitWriterBuf(a.parts_[p]);
|
||
|
|
var i = VP8BitWriterSize(a.parts_[p]);
|
||
|
|
if (i) d = d && b.writer(h, i, b);
|
||
|
|
h = ''
|
||
|
|
}
|
||
|
|
if (d && pad) {
|
||
|
|
var j = new Array(0);
|
||
|
|
d = b.writer(j, 1, b)
|
||
|
|
}
|
||
|
|
a.coded_size_ = e + bZ;
|
||
|
|
return d
|
||
|
|
}
|
||
|
|
var ce = Arr(255 + 255 + 1, uint8_t);
|
||
|
|
var cf = Arr(255 + 255 + 1, uint8_t);
|
||
|
|
var cg = Arr(1020 + 1020 + 1, int8_t);
|
||
|
|
var ci = Arr(112 + 112 + 1, int8_t);
|
||
|
|
var cj = Arr(255 + 510 + 1, uint8_t);
|
||
|
|
var ck = 0;
|
||
|
|
|
||
|
|
function InitTables(a) {
|
||
|
|
if (!ck) {
|
||
|
|
var i;
|
||
|
|
for (i = -255; i <= 255; ++i) {
|
||
|
|
ce[255 + i] = (i < 0) ? -i : i;
|
||
|
|
cf[255 + i] = ce[255 + i] >> 1
|
||
|
|
}
|
||
|
|
for (i = -1020; i <= 1020; ++i) {
|
||
|
|
cg[1020 + i] = (i < -128) ? -128 : (i > 127) ? 127 : i
|
||
|
|
}
|
||
|
|
for (i = -112; i <= 112; ++i) {
|
||
|
|
ci[112 + i] = (i < -16) ? -16 : (i > 15) ? 15 : i
|
||
|
|
}
|
||
|
|
for (i = -255; i <= 255 + 255; ++i) {
|
||
|
|
cj[255 + i] = (i < 0) ? 0 : (i > 255) ? 255 : i
|
||
|
|
}
|
||
|
|
ck = 1
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function do_filter2(p, b, c) {
|
||
|
|
var d = p[b - 2 * c],
|
||
|
|
p0 = p[b - c],
|
||
|
|
q0 = p[b + 0],
|
||
|
|
q1 = p[b + c];
|
||
|
|
var a = 3 * (q0 - p0) + cg[1020 + d - q1];
|
||
|
|
var e = ci[112 + ((a + 4) >> 3)];
|
||
|
|
var f = ci[112 + ((a + 3) >> 3)];
|
||
|
|
p[b - c] = cj[255 + p0 + f];
|
||
|
|
p[b + 0] = cj[255 + q0 - e]
|
||
|
|
}
|
||
|
|
|
||
|
|
function do_filter4(p, b, c) {
|
||
|
|
var d = p[b - 2 * c],
|
||
|
|
p0 = p[b - c],
|
||
|
|
q0 = p[b + 0],
|
||
|
|
q1 = p[b + c];
|
||
|
|
var a = 3 * (q0 - p0);
|
||
|
|
var e = ci[112 + ((a + 4) >> 3)];
|
||
|
|
var f = ci[112 + ((a + 3) >> 3)];
|
||
|
|
var g = (e + 1) >> 1;
|
||
|
|
p[b - 2 * c] = cj[255 + d + g];
|
||
|
|
p[b - c] = cj[255 + p0 + f];
|
||
|
|
p[b + 0] = cj[255 + q0 - e];
|
||
|
|
p[b + c] = cj[255 + q1 - g]
|
||
|
|
}
|
||
|
|
|
||
|
|
function hev(p, a, b, c) {
|
||
|
|
var d = p[a - 2 * b],
|
||
|
|
p0 = p[a - b],
|
||
|
|
q0 = p[a + 0],
|
||
|
|
q1 = p[a + b];
|
||
|
|
return (ce[255 + d - p0] > c) || (ce[255 + q1 - q0] > c)
|
||
|
|
}
|
||
|
|
|
||
|
|
function needs_filter(p, a, b, c) {
|
||
|
|
var d = p[a - 2 * b],
|
||
|
|
p0 = p[a - b],
|
||
|
|
q0 = p[a + 0],
|
||
|
|
q1 = p[a + b];
|
||
|
|
return (2 * ce[255 + p0 - q0] + cf[255 + d - q1]) <= c
|
||
|
|
}
|
||
|
|
|
||
|
|
function needs_filter2(p, a, b, t, c) {
|
||
|
|
var d = p[a - 4 * b],
|
||
|
|
p2 = p[a - 3 * b],
|
||
|
|
p1 = p[a - 2 * b],
|
||
|
|
p0 = p[a - b];
|
||
|
|
var e = p[a + 0],
|
||
|
|
q1 = p[a + b],
|
||
|
|
q2 = p[a + 2 * b],
|
||
|
|
q3 = p[a + 3 * b];
|
||
|
|
if ((2 * ce[255 + p0 - e] + cf[255 + p1 - q1]) > t) return 0;
|
||
|
|
return ce[255 + d - p2] <= c && ce[255 + p2 - p1] <= c && ce[255 + p1 - p0] <= c && ce[255 + q3 - q2] <= c && ce[255 + q2 - q1] <= c && ce[255 + q1 - e] <= c
|
||
|
|
}
|
||
|
|
|
||
|
|
function SimpleVFilter16(p, a, b, c) {
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 16; ++i) {
|
||
|
|
if (needs_filter(p, a + i, b, c)) {
|
||
|
|
do_filter2(p, a + i, b)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function SimpleHFilter16(p, a, b, c) {
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 16; ++i) {
|
||
|
|
if (needs_filter(p, a + i * b, 1, c)) {
|
||
|
|
do_filter2(p, a + i * b, 1)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function SimpleVFilter16i(p, a, b, c) {
|
||
|
|
var k;
|
||
|
|
for (k = 3; k > 0; --k) {
|
||
|
|
a += 4 * b;
|
||
|
|
SimpleVFilter16(p, a, b, c)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function SimpleHFilter16i(p, a, b, c) {
|
||
|
|
var k;
|
||
|
|
for (k = 3; k > 0; --k) {
|
||
|
|
a += 4;
|
||
|
|
SimpleHFilter16(p, a, b, c)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function FilterLoop24(p, a, b, c, d, e, f, g) {
|
||
|
|
while (d-- > 0) {
|
||
|
|
if (needs_filter2(p, a, b, e, f)) {
|
||
|
|
if (hev(p, a, b, g)) {
|
||
|
|
do_filter2(p, a, b)
|
||
|
|
} else {
|
||
|
|
do_filter4(p, a, b)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
a += c
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function VFilter16i(p, a, b, c, d, e) {
|
||
|
|
var k;
|
||
|
|
for (k = 3; k > 0; --k) {
|
||
|
|
a += 4 * b;
|
||
|
|
FilterLoop24(p, a, b, 1, 16, c, d, e)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function HFilter16i(p, a, b, c, d, e) {
|
||
|
|
var k;
|
||
|
|
for (k = 3; k > 0; --k) {
|
||
|
|
a += 4;
|
||
|
|
FilterLoop24(p, a, 1, b, 16, c, d, e)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function VFilter8i(u, a, v, b, c, d, e, f) {
|
||
|
|
FilterLoop24(u, a + 4 * c, c, 1, 8, d, e, f);
|
||
|
|
FilterLoop24(v, b + 4 * c, c, 1, 8, d, e, f)
|
||
|
|
}
|
||
|
|
|
||
|
|
function HFilter8i(u, a, v, b, c, d, e, f) {
|
||
|
|
FilterLoop24(u, a + 4, 1, c, 8, d, e, f);
|
||
|
|
FilterLoop24(v, b + 4, 1, c, 8, d, e, f)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8EncVFilter16i(p, a, b, c, d, e) {
|
||
|
|
VFilter16i(p, a, b, c, d, e)
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8EncHFilter16i(p, a, b, c, d, e) {
|
||
|
|
HFilter16i(p, a, b, c, d, e)
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8EncVFilter8i(u, a, v, b, c, d, e, f) {
|
||
|
|
VFilter8i(u, a, v, b, c, d, e, f)
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8EncHFilter8i(u, a, v, b, c, d, e, f) {
|
||
|
|
HFilter8i(u, a, v, b, c, d, e, f)
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8EncSimpleVFilter16i(p, a, b, c) {
|
||
|
|
SimpleVFilter16i(p, a, b, c)
|
||
|
|
};
|
||
|
|
|
||
|
|
function VP8EncSimpleHFilter16i(p, a, b, c) {
|
||
|
|
SimpleHFilter16i(p, a, b, c)
|
||
|
|
};
|
||
|
|
|
||
|
|
function GetILevel(a, b) {
|
||
|
|
if (a > 0) {
|
||
|
|
if (a > 4) {
|
||
|
|
b >>= 2
|
||
|
|
} else {
|
||
|
|
b >>= 1
|
||
|
|
}
|
||
|
|
if (b > 9 - a) {
|
||
|
|
b = 9 - a
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (b < 1) b = 1;
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
|
||
|
|
function DoFilter(a, b) {
|
||
|
|
var c = a.enc_;
|
||
|
|
var d = GetILevel(c.config_.filter_sharpness, b);
|
||
|
|
var e = 2 * b + d;
|
||
|
|
var f = a.yuv_out2_;
|
||
|
|
var g = a.yuv_out2_off + bk;
|
||
|
|
var h = a.yuv_out2_;
|
||
|
|
var i = a.yuv_out2_off + bl;
|
||
|
|
var j = a.yuv_out2_;
|
||
|
|
var k = a.yuv_out2_off + bm;
|
||
|
|
memcpy(f, g, a.yuv_out_, a.yuv_out_off, bi * sizeof(uint8_t));
|
||
|
|
if (c.filter_hdr_.simple_ == 1) {
|
||
|
|
VP8EncSimpleHFilter16i(f, g, bf, e);
|
||
|
|
VP8EncSimpleVFilter16i(f, g, bf, e)
|
||
|
|
} else {
|
||
|
|
var l = (b >= 40) ? 2 : (b >= 15) ? 1 : 0;
|
||
|
|
VP8EncHFilter16i(f, g, bf, e, d, l);
|
||
|
|
VP8EncHFilter8i(h, i, j, k, bf, e, d, l);
|
||
|
|
VP8EncVFilter16i(f, g, bf, e, d, l);
|
||
|
|
VP8EncVFilter8i(h, i, j, k, bf, e, d, l)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var cl = 3;
|
||
|
|
var cm = {
|
||
|
|
w: double,
|
||
|
|
xm: double,
|
||
|
|
ym: double,
|
||
|
|
xxm: double,
|
||
|
|
xym: double,
|
||
|
|
yym: double
|
||
|
|
};
|
||
|
|
|
||
|
|
function Accumulate(a, b, c, d, e, f, g, h, W, H, i) {
|
||
|
|
var j = (h - cl < 0) ? 0 : h - cl;
|
||
|
|
var k = (h + cl > H - 1) ? H - 1 : h + cl;
|
||
|
|
var l = (g - cl < 0) ? 0 : g - cl;
|
||
|
|
var m = (g + cl > W - 1) ? W - 1 : g + cl;
|
||
|
|
var x, y;
|
||
|
|
b += j * c;
|
||
|
|
e += j * f;
|
||
|
|
for (y = j; y <= k; ++y, b += c, e += f) {
|
||
|
|
for (x = l; x <= m; ++x) {
|
||
|
|
var n = a[b + x];
|
||
|
|
var o = d[e + x];
|
||
|
|
i.w += 1;
|
||
|
|
i.xm += n;
|
||
|
|
i.ym += o;
|
||
|
|
i.xxm += n * n;
|
||
|
|
i.xym += n * o;
|
||
|
|
i.yym += o * o
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function GetSSIM(a) {
|
||
|
|
var b = a.xm * a.xm;
|
||
|
|
var c = a.ym * a.ym;
|
||
|
|
var d = a.xm * a.ym;
|
||
|
|
var e = a.w * a.w;
|
||
|
|
var f = a.xxm * a.w - b;
|
||
|
|
var g = a.yym * a.w - c;
|
||
|
|
var h = a.xym * a.w - d;
|
||
|
|
var i = double,
|
||
|
|
C2 = double;
|
||
|
|
var j = double;
|
||
|
|
var k = double;
|
||
|
|
if (f < 0.) f = 0.;
|
||
|
|
if (g < 0.) g = 0.;
|
||
|
|
i = 6.5025 * e;
|
||
|
|
C2 = 58.5225 * e;
|
||
|
|
j = (2 * d + i) * (2 * h + C2);
|
||
|
|
k = (b + c + i) * (f + g + C2);
|
||
|
|
return (k != 0) ? j / k : 0.
|
||
|
|
}
|
||
|
|
|
||
|
|
function GetMBSSIM(a, b, c, d) {
|
||
|
|
var x, y;
|
||
|
|
var s = {
|
||
|
|
w: double,
|
||
|
|
xm: double,
|
||
|
|
ym: double,
|
||
|
|
xxm: double,
|
||
|
|
xym: double,
|
||
|
|
yym: double
|
||
|
|
};
|
||
|
|
for (x = 3; x < 13; x++) {
|
||
|
|
for (y = 3; y < 13; y++) {
|
||
|
|
Accumulate(a, b + bk, bf, c, d + bk, bf, x, y, 16, 16, s)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (x = 1; x < 7; x++) {
|
||
|
|
for (y = 1; y < 7; y++) {
|
||
|
|
Accumulate(a, b + bl, bf, c, d + bl, bf, x, y, 8, 8, s);
|
||
|
|
Accumulate(a, b + bm, bf, c, d + bm, bf, x, y, 8, 8, s)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return GetSSIM(s)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8InitFilter(a) {
|
||
|
|
var s, i;
|
||
|
|
if (!a.lf_stats_) return;
|
||
|
|
InitTables();
|
||
|
|
for (s = 0; s < be; s++) {
|
||
|
|
for (i = 0; i < MAX_LF_LEVELS; i++) {
|
||
|
|
a.lf_stats_[s][i] = 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8StoreFilterStats(a) {
|
||
|
|
var d = int;
|
||
|
|
var s = a.mb_[a.mb_off].segment_;
|
||
|
|
var b = a.enc_.dqm_[s].fstrength_;
|
||
|
|
var c = -a.enc_.dqm_[s].quant_;
|
||
|
|
var e = a.enc_.dqm_[s].quant_;
|
||
|
|
var f = (e - c >= 4) ? 4 : 1;
|
||
|
|
if (!a.lf_stats_) return;
|
||
|
|
if (a.mb_[a.mb_off].type_ == 1 && a.mb_[a.mb_off].skip_) return;
|
||
|
|
a.lf_stats_[s][0] += GetMBSSIM(a.yuv_in_, a.yuv_in_off, a.yuv_out_, a.yuv_out_off);
|
||
|
|
for (d = c; d <= e; d += f) {
|
||
|
|
var g = b + d;
|
||
|
|
if (g <= 0 || g >= MAX_LF_LEVELS) {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
DoFilter(a, g);
|
||
|
|
a.lf_stats_[s][g] += GetMBSSIM(a.yuv_in_, a.yuv_in_off, a.yuv_out2_, a.yuv_out2_off)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8AdjustFilterStrength(a) {
|
||
|
|
var s;
|
||
|
|
var b = a.enc_;
|
||
|
|
if (!a.lf_stats_) {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
for (s = 0; s < be; s++) {
|
||
|
|
var i, best_level = 0;
|
||
|
|
var c = 1.00001 * a.lf_stats_[s][0];
|
||
|
|
for (i = 1; i < MAX_LF_LEVELS; i++) {
|
||
|
|
var v = a.lf_stats_[s][i];
|
||
|
|
if (v > c) {
|
||
|
|
c = v;
|
||
|
|
best_level = i
|
||
|
|
}
|
||
|
|
}
|
||
|
|
b.dqm_[s].fstrength_ = best_level
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function BitWriterResize(a, b) {
|
||
|
|
var c = uint8_t;
|
||
|
|
var d = 0;
|
||
|
|
var e = size_t;
|
||
|
|
var f = a.pos_ + b;
|
||
|
|
if (f <= a.max_pos_) return 1;
|
||
|
|
e = 2 * a.max_pos_;
|
||
|
|
if (e < f) e = f;
|
||
|
|
if (e < 1024) e = 1024;
|
||
|
|
c = malloc(e, uint8_t);
|
||
|
|
if (c == null) {
|
||
|
|
a.error_ = 1;
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (a.pos_ > 0) memcpy(c, d, a.buf_, a.buf_off, a.pos_);
|
||
|
|
a.buf_ = '';
|
||
|
|
a.buf_ = c;
|
||
|
|
a.buf_off = d;
|
||
|
|
a.max_pos_ = e;
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function kFlush(a) {
|
||
|
|
var s = 8 + a.nb_bits_;
|
||
|
|
var b = a.value_ >> s;
|
||
|
|
assert(a.nb_bits_ >= 0);
|
||
|
|
a.value_ -= b << s;
|
||
|
|
a.nb_bits_ -= 8;
|
||
|
|
if ((b & 0xff) != 0xff) {
|
||
|
|
var c = a.pos_;
|
||
|
|
if (c + a.run_ >= a.max_pos_) {
|
||
|
|
if (!BitWriterResize(a, a.run_ + 1)) {
|
||
|
|
return
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (b & 0x100) {
|
||
|
|
if (c > 0) a.buf_[c - 1]++
|
||
|
|
}
|
||
|
|
if (a.run_ > 0) {
|
||
|
|
var d = (b & 0x100) ? 0x00 : 0xff;
|
||
|
|
for (; a.run_ > 0; --a.run_) a.buf_[c++] = d
|
||
|
|
}
|
||
|
|
a.buf_[c++] = (b > 255 ? b - 256 : b);
|
||
|
|
a.pos_ = c
|
||
|
|
} else {
|
||
|
|
a.run_++
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var cn = new Array(7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0);
|
||
|
|
var co = new Array(127, 127, 191, 127, 159, 191, 223, 127, 143, 159, 175, 191, 207, 223, 239, 127, 135, 143, 151, 159, 167, 175, 183, 191, 199, 207, 215, 223, 231, 239, 247, 127, 131, 135, 139, 143, 147, 151, 155, 159, 163, 167, 171, 175, 179, 183, 187, 191, 195, 199, 203, 207, 211, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251, 127, 129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 171, 173, 175, 177, 179, 181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, 213, 215, 217, 219, 221, 223, 225, 227, 229, 231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 127);
|
||
|
|
|
||
|
|
function VP8PutBit(a, b, c) {
|
||
|
|
b = b ? 1 : 0;
|
||
|
|
var d = (a.range_ * c) >> 8;
|
||
|
|
if (b) {
|
||
|
|
a.value_ += d + 1;
|
||
|
|
a.range_ -= d + 1
|
||
|
|
} else {
|
||
|
|
a.range_ = d
|
||
|
|
}
|
||
|
|
if (a.range_ < 127) {
|
||
|
|
var e = cn[a.range_];
|
||
|
|
a.range_ = co[a.range_];
|
||
|
|
a.value_ <<= e;
|
||
|
|
a.nb_bits_ += e;
|
||
|
|
if (a.nb_bits_ > 0) kFlush(a)
|
||
|
|
}
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8PutBitUniform(a, b) {
|
||
|
|
b = b ? 1 : 0;
|
||
|
|
var c = a.range_ >> 1;
|
||
|
|
if (b) {
|
||
|
|
a.value_ += c + 1;
|
||
|
|
a.range_ -= c + 1
|
||
|
|
} else {
|
||
|
|
a.range_ = c
|
||
|
|
}
|
||
|
|
if (a.range_ < 127) {
|
||
|
|
a.range_ = co[a.range_];
|
||
|
|
a.value_ <<= 1;
|
||
|
|
a.nb_bits_ += 1;
|
||
|
|
if (a.nb_bits_ > 0) kFlush(a)
|
||
|
|
}
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8PutValue(a, b, c) {
|
||
|
|
var d;
|
||
|
|
for (d = 1 << (c - 1); d; d >>= 1) VP8PutBitUniform(a, b & d)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8PutSignedValue(a, b, c) {
|
||
|
|
if (!VP8PutBitUniform(a, b != 0)) return;
|
||
|
|
if (b < 0) {
|
||
|
|
VP8PutValue(a, ((-b) << 1) | 1, c + 1)
|
||
|
|
} else {
|
||
|
|
VP8PutValue(a, b << 1, c + 1)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8BitWriterInit(a, b) {
|
||
|
|
a.range_ = 255 - 1;
|
||
|
|
a.value_ = 0;
|
||
|
|
a.run_ = 0;
|
||
|
|
a.nb_bits_ = -8;
|
||
|
|
a.pos_ = 0;
|
||
|
|
a.max_pos_ = 0;
|
||
|
|
a.error_ = 0;
|
||
|
|
a.buf_ = null;
|
||
|
|
return (b > 0) ? BitWriterResize(a, b) : 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8BitWriterFinish(a) {
|
||
|
|
VP8PutValue(a, 0, 9 - a.nb_bits_);
|
||
|
|
a.nb_bits_ = 0;
|
||
|
|
kFlush(a);
|
||
|
|
return a.buf_
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8BitWriterAppend(a, b, c, d) {
|
||
|
|
assert(b);
|
||
|
|
if (a.nb_bits_ != -8) return 0;
|
||
|
|
if (!BitWriterResize(a, d)) return 0;
|
||
|
|
memcpy(a.buf_, a.buf_off + a.pos_, b, c, d);
|
||
|
|
a.pos_ += d;
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8BitCost(a, b) {
|
||
|
|
return !a ? cp[b] : cp[255 - b]
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8BranchCost(a, b, c) {
|
||
|
|
return a * VP8BitCost(1, c) + (b - a) * VP8BitCost(0, c)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8LevelCost(a, b) {
|
||
|
|
return cr[b] + a[b > MAX_VARIABLE_LEVEL ? MAX_VARIABLE_LEVEL : b]
|
||
|
|
}
|
||
|
|
var cp = new Array(1792, 1792, 1792, 1536, 1536, 1408, 1366, 1280, 1280, 1216, 1178, 1152, 1110, 1076, 1061, 1024, 1024, 992, 968, 951, 939, 911, 896, 878, 871, 854, 838, 820, 811, 794, 786, 768, 768, 752, 740, 732, 720, 709, 704, 690, 683, 672, 666, 655, 647, 640, 631, 622, 615, 607, 598, 592, 586, 576, 572, 564, 559, 555, 547, 541, 534, 528, 522, 512, 512, 504, 500, 494, 488, 483, 477, 473, 467, 461, 458, 452, 448, 443, 438, 434, 427, 424, 419, 415, 410, 406, 403, 399, 394, 390, 384, 384, 377, 374, 370, 366, 362, 359, 355, 351, 347, 342, 342, 336, 333, 330, 326, 323, 320, 316, 312, 308, 305, 302, 299, 296, 293, 288, 287, 283, 280, 277, 274, 272, 268, 266, 262, 256, 256, 256, 251, 248, 245, 242, 240, 237, 234, 232, 228, 226, 223, 221, 218, 216, 214, 211, 208, 205, 203, 201, 198, 196, 192, 191, 188, 187, 183, 181, 179, 176, 175, 171, 171, 168, 165, 163, 160, 159, 156, 154, 152, 150, 148, 146, 144, 142, 139, 138, 135, 133, 131, 128, 128, 125, 123, 121, 119, 117, 115, 113, 111, 110, 107, 105, 103, 102, 100, 98, 96, 94, 92, 91, 89, 86, 86, 83, 82, 80, 77, 76, 74, 73, 71, 69, 67, 66, 64, 63, 61, 59, 57, 55, 54, 52, 51, 49, 47, 46, 44, 43, 41, 40, 38, 36, 35, 33, 32, 30, 29, 27, 25, 24, 22, 21, 19, 18, 16, 15, 13, 12, 10, 9, 7, 6, 4, 3);
|
||
|
|
var cq = new Array(new Array(0x001, 0x000), new Array(0x007, 0x001), new Array(0x00f, 0x005), new Array(0x00f, 0x00d), new Array(0x033, 0x003), new Array(0x033, 0x003), new Array(0x033, 0x023), new Array(0x033, 0x023), new Array(0x033, 0x023), new Array(0x033, 0x023), new Array(0x0d3, 0x013), new Array(0x0d3, 0x013), new Array(0x0d3, 0x013), new Array(0x0d3, 0x013), new Array(0x0d3, 0x013), new Array(0x0d3, 0x013), new Array(0x0d3, 0x013), new Array(0x0d3, 0x013), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x0d3, 0x093), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x053), new Array(0x153, 0x153));
|
||
|
|
var cr = new Array(0, 256, 256, 256, 256, 432, 618, 630, 731, 640, 640, 828, 901, 948, 1021, 1101, 1174, 1221, 1294, 1042, 1085, 1115, 1158, 1202, 1245, 1275, 1318, 1337, 1380, 1410, 1453, 1497, 1540, 1570, 1613, 1280, 1295, 1317, 1332, 1358, 1373, 1395, 1410, 1454, 1469, 1491, 1506, 1532, 1547, 1569, 1584, 1601, 1616, 1638, 1653, 1679, 1694, 1716, 1731, 1775, 1790, 1812, 1827, 1853, 1868, 1890, 1905, 1727, 1733, 1742, 1748, 1759, 1765, 1774, 1780, 1800, 1806, 1815, 1821, 1832, 1838, 1847, 1853, 1878, 1884, 1893, 1899, 1910, 1916, 1925, 1931, 1951, 1957, 1966, 1972, 1983, 1989, 1998, 2004, 2027, 2033, 2042, 2048, 2059, 2065, 2074, 2080, 2100, 2106, 2115, 2121, 2132, 2138, 2147, 2153, 2178, 2184, 2193, 2199, 2210, 2216, 2225, 2231, 2251, 2257, 2266, 2272, 2283, 2289, 2298, 2304, 2168, 2174, 2183, 2189, 2200, 2206, 2215, 2221, 2241, 2247, 2256, 2262, 2273, 2279, 2288, 2294, 2319, 2325, 2334, 2340, 2351, 2357, 2366, 2372, 2392, 2398, 2407, 2413, 2424, 2430, 2439, 2445, 2468, 2474, 2483, 2489, 2500, 2506, 2515, 2521, 2541, 2547, 2556, 2562, 2573, 2579, 2588, 2594, 2619, 2625, 2634, 2640, 2651, 2657, 2666, 2672, 2692, 2698, 2707, 2713, 2724, 2730, 2739, 2745, 2540, 2546, 2555, 2561, 2572, 2578, 2587, 2593, 2613, 2619, 2628, 2634, 2645, 2651, 2660, 2666, 2691, 2697, 2706, 2712, 2723, 2729, 2738, 2744, 2764, 2770, 2779, 2785, 2796, 2802, 2811, 2817, 2840, 2846, 2855, 2861, 2872, 2878, 2887, 2893, 2913, 2919, 2928, 2934, 2945, 2951, 2960, 2966, 2991, 2997, 3006, 3012, 3023, 3029, 3038, 3044, 3064, 3070, 3079, 3085, 3096, 3102, 3111, 3117, 2981, 2987, 2996, 3002, 3013, 3019, 3028, 3034, 3054, 3060, 3069, 3075, 3086, 3092, 3101, 3107, 3132, 3138, 3147, 3153, 3164, 3170, 3179, 3185, 3205, 3211, 3220, 3226, 3237, 3243, 3252, 3258, 3281, 3287, 3296, 3302, 3313, 3319, 3328, 3334, 3354, 3360, 3369, 3375, 3386, 3392, 3401, 3407, 3432, 3438, 3447, 3453, 3464, 3470, 3479, 3485, 3505, 3511, 3520, 3526, 3537, 3543, 3552, 3558, 2816, 2822, 2831, 2837, 2848, 2854, 2863, 2869, 2889, 2895, 2904, 2910, 2921, 2927, 2936, 2942, 2967, 2973, 2982, 2988, 2999, 3005, 3014, 3020, 3040, 3046, 3055, 3061, 3072, 3078, 3087, 3093, 3116, 3122, 3131, 3137, 3148, 3154, 3163, 3169, 3189, 3195, 3204, 3210, 3221, 3227, 3236, 3242, 3267, 3273, 3282, 3288, 3299, 3305, 3314, 3320, 3340, 3346, 3355, 3361, 3372, 3378, 3387, 3393, 3257, 3263, 3272, 3278, 3289, 3295, 3304, 3310, 3330, 3336, 3345, 3351, 3362, 3368, 3377, 3383, 3408, 3414, 3423, 3429, 3440, 3446, 3455, 3461, 3481, 3487, 3496, 3502, 3513, 3519, 3528, 3534, 3557, 3563, 3572, 3578, 3589, 3595, 3604, 3610, 3630, 3636, 3645, 3651, 3662, 3668, 3677, 3683, 3708, 3714, 3723, 3729, 3740, 3746, 3755, 3761, 3781, 3787, 3796, 3802, 3813, 3819, 3828, 3834, 3629, 3635, 3644, 3650, 3661, 3667, 3676, 3682, 3702, 3708, 3717, 3723, 3734, 3740, 3749, 3755, 3780, 3786, 3795, 3801, 3812, 3818, 3827, 3833, 3853, 3859, 3868, 3874, 3885, 3891, 3900, 3906, 3929, 3935, 3944, 3950, 3961, 3967, 3976, 3982, 4002, 4008, 4017, 4023, 4034, 4040, 4049, 4055, 4080, 4086, 4095, 4101, 4112, 4118, 4127, 4133, 4153, 4159, 4168, 4174, 4185, 4191, 4200, 4206, 4070, 4076, 4085, 4091, 4102, 4108, 4117, 4123, 4143, 4149, 4158, 4164, 4175, 4181, 4190, 4196, 4221, 4227, 4236, 4242, 4253, 4259, 4268, 4274, 4294, 4300, 4309, 4315, 4326, 4332, 4341, 4347, 4370, 4376, 4385, 4391, 4402, 4408, 4417, 4423, 4443, 4449, 4458, 4464, 4475, 4481, 4490, 4496, 4521, 4527, 4536, 4542, 4553, 4559, 4568, 4574, 4594, 4600, 4609, 4615, 4626, 4632, 4641, 4647, 3515, 3521, 3530, 3536, 3547, 3553, 3562, 3568, 3588, 3594, 3603, 3609, 3620, 3626, 3635, 3641, 3666, 3672, 3681, 3687, 3698, 3704, 3713, 3719, 3739, 3745, 3754, 3760, 3771, 3777, 3786, 3792, 3815, 3821, 3830, 3836, 3847, 3853, 3862, 3868, 3888, 3894, 3903, 3909, 3920, 3926, 3935, 3941, 3966, 3972, 3981, 3987, 3998, 4004, 4013, 4019, 4039, 4045, 4054, 4060, 4071, 4077, 4086, 4092, 3956, 3962, 3971, 3977, 3988, 3994, 4003, 4009, 4029, 4035, 4044, 4050, 4061, 4067, 4076, 4082, 4107, 4113, 4122, 4128, 4139, 4145, 4154, 4160, 4180, 4186, 4195, 4201, 4212, 4218, 4227, 4233, 4256, 4262, 4271, 4277, 4288, 4294, 43
|
||
|
|
|
||
|
|
function VariableLevelCost(a, b) {
|
||
|
|
var c = cq[a - 1][0];
|
||
|
|
var d = cq[a - 1][1];
|
||
|
|
var e = 0;
|
||
|
|
var i = int;
|
||
|
|
for (i = 2; c; ++i) {
|
||
|
|
if (c & 1) {
|
||
|
|
e += VP8BitCost(d & 1, b[i])
|
||
|
|
}
|
||
|
|
d >>= 1;
|
||
|
|
c >>= 1
|
||
|
|
}
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8CalculateLevelCosts(a) {
|
||
|
|
var b, band, ctx;
|
||
|
|
for (b = 0; b < NUM_TYPES; ++b) {
|
||
|
|
for (band = 0; band < NUM_BANDS; ++band) {
|
||
|
|
for (ctx = 0; ctx < NUM_CTX; ++ctx) {
|
||
|
|
var p = a.coeffs_[b][band][ctx];
|
||
|
|
var c = a.level_cost_[b][band][ctx];
|
||
|
|
var d = VP8BitCost(1, p[1]);
|
||
|
|
var v;
|
||
|
|
c[0] = VP8BitCost(0, p[1]);
|
||
|
|
for (v = 1; v <= MAX_VARIABLE_LEVEL; ++v) {
|
||
|
|
c[v] = d + VariableLevelCost(v, p)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var cs = new Array(302, 984, 439, 642);
|
||
|
|
var ct = new Array(663, 919, 872, 919);
|
||
|
|
var cu = new Array(new Array(new Array(251, 1362, 1934, 2085, 2314, 2230, 1839, 1988, 2437, 2348), new Array(403, 680, 1507, 1519, 2060, 2005, 1992, 1914, 1924, 1733), new Array(353, 1121, 973, 1895, 2060, 1787, 1671, 1516, 2012, 1868), new Array(770, 852, 1581, 632, 1393, 1780, 1823, 1936, 1074, 1218), new Array(510, 1270, 1467, 1319, 847, 1279, 1792, 2094, 1080, 1353), new Array(488, 1322, 918, 1573, 1300, 883, 1814, 1752, 1756, 1502), new Array(425, 992, 1820, 1514, 1843, 2440, 937, 1771, 1924, 1129), new Array(363, 1248, 1257, 1970, 2194, 2385, 1569, 953, 1951, 1601), new Array(723, 1257, 1631, 964, 963, 1508, 1697, 1824, 671, 1418), new Array(635, 1038, 1573, 930, 1673, 1413, 1410, 1687, 1410, 749)), new Array(new Array(451, 613, 1345, 1702, 1870, 1716, 1728, 1766, 2190, 2310), new Array(678, 453, 1171, 1443, 1925, 1831, 2045, 1781, 1887, 1602), new Array(711, 666, 674, 1718, 1910, 1493, 1775, 1193, 2325, 2325), new Array(883, 854, 1583, 542, 1800, 1878, 1664, 2149, 1207, 1087), new Array(669, 994, 1248, 1122, 949, 1179, 1376, 1729, 1070, 1244), new Array(715, 1026, 715, 1350, 1430, 930, 1717, 1296, 1479, 1479), new Array(544, 841, 1656, 1450, 2094, 3883, 1010, 1759, 2076, 809), new Array(610, 855, 957, 1553, 2067, 1561, 1704, 824, 2066, 1226), new Array(833, 960, 1416, 819, 1277, 1619, 1501, 1617, 757, 1182), new Array(711, 964, 1252, 879, 1441, 1828, 1508, 1636, 1594, 734)), new Array(new Array(605, 764, 734, 1713, 1747, 1192, 1819, 1353, 1877, 2392), new Array(866, 641, 586, 1622, 2072, 1431, 1888, 1346, 2189, 1764), new Array(901, 851, 456, 2165, 2281, 1405, 1739, 1193, 2183, 2443), new Array(770, 1045, 952, 1078, 1342, 1191, 1436, 1063, 1303, 995), new Array(901, 1086, 727, 1170, 884, 1105, 1267, 1401, 1739, 1337), new Array(951, 1162, 595, 1488, 1388, 703, 1790, 1366, 2057, 1724), new Array(534, 986, 1273, 1987, 3273, 1485, 1024, 1399, 1583, 866), new Array(699, 1182, 695, 1978, 1726, 1986, 1326, 714, 1750, 1672), new Array(951, 1217, 1209, 920, 1062, 1441, 1548, 999, 952, 932), new Array(733, 1284, 784, 1256, 1557, 1098, 1257, 1357, 1414, 908)), new Array(new Array(316, 1075, 1653, 1220, 2145, 2051, 1730, 2131, 1884, 1790), new Array(745, 516, 1404, 894, 1599, 2375, 2013, 2105, 1475, 1381), new Array(516, 729, 1088, 1319, 1637, 3426, 1636, 1275, 1531, 1453), new Array(894, 943, 2138, 468, 1704, 2259, 2069, 1763, 1266, 1158), new Array(605, 1025, 1235, 871, 1170, 1767, 1493, 1500, 1104, 1258), new Array(739, 826, 1207, 1151, 1412, 846, 1305, 2726, 1014, 1569), new Array(558, 825, 1820, 1398, 3344, 1556, 1218, 1550, 1228, 878), new Array(429, 951, 1089, 1816, 3861, 3861, 1556, 969, 1568, 1828), new Array(883, 961, 1752, 769, 1468, 1810, 2081, 2346, 613, 1298), new Array(803, 895, 1372, 641, 1303, 1708, 1686, 1700, 1306, 1033)), new Array(new Array(439, 1267, 1270, 1579, 963, 1193, 1723, 1729, 1198, 1993), new Array(705, 725, 1029, 1153, 1176, 1103, 1821, 1567, 1259, 1574), new Array(723, 859, 802, 1253, 972, 1202, 1407, 1665, 1520, 1674), new Array(894, 960, 1254, 887, 1052, 1607, 1344, 1349, 865, 1150), new Array(833, 1312, 1337, 1205, 572, 1288, 1414, 1529, 1088, 1430), new Array(842, 1279, 1068, 1861, 862, 688, 1861, 1630, 1039, 1381), new Array(766, 938, 1279, 1546, 3338, 1550, 1031, 1542, 1288, 640), new Array(715, 1090, 835, 1609, 1100, 1100, 1603, 1019, 1102, 1617), new Array(894, 1813, 1500, 1188, 789, 1194, 1491, 1919, 617, 1333), new Array(610, 1076, 1644, 1281, 1283, 975, 1179, 1688, 1434, 889)), new Array(new Array(544, 971, 1146, 1849, 1221, 740, 1857, 1621, 1683, 2430), new Array(723, 705, 961, 1371, 1426, 821, 2081, 2079, 1839, 1380), new Array(783, 857, 703, 2145, 1419, 814, 1791, 1310, 1609, 2206), new Array(997, 1000, 1153, 792, 1229, 1162, 1810, 1418, 942, 979), new Array(901, 1226, 883, 1289, 793, 715, 1904, 1649, 1319, 3108), new Array(979, 1478, 782, 2216, 1454, 455, 3092, 1591, 1997, 1664), new Array(663, 1110, 1504, 1114, 1522, 3311, 676, 1522, 1530, 1024), new Array(605, 1138, 1153, 1314, 1569, 1315, 1157, 804, 1574, 1320), new Array(770, 1216, 1218, 1227, 869, 1384, 1232, 1375, 83
|
||
|
|
var cv = {
|
||
|
|
first: int,
|
||
|
|
last: int,
|
||
|
|
coeffs: int16_t,
|
||
|
|
coeffs_off: 0,
|
||
|
|
coeff_type: int,
|
||
|
|
prob: newObjectIt(bJ),
|
||
|
|
stats: newObjectIt(bK),
|
||
|
|
cost: newObjectIt(bL)
|
||
|
|
};
|
||
|
|
var cw = new Array(0, 1, 2, 3, 6, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7, 0);
|
||
|
|
var cx = new Array(173, 148, 140);
|
||
|
|
var cy = new Array(176, 155, 140, 135);
|
||
|
|
var cz = new Array(180, 157, 141, 134, 130);
|
||
|
|
var cA = new Array(254, 254, 243, 230, 196, 177, 153, 140, 133, 130, 129);
|
||
|
|
|
||
|
|
function ResetStats(a, b) {
|
||
|
|
var c = a.proba_;
|
||
|
|
if (b) VP8CalculateLevelCosts(c);
|
||
|
|
c.nb_skip_ = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function CalcSkipProba(a, b) {
|
||
|
|
return parseInt(b ? (b - a) * 255 / b : 255)
|
||
|
|
}
|
||
|
|
|
||
|
|
function FinalizeSkipProba(a) {
|
||
|
|
var b = a.proba_;
|
||
|
|
var c = a.mb_w_ * a.mb_h_;
|
||
|
|
var d = b.nb_skip_;
|
||
|
|
var e = int;
|
||
|
|
b.skip_proba_ = CalcSkipProba(d, c);
|
||
|
|
b.use_skip_proba_ = (b.skip_proba_ < 250) + 0;
|
||
|
|
e = 256;
|
||
|
|
if (b.use_skip_proba_) {
|
||
|
|
e += d * VP8BitCost(1, b.skip_proba_) + (c - d) * VP8BitCost(0, b.skip_proba_);
|
||
|
|
e += 8 * 256
|
||
|
|
}
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
function ResetTokenStats(a) {
|
||
|
|
var b = a.proba_;
|
||
|
|
b.stats = newObjectIt(bK)
|
||
|
|
}
|
||
|
|
|
||
|
|
function Record(a, b) {
|
||
|
|
b[0] += parseInt(a + 0);
|
||
|
|
b[1] += 1;
|
||
|
|
return a
|
||
|
|
}
|
||
|
|
|
||
|
|
function RecordCoeffs(a, b) {
|
||
|
|
var n = b.first;
|
||
|
|
var s = b.stats[cw[n]][a];
|
||
|
|
if (!Record(b.last >= 0, s[0])) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
while (1) {
|
||
|
|
var v = b.coeffs[n++];
|
||
|
|
if (!Record(v != 0, s[1])) {
|
||
|
|
s = b.stats[cw[n]][0];
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if (!Record(2 < (v + 1), s[2])) {
|
||
|
|
s = b.stats[cw[n]][1]
|
||
|
|
} else {
|
||
|
|
v = Math.abs(v);
|
||
|
|
if (v > MAX_VARIABLE_LEVEL) v = MAX_VARIABLE_LEVEL; {
|
||
|
|
var c = cq[v - 1][1];
|
||
|
|
var d = cq[v - 1][0];
|
||
|
|
var i;
|
||
|
|
for (i = 0;
|
||
|
|
(d >>= 1) != 0; ++i) {
|
||
|
|
var e = 2 << i;
|
||
|
|
if (d & 1) Record(!!(c & e), s[3 + i])
|
||
|
|
}
|
||
|
|
}
|
||
|
|
s = b.stats[cw[n]][2]
|
||
|
|
}
|
||
|
|
if (n == 16 || !Record(n <= b.last, s[0])) {
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function CalcTokenProba(a, b) {
|
||
|
|
return a ? parseInt(((b - a) * 255 + b / 2) / b) : 255
|
||
|
|
}
|
||
|
|
|
||
|
|
function FinalizeTokenProbas(a) {
|
||
|
|
var d = a.proba_;
|
||
|
|
var e = 0;
|
||
|
|
var t, b, c, p;
|
||
|
|
for (t = 0; t < NUM_TYPES; ++t) {
|
||
|
|
for (b = 0; b < NUM_BANDS; ++b) {
|
||
|
|
for (c = 0; c < NUM_CTX; ++c) {
|
||
|
|
for (p = 0; p < NUM_PROBAS; ++p) {
|
||
|
|
var f = d.stats_[t][b][c][p];
|
||
|
|
var g = dz[t][b][c][p];
|
||
|
|
var h = dw[t][b][c][p];
|
||
|
|
var i = CalcTokenProba(f[0], f[1]);
|
||
|
|
var j = VP8BranchCost(f[0], f[1], h) + VP8BitCost(0, g);
|
||
|
|
var k = VP8BranchCost(f[0], f[1], i) + VP8BitCost(1, g) + 8 * 256;
|
||
|
|
var l = (j > k) + 0;
|
||
|
|
e += VP8BitCost(l, g);
|
||
|
|
if (l) {
|
||
|
|
d.coeffs_[t][b][c][p] = i;
|
||
|
|
e += 8 * 256
|
||
|
|
} else {
|
||
|
|
d.coeffs_[t][b][c][p] = h
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
function InitResidual(a, b, c, d) {
|
||
|
|
d.coeff_type = b;
|
||
|
|
d.prob = c.proba_.coeffs_[b];
|
||
|
|
d.stats = c.proba_.stats_[b];
|
||
|
|
d.cost = c.proba_.level_cost_[b];
|
||
|
|
d.first = a
|
||
|
|
}
|
||
|
|
|
||
|
|
function SetResidualCoeffs(a, b) {
|
||
|
|
var n;
|
||
|
|
b.last = -1;
|
||
|
|
for (n = 15; n >= b.first; --n) {
|
||
|
|
if (a[n]) {
|
||
|
|
b.last = n;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
}
|
||
|
|
b.coeffs = a
|
||
|
|
}
|
||
|
|
|
||
|
|
function GetResidualCost(a, b) {
|
||
|
|
var n = b.first;
|
||
|
|
var p = b.prob[cw[n]][a];
|
||
|
|
var t = b.cost[cw[n]][a];
|
||
|
|
var c = int;
|
||
|
|
c = VP8BitCost(b.last >= 0, p[0]);
|
||
|
|
if (b.last < 0) {
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
while (n <= b.last) {
|
||
|
|
var v = b.coeffs[n++];
|
||
|
|
if (v == 0) {
|
||
|
|
p = b.prob[cw[n]][0];
|
||
|
|
t = b.cost[cw[n]][0];
|
||
|
|
continue
|
||
|
|
} else if (2 >= (v + 1)) {
|
||
|
|
c += VP8LevelCost(t, 1);
|
||
|
|
p = b.prob[cw[n]][1];
|
||
|
|
t = b.cost[cw[n]][1]
|
||
|
|
} else {
|
||
|
|
c += VP8LevelCost(t, Math.abs(v));
|
||
|
|
p = b.prob[cw[n]][2];
|
||
|
|
t = b.cost[cw[n]][2]
|
||
|
|
}
|
||
|
|
if (n < 16) {
|
||
|
|
c += VP8BitCost(n <= b.last, p[0])
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
var cB = newObjectIt(cv);
|
||
|
|
|
||
|
|
function VP8GetCostLuma4(a, b) {
|
||
|
|
var x = (a.i4_ & 3) + 0,
|
||
|
|
y = (a.i4_ >> 2) + 0;
|
||
|
|
var c = (cB);
|
||
|
|
var R = 0;
|
||
|
|
var d = int;
|
||
|
|
InitResidual(0, 3, a.enc_, c);
|
||
|
|
d = a.top_nz_[x] + a.left_nz_[y];
|
||
|
|
SetResidualCoeffs(b, c);
|
||
|
|
R += GetResidualCost(d, c);
|
||
|
|
return R
|
||
|
|
}
|
||
|
|
var cC = newObjectIt(cv);
|
||
|
|
|
||
|
|
function VP8GetCostLuma16(a, b) {
|
||
|
|
var c = (cC);
|
||
|
|
var x, y = int;
|
||
|
|
var R = 0;
|
||
|
|
VP8IteratorNzToBytes(a);
|
||
|
|
InitResidual(0, 1, a.enc_, c);
|
||
|
|
SetResidualCoeffs(b.y_dc_levels, c);
|
||
|
|
R += GetResidualCost(a.top_nz_[8] + a.left_nz_[8], c);
|
||
|
|
InitResidual(1, 0, a.enc_, c);
|
||
|
|
for (y = 0; y < 4; ++y) {
|
||
|
|
for (x = 0; x < 4; ++x) {
|
||
|
|
var d = a.top_nz_[x] + a.left_nz_[y];
|
||
|
|
SetResidualCoeffs(b.y_ac_levels[x + y * 4], c);
|
||
|
|
R += GetResidualCost(d, c);
|
||
|
|
a.top_nz_[x] = a.left_nz_[y] = (c.last >= 0) + 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return R
|
||
|
|
}
|
||
|
|
var cD = newObjectIt(cv);
|
||
|
|
|
||
|
|
function VP8GetCostUV(a, b) {
|
||
|
|
var c = (cD);
|
||
|
|
var d, x, y;
|
||
|
|
var R = 0;
|
||
|
|
VP8IteratorNzToBytes(a);
|
||
|
|
InitResidual(0, 2, a.enc_, c);
|
||
|
|
for (d = 0; d <= 2; d += 2) {
|
||
|
|
for (y = 0; y < 2; ++y) {
|
||
|
|
for (x = 0; x < 2; ++x) {
|
||
|
|
var e = a.top_nz_[4 + d + x] + a.left_nz_[4 + d + y];
|
||
|
|
SetResidualCoeffs(b.uv_levels[d * 2 + x + y * 2], c);
|
||
|
|
R += GetResidualCost(e, c);
|
||
|
|
a.top_nz_[4 + d + x] = a.left_nz_[4 + d + y] = (c.last >= 0) + 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return R
|
||
|
|
}
|
||
|
|
|
||
|
|
function PutCoeffs(a, b, d) {
|
||
|
|
var n = d.first;
|
||
|
|
var p = d.prob[cw[n]][b];
|
||
|
|
if (!VP8PutBit(a, d.last >= 0, p[0])) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
while (n < 16) {
|
||
|
|
var c = d.coeffs[n++];
|
||
|
|
var e = (c < 0) + 0;
|
||
|
|
var v = e ? -c : c;
|
||
|
|
if (!VP8PutBit(a, v != 0, p[1])) {
|
||
|
|
p = d.prob[cw[n]][0];
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if (!VP8PutBit(a, v > 1, p[2])) {
|
||
|
|
p = d.prob[cw[n]][1]
|
||
|
|
} else {
|
||
|
|
if (!VP8PutBit(a, v > 4, p[3])) {
|
||
|
|
if (VP8PutBit(a, v != 2, p[4])) VP8PutBit(a, v == 4, p[5])
|
||
|
|
} else if (!VP8PutBit(a, v > 10, p[6])) {
|
||
|
|
if (!VP8PutBit(a, v > 6, p[7])) {
|
||
|
|
VP8PutBit(a, v == 6, 159)
|
||
|
|
} else {
|
||
|
|
VP8PutBit(a, v >= 9, 165);
|
||
|
|
VP8PutBit(a, !(v & 1), 145)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var f = int;
|
||
|
|
var g;
|
||
|
|
var h = 0;
|
||
|
|
if (v < 3 + (8 << 1)) {
|
||
|
|
VP8PutBit(a, 0, p[8]);
|
||
|
|
VP8PutBit(a, 0, p[9]);
|
||
|
|
v -= 3 + (8 << 0);
|
||
|
|
f = 1 << 2;
|
||
|
|
g = cx;
|
||
|
|
h = 0
|
||
|
|
} else if (v < 3 + (8 << 2)) {
|
||
|
|
VP8PutBit(a, 0, p[8]);
|
||
|
|
VP8PutBit(a, 1, p[9]);
|
||
|
|
v -= 3 + (8 << 1);
|
||
|
|
f = 1 << 3;
|
||
|
|
g = cy;
|
||
|
|
h = 0
|
||
|
|
} else if (v < 3 + (8 << 3)) {
|
||
|
|
VP8PutBit(a, 1, p[8]);
|
||
|
|
VP8PutBit(a, 0, p[10]);
|
||
|
|
v -= 3 + (8 << 2);
|
||
|
|
f = 1 << 4;
|
||
|
|
g = cz;
|
||
|
|
h = 0
|
||
|
|
} else {
|
||
|
|
VP8PutBit(a, 1, p[8]);
|
||
|
|
VP8PutBit(a, 1, p[10]);
|
||
|
|
v -= 3 + (8 << 3);
|
||
|
|
f = 1 << 10;
|
||
|
|
g = cA;
|
||
|
|
h = 0
|
||
|
|
}
|
||
|
|
while (f) {
|
||
|
|
VP8PutBit(a, !!(v & f), g[h++]);
|
||
|
|
f >>= 1
|
||
|
|
}
|
||
|
|
}
|
||
|
|
p = d.prob[cw[n]][2]
|
||
|
|
}
|
||
|
|
VP8PutBitUniform(a, e);
|
||
|
|
if (n == 16 || !VP8PutBit(a, n <= d.last, p[0])) {
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
var cE = newObjectIt(cv);
|
||
|
|
|
||
|
|
function CodeResiduals(a, b, c) {
|
||
|
|
var x, y, ch;
|
||
|
|
var d = (cE);
|
||
|
|
var e = uint64_t,
|
||
|
|
pos2 = uint64_t,
|
||
|
|
pos3 = uint64_t;
|
||
|
|
var f = (b.mb_[b.mb_off].type_ == 1) + 0;
|
||
|
|
var g = b.mb_[b.mb_off].segment_;
|
||
|
|
VP8IteratorNzToBytes(b);
|
||
|
|
e = VP8BitWriterPos(a);
|
||
|
|
if (f) {
|
||
|
|
InitResidual(0, 1, b.enc_, d);
|
||
|
|
SetResidualCoeffs(c.y_dc_levels, d);
|
||
|
|
b.top_nz_[8] = b.left_nz_[8] = PutCoeffs(a, b.top_nz_[8] + b.left_nz_[8], d);
|
||
|
|
InitResidual(1, 0, b.enc_, d)
|
||
|
|
} else {
|
||
|
|
InitResidual(0, 3, b.enc_, d)
|
||
|
|
}
|
||
|
|
for (y = 0; y < 4; ++y) {
|
||
|
|
for (x = 0; x < 4; ++x) {
|
||
|
|
var h = b.top_nz_[x] + b.left_nz_[y];
|
||
|
|
SetResidualCoeffs(c.y_ac_levels[x + y * 4], d);
|
||
|
|
b.top_nz_[x] = b.left_nz_[y] = PutCoeffs(a, h, d)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
pos2 = VP8BitWriterPos(a);
|
||
|
|
InitResidual(0, 2, b.enc_, d);
|
||
|
|
for (ch = 0; ch <= 2; ch += 2) {
|
||
|
|
for (y = 0; y < 2; ++y) {
|
||
|
|
for (x = 0; x < 2; ++x) {
|
||
|
|
var h = b.top_nz_[4 + ch + x] + b.left_nz_[4 + ch + y];
|
||
|
|
SetResidualCoeffs(c.uv_levels[ch * 2 + x + y * 2], d);
|
||
|
|
b.top_nz_[4 + ch + x] = b.left_nz_[4 + ch + y] = PutCoeffs(a, h, d)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
pos3 = VP8BitWriterPos(a);
|
||
|
|
b.luma_bits_ = pos2 - e;
|
||
|
|
b.uv_bits_ = pos3 - pos2;
|
||
|
|
b.bit_count_[g][f] += b.luma_bits_;
|
||
|
|
b.bit_count_[g][2] += b.uv_bits_;
|
||
|
|
VP8IteratorBytesToNz(b)
|
||
|
|
}
|
||
|
|
var cF = newObjectIt(cv);
|
||
|
|
|
||
|
|
function RecordResiduals(a, b) {
|
||
|
|
var x, y, ch;
|
||
|
|
var c = (cF);
|
||
|
|
VP8IteratorNzToBytes(a);
|
||
|
|
if (a.mb_[a.mb_off].type_ == 1) {
|
||
|
|
InitResidual(0, 1, a.enc_, c);
|
||
|
|
SetResidualCoeffs(b.y_dc_levels, c);
|
||
|
|
a.top_nz_[8] = a.left_nz_[8] = RecordCoeffs(a.top_nz_[8] + a.left_nz_[8], c);
|
||
|
|
InitResidual(1, 0, a.enc_, c)
|
||
|
|
} else {
|
||
|
|
InitResidual(0, 3, a.enc_, c)
|
||
|
|
}
|
||
|
|
for (y = 0; y < 4; ++y) {
|
||
|
|
for (x = 0; x < 4; ++x) {
|
||
|
|
var d = a.top_nz_[x] + a.left_nz_[y];
|
||
|
|
SetResidualCoeffs(b.y_ac_levels[x + y * 4], c);
|
||
|
|
a.top_nz_[x] = a.left_nz_[y] = RecordCoeffs(d, c)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
InitResidual(0, 2, a.enc_, c);
|
||
|
|
for (ch = 0; ch <= 2; ch += 2) {
|
||
|
|
for (y = 0; y < 2; ++y) {
|
||
|
|
for (x = 0; x < 2; ++x) {
|
||
|
|
var d = a.top_nz_[4 + ch + x] + a.left_nz_[4 + ch + y];
|
||
|
|
SetResidualCoeffs(b.uv_levels[ch * 2 + x + y * 2], c);
|
||
|
|
a.top_nz_[4 + ch + x] = a.left_nz_[4 + ch + y] = RecordCoeffs(d, c)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
VP8IteratorBytesToNz(a)
|
||
|
|
}
|
||
|
|
|
||
|
|
function ResetSSE(a) {
|
||
|
|
memset_(a.sse_, 0, 0, sizeof(a.sse_) * 3);
|
||
|
|
a.sse_count_ = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function StoreSSE(a) {
|
||
|
|
var b = a.enc_;
|
||
|
|
var c = a.yuv_in_;
|
||
|
|
var d = a.yuv_in_off;
|
||
|
|
var e = a.yuv_out_;
|
||
|
|
var f = a.yuv_out_off;
|
||
|
|
b.sse_[0] += dM(c, d + bk, e, f + bk);
|
||
|
|
b.sse_[1] += dN(c, d + bl, e, f + bl);
|
||
|
|
b.sse_[2] += dN(c, d + bm, e, f + bm);
|
||
|
|
b.sse_count_ += 16 * 16
|
||
|
|
}
|
||
|
|
|
||
|
|
function StoreSideInfo(a) {
|
||
|
|
var c = a.enc_;
|
||
|
|
var d = a.mb_[a.mb_off];
|
||
|
|
var e = c.pic_;
|
||
|
|
if (e.stats_nozero) {
|
||
|
|
StoreSSE(a);
|
||
|
|
c.block_count_[0] += (d.type_ == 0) + 0;
|
||
|
|
c.block_count_[1] += (d.type_ == 1) + 0;
|
||
|
|
c.block_count_[2] += (d.skip_ != 0) + 0
|
||
|
|
}
|
||
|
|
if (e.extra_info) {
|
||
|
|
switch (e.extra_info_type) {
|
||
|
|
case 1:
|
||
|
|
e.extra_info[a.x_ + a.y_ * c.mb_w_] = d.type_;
|
||
|
|
break;
|
||
|
|
case 2:
|
||
|
|
e.extra_info[a.x_ + a.y_ * c.mb_w_] = d.segment_;
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
e.extra_info[a.x_ + a.y_ * c.mb_w_] = c.dqm_[d.segment_].quant_;
|
||
|
|
break;
|
||
|
|
case 4:
|
||
|
|
e.extra_info[a.x_ + a.y_ * c.mb_w_] = (d.type_ == 1) ? a.preds_[a.preds_off + 0] : 0xff;
|
||
|
|
break;
|
||
|
|
case 5:
|
||
|
|
e.extra_info[a.x_ + a.y_ * c.mb_w_] = d.uv_mode_;
|
||
|
|
break;
|
||
|
|
case 6:
|
||
|
|
{
|
||
|
|
var b = parseInt((a.luma_bits_ + a.uv_bits_ + 7) >> 3);
|
||
|
|
e.extra_info[a.x_ + a.y_ * c.mb_w_] = (b > 255) ? 255 : b;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
default:
|
||
|
|
info = 0;
|
||
|
|
break
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function ResetAfterSkip(a) {
|
||
|
|
if (a.mb_[a.mb_off].type_ == 1) {
|
||
|
|
a.nz_[a.nz_off] = 0;
|
||
|
|
a.left_nz_[8] = 0
|
||
|
|
} else {
|
||
|
|
a.nz_[a.nz_off] &= (1 << 24)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8EncLoop(a) {
|
||
|
|
var i, s, p;
|
||
|
|
var b = newObjectIt(bV);
|
||
|
|
var c = newObjectIt(bU);
|
||
|
|
var d = (!a.proba_.use_skip_proba_) + 0;
|
||
|
|
var e = a.rd_opt_level_;
|
||
|
|
var f = 5;
|
||
|
|
var g = parseInt(a.mb_w_ * a.mb_h_ * f / a.num_parts_);
|
||
|
|
for (p = 0; p < a.num_parts_; ++p) {
|
||
|
|
VP8BitWriterInit(a.parts_[+p], g)
|
||
|
|
}
|
||
|
|
ResetStats(a, (e != 0));
|
||
|
|
ResetSSE(a);
|
||
|
|
VP8IteratorInit(a, b);
|
||
|
|
VP8InitFilter(b);
|
||
|
|
do {
|
||
|
|
VP8IteratorImport(b);
|
||
|
|
if (!VP8Decimate(b, c, e) || (!a.proba_.use_skip_proba_)) {
|
||
|
|
CodeResiduals(b.bw_, b, c)
|
||
|
|
} else {
|
||
|
|
ResetAfterSkip(b)
|
||
|
|
}
|
||
|
|
if (a.has_alpha_) {
|
||
|
|
VP8EncCodeAlphaBlock(b)
|
||
|
|
}
|
||
|
|
if (a.use_layer_) {
|
||
|
|
VP8EncCodeLayerBlock(b)
|
||
|
|
}
|
||
|
|
StoreSideInfo(b);
|
||
|
|
VP8StoreFilterStats(b);
|
||
|
|
VP8IteratorExport(b)
|
||
|
|
} while (VP8IteratorNext(b, b.yuv_out_, b.yuv_out_off));
|
||
|
|
VP8AdjustFilterStrength(b);
|
||
|
|
for (p = 0; p < a.num_parts_; ++p) {
|
||
|
|
VP8BitWriterFinish(a.parts_[+p])
|
||
|
|
}
|
||
|
|
if (a.pic_.stats_nozero) {
|
||
|
|
for (i = 0; i <= 2; ++i) {
|
||
|
|
for (s = 0; s < be; ++s) {
|
||
|
|
a.residual_bytes_[i][s] = parseInt((b.bit_count_[s][i] + 7) >> 3)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
var cG = (15 + 20 + 10);
|
||
|
|
|
||
|
|
function OneStatPass(a, q, b, c, d) {
|
||
|
|
var e = newObjectIt(bV);
|
||
|
|
var f = 0;
|
||
|
|
var g = 0;
|
||
|
|
var h = c * 384;
|
||
|
|
if (q < 0.) {
|
||
|
|
q = 0
|
||
|
|
} else if (q > 100.) {
|
||
|
|
q = 100
|
||
|
|
}
|
||
|
|
VP8SetSegmentParams(a, q);
|
||
|
|
ResetStats(a, b != 0);
|
||
|
|
ResetTokenStats(a);
|
||
|
|
VP8IteratorInit(a, e);
|
||
|
|
var i = newObjectIt(bU);
|
||
|
|
do {
|
||
|
|
var j = (i);
|
||
|
|
VP8IteratorImport(e);
|
||
|
|
if (VP8Decimate(e, j, b)) {
|
||
|
|
a.proba_.nb_skip_++
|
||
|
|
}
|
||
|
|
RecordResiduals(e, j);
|
||
|
|
f += j.R;
|
||
|
|
g += j.D
|
||
|
|
} while (VP8IteratorNext(e, e.yuv_out_, e.yuv_out_off) && --c > 0);
|
||
|
|
f += FinalizeSkipProba(a);
|
||
|
|
f += FinalizeTokenProbas(a);
|
||
|
|
f += a.segment_hdr_.size_;
|
||
|
|
f = ((f + 1024) >> 11) + cG;
|
||
|
|
if (d) {
|
||
|
|
d.f = parseFloat(10. * (Math.LOG10E * Math.log(255. * 255. * h / g)))
|
||
|
|
}
|
||
|
|
return parseInt(f)
|
||
|
|
}
|
||
|
|
var cH = new Array(20, 15, 10, 8, 6, 4, 2, 1, 0);
|
||
|
|
|
||
|
|
function VP8StatLoop(a) {
|
||
|
|
var b = (a.config_.target_size > 0 || a.config_.target_PSNR > 0) + 0;
|
||
|
|
var c = (a.method_ < 2 && !b) + 0;
|
||
|
|
var q = parseFloat(a.config_.quality);
|
||
|
|
var d = int;
|
||
|
|
var e = int;
|
||
|
|
e = a.mb_w_ * a.mb_h_;
|
||
|
|
if (c && e > 100) e = 100;
|
||
|
|
if (!b) {
|
||
|
|
for (d = 0; d < a.config_.pass; ++d) {
|
||
|
|
var f = (a.method_ > 2) + 0;
|
||
|
|
OneStatPass(a, q, f, e, null)
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
for (d = 0; d < a.config_.pass && (cH[d] > 0); ++d) {
|
||
|
|
var f = 1;
|
||
|
|
var g = {
|
||
|
|
f: float
|
||
|
|
};
|
||
|
|
var h = int;
|
||
|
|
var i = OneStatPass(a, q, f, e, g);
|
||
|
|
if (a.config_.target_PSNR > 0) {
|
||
|
|
h = (g.f < a.config_.target_PSNR)
|
||
|
|
} else {
|
||
|
|
h = (i < a.config_.target_size)
|
||
|
|
}
|
||
|
|
if (h) {
|
||
|
|
q += cH[d]
|
||
|
|
} else {
|
||
|
|
q -= cH[d]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function InitLeft(a) {
|
||
|
|
var b = a.enc_;
|
||
|
|
b.y_left_[b.y_left_off - 1] = b.u_left_[b.u_left_off - 1] = b.v_left_[b.v_left_off - 1] = (a.y_) > 0 ? 129 : 127;
|
||
|
|
memset_(b.y_left_, b.y_left_off + 0, 129, 16);
|
||
|
|
memset_(b.u_left_, b.u_left_off + 0, 129, 8);
|
||
|
|
memset_(b.v_left_, b.v_left_off + 0, 129, 8);
|
||
|
|
a.left_nz_[8] = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function InitTop(a) {
|
||
|
|
var b = a.enc_;
|
||
|
|
var c = b.mb_w_ * 16;
|
||
|
|
memset_(b.y_top_, 0, 127, 2 * c);
|
||
|
|
memset_(b.nz_, b.nz_off + 0, 0, b.mb_w_ * sizeof(b.nz_))
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8IteratorReset(a) {
|
||
|
|
var b = a.enc_;
|
||
|
|
a.x_ = 0;
|
||
|
|
a.y_ = 0;
|
||
|
|
a.y_offset_ = 0;
|
||
|
|
a.uv_offset_ = 0;
|
||
|
|
a.mb_ = b.mb_info_;
|
||
|
|
a.mb_off = b.mb_info_off;
|
||
|
|
a.preds_ = b.preds_;
|
||
|
|
a.preds_off = b.preds_off;
|
||
|
|
a.nz_ = b.nz_;
|
||
|
|
a.nz_off = b.nz_off;
|
||
|
|
a.bw_ = b.parts_[0];
|
||
|
|
a.done_ = b.mb_w_ * b.mb_h_;
|
||
|
|
InitTop(a);
|
||
|
|
InitLeft(a);
|
||
|
|
a.bit_count_ = ArrM(Array(4, 3), 0);
|
||
|
|
a.do_trellis_ = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8IteratorInit(a, b) {
|
||
|
|
b.enc_ = a;
|
||
|
|
b.y_stride_ = a.pic_.y_stride;
|
||
|
|
b.uv_stride_ = a.pic_.uv_stride;
|
||
|
|
b.yuv_in_ = a.yuv_in_;
|
||
|
|
b.yuv_out_ = a.yuv_out_;
|
||
|
|
b.yuv_out2_ = a.yuv_out2_;
|
||
|
|
b.yuv_p_ = a.yuv_p_;
|
||
|
|
b.lf_stats_ = a.lf_stats_;
|
||
|
|
VP8IteratorReset(b)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8IteratorImport(a) {
|
||
|
|
var b = a.enc_;
|
||
|
|
var x = a.x_,
|
||
|
|
y = a.y_;
|
||
|
|
var c = b.pic_;
|
||
|
|
var d = c.y;
|
||
|
|
var e = c.y_off + (y * c.y_stride + x) * 16;
|
||
|
|
var f = c.u;
|
||
|
|
var g = c.u_off + (y * c.uv_stride + x) * 8;
|
||
|
|
var j = c.v;
|
||
|
|
var k = c.v_off + (y * c.uv_stride + x) * 8;
|
||
|
|
var l = a.yuv_in_;
|
||
|
|
var m = a.yuv_in_off + bk;
|
||
|
|
var n = a.yuv_in_;
|
||
|
|
var o = a.yuv_in_off + bl;
|
||
|
|
var p = a.yuv_in_;
|
||
|
|
var q = a.yuv_in_off + bm;
|
||
|
|
var w = (c.width - x * 16);
|
||
|
|
var h = (c.height - y * 16);
|
||
|
|
var i;
|
||
|
|
if (w > 16) w = 16;
|
||
|
|
if (h > 16) h = 16;
|
||
|
|
for (i = 0; i < h; ++i) {
|
||
|
|
memcpy(l, m, d, e, w);
|
||
|
|
if (w < 16) memset_(l, m + w, l[m + w - 1], 16 - w);
|
||
|
|
m += bf;
|
||
|
|
e += c.y_stride
|
||
|
|
}
|
||
|
|
for (i = h; i < 16; ++i) {
|
||
|
|
memcpy(l, m, l, m - bf, 16);
|
||
|
|
m += bf
|
||
|
|
}
|
||
|
|
w = parseInt((w + 1) / 2);
|
||
|
|
h = parseInt((h + 1) / 2);
|
||
|
|
for (i = 0; i < h; ++i) {
|
||
|
|
memcpy(n, o, f, g, w);
|
||
|
|
memcpy(p, q, j, k, w);
|
||
|
|
if (w < 8) {
|
||
|
|
memset_(n, o + w, n[o + w - 1], 8 - w);
|
||
|
|
memset_(p, q + w, p[q + w - 1], 8 - w)
|
||
|
|
}
|
||
|
|
o += bf;
|
||
|
|
q += bf;
|
||
|
|
g += c.uv_stride;
|
||
|
|
k += c.uv_stride
|
||
|
|
}
|
||
|
|
for (i = h; i < 8; ++i) {
|
||
|
|
memcpy(n, o, n, o - bf, 8);
|
||
|
|
memcpy(p, q, p, q - bf, 8);
|
||
|
|
o += bf;
|
||
|
|
q += bf
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8IteratorExport(a) {
|
||
|
|
var b = a.enc_;
|
||
|
|
if (b.config_.show_compressed) {
|
||
|
|
var x = a.x_,
|
||
|
|
y = a.y_;
|
||
|
|
var c = a.yuv_out_;
|
||
|
|
var d = a.yuv_out_off + bk;
|
||
|
|
var e = a.yuv_out_;
|
||
|
|
var f = a.yuv_out_off + bl;
|
||
|
|
var g = a.yuv_out_;
|
||
|
|
var j = a.yuv_out_off + bm;
|
||
|
|
var k = b.pic_;
|
||
|
|
var l = k.y;
|
||
|
|
var m = k.y_off + (y * k.y_stride + x) * 16;
|
||
|
|
var n = k.u;
|
||
|
|
var o = k.u_off + (y * k.uv_stride + x) * 8;
|
||
|
|
var p = k.v;
|
||
|
|
var q = k.v_off + (y * k.uv_stride + x) * 8;
|
||
|
|
var w = (k.width - x * 16);
|
||
|
|
var h = (k.height - y * 16);
|
||
|
|
var i;
|
||
|
|
if (w > 16) w = 16;
|
||
|
|
if (h > 16) h = 16;
|
||
|
|
for (i = 0; i < h; ++i) {
|
||
|
|
memcpy(l, m + i * k.y_stride, c, d + i * bf, w)
|
||
|
|
} {
|
||
|
|
var r = parseInt((w + 1) / 2);
|
||
|
|
var s = parseInt((h + 1) / 2);
|
||
|
|
for (i = 0; i < s; ++i) {
|
||
|
|
memcpy(n, o + i * k.uv_stride, e, f + i * bf, r);
|
||
|
|
memcpy(p, q + i * k.uv_stride, g, j + i * bf, r)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function BIT(a, n) {
|
||
|
|
return (!!((a) & (1 << (n)))) + 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8IteratorNzToBytes(a) {
|
||
|
|
var b = a.nz_[a.nz_off + 0],
|
||
|
|
lnz = a.nz_[a.nz_off - 1];
|
||
|
|
a.top_nz_[0] = BIT(b, 12);
|
||
|
|
a.top_nz_[1] = BIT(b, 13);
|
||
|
|
a.top_nz_[2] = BIT(b, 14);
|
||
|
|
a.top_nz_[3] = BIT(b, 15);
|
||
|
|
a.top_nz_[4] = BIT(b, 18);
|
||
|
|
a.top_nz_[5] = BIT(b, 19);
|
||
|
|
a.top_nz_[6] = BIT(b, 22);
|
||
|
|
a.top_nz_[7] = BIT(b, 23);
|
||
|
|
a.top_nz_[8] = BIT(b, 24);
|
||
|
|
a.left_nz_[0] = BIT(lnz, 3);
|
||
|
|
a.left_nz_[1] = BIT(lnz, 7);
|
||
|
|
a.left_nz_[2] = BIT(lnz, 11);
|
||
|
|
a.left_nz_[3] = BIT(lnz, 15);
|
||
|
|
a.left_nz_[4] = BIT(lnz, 17);
|
||
|
|
a.left_nz_[5] = BIT(lnz, 19);
|
||
|
|
a.left_nz_[6] = BIT(lnz, 21);
|
||
|
|
a.left_nz_[7] = BIT(lnz, 23)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8IteratorBytesToNz(a) {
|
||
|
|
var b = 0;
|
||
|
|
b |= (a.top_nz_[0] << 12) | (a.top_nz_[1] << 13);
|
||
|
|
b |= (a.top_nz_[2] << 14) | (a.top_nz_[3] << 15);
|
||
|
|
b |= (a.top_nz_[4] << 18) | (a.top_nz_[5] << 19);
|
||
|
|
b |= (a.top_nz_[6] << 22) | (a.top_nz_[7] << 23);
|
||
|
|
b |= (a.top_nz_[8] << 24);
|
||
|
|
b |= (a.left_nz_[0] << 3) | (a.left_nz_[1] << 7);
|
||
|
|
b |= (a.left_nz_[2] << 11);
|
||
|
|
b |= (a.left_nz_[4] << 17) | (a.left_nz_[6] << 21);
|
||
|
|
a.nz_[a.nz_off] = b
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8IteratorNext(a, b, c) {
|
||
|
|
var d = a.enc_;
|
||
|
|
if (b) {
|
||
|
|
var x = a.x_,
|
||
|
|
y = a.y_;
|
||
|
|
var e = b;
|
||
|
|
var f = c + bk;
|
||
|
|
var g = b;
|
||
|
|
var h = c + bl;
|
||
|
|
if (x < d.mb_w_ - 1) {
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 16; ++i) {
|
||
|
|
d.y_left_[d.y_left_off + i] = e[f + 15 + i * bf]
|
||
|
|
}
|
||
|
|
for (i = 0; i < 8; ++i) {
|
||
|
|
d.u_left_[d.u_left_off + i] = g[h + 7 + i * bf];
|
||
|
|
d.v_left_[d.v_left_off + i] = g[h + 15 + i * bf]
|
||
|
|
}
|
||
|
|
d.y_left_[d.y_left_off - 1] = d.y_top_[d.y_top_off + x * 16 + 15];
|
||
|
|
d.u_left_[d.u_left_off - 1] = d.uv_top_[d.uv_top_off + x * 16 + 0 + 7];
|
||
|
|
d.v_left_[d.v_left_off - 1] = d.uv_top_[d.uv_top_off + x * 16 + 8 + 7]
|
||
|
|
}
|
||
|
|
if (y < d.mb_h_ - 1) {
|
||
|
|
memcpy(d.y_top_, d.y_top_off + x * 16, e, f + 15 * bf, 16);
|
||
|
|
memcpy(d.uv_top_, d.uv_top_off + x * 16, g, h + 7 * bf, 8 + 8)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
a.mb_off++;
|
||
|
|
a.preds_off += 4;
|
||
|
|
a.nz_off++;
|
||
|
|
a.x_++;
|
||
|
|
if (a.x_ == d.mb_w_) {
|
||
|
|
a.x_ = 0;
|
||
|
|
a.y_++;
|
||
|
|
a.bw_ = d.parts_[a.y_ & (d.num_parts_ - 1)];
|
||
|
|
a.preds_ = d.preds_;
|
||
|
|
a.preds_off = d.preds_off + a.y_ * 4 * d.preds_w_;
|
||
|
|
a.nz_ = d.nz_;
|
||
|
|
a.nz_off = d.nz_off;
|
||
|
|
InitLeft(a)
|
||
|
|
}
|
||
|
|
return (0 < --a.done_)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8SetIntra16Mode(a, b) {
|
||
|
|
var y;
|
||
|
|
var c = a.preds_;
|
||
|
|
var d = a.preds_off;
|
||
|
|
for (y = 0; y < 4; ++y) {
|
||
|
|
memset_(c, d, b, 4);
|
||
|
|
d += a.enc_.preds_w_
|
||
|
|
}
|
||
|
|
a.mb_[a.mb_off].type_ = 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8SetIntra4Mode(a, b) {
|
||
|
|
var x, y;
|
||
|
|
var c = a.preds_;
|
||
|
|
var d = a.preds_off;
|
||
|
|
for (y = 0; y < 4; ++y) {
|
||
|
|
for (x = 0; x < 4; ++x) {
|
||
|
|
c[d + x] = b[x + y * 4]
|
||
|
|
}
|
||
|
|
d += a.enc_.preds_w_
|
||
|
|
}
|
||
|
|
a.mb_[a.mb_off].type_ = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8SetIntraUVMode(a, b) {
|
||
|
|
a.mb_[a.mb_off].uv_mode_ = b
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8SetSkip(a, b) {
|
||
|
|
a.mb_[a.mb_off].skip_ = b
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8SetSegment(a, b) {
|
||
|
|
a.mb_[a.mb_off].segment_ = b
|
||
|
|
}
|
||
|
|
var cI = new Array(17, 21, 25, 29, 13, 17, 21, 25, 9, 13, 17, 21, 5, 9, 13, 17);
|
||
|
|
|
||
|
|
function VP8IteratorStartI4(a) {
|
||
|
|
var b = a.enc_;
|
||
|
|
var i;
|
||
|
|
a.i4_ = 0;
|
||
|
|
a.i4_top_ = a.i4_boundary_;
|
||
|
|
a.i4_top_off = +cI[0];
|
||
|
|
for (i = 0; i < 17; ++i) {
|
||
|
|
a.i4_boundary_[i] = b.y_left_[b.y_left_off + 15 - i]
|
||
|
|
}
|
||
|
|
for (i = 0; i < 16; ++i) {
|
||
|
|
a.i4_boundary_[17 + i] = b.y_top_[b.y_top_off + a.x_ * 16 + i]
|
||
|
|
}
|
||
|
|
if (a.x_ < b.mb_w_ - 1) {
|
||
|
|
for (i = 16; i < 16 + 4; ++i) {
|
||
|
|
a.i4_boundary_[17 + i] = b.y_top_[b.y_top_off + a.x_ * 16 + i]
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (i = 16; i < 16 + 4; ++i) {
|
||
|
|
a.i4_boundary_[17 + i] = a.i4_boundary_[17 + 15]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
VP8IteratorNzToBytes(a)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8IteratorRotateI4(a, b, c) {
|
||
|
|
var d = b;
|
||
|
|
var e = c + di[a.i4_];
|
||
|
|
var f = a.i4_top_;
|
||
|
|
var g = a.i4_top_off;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i <= 3; ++i) {
|
||
|
|
f[g - 4 + i] = d[e + i + 3 * bf]
|
||
|
|
}
|
||
|
|
if ((a.i4_ & 3) != 3) {
|
||
|
|
for (i = 0; i <= 2; ++i) {
|
||
|
|
f[g + i] = d[e + 3 + (2 - i) * bf]
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (i = 0; i <= 3; ++i) {
|
||
|
|
f[g + i] = f[g + i + 4]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
a.i4_++;
|
||
|
|
if (a.i4_ == 16) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
a.i4_top_ = a.i4_boundary_;
|
||
|
|
a.i4_top_off = +cI[a.i4_];
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
var bc = 64;
|
||
|
|
var cJ = 6;
|
||
|
|
|
||
|
|
function ClipAlpha(a) {
|
||
|
|
return a < 0 ? 0 : a > 255 ? 255 : a
|
||
|
|
}
|
||
|
|
|
||
|
|
function SmoothSegmentMap(a) {
|
||
|
|
var n, x, y = int;
|
||
|
|
var b = 0;
|
||
|
|
var w = a.mb_w_;
|
||
|
|
var h = a.mb_h_;
|
||
|
|
var c = 5;
|
||
|
|
var d = malloc(w * h * sizeof(uint8_t), uint8_t);
|
||
|
|
var e = a.mb_info_;
|
||
|
|
if (d == null) return;
|
||
|
|
for (y = 1; y < h - 1; ++y) {
|
||
|
|
for (x = 1; x < w - 1; ++x) {
|
||
|
|
var f = Arr(be, 0);
|
||
|
|
b = (x + w * y);
|
||
|
|
var g = e[b].segment_;
|
||
|
|
f[e[b - w - 1].segment_]++;
|
||
|
|
f[e[b - w + 0].segment_]++;
|
||
|
|
f[e[b - w + 1].segment_]++;
|
||
|
|
f[e[b - 1].segment_]++;
|
||
|
|
f[e[b + 1].segment_]++;
|
||
|
|
f[e[b + w - 1].segment_]++;
|
||
|
|
f[e[b + w + 0].segment_]++;
|
||
|
|
f[e[b + w + 1].segment_]++;
|
||
|
|
for (n = 0; n < be; ++n) {
|
||
|
|
if (f[n] >= c) {
|
||
|
|
e[b].segment_ = n
|
||
|
|
}
|
||
|
|
}
|
||
|
|
d[x + y * w] = g
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (y = 1; y < h - 1; ++y) {
|
||
|
|
for (x = 1; x < w - 1; ++x) {
|
||
|
|
var e = a.mb_info_[x + w * y];
|
||
|
|
e.segment_ = d[x + y * w]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
d = ''
|
||
|
|
}
|
||
|
|
|
||
|
|
function GetProba(a, b) {
|
||
|
|
var c = int;
|
||
|
|
var d = a + b;
|
||
|
|
if (d == 0) return 255;
|
||
|
|
c = parseInt((255 * a + d / 2) / d);
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function SetSegmentProbas(a) {
|
||
|
|
var p = Arr(be, 0);
|
||
|
|
var n = int;
|
||
|
|
for (n = 0; n < a.mb_w_ * a.mb_h_; ++n) {
|
||
|
|
var b = a.mb_info_[n];
|
||
|
|
p[b.segment_]++
|
||
|
|
}
|
||
|
|
if (a.pic_.stats_nozero) {
|
||
|
|
for (n = 0; n < be; ++n) {
|
||
|
|
a.pic_.stats.segment_size[n] = p[n]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (a.segment_hdr_.num_segments_ > 1) {
|
||
|
|
var c = a.proba_.segments_;
|
||
|
|
c[0] = GetProba(p[0] + p[1], p[2] + p[3]);
|
||
|
|
c[1] = GetProba(p[0], p[1]);
|
||
|
|
c[2] = GetProba(p[2], p[3]);
|
||
|
|
a.segment_hdr_.update_map_ = (c[0] != 255) || (c[1] != 255) || (c[2] != 255) + 0;
|
||
|
|
a.segment_hdr_.size_ = p[0] * (VP8BitCost(0, c[0]) + VP8BitCost(0, c[1])) + p[1] * (VP8BitCost(0, c[0]) + VP8BitCost(1, c[1])) + p[2] * (VP8BitCost(1, c[0]) + VP8BitCost(0, c[2])) + p[3] * (VP8BitCost(1, c[0]) + VP8BitCost(1, c[2]))
|
||
|
|
} else {
|
||
|
|
a.segment_hdr_.update_map_ = 0;
|
||
|
|
a.segment_hdr_.size_ = 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function clip(v, m, M) {
|
||
|
|
return v < m ? m : v > M ? M : v
|
||
|
|
}
|
||
|
|
|
||
|
|
function SetSegmentAlphas(a, b, c) {
|
||
|
|
var d = a.segment_hdr_.num_segments_;
|
||
|
|
var e = b[0],
|
||
|
|
maxx = b[0];
|
||
|
|
var n = int;
|
||
|
|
if (d > 1) {
|
||
|
|
for (n = 0; n < d; ++n) {
|
||
|
|
if (e > b[n]) e = b[n];
|
||
|
|
if (maxx < b[n]) maxx = b[n]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (maxx == e) maxx = e + 1;
|
||
|
|
assert(c <= maxx && c >= e);
|
||
|
|
for (n = 0; n < d; ++n) {
|
||
|
|
var f = parseInt(255 * (b[n] - c) / (maxx - e));
|
||
|
|
var g = parseInt(255 * (b[n] - e) / (maxx - e));
|
||
|
|
a.dqm_[n].alpha_ = clip(f, -127, 127);
|
||
|
|
a.dqm_[n].beta_ = clip(g, 0, 255)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function AssignSegments(b, c) {
|
||
|
|
var d = b.segment_hdr_.num_segments_;
|
||
|
|
var e = Arr(be, int);
|
||
|
|
var f = int;
|
||
|
|
var g = Arr(256, int);
|
||
|
|
var a, n, k;
|
||
|
|
var h = 0,
|
||
|
|
max_a = 255,
|
||
|
|
range_a = int;
|
||
|
|
var i = Arr(be, int),
|
||
|
|
dist_accum = Arr(be, int);
|
||
|
|
for (n = 0; n < 256 && c[n] == 0; ++n) {}
|
||
|
|
h = n;
|
||
|
|
for (n = 255; n > h && c[n] == 0; --n) {}
|
||
|
|
max_a = n;
|
||
|
|
range_a = max_a - h;
|
||
|
|
for (n = 1, k = 0; n < 2 * d; n += 2) {
|
||
|
|
e[k++] = parseInt(h + (n * range_a) / (2 * d))
|
||
|
|
}
|
||
|
|
for (k = 0; k < cJ; ++k) {
|
||
|
|
var j = int;
|
||
|
|
var l = int;
|
||
|
|
for (n = 0; n < d; ++n) {
|
||
|
|
i[n] = 0;
|
||
|
|
dist_accum[n] = 0
|
||
|
|
}
|
||
|
|
var n = 0;
|
||
|
|
for (a = h; a <= max_a; ++a) {
|
||
|
|
if (c[a]) {
|
||
|
|
while (n < d - 1 && Math.abs(a - e[n + 1]) < Math.abs(a - e[n])) {
|
||
|
|
n++
|
||
|
|
}
|
||
|
|
g[a] = n;
|
||
|
|
dist_accum[n] += a * c[a];
|
||
|
|
i[n] += c[a]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
l = 0;
|
||
|
|
f = 0;
|
||
|
|
j = 0;
|
||
|
|
for (n = 0; n < d; ++n) {
|
||
|
|
if (i[n]) {
|
||
|
|
var m = parseInt((dist_accum[n] + i[n] / 2) / i[n]);
|
||
|
|
l += Math.abs(e[n] - m);
|
||
|
|
e[n] = m;
|
||
|
|
f += m * i[n];
|
||
|
|
j += i[n]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
f = parseInt((f + j / 2) / j);
|
||
|
|
if (l < 5) break
|
||
|
|
}
|
||
|
|
for (n = 0; n < b.mb_w_ * b.mb_h_; ++n) {
|
||
|
|
var o = b.mb_info_[n];
|
||
|
|
var a = o.alpha_;
|
||
|
|
o.segment_ = g[a];
|
||
|
|
o.alpha_ = e[g[a]]
|
||
|
|
}
|
||
|
|
if (d > 1) {
|
||
|
|
var p = (b.config_.preprocessing & 1);
|
||
|
|
if (p) SmoothSegmentMap(b)
|
||
|
|
}
|
||
|
|
SetSegmentProbas(b);
|
||
|
|
SetSegmentAlphas(b, e, f)
|
||
|
|
}
|
||
|
|
var cK = 2;
|
||
|
|
var cL = 2;
|
||
|
|
var cM = 2;
|
||
|
|
|
||
|
|
function MBAnalyzeBestIntra16Mode(a) {
|
||
|
|
var b = (a.enc_.method_ >= 3) ? cK : 4;
|
||
|
|
var c;
|
||
|
|
var d = -1;
|
||
|
|
var e = 0;
|
||
|
|
VP8MakeLuma16Preds(a);
|
||
|
|
for (c = 0; c < b; ++c) {
|
||
|
|
var f = dE(a.yuv_in_, a.yuv_in_off + bk, a.yuv_p_, a.yuv_p_off + df[c], 0, 16);
|
||
|
|
if (f > d) {
|
||
|
|
d = f;
|
||
|
|
e = c
|
||
|
|
}
|
||
|
|
}
|
||
|
|
VP8SetIntra16Mode(a, e);
|
||
|
|
return d
|
||
|
|
}
|
||
|
|
|
||
|
|
function MBAnalyzeBestIntra4Mode(a, b) {
|
||
|
|
var c = Arr(16, int);
|
||
|
|
var d = (a.enc_.method_ >= 3) ? cL : NUM_BMODES;
|
||
|
|
var e = 0;
|
||
|
|
VP8IteratorStartI4(a);
|
||
|
|
do {
|
||
|
|
var f;
|
||
|
|
var g = -1;
|
||
|
|
var h = a.yuv_in_;
|
||
|
|
var i = a.yuv_in_off + bk + di[a.i4_];
|
||
|
|
VP8MakeIntra4Preds(a);
|
||
|
|
for (f = 0; f < d; ++f) {
|
||
|
|
var j = dE(h, i, a.yuv_p_, a.yuv_p_off + dh[f], 0, 1);
|
||
|
|
if (j > g) {
|
||
|
|
g = j;
|
||
|
|
c[a.i4_] = f
|
||
|
|
}
|
||
|
|
}
|
||
|
|
e += g
|
||
|
|
} while (VP8IteratorRotateI4(a, a.yuv_in_, a.yuv_in_off + bk));
|
||
|
|
if (e > b) {
|
||
|
|
VP8SetIntra4Mode(a, c);
|
||
|
|
b = ClipAlpha(e)
|
||
|
|
}
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
|
||
|
|
function MBAnalyzeBestUVMode(a) {
|
||
|
|
var b = -1;
|
||
|
|
var c = 0;
|
||
|
|
var d = (a.enc_.method_ >= 3) ? cM : 4;
|
||
|
|
var e;
|
||
|
|
VP8MakeChroma8Preds(a);
|
||
|
|
for (e = 0; e < d; ++e) {
|
||
|
|
var f = dE(a.yuv_in_, a.yuv_in_off + bl, a.yuv_p_, a.yuv_p_off + dg[e], 16, 16 + 4 + 4);
|
||
|
|
if (f > b) {
|
||
|
|
b = f;
|
||
|
|
c = e
|
||
|
|
}
|
||
|
|
}
|
||
|
|
VP8SetIntraUVMode(a, c);
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
|
||
|
|
function MBAnalyze(a, b, c) {
|
||
|
|
var d = a.enc_;
|
||
|
|
var e, best_uv_alpha = int;
|
||
|
|
VP8SetIntra16Mode(a, 0);
|
||
|
|
VP8SetSkip(a, 0);
|
||
|
|
VP8SetSegment(a, 0);
|
||
|
|
e = MBAnalyzeBestIntra16Mode(a);
|
||
|
|
if (d.method_ != 3) {
|
||
|
|
e = MBAnalyzeBestIntra4Mode(a, e)
|
||
|
|
}
|
||
|
|
best_uv_alpha = MBAnalyzeBestUVMode(a);
|
||
|
|
e = parseInt((e + best_uv_alpha + 1) / 2);
|
||
|
|
b[e]++;
|
||
|
|
c += best_uv_alpha;
|
||
|
|
a.mb_[a.mb_off].alpha_ = e;
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8EncAnalyze(a) {
|
||
|
|
var b = Arr(256, 0);
|
||
|
|
var c = newObjectIt(bV);
|
||
|
|
VP8IteratorInit(a, c);
|
||
|
|
a.uv_alpha_ = 0;
|
||
|
|
do {
|
||
|
|
VP8IteratorImport(c);
|
||
|
|
a.uv_alpha_ = MBAnalyze(c, b, a.uv_alpha_)
|
||
|
|
} while (VP8IteratorNext(c, c.yuv_in_, c.yuv_in_off));
|
||
|
|
a.uv_alpha_ /= a.mb_w_ * a.mb_h_;
|
||
|
|
a.uv_alpha_ = parseInt(a.uv_alpha_);
|
||
|
|
AssignSegments(a, b);
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
var cN = 1;
|
||
|
|
var cO = 1;
|
||
|
|
var cP = 0;
|
||
|
|
var cQ = 1;
|
||
|
|
var cR = 64;
|
||
|
|
var cS = 30;
|
||
|
|
var cT = 100;
|
||
|
|
var cU = 0.9;
|
||
|
|
|
||
|
|
function MULT_8B(a, b) {
|
||
|
|
return (((a) * (b) + 128) >> 8)
|
||
|
|
}
|
||
|
|
|
||
|
|
function clip(v, m, M) {
|
||
|
|
return v < m ? m : v > M ? M : v
|
||
|
|
}
|
||
|
|
var cV = new Array(0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15);
|
||
|
|
var cW = new Array(4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 17, 18, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 25, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 91, 93, 95, 96, 98, 100, 101, 102, 104, 106, 108, 110, 112, 114, 116, 118, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 143, 145, 148, 151, 154, 157);
|
||
|
|
var cX = new Array(4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 119, 122, 125, 128, 131, 134, 137, 140, 143, 146, 149, 152, 155, 158, 161, 164, 167, 170, 173, 177, 181, 185, 189, 193, 197, 201, 205, 209, 213, 217, 221, 225, 229, 234, 239, 245, 249, 254, 259, 264, 269, 274, 279, 284);
|
||
|
|
var cY = new Array(8, 8, 9, 10, 12, 13, 15, 17, 18, 20, 21, 23, 24, 26, 27, 29, 31, 32, 34, 35, 37, 38, 40, 41, 43, 44, 46, 48, 49, 51, 52, 54, 55, 57, 58, 60, 62, 63, 65, 66, 68, 69, 71, 72, 74, 75, 77, 79, 80, 82, 83, 85, 86, 88, 89, 93, 96, 99, 102, 105, 108, 111, 114, 117, 120, 124, 127, 130, 133, 136, 139, 142, 145, 148, 151, 155, 158, 161, 164, 167, 170, 173, 176, 179, 184, 189, 193, 198, 203, 207, 212, 217, 221, 226, 230, 235, 240, 244, 249, 254, 258, 263, 268, 274, 280, 286, 292, 299, 305, 311, 317, 323, 330, 336, 342, 348, 354, 362, 370, 379, 385, 393, 401, 409, 416, 424, 432, 440);
|
||
|
|
var cZ = new Array(0, 10, 20, 30, 10, 20, 30, 30, 20, 30, 30, 30, 30, 30, 30, 30);
|
||
|
|
var da = new Array(new Array(96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96), new Array(96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96), new Array(96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96, 96));
|
||
|
|
var db = new Array(0, 30, 60, 90, 30, 60, 90, 90, 60, 90, 90, 90, 90, 90, 90, 90);
|
||
|
|
|
||
|
|
function ExpandMatrix(m, a) {
|
||
|
|
var i;
|
||
|
|
var b = 0;
|
||
|
|
for (i = 2; i < 16; ++i) {
|
||
|
|
m.q_[i] = m.q_[1]
|
||
|
|
}
|
||
|
|
for (i = 0; i < 16; ++i) {
|
||
|
|
var j = cV[i];
|
||
|
|
var c = da[a][j];
|
||
|
|
m.iq_[j] = parseInt((1 << bI) / m.q_[j]);
|
||
|
|
m.bias_[j] = BIAS(c);
|
||
|
|
m.zthresh_[j] = ((256 - c) * m.q_[j] + 127) >> 8;
|
||
|
|
m.sharpen_[j] = (db[j] * m.q_[j]) >> 11;
|
||
|
|
b += m.q_[j]
|
||
|
|
}
|
||
|
|
return (b + 8) >> 4
|
||
|
|
}
|
||
|
|
|
||
|
|
function SetupMatrices(a) {
|
||
|
|
var i;
|
||
|
|
var b = (a.method_ >= 4) ? a.config_.sns_strength : 0;
|
||
|
|
var c = a.segment_hdr_.num_segments_;
|
||
|
|
for (i = 0; i < c; ++i) {
|
||
|
|
var m = a.dqm_[i];
|
||
|
|
var q = m.quant_;
|
||
|
|
var d = int,
|
||
|
|
q16 = int,
|
||
|
|
quv = int;
|
||
|
|
m.y1_.q_[0] = cW[clip(q + a.dq_y1_dc_, 0, 127)];
|
||
|
|
m.y1_.q_[1] = cX[clip(q, 0, 127)];
|
||
|
|
m.y2_.q_[0] = cW[clip(q + a.dq_y2_dc_, 0, 127)] * 2;
|
||
|
|
m.y2_.q_[1] = cY[clip(q + a.dq_y2_ac_, 0, 127)];
|
||
|
|
m.uv_.q_[0] = cW[clip(q + a.dq_uv_dc_, 0, 117)];
|
||
|
|
m.uv_.q_[1] = cX[clip(q + a.dq_uv_ac_, 0, 127)];
|
||
|
|
d = ExpandMatrix(m.y1_, 0);
|
||
|
|
q16 = ExpandMatrix(m.y2_, 1);
|
||
|
|
quv = ExpandMatrix(m.uv_, 2); {
|
||
|
|
m.lambda_i4_ = (3 * d * d) >> 7;
|
||
|
|
m.lambda_i16_ = (3 * q16 * q16);
|
||
|
|
m.lambda_uv_ = (3 * quv * quv) >> 6;
|
||
|
|
m.lambda_mode_ = (1 * d * d) >> 7;
|
||
|
|
m.lambda_trellis_i4_ = (7 * d * d) >> 3;
|
||
|
|
m.lambda_trellis_i16_ = (q16 * q16) >> 2;
|
||
|
|
m.lambda_trellis_uv_ = (quv * quv) << 1;
|
||
|
|
m.tlambda_ = (b * d) >> 5
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var dc = 3;
|
||
|
|
|
||
|
|
function SetupFilterStrength(a) {
|
||
|
|
var i;
|
||
|
|
var b = a.config_.filter_strength;
|
||
|
|
for (i = 0; i < be; ++i) {
|
||
|
|
var c = parseInt(b * 256 * a.dqm_[i].quant_ / 128);
|
||
|
|
var f = parseInt(c / (256 + a.dqm_[i].beta_));
|
||
|
|
a.dqm_[i].fstrength_ = (f < dc) ? 0 : (f > 63) ? 63 : f
|
||
|
|
}
|
||
|
|
a.filter_hdr_.level_ = a.dqm_[0].fstrength_;
|
||
|
|
a.filter_hdr_.simple_ = (a.config_.filter_type == 0) + 0;
|
||
|
|
a.filter_hdr_.sharpness_ = a.config_.filter_sharpness
|
||
|
|
}
|
||
|
|
var dd = (6);
|
||
|
|
var de = (-4);
|
||
|
|
|
||
|
|
function QualityToCompression(q) {
|
||
|
|
var c = q / 100.;
|
||
|
|
return (c < 0.75) ? c * (2. / 3.) : 2. * c - 1.
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8SetSegmentParams(a, b) {
|
||
|
|
var i;
|
||
|
|
var d, dq_uv_dc = int;
|
||
|
|
var e = a.config_.segments;
|
||
|
|
var f = cU * a.config_.sns_strength / 100. / 128.;
|
||
|
|
var g = QualityToCompression(b);
|
||
|
|
for (i = 0; i < e; ++i) {
|
||
|
|
var h = (1. - f * a.dqm_[i].alpha_) / 3.;
|
||
|
|
var c = Math.pow(g, h);
|
||
|
|
var q = parseInt((127. * (1. - c)));
|
||
|
|
assert(h > 0.);
|
||
|
|
a.dqm_[i].quant_ = clip(q, 0, 127)
|
||
|
|
}
|
||
|
|
a.base_quant_ = a.dqm_[0].quant_;
|
||
|
|
for (i = e; i < be; ++i) {
|
||
|
|
a.dqm_[i].quant_ = a.base_quant_
|
||
|
|
}
|
||
|
|
d = parseInt((a.uv_alpha_ - cR) * (dd - de) / (cT - cS));
|
||
|
|
d = parseInt(d * a.config_.sns_strength / 100);
|
||
|
|
d = clip(d, de, dd);
|
||
|
|
dq_uv_dc = parseInt(-4 * a.config_.sns_strength / 100);
|
||
|
|
dq_uv_dc = clip(dq_uv_dc, -15, 15);
|
||
|
|
a.dq_y1_dc_ = 0;
|
||
|
|
a.dq_y2_dc_ = 0;
|
||
|
|
a.dq_y2_ac_ = 0;
|
||
|
|
a.dq_uv_dc_ = dq_uv_dc;
|
||
|
|
a.dq_uv_ac_ = d;
|
||
|
|
SetupMatrices(a);
|
||
|
|
SetupFilterStrength(a)
|
||
|
|
}
|
||
|
|
var df = new Array(bo, bp, bq, br);
|
||
|
|
var dg = new Array(bs, bt, bu, bv);
|
||
|
|
var dh = new Array(bw, bx, by, bz, bA, bB, bC, bD, bE, bF);
|
||
|
|
|
||
|
|
function VP8MakeLuma16Preds(a) {
|
||
|
|
var b = a.enc_;
|
||
|
|
var c = a.x_ ? b.y_left_ : null;
|
||
|
|
var d = a.x_ ? b.y_left_off : null;
|
||
|
|
var e = a.y_ ? b.y_top_ : null;
|
||
|
|
var f = a.y_ ? b.y_top_off + a.x_ * 16 : null;
|
||
|
|
dK(a.yuv_p_, a.yuv_p_off, c, d, e, f)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8MakeChroma8Preds(a) {
|
||
|
|
var b = a.enc_;
|
||
|
|
var c = a.x_ ? b.u_left_ : null;
|
||
|
|
var d = a.x_ ? b.u_left_off : null;
|
||
|
|
var e = a.y_ ? b.uv_top_ : null;
|
||
|
|
var f = a.y_ ? b.uv_top_off + a.x_ * 16 : null;
|
||
|
|
dL(a.yuv_p_, a.yuv_p_off, c, d, e, f)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8MakeIntra4Preds(a) {
|
||
|
|
dJ(a.yuv_p_, a.yuv_p_off, a.i4_top_, a.i4_top_off)
|
||
|
|
}
|
||
|
|
var di = new Array(0 + 0 * bf, 4 + 0 * bf, 8 + 0 * bf, 12 + 0 * bf, 0 + 4 * bf, 4 + 4 * bf, 8 + 4 * bf, 12 + 4 * bf, 0 + 8 * bf, 4 + 8 * bf, 8 + 8 * bf, 12 + 8 * bf, 0 + 12 * bf, 4 + 12 * bf, 8 + 12 * bf, 12 + 12 * bf, 0 + 0 * bf, 4 + 0 * bf, 0 + 4 * bf, 4 + 4 * bf, 8 + 0 * bf, 12 + 0 * bf, 8 + 4 * bf, 12 + 4 * bf);
|
||
|
|
var dj = new Array(38, 32, 20, 9, 32, 28, 17, 7, 20, 17, 10, 4, 9, 7, 4, 2);
|
||
|
|
var dk = new Array(30, 27, 19, 11, 27, 24, 17, 10, 19, 17, 12, 8, 11, 10, 8, 6);
|
||
|
|
|
||
|
|
function InitScore(a) {
|
||
|
|
a.D = 0;
|
||
|
|
a.SD = 0;
|
||
|
|
a.R = 0;
|
||
|
|
a.nz = 0;
|
||
|
|
a.score = bH
|
||
|
|
}
|
||
|
|
|
||
|
|
function CopyScore(a, b) {
|
||
|
|
a.D = (b.D);
|
||
|
|
a.SD = (b.SD);
|
||
|
|
a.R = (b.R);
|
||
|
|
a.nz = (b.nz);
|
||
|
|
a.score = (b.score)
|
||
|
|
}
|
||
|
|
|
||
|
|
function AddScore(a, b) {
|
||
|
|
a.D += b.D;
|
||
|
|
a.SD += b.SD;
|
||
|
|
a.R += b.R;
|
||
|
|
a.nz |= b.nz;
|
||
|
|
a.score += b.score
|
||
|
|
}
|
||
|
|
var dl = {
|
||
|
|
prev: int,
|
||
|
|
level: int,
|
||
|
|
sign: int,
|
||
|
|
cost: score_t,
|
||
|
|
error: score_t,
|
||
|
|
ctx: int
|
||
|
|
};
|
||
|
|
var dm = 0;
|
||
|
|
var dn = 1;
|
||
|
|
var dp = (dm + 1 + dn);
|
||
|
|
|
||
|
|
function SetRDScore(a, b) {
|
||
|
|
b.score = b.R * a + 256 * (b.D + b.SD)
|
||
|
|
}
|
||
|
|
|
||
|
|
function RDScoreTrellis(a, b, c) {
|
||
|
|
return b * a + 256 * c
|
||
|
|
}
|
||
|
|
|
||
|
|
function TrellisQuantizeBlock(a, b, c, d, e, f, g) {
|
||
|
|
var h = a.enc_.proba_.coeffs_[e];
|
||
|
|
var i = a.enc_.proba_.level_cost_[e];
|
||
|
|
var k = (e == 0) ? 1 : 0;
|
||
|
|
var l = ArrM(new Array(17, dp), dl);
|
||
|
|
var o = new Array(-1, -1, -1);
|
||
|
|
var q = score_t;
|
||
|
|
var r;
|
||
|
|
var s = k - 1;
|
||
|
|
var n = int,
|
||
|
|
m = int,
|
||
|
|
p = int,
|
||
|
|
nz = int; {
|
||
|
|
var t = score_t;
|
||
|
|
var u = score_t;
|
||
|
|
var v = parseInt(f.q_[1] * f.q_[1] / 4);
|
||
|
|
var w = h[cw[k]][d][0];
|
||
|
|
u = 0;
|
||
|
|
for (n = k; n < 16; ++n) {
|
||
|
|
var j = cV[n];
|
||
|
|
var x = b[j] * b[j];
|
||
|
|
u += dk[j] * x;
|
||
|
|
if (x > v) s = n
|
||
|
|
}
|
||
|
|
if (s < 15) ++s;
|
||
|
|
t = VP8BitCost(0, w);
|
||
|
|
q = RDScoreTrellis(g, t, u);
|
||
|
|
n = k - 1;
|
||
|
|
for (m = -dm; m <= dn; ++m) {
|
||
|
|
l[n + 1][m + dm].cost = 0;
|
||
|
|
l[n + 1][m + dm].error = u;
|
||
|
|
l[n + 1][m + dm].ctx = d
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (n = k; n <= s; ++n) {
|
||
|
|
var j = cV[n];
|
||
|
|
var Q = f.q_[j];
|
||
|
|
var y = f.iq_[j];
|
||
|
|
var B = BIAS(0x00);
|
||
|
|
var z = (b[j] < 0) + 0;
|
||
|
|
var A = (z ? -b[j] : b[j]) + f.sharpen_[j];
|
||
|
|
var C;
|
||
|
|
if (A > 2047) A = 2047;
|
||
|
|
C = QUANTDIV(A, y, B);
|
||
|
|
for (m = -dm; m <= dn; ++m) {
|
||
|
|
var D = l[n + 1][m + dm];
|
||
|
|
var E, new_error;
|
||
|
|
var F = bH;
|
||
|
|
var G = C + m;
|
||
|
|
var w;
|
||
|
|
D.sign = z;
|
||
|
|
D.level = G;
|
||
|
|
D.ctx = (G == 0) ? 0 : (G == 1) ? 1 : 2;
|
||
|
|
if (G >= 2048 || G < 0) {
|
||
|
|
D.cost = bH;
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
w = h[cw[n + 1]][D.ctx][0];
|
||
|
|
new_error = A - G * Q;
|
||
|
|
E = dk[j] * (A * A - new_error * new_error);
|
||
|
|
for (p = -dm; p <= dn; ++p) {
|
||
|
|
var H = l[n - 1 + 1][p + dm];
|
||
|
|
var I = H.ctx;
|
||
|
|
var J = i[cw[n]][I];
|
||
|
|
var K = H.error - E;
|
||
|
|
var t = score_t,
|
||
|
|
base_cost = score_t,
|
||
|
|
score = score_t;
|
||
|
|
if (H.cost >= bH) {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
base_cost = H.cost + VP8LevelCost(J, G);
|
||
|
|
t = base_cost;
|
||
|
|
if (G && n < 15) {
|
||
|
|
t += VP8BitCost(1, w)
|
||
|
|
}
|
||
|
|
score = RDScoreTrellis(g, t, K);
|
||
|
|
if (score < F) {
|
||
|
|
F = score;
|
||
|
|
D.cost = t;
|
||
|
|
D.error = K;
|
||
|
|
D.prev = p
|
||
|
|
}
|
||
|
|
if (G) {
|
||
|
|
t = base_cost;
|
||
|
|
if (n < 15) t += VP8BitCost(0, w);
|
||
|
|
score = RDScoreTrellis(g, t, K);
|
||
|
|
if (score < q) {
|
||
|
|
q = score;
|
||
|
|
o[0] = n;
|
||
|
|
o[1] = m;
|
||
|
|
o[2] = p
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
memset_(b, +k, 0, (16 - k) * sizeof(b));
|
||
|
|
memset_(c, +k, 0, (16 - k) * sizeof(c));
|
||
|
|
if (o[0] == -1) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
n = o[0];
|
||
|
|
r = o[1];
|
||
|
|
l[n + 1][r + dm].prev = o[2];
|
||
|
|
nz = 0;
|
||
|
|
for (; n >= k; --n) {
|
||
|
|
var L = l[n + 1][r + dm];
|
||
|
|
var j = cV[n];
|
||
|
|
c[n] = L.sign ? -L.level : L.level;
|
||
|
|
nz |= (L.level != 0);
|
||
|
|
b[j] = c[n] * f.q_[j];
|
||
|
|
r = L.prev
|
||
|
|
}
|
||
|
|
return nz
|
||
|
|
}
|
||
|
|
|
||
|
|
function ReconstructIntra16(a, b, c, d, e) {
|
||
|
|
var f = a.enc_;
|
||
|
|
var g = a.yuv_p_;
|
||
|
|
var h = a.yuv_p_off + df[e];
|
||
|
|
var i = a.yuv_in_;
|
||
|
|
var j = a.yuv_in_off + bk;
|
||
|
|
var k = f.dqm_[a.mb_[a.mb_off].segment_];
|
||
|
|
var l = 0;
|
||
|
|
var n = int;
|
||
|
|
var m = ArrM(Array(16, 16), int16_t),
|
||
|
|
dc_tmp = Arr(16, int16_t);
|
||
|
|
for (n = 0; n < 16; ++n) {
|
||
|
|
dG(i, j + di[n], g, h + di[n], m[n])
|
||
|
|
}
|
||
|
|
dI(m, dc_tmp);
|
||
|
|
l |= dS(dc_tmp, b.y_dc_levels, 0, k.y2_) << 24;
|
||
|
|
if (cO && a.do_trellis_) {
|
||
|
|
var x, y;
|
||
|
|
VP8IteratorNzToBytes(a);
|
||
|
|
for (y = 0, n = 0; y < 4; ++y) {
|
||
|
|
for (x = 0; x < 4; ++x) {
|
||
|
|
var o = a.top_nz_[x] + a.left_nz_[y];
|
||
|
|
var p = TrellisQuantizeBlock(a, m[n], b.y_ac_levels[n], o, 0, k.y1_, k.lambda_trellis_i16_);
|
||
|
|
a.top_nz_[x] = a.left_nz_[y] = p;
|
||
|
|
l |= p << n;
|
||
|
|
++n
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (n = 0; n < 16; ++n) {
|
||
|
|
l |= dS(m[n], b.y_ac_levels[n], 1, k.y1_) << n
|
||
|
|
}
|
||
|
|
}
|
||
|
|
dH(dc_tmp, m);
|
||
|
|
for (n = 0; n < 16; n += 2) {
|
||
|
|
dF(g, h + di[n], m[n], 0, c, d + di[n], 1)
|
||
|
|
}
|
||
|
|
return l
|
||
|
|
}
|
||
|
|
|
||
|
|
function ReconstructIntra4(a, b, c, d, e, f, g) {
|
||
|
|
var h = a.enc_;
|
||
|
|
var i = a.yuv_p_;
|
||
|
|
var j = a.yuv_p_off + dh[g];
|
||
|
|
var k = h.dqm_[a.mb_[a.mb_off].segment_];
|
||
|
|
var l = 0;
|
||
|
|
var m = Arr(16, int16_t);
|
||
|
|
dG(c, d, i, j, m);
|
||
|
|
if (cN && a.do_trellis_) {
|
||
|
|
var x = a.i4_ & 3,
|
||
|
|
y = a.i4_ >> 2;
|
||
|
|
var n = a.top_nz_[x] + a.left_nz_[y];
|
||
|
|
l = TrellisQuantizeBlock(a, m, b, n, 3, k.y1_, k.lambda_trellis_i4_)
|
||
|
|
} else {
|
||
|
|
l = dS(m, b, 0, k.y1_)
|
||
|
|
}
|
||
|
|
dF(i, j, m, 0, e, f, 0);
|
||
|
|
return l
|
||
|
|
}
|
||
|
|
|
||
|
|
function ReconstructUV(a, b, c, d, e) {
|
||
|
|
var f = a.enc_;
|
||
|
|
var g = a.yuv_p_;
|
||
|
|
var h = a.yuv_p_off + dg[e];
|
||
|
|
var i = a.yuv_in_;
|
||
|
|
var j = a.yuv_in_off + bl;
|
||
|
|
var k = f.dqm_[a.mb_[a.mb_off].segment_];
|
||
|
|
var l = 0;
|
||
|
|
var n;
|
||
|
|
var m = ArrM(new Array(8, 16), int16_t);
|
||
|
|
for (n = 0; n < 8; ++n) {
|
||
|
|
dG(i, j + di[16 + n], g, h + di[16 + n], m[n])
|
||
|
|
}
|
||
|
|
if (cP && a.do_trellis_) {
|
||
|
|
var o, x, y;
|
||
|
|
for (o = 0; o <= 2; o += 2) {
|
||
|
|
n = 0;
|
||
|
|
for (y = 0; y < 2; ++y) {
|
||
|
|
for (x = 0; x < 2; ++x) {
|
||
|
|
var p = a.top_nz_[4 + o + x] + a.left_nz_[4 + o + y];
|
||
|
|
var q = TrellisQuantizeBlock(a, m[n], b.uv_levels[n], p, 2, k.uv_, k.lambda_trellis_uv_);
|
||
|
|
a.top_nz_[4 + o + x] = a.left_nz_[4 + o + y] = q;
|
||
|
|
l |= q << n;
|
||
|
|
++n
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (n = 0; n < 8; ++n) {
|
||
|
|
l |= dS(m[n], b.uv_levels[n], 0, k.uv_) << n
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for (n = 0; n < 8; n += 1) {
|
||
|
|
dF(g, h + di[16 + n], m[n], 0, c, d + di[16 + n], 0)
|
||
|
|
}
|
||
|
|
return (l << 16)
|
||
|
|
}
|
||
|
|
|
||
|
|
function SwapPtr(a, c, b, d) {}
|
||
|
|
|
||
|
|
function SwapOut(a) {
|
||
|
|
var b = (a.yuv_out_);
|
||
|
|
var c = (a.yuv_out_off);
|
||
|
|
a.yuv_out_ = (a.yuv_out2_);
|
||
|
|
a.yuv_out_off = (a.yuv_out2_off);
|
||
|
|
a.yuv_out2_ = (b);
|
||
|
|
a.yuv_out2_off = (c)
|
||
|
|
}
|
||
|
|
var dq = newObjectIt(bU);
|
||
|
|
|
||
|
|
function PickBestIntra16(a, b) {
|
||
|
|
var c = a.enc_;
|
||
|
|
var d = c.dqm_[a.mb_[a.mb_off].segment_];
|
||
|
|
var e = d.lambda_i16_;
|
||
|
|
var f = d.tlambda_;
|
||
|
|
var g = a.yuv_in_;
|
||
|
|
var h = a.yuv_in_off + bk;
|
||
|
|
var i = (dq);
|
||
|
|
var j;
|
||
|
|
b.mode_i16 = -1;
|
||
|
|
for (j = 0; j < 4; ++j) {
|
||
|
|
var k = a.yuv_out2_;
|
||
|
|
var l = a.yuv_out2_off + bk;
|
||
|
|
var m = int;
|
||
|
|
m = ReconstructIntra16(a, i, k, l, j);
|
||
|
|
i.D = dM(g, h, k, l);
|
||
|
|
i.SD = f ? MULT_8B(f, dR(g, h, k, l, dj)) : 0;
|
||
|
|
i.R = VP8GetCostLuma16(a, i);
|
||
|
|
i.R += ct[j];
|
||
|
|
SetRDScore(e, i);
|
||
|
|
if (j == 0 || i.score < b.score) {
|
||
|
|
CopyScore(b, i);
|
||
|
|
b.mode_i16 = j;
|
||
|
|
b.nz = m;
|
||
|
|
memcpyArrM(b.y_ac_levels, 0, i.y_ac_levels, 0, i.y_ac_levels.length);
|
||
|
|
memcpy(b.y_dc_levels, 0, i.y_dc_levels, 0, i.y_dc_levels.length);
|
||
|
|
SwapOut(a)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
SetRDScore(d.lambda_mode_, b);
|
||
|
|
VP8SetIntra16Mode(a, b.mode_i16)
|
||
|
|
}
|
||
|
|
|
||
|
|
function GetCostModeI4(a, b) {
|
||
|
|
var c = a.enc_.preds_w_;
|
||
|
|
var x = (a.i4_ & 3),
|
||
|
|
y = a.i4_ >> 2;
|
||
|
|
var d = (x == 0) ? a.preds_[a.preds_off + y * c - 1] : b[a.i4_ - 1];
|
||
|
|
var e = (y == 0) ? a.preds_[a.preds_off - c + x] : b[a.i4_ - 4];
|
||
|
|
return cu[e][d]
|
||
|
|
}
|
||
|
|
var dr = newObjectIt(bU);
|
||
|
|
var ds = newObjectIt(bU);
|
||
|
|
var dt = newObjectIt(bU);
|
||
|
|
|
||
|
|
function PickBestIntra4(a, b) {
|
||
|
|
var c = a.enc_;
|
||
|
|
var d = c.dqm_[a.mb_[a.mb_off].segment_];
|
||
|
|
var e = d.lambda_i4_;
|
||
|
|
var f = d.tlambda_;
|
||
|
|
var g = a.yuv_in_;
|
||
|
|
var h = a.yuv_in_off + bk;
|
||
|
|
var i = a.yuv_out2_;
|
||
|
|
var j = a.yuv_out2_off + bk;
|
||
|
|
var k = 0;
|
||
|
|
var l = (dr);
|
||
|
|
if (c.max_i4_header_bits_ == 0) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
InitScore(l);
|
||
|
|
l.score = 211;
|
||
|
|
VP8IteratorStartI4(a);
|
||
|
|
do {
|
||
|
|
var m = (ds);
|
||
|
|
var n;
|
||
|
|
var o = -1;
|
||
|
|
var p = g;
|
||
|
|
var q = h + di[a.i4_];
|
||
|
|
var r = GetCostModeI4(a, b.modes_i4);
|
||
|
|
var s = (i);
|
||
|
|
var t = (j + di[a.i4_]);
|
||
|
|
var u = (a.yuv_p_);
|
||
|
|
var v = (a.yuv_p_off + bG);
|
||
|
|
InitScore(m);
|
||
|
|
VP8MakeIntra4Preds(a);
|
||
|
|
for (n = 0; n < NUM_BMODES; ++n) {
|
||
|
|
var w = (dt);
|
||
|
|
var x = Arr(16, int16_t);
|
||
|
|
w.nz = ReconstructIntra4(a, x, p, q, u, v, n) << a.i4_;
|
||
|
|
w.D = dP(p, q, u, v);
|
||
|
|
w.SD = f ? MULT_8B(f, dQ(p, q, u, v, dj)) : 0;
|
||
|
|
w.R = VP8GetCostLuma4(a, x);
|
||
|
|
w.R += r[n];
|
||
|
|
SetRDScore(e, w);
|
||
|
|
if (o < 0 || w.score < m.score) {
|
||
|
|
CopyScore(m, w);
|
||
|
|
o = n;
|
||
|
|
var y = (u);
|
||
|
|
var z = (v);
|
||
|
|
u = (s);
|
||
|
|
v = (t);
|
||
|
|
s = (y);
|
||
|
|
t = (z);
|
||
|
|
memcpy(l.y_ac_levels[a.i4_], 0, x, 0, sizeof(x) * 16)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
SetRDScore(d.lambda_mode_, m);
|
||
|
|
AddScore(l, m);
|
||
|
|
k += r[o];
|
||
|
|
if (l.score >= b.score || k > c.max_i4_header_bits_) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (t != j + di[a.i4_]) dT(s, t, i, j + di[a.i4_]);
|
||
|
|
b.modes_i4[a.i4_] = o;
|
||
|
|
a.top_nz_[a.i4_ & 3] = a.left_nz_[a.i4_ >> 2] = (m.nz ? 1 : 0)
|
||
|
|
} while (VP8IteratorRotateI4(a, i, j));
|
||
|
|
CopyScore(b, l);
|
||
|
|
VP8SetIntra4Mode(a, b.modes_i4);
|
||
|
|
SwapOut(a);
|
||
|
|
memcpyArrM(b.y_ac_levels, 0, l.y_ac_levels, 0, b.y_ac_levels.length);
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
var du = newObjectIt(bU);
|
||
|
|
var dv = newObjectIt(bU);
|
||
|
|
|
||
|
|
function PickBestUV(a, b) {
|
||
|
|
var c = a.enc_;
|
||
|
|
var d = c.dqm_[a.mb_[a.mb_off].segment_];
|
||
|
|
var e = d.lambda_uv_;
|
||
|
|
var f = a.yuv_in_;
|
||
|
|
var g = a.yuv_in_off + bl;
|
||
|
|
var h = a.yuv_out2_;
|
||
|
|
var i = a.yuv_out2_off + bl;
|
||
|
|
var j = a.yuv_out_;
|
||
|
|
var k = a.yuv_out_off + bl;
|
||
|
|
var l = (du);
|
||
|
|
var m;
|
||
|
|
b.mode_uv = -1;
|
||
|
|
InitScore(l);
|
||
|
|
for (m = 0; m < 4; ++m) {
|
||
|
|
var n = (dv);
|
||
|
|
n.nz = ReconstructUV(a, n, h, i, m);
|
||
|
|
n.D = dO(f, g, h, i);
|
||
|
|
n.SD = 0;
|
||
|
|
n.R = VP8GetCostUV(a, n);
|
||
|
|
n.R += cs[m];
|
||
|
|
SetRDScore(e, n);
|
||
|
|
if (m == 0 || n.score < l.score) {
|
||
|
|
CopyScore(l, n);
|
||
|
|
b.mode_uv = m;
|
||
|
|
memcpyArrM(b.uv_levels, 0, n.uv_levels, 0, b.uv_levels.length);
|
||
|
|
memcpy(j, k, h, i, bh)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
VP8SetIntraUVMode(a, b.mode_uv);
|
||
|
|
AddScore(b, l)
|
||
|
|
}
|
||
|
|
|
||
|
|
function SimpleQuantize(a, b) {
|
||
|
|
var c = a.enc_;
|
||
|
|
var d = (a.mb_[a.mb_off].type_ == 1);
|
||
|
|
var e = 0;
|
||
|
|
if (d) {
|
||
|
|
e = ReconstructIntra16(a, b, a.yuv_out_, a.yuv_out_off + bk, a.preds_[a.preds_off + 0])
|
||
|
|
} else {
|
||
|
|
VP8IteratorStartI4(a);
|
||
|
|
do {
|
||
|
|
var f = a.preds_[a.preds_off + (a.i4_ & 3) + (a.i4_ >> 2) * c.preds_w_];
|
||
|
|
var g = a.yuv_in_;
|
||
|
|
var h = a.yuv_in_off + bk + di[a.i4_];
|
||
|
|
var i = a.yuv_out_;
|
||
|
|
var j = a.yuv_out_off + bk + di[a.i4_];
|
||
|
|
VP8MakeIntra4Preds(a);
|
||
|
|
e |= ReconstructIntra4(a, b.y_ac_levels[a.i4_], g, h, i, j, f) << a.i4_
|
||
|
|
} while (VP8IteratorRotateI4(a, a.yuv_out_, a.yuv_out_off + bk))
|
||
|
|
}
|
||
|
|
e |= ReconstructUV(a, b, a.yuv_out_, a.yuv_out_off + bl, a.mb_[a.mb_off].uv_mode_);
|
||
|
|
b.nz = e
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8Decimate(a, b, c) {
|
||
|
|
var d = int;
|
||
|
|
InitScore(b);
|
||
|
|
VP8MakeLuma16Preds(a);
|
||
|
|
VP8MakeChroma8Preds(a);
|
||
|
|
if (c > 0) {
|
||
|
|
a.do_trellis_ = (c > 2) + 0;
|
||
|
|
PickBestIntra16(a, b);
|
||
|
|
if (a.enc_.method_ >= 2) {
|
||
|
|
PickBestIntra4(a, b)
|
||
|
|
}
|
||
|
|
PickBestUV(a, b);
|
||
|
|
if (c == 2) {
|
||
|
|
a.do_trellis_ = 1;
|
||
|
|
SimpleQuantize(a, b)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
a.do_trellis_ = (a.enc_.method_ == 2) + 0;
|
||
|
|
SimpleQuantize(a, b)
|
||
|
|
}
|
||
|
|
d = (b.nz == 0) + 0;
|
||
|
|
VP8SetSkip(a, d);
|
||
|
|
return d
|
||
|
|
}
|
||
|
|
var dw = new Array(new Array(new Array(new Array(128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128), new Array(128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128), new Array(128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128)), new Array(new Array(253, 136, 254, 255, 228, 219, 128, 128, 128, 128, 128), new Array(189, 129, 242, 255, 227, 213, 255, 219, 128, 128, 128), new Array(106, 126, 227, 252, 214, 209, 255, 255, 128, 128, 128)), new Array(new Array(1, 98, 248, 255, 236, 226, 255, 255, 128, 128, 128), new Array(181, 133, 238, 254, 221, 234, 255, 154, 128, 128, 128), new Array(78, 134, 202, 247, 198, 180, 255, 219, 128, 128, 128)), new Array(new Array(1, 185, 249, 255, 243, 255, 128, 128, 128, 128, 128), new Array(184, 150, 247, 255, 236, 224, 128, 128, 128, 128, 128), new Array(77, 110, 216, 255, 236, 230, 128, 128, 128, 128, 128)), new Array(new Array(1, 101, 251, 255, 241, 255, 128, 128, 128, 128, 128), new Array(170, 139, 241, 252, 236, 209, 255, 255, 128, 128, 128), new Array(37, 116, 196, 243, 228, 255, 255, 255, 128, 128, 128)), new Array(new Array(1, 204, 254, 255, 245, 255, 128, 128, 128, 128, 128), new Array(207, 160, 250, 255, 238, 128, 128, 128, 128, 128, 128), new Array(102, 103, 231, 255, 211, 171, 128, 128, 128, 128, 128)), new Array(new Array(1, 152, 252, 255, 240, 255, 128, 128, 128, 128, 128), new Array(177, 135, 243, 255, 234, 225, 128, 128, 128, 128, 128), new Array(80, 129, 211, 255, 194, 224, 128, 128, 128, 128, 128)), new Array(new Array(1, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128), new Array(246, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128), new Array(255, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128))), new Array(new Array(new Array(198, 35, 237, 223, 193, 187, 162, 160, 145, 155, 62), new Array(131, 45, 198, 221, 172, 176, 220, 157, 252, 221, 1), new Array(68, 47, 146, 208, 149, 167, 221, 162, 255, 223, 128)), new Array(new Array(1, 149, 241, 255, 221, 224, 255, 255, 128, 128, 128), new Array(184, 141, 234, 253, 222, 220, 255, 199, 128, 128, 128), new Array(81, 99, 181, 242, 176, 190, 249, 202, 255, 255, 128)), new Array(new Array(1, 129, 232, 253, 214, 197, 242, 196, 255, 255, 128), new Array(99, 121, 210, 250, 201, 198, 255, 202, 128, 128, 128), new Array(23, 91, 163, 242, 170, 187, 247, 210, 255, 255, 128)), new Array(new Array(1, 200, 246, 255, 234, 255, 128, 128, 128, 128, 128), new Array(109, 178, 241, 255, 231, 245, 255, 255, 128, 128, 128), new Array(44, 130, 201, 253, 205, 192, 255, 255, 128, 128, 128)), new Array(new Array(1, 132, 239, 251, 219, 209, 255, 165, 128, 128, 128), new Array(94, 136, 225, 251, 218, 190, 255, 255, 128, 128, 128), new Array(22, 100, 174, 245, 186, 161, 255, 199, 128, 128, 128)), new Array(new Array(1, 182, 249, 255, 232, 235, 128, 128, 128, 128, 128), new Array(124, 143, 241, 255, 227, 234, 128, 128, 128, 128, 128), new Array(35, 77, 181, 251, 193, 211, 255, 205, 128, 128, 128)), new Array(new Array(1, 157, 247, 255, 236, 231, 255, 255, 128, 128, 128), new Array(121, 141, 235, 255, 225, 227, 255, 255, 128, 128, 128), new Array(45, 99, 188, 251, 195, 217, 255, 224, 128, 128, 128)), new Array(new Array(1, 1, 251, 255, 213, 255, 128, 128, 128, 128, 128), new Array(203, 1, 248, 255, 255, 128, 128, 128, 128, 128, 128), new Array(137, 1, 177, 255, 224, 255, 128, 128, 128, 128, 128))), new Array(new Array(new Array(253, 9, 248, 251, 207, 208, 255, 192, 128, 128, 128), new Array(175, 13, 224, 243, 193, 185, 249, 198, 255, 255, 128), new Array(73, 17, 171, 221, 161, 179, 236, 167, 255, 234, 128)), new Array(new Array(1, 95, 247, 253, 212, 183, 255, 255, 128, 128, 128), new Array(239, 90, 244, 250, 211, 209, 255, 255, 128, 128, 128), new Array(155, 77, 195, 248, 188, 195, 255, 255, 128, 128, 128)), new Array(new Array(1, 24, 239, 251, 218, 219, 255, 205, 128, 128, 128), new Array(201, 51, 219, 255, 196, 186, 128, 128, 128, 128, 128), new Array(69, 46, 190, 239, 201, 218, 255, 228, 128, 128, 128)), new Array(new Array(1, 191, 251, 255, 255, 128, 128, 128, 128, 128, 128), new Array(223, 165, 249, 255, 213, 255, 128, 128, 128, 128, 128), new A
|
||
|
|
|
||
|
|
function VP8DefaultProbas(a) {
|
||
|
|
var b = a.proba_;
|
||
|
|
for (var i = 0; i < b.segments_.length; ++i) b.segments_[i] = 255;
|
||
|
|
b.coeffs_ = newObjectIt(dw);
|
||
|
|
b.use_skip_proba_ = 0
|
||
|
|
}
|
||
|
|
var dx = new Array(new Array(new Array(231, 120, 48, 89, 115, 113, 120, 152, 112), new Array(152, 179, 64, 126, 170, 118, 46, 70, 95), new Array(175, 69, 143, 80, 85, 82, 72, 155, 103), new Array(56, 58, 10, 171, 218, 189, 17, 13, 152), new Array(114, 26, 17, 163, 44, 195, 21, 10, 173), new Array(121, 24, 80, 195, 26, 62, 44, 64, 85), new Array(144, 71, 10, 38, 171, 213, 144, 34, 26), new Array(170, 46, 55, 19, 136, 160, 33, 206, 71), new Array(63, 20, 8, 114, 114, 208, 12, 9, 226), new Array(81, 40, 11, 96, 182, 84, 29, 16, 36)), new Array(new Array(134, 183, 89, 137, 98, 101, 106, 165, 148), new Array(72, 187, 100, 130, 157, 111, 32, 75, 80), new Array(66, 102, 167, 99, 74, 62, 40, 234, 128), new Array(41, 53, 9, 178, 241, 141, 26, 8, 107), new Array(74, 43, 26, 146, 73, 166, 49, 23, 157), new Array(65, 38, 105, 160, 51, 52, 31, 115, 128), new Array(104, 79, 12, 27, 217, 255, 87, 17, 7), new Array(87, 68, 71, 44, 114, 51, 15, 186, 23), new Array(47, 41, 14, 110, 182, 183, 21, 17, 194), new Array(66, 45, 25, 102, 197, 189, 23, 18, 22)), new Array(new Array(88, 88, 147, 150, 42, 46, 45, 196, 205), new Array(43, 97, 183, 117, 85, 38, 35, 179, 61), new Array(39, 53, 200, 87, 26, 21, 43, 232, 171), new Array(56, 34, 51, 104, 114, 102, 29, 93, 77), new Array(39, 28, 85, 171, 58, 165, 90, 98, 64), new Array(34, 22, 116, 206, 23, 34, 43, 166, 73), new Array(107, 54, 32, 26, 51, 1, 81, 43, 31), new Array(68, 25, 106, 22, 64, 171, 36, 225, 114), new Array(34, 19, 21, 102, 132, 188, 16, 76, 124), new Array(62, 18, 78, 95, 85, 57, 50, 48, 51)), new Array(new Array(193, 101, 35, 159, 215, 111, 89, 46, 111), new Array(60, 148, 31, 172, 219, 228, 21, 18, 111), new Array(112, 113, 77, 85, 179, 255, 38, 120, 114), new Array(40, 42, 1, 196, 245, 209, 10, 25, 109), new Array(88, 43, 29, 140, 166, 213, 37, 43, 154), new Array(61, 63, 30, 155, 67, 45, 68, 1, 209), new Array(100, 80, 8, 43, 154, 1, 51, 26, 71), new Array(142, 78, 78, 16, 255, 128, 34, 197, 171), new Array(41, 40, 5, 102, 211, 183, 4, 1, 221), new Array(51, 50, 17, 168, 209, 192, 23, 25, 82)), new Array(new Array(138, 31, 36, 171, 27, 166, 38, 44, 229), new Array(67, 87, 58, 169, 82, 115, 26, 59, 179), new Array(63, 59, 90, 180, 59, 166, 93, 73, 154), new Array(40, 40, 21, 116, 143, 209, 34, 39, 175), new Array(47, 15, 16, 183, 34, 223, 49, 45, 183), new Array(46, 17, 33, 183, 6, 98, 15, 32, 183), new Array(57, 46, 22, 24, 128, 1, 54, 17, 37), new Array(65, 32, 73, 115, 28, 128, 23, 128, 205), new Array(40, 3, 9, 115, 51, 192, 18, 6, 223), new Array(87, 37, 9, 115, 59, 77, 64, 21, 47)), new Array(new Array(104, 55, 44, 218, 9, 54, 53, 130, 226), new Array(64, 90, 70, 205, 40, 41, 23, 26, 57), new Array(54, 57, 112, 184, 5, 41, 38, 166, 213), new Array(30, 34, 26, 133, 152, 116, 10, 32, 134), new Array(39, 19, 53, 221, 26, 114, 32, 73, 255), new Array(31, 9, 65, 234, 2, 15, 1, 118, 73), new Array(75, 32, 12, 51, 192, 255, 160, 43, 51), new Array(88, 31, 35, 67, 102, 85, 55, 186, 85), new Array(56, 21, 23, 111, 59, 205, 45, 37, 192), new Array(55, 38, 70, 124, 73, 102, 1, 34, 98)), new Array(new Array(125, 98, 42, 88, 104, 85, 117, 175, 82), new Array(95, 84, 53, 89, 128, 100, 113, 101, 45), new Array(75, 79, 123, 47, 51, 128, 81, 171, 1), new Array(57, 17, 5, 71, 102, 57, 53, 41, 49), new Array(38, 33, 13, 121, 57, 73, 26, 1, 85), new Array(41, 10, 67, 138, 77, 110, 90, 47, 114), new Array(115, 21, 2, 10, 102, 255, 166, 23, 6), new Array(101, 29, 16, 10, 85, 128, 101, 196, 26), new Array(57, 18, 10, 102, 102, 213, 34, 20, 43), new Array(117, 20, 15, 36, 163, 128, 68, 1, 26)), new Array(new Array(102, 61, 71, 37, 34, 53, 31, 243, 192), new Array(69, 60, 71, 38, 73, 119, 28, 222, 37), new Array(68, 45, 128, 34, 1, 47, 11, 245, 171), new Array(62, 17, 19, 70, 146, 85, 55, 62, 70), new Array(37, 43, 37, 154, 100, 163, 85, 160, 1), new Array(63, 9, 92, 136, 28, 64, 32, 201, 85), new Array(75, 15, 9, 9, 64, 255, 184, 119, 16), new Array(86, 6, 28, 5, 64, 255, 25, 248, 1), new Array(56, 8, 17, 132, 137, 255, 55, 116, 128), new Array(58, 15, 20, 82, 135, 57, 26, 121, 40)), new A
|
||
|
|
|
||
|
|
function PutI4Mode(a, b, c) {
|
||
|
|
if (VP8PutBit(a, b != bd, c[0])) {
|
||
|
|
if (VP8PutBit(a, b != B_TM_PRED, c[1])) {
|
||
|
|
if (VP8PutBit(a, b != B_VE_PRED, c[2])) {
|
||
|
|
if (!VP8PutBit(a, b >= B_LD_PRED, c[3])) {
|
||
|
|
if (VP8PutBit(a, b != B_HE_PRED, c[4])) {
|
||
|
|
VP8PutBit(a, b != B_RD_PRED, c[5])
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (VP8PutBit(a, b != B_LD_PRED, c[6])) {
|
||
|
|
if (VP8PutBit(a, b != B_VL_PRED, c[7])) {
|
||
|
|
VP8PutBit(a, b != B_HD_PRED, c[8])
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return b
|
||
|
|
}
|
||
|
|
|
||
|
|
function PutI16Mode(a, b) {
|
||
|
|
if (VP8PutBit(a, (b == TM_PRED || b == H_PRED), 156)) {
|
||
|
|
VP8PutBit(a, b == TM_PRED, 128)
|
||
|
|
} else {
|
||
|
|
VP8PutBit(a, b == V_PRED, 163)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function PutUVMode(a, b) {
|
||
|
|
if (VP8PutBit(a, b != DC_PRED, 142)) {
|
||
|
|
if (VP8PutBit(a, b != V_PRED, 114)) {
|
||
|
|
VP8PutBit(a, b != H_PRED, 183)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function PutSegment(a, s, p, b) {
|
||
|
|
if (VP8PutBit(a, s >= 2, p[b + 0])) b += 1;
|
||
|
|
VP8PutBit(a, s & 1, p[b + 1])
|
||
|
|
}
|
||
|
|
var dy = newObjectIt(bV);
|
||
|
|
|
||
|
|
function VP8CodeIntraModes(a) {
|
||
|
|
var b = a.bw_;
|
||
|
|
var c = (dy);
|
||
|
|
VP8IteratorInit(a, c);
|
||
|
|
do {
|
||
|
|
var d = c.mb_[c.mb_off];
|
||
|
|
var e = c.preds_;
|
||
|
|
var f = c.preds_off;
|
||
|
|
if (a.segment_hdr_.update_map_) {
|
||
|
|
PutSegment(b, d.segment_, a.proba_.segments_, 0)
|
||
|
|
}
|
||
|
|
if (a.proba_.use_skip_proba_) {
|
||
|
|
VP8PutBit(b, d.skip_, a.proba_.skip_proba_)
|
||
|
|
}
|
||
|
|
if (VP8PutBit(b, (d.type_ != 0), 145)) {
|
||
|
|
PutI16Mode(b, e[f + 0])
|
||
|
|
} else {
|
||
|
|
var g = a.preds_w_;
|
||
|
|
var h = e;
|
||
|
|
var i = f - g;
|
||
|
|
var x, y;
|
||
|
|
for (y = 0; y < 4; ++y) {
|
||
|
|
var j = e[f - 1];
|
||
|
|
for (x = 0; x < 4; ++x) {
|
||
|
|
var k = dx[h[i + x]][j];
|
||
|
|
j = PutI4Mode(b, e[f + x], k)
|
||
|
|
}
|
||
|
|
i = f;
|
||
|
|
f += g
|
||
|
|
}
|
||
|
|
}
|
||
|
|
PutUVMode(b, d.uv_mode_)
|
||
|
|
} while (VP8IteratorNext(c, 0, 0))
|
||
|
|
}
|
||
|
|
var dz = new Array(new Array(new Array(new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(176, 246, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(223, 241, 252, 255, 255, 255, 255, 255, 255, 255, 255), new Array(249, 253, 253, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 244, 252, 255, 255, 255, 255, 255, 255, 255, 255), new Array(234, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 246, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(239, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(254, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 248, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(251, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(251, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(254, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 254, 253, 255, 254, 255, 255, 255, 255, 255, 255), new Array(250, 255, 254, 255, 254, 255, 255, 255, 255, 255, 255), new Array(254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255))), new Array(new Array(new Array(217, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(225, 252, 241, 253, 255, 255, 254, 255, 255, 255, 255), new Array(234, 250, 241, 250, 253, 255, 253, 254, 255, 255, 255)), new Array(new Array(255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(223, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(238, 253, 254, 254, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 248, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(249, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(247, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 254, 253, 255, 255, 255, 255, 255, 255, 255, 255), new Array(250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255))), new Array(new Array(new Array(186, 251, 250, 255, 255, 255, 255, 255, 255, 255, 255), new Array(234, 251, 244, 254, 255, 255, 255, 255, 255, 255, 255), new Array(251, 251, 243, 253, 254, 255, 254, 255, 255, 255, 255)), new Array(new Array(255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(236, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(251, 253, 253, 254, 254, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255), new Array(255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255)), new Array(new Array(255, 254, 255, 255, 255, 255, 255, 255, 255, 255,
|
||
|
|
|
||
|
|
function VP8WriteProbas(a, d) {
|
||
|
|
var t, b, c, p;
|
||
|
|
for (t = 0; t < NUM_TYPES; ++t) {
|
||
|
|
for (b = 0; b < NUM_BANDS; ++b) {
|
||
|
|
for (c = 0; c < NUM_CTX; ++c) {
|
||
|
|
for (p = 0; p < NUM_PROBAS; ++p) {
|
||
|
|
var e = d.coeffs_[t][b][c][p];
|
||
|
|
var f = (e != dw[t][b][c][p]) + 0;
|
||
|
|
if (VP8PutBit(a, f, dz[t][b][c][p])) {
|
||
|
|
VP8PutValue(a, e, 8)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (VP8PutBitUniform(a, d.use_skip_proba_)) {
|
||
|
|
VP8PutValue(a, d.skip_proba_, 8)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function ClipAlpha(a) {
|
||
|
|
return a < 0 ? 0 : a > 255 ? 255 : a
|
||
|
|
}
|
||
|
|
|
||
|
|
function VP8GetAlpha(a) {
|
||
|
|
var b = 0,
|
||
|
|
den = 0,
|
||
|
|
val = 0;
|
||
|
|
var k;
|
||
|
|
var c = int;
|
||
|
|
for (k = 0; k < bc; ++k) {
|
||
|
|
if (a[k + 1]) {
|
||
|
|
val += a[k + 1];
|
||
|
|
b += val * (k + 1);
|
||
|
|
den += (k + 1) * (k + 1)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
c = den ? parseInt(10 * b / den - 5) : 0;
|
||
|
|
return ClipAlpha(c)
|
||
|
|
}
|
||
|
|
|
||
|
|
function CollectHistogram(a, b, c, d, e, f) {
|
||
|
|
var g = Arr(bc + 1, 0);
|
||
|
|
var h = Arr(16, int16_t);
|
||
|
|
var j, k;
|
||
|
|
for (j = e; j < f; ++j) {
|
||
|
|
dG(a, b + di[j], c, d + di[j], h);
|
||
|
|
for (k = 0; k < 16; ++k) {
|
||
|
|
var v = Math.abs(h[k]) >> 2;
|
||
|
|
h[k] = (v > bc) ? bc : v
|
||
|
|
}
|
||
|
|
for (k = 0; k < 16; ++k) {
|
||
|
|
g[h[k]]++
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return VP8GetAlpha(g)
|
||
|
|
}
|
||
|
|
var cj = Arr((255 + 510 + 1), uint8_t);
|
||
|
|
var ck = 0;
|
||
|
|
|
||
|
|
function InitTables(a) {
|
||
|
|
if (!ck) {
|
||
|
|
var i;
|
||
|
|
for (i = -255; i <= 255 + 255; ++i) {
|
||
|
|
cj[255 + i] = (i < 0) ? 0 : (i > 255) ? 255 : i
|
||
|
|
}
|
||
|
|
ck = 1
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function clip_8b(v) {
|
||
|
|
return (!(v & ~0xff)) ? v : v < 0 ? 0 : 255
|
||
|
|
}
|
||
|
|
var dA = 20091 + (1 << 16);
|
||
|
|
var dB = 35468;
|
||
|
|
|
||
|
|
function MUL(a, b) {
|
||
|
|
return (((a) * (b)) >> 16)
|
||
|
|
}
|
||
|
|
var C = Arr(4 * 4, int),
|
||
|
|
dD, tmp_off;
|
||
|
|
tmp_off = 0;
|
||
|
|
|
||
|
|
function ITransformOne(e, f, g, h, j, k) {
|
||
|
|
var C = Arr(4 * 4, int),
|
||
|
|
dD, tmp_off;
|
||
|
|
tmp_off = 0;
|
||
|
|
var i;
|
||
|
|
dD = C;
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var a = g[h + 0] + g[h + 8];
|
||
|
|
var b = g[h + 0] - g[h + 8];
|
||
|
|
var c = ((g[h + 4] * dB) >> 16) - ((g[h + 12] * dA) >> 16);
|
||
|
|
var d = ((g[h + 4] * dA) >> 16) + ((g[h + 12] * dB) >> 16);
|
||
|
|
dD[tmp_off + 0] = a + d;
|
||
|
|
dD[tmp_off + 1] = b + c;
|
||
|
|
dD[tmp_off + 2] = b - c;
|
||
|
|
dD[tmp_off + 3] = a - d;
|
||
|
|
tmp_off += 4;
|
||
|
|
h++
|
||
|
|
}
|
||
|
|
tmp_off = 0;
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var l = dD[tmp_off + 0] + 4;
|
||
|
|
var a = l + dD[tmp_off + 8];
|
||
|
|
var b = l - dD[tmp_off + 8];
|
||
|
|
var c = ((dD[tmp_off + 4] * dB) >> 16) - ((dD[tmp_off + 12] * dA) >> 16);
|
||
|
|
var d = ((dD[tmp_off + 4] * dA) >> 16) + ((dD[tmp_off + 12] * dB) >> 16);
|
||
|
|
j[k + 0 + i * bf] = clip_8b(e[f + 0 + i * bf] + ((a + d) >> 3));
|
||
|
|
j[k + 1 + i * bf] = clip_8b(e[f + 1 + i * bf] + ((b + c) >> 3));
|
||
|
|
j[k + 2 + i * bf] = clip_8b(e[f + 2 + i * bf] + ((b - c) >> 3));
|
||
|
|
j[k + 3 + i * bf] = clip_8b(e[f + 3 + i * bf] + ((a - d) >> 3));
|
||
|
|
tmp_off++
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function ITransform(a, b, c, d, e, f, g) {
|
||
|
|
ITransformOne(a, b, c, d, e, f);
|
||
|
|
if (g) {
|
||
|
|
ITransformOne(a, b + 4, c, d + 16, e, f + 4)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function FTransform(a, b, c, d, e) {
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var f = a[b + 0] - c[d + 0];
|
||
|
|
var g = a[b + 1] - c[d + 1];
|
||
|
|
var h = a[b + 2] - c[d + 2];
|
||
|
|
var j = a[b + 3] - c[d + 3];
|
||
|
|
var k = (f + j) << 3;
|
||
|
|
var l = (g + h) << 3;
|
||
|
|
var m = (g - h) << 3;
|
||
|
|
var n = (f - j) << 3;
|
||
|
|
dD[0 + i * 4] = (k + l) + 0;
|
||
|
|
dD[1 + i * 4] = (m * 2217 + n * 5352 + 14500) >> 12;
|
||
|
|
dD[2 + i * 4] = (k - l) + 0;
|
||
|
|
dD[3 + i * 4] = (n * 2217 - m * 5352 + 7500) >> 12;
|
||
|
|
b += bf, d += bf
|
||
|
|
}
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var k = (dD[0 + i] + dD[12 + i]);
|
||
|
|
var l = (dD[4 + i] + dD[8 + i]);
|
||
|
|
var m = (dD[4 + i] - dD[8 + i]);
|
||
|
|
var n = (dD[0 + i] - dD[12 + i]);
|
||
|
|
e[0 + i] = (k + l + 7) >> 4;
|
||
|
|
e[4 + i] = ((m * 2217 + n * 5352 + 12000) >> 16) + (n != 0) + 0;
|
||
|
|
e[8 + i] = (k - l + 7) >> 4;
|
||
|
|
e[12 + i] = ((n * 2217 - m * 5352 + 51000) >> 16)
|
||
|
|
}
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
var dC = 0;
|
||
|
|
|
||
|
|
function ITransformWHT(a, b) {
|
||
|
|
dC = 0;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var c = a[0 + i] + a[12 + i];
|
||
|
|
var d = a[4 + i] + a[8 + i];
|
||
|
|
var e = a[4 + i] - a[8 + i];
|
||
|
|
var f = a[0 + i] - a[12 + i];
|
||
|
|
dD[0 + i] = c + d;
|
||
|
|
dD[8 + i] = c - d;
|
||
|
|
dD[4 + i] = f + e;
|
||
|
|
dD[12 + i] = f - e
|
||
|
|
}
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var g = dD[0 + i * 4] + 3;
|
||
|
|
var c = g + dD[3 + i * 4];
|
||
|
|
var d = dD[1 + i * 4] + dD[2 + i * 4];
|
||
|
|
var e = dD[1 + i * 4] - dD[2 + i * 4];
|
||
|
|
var f = g - dD[3 + i * 4];
|
||
|
|
b[dC + 0][0] = (c + d) >> 3;
|
||
|
|
b[dC + 1][0] = (f + e) >> 3;
|
||
|
|
b[dC + 2][0] = (c - d) >> 3;
|
||
|
|
b[dC + 3][0] = (f - e) >> 3;
|
||
|
|
dC += 4
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function FTransformWHT(a, b) {
|
||
|
|
var c = 0;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var d = (a[c + 0][0] + a[c + 2][0]) << 2;
|
||
|
|
var e = (a[c + 1][0] + a[c + 3][0]) << 2;
|
||
|
|
var f = (a[c + 1][0] - a[c + 3][0]) << 2;
|
||
|
|
var g = (a[c + 0][0] - a[c + 2][0]) << 2;
|
||
|
|
dD[0 + i * 4] = (d + e) + (d != 0) + 0;
|
||
|
|
dD[1 + i * 4] = g + f;
|
||
|
|
dD[2 + i * 4] = g - f;
|
||
|
|
dD[3 + i * 4] = d - e;
|
||
|
|
c += 4
|
||
|
|
}
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var d = (dD[0 + i] + dD[8 + i]);
|
||
|
|
var e = (dD[4 + i] + dD[12 + i]);
|
||
|
|
var f = (dD[4 + i] - dD[12 + i]);
|
||
|
|
var g = (dD[0 + i] - dD[8 + i]);
|
||
|
|
var h = d + e;
|
||
|
|
var j = g + f;
|
||
|
|
var k = g - f;
|
||
|
|
var l = d - e;
|
||
|
|
b[0 + i] = (h + (h > 0) + 3) >> 3;
|
||
|
|
b[4 + i] = (j + (j > 0) + 3) >> 3;
|
||
|
|
b[8 + i] = (k + (k > 0) + 3) >> 3;
|
||
|
|
b[12 + i] = (l + (l > 0) + 3) >> 3
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function Fill(a, b, c, d) {
|
||
|
|
var j;
|
||
|
|
for (j = 0; j < d; ++j) {
|
||
|
|
memset_(a, b + j * bf, c, d)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function VerticalPred(a, b, c, d, e) {
|
||
|
|
var j;
|
||
|
|
if (c) {
|
||
|
|
for (j = 0; j < e; ++j) memcpy(b, a + j * bf, c, d, e)
|
||
|
|
} else {
|
||
|
|
Fill(b, a, 127, e)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function HorizontalPred(a, b, c, d, e) {
|
||
|
|
if (c) {
|
||
|
|
var j;
|
||
|
|
for (j = 0; j < e; ++j) {
|
||
|
|
memset_(b, a + j * bf, c[d + j], e)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
Fill(b, a, 129, e)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function TrueMotion(a, b, c, d, e, f, g) {
|
||
|
|
var y;
|
||
|
|
if (c) {
|
||
|
|
if (e) {
|
||
|
|
var h = cj;
|
||
|
|
var i = +255 - c[d - 1];
|
||
|
|
for (y = 0; y < g; ++y) {
|
||
|
|
var j = h;
|
||
|
|
var k = i + c[d + y];
|
||
|
|
var x;
|
||
|
|
for (x = 0; x < g; ++x) {
|
||
|
|
b[a + x] = j[k + e[f + x]]
|
||
|
|
}
|
||
|
|
a += bf
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
HorizontalPred(a, b, c, d, g)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (e) {
|
||
|
|
VerticalPred(a, b, e, f, g)
|
||
|
|
} else {
|
||
|
|
Fill(b, a, 129, g)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function DCMode(a, b, c, d, e, f, g, h, i) {
|
||
|
|
var k = 0;
|
||
|
|
var j;
|
||
|
|
if (e) {
|
||
|
|
for (j = 0; j < g; ++j) k += e[f + j];
|
||
|
|
if (c) {
|
||
|
|
for (j = 0; j < g; ++j) k += c[d + j]
|
||
|
|
} else {
|
||
|
|
k += k
|
||
|
|
}
|
||
|
|
k = (k + h) >> i
|
||
|
|
} else if (c) {
|
||
|
|
for (j = 0; j < g; ++j) k += c[d + j];
|
||
|
|
k += k;
|
||
|
|
k = (k + h) >> i
|
||
|
|
} else {
|
||
|
|
k = 0x80
|
||
|
|
}
|
||
|
|
Fill(b, a, k, g)
|
||
|
|
}
|
||
|
|
|
||
|
|
function IntraChromaPreds(a, b, c, d, e, f) {
|
||
|
|
DCMode(bs + b, a, c, d, e, f, 8, 8, 4);
|
||
|
|
VerticalPred(bu + b, a, e, f, 8);
|
||
|
|
HorizontalPred(bv + b, a, c, d, 8);
|
||
|
|
TrueMotion(bt + b, a, c, d, e, f, 8);
|
||
|
|
b += 8;
|
||
|
|
if (e) f += 8;
|
||
|
|
if (c) d += 16;
|
||
|
|
DCMode(bs + b, a, c, d, e, f, 8, 8, 4);
|
||
|
|
VerticalPred(bu + b, a, e, f, 8);
|
||
|
|
HorizontalPred(bv + b, a, c, d, 8);
|
||
|
|
TrueMotion(bt + b, a, c, d, e, f, 8)
|
||
|
|
}
|
||
|
|
|
||
|
|
function Intra16Preds(a, b, c, d, e, f) {
|
||
|
|
DCMode(bo + b, a, c, d, e, f, 16, 16, 5);
|
||
|
|
VerticalPred(bq + b, a, e, f, 16);
|
||
|
|
HorizontalPred(br + b, a, c, d, 16);
|
||
|
|
TrueMotion(bp + b, a, c, d, e, f, 16)
|
||
|
|
}
|
||
|
|
|
||
|
|
function AVG3(a, b, c) {
|
||
|
|
return (((a) + 2 * (b) + (c) + 2) >> 2)
|
||
|
|
};
|
||
|
|
|
||
|
|
function AVG2(a, b) {
|
||
|
|
return (((a) + (b) + 1) >> 1)
|
||
|
|
};
|
||
|
|
|
||
|
|
function VE4(a, b, c, d) {
|
||
|
|
var e = new Array();
|
||
|
|
e.push(AVG3(c[d - 1], c[d + 0], c[d + 1]));
|
||
|
|
e.push(AVG3(c[d + 0], c[d + 1], c[d + 2]));
|
||
|
|
e.push(AVG3(c[d + 1], c[d + 2], c[d + 3]));
|
||
|
|
e.push(AVG3(c[d + 2], c[d + 3], c[d + 4]));
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
memcpy(b, a + i * bf, e, 0, 4)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function HE4(a, b, c, d) {
|
||
|
|
var X = c[d - 1];
|
||
|
|
var I = c[d - 2];
|
||
|
|
var J = c[d - 3];
|
||
|
|
var K = c[d - 4];
|
||
|
|
var L = c[d - 5];
|
||
|
|
b[a + 0 + 0 * bf] = b[a + 1 + 0 * bf] = b[a + 2 + 0 * bf] = b[a + 3 + 0 * bf] = AVG3(X, I, J);
|
||
|
|
b[a + 0 + 1 * bf] = b[a + 1 + 1 * bf] = b[a + 2 + 1 * bf] = b[a + 3 + 1 * bf] = AVG3(I, J, K);
|
||
|
|
b[a + 0 + 2 * bf] = b[a + 1 + 2 * bf] = b[a + 2 + 2 * bf] = b[a + 3 + 2 * bf] = AVG3(J, K, L);
|
||
|
|
b[a + 0 + 3 * bf] = b[a + 1 + 3 * bf] = b[a + 2 + 3 * bf] = b[a + 3 + 3 * bf] = AVG3(K, L, L)
|
||
|
|
}
|
||
|
|
|
||
|
|
function DC4(a, b, c, d) {
|
||
|
|
var e = 4;
|
||
|
|
var i;
|
||
|
|
for (i = 0; i < 4; ++i) e += c[d + i] + c[d - 5 + i];
|
||
|
|
Fill(b, a, e >> 3, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function RD4(a, b, c, d) {
|
||
|
|
var X = c[d - 1];
|
||
|
|
var I = c[d - 2];
|
||
|
|
var J = c[d - 3];
|
||
|
|
var K = c[d - 4];
|
||
|
|
var L = c[d - 5];
|
||
|
|
var A = c[d + 0];
|
||
|
|
var B = c[d + 1];
|
||
|
|
var C = c[d + 2];
|
||
|
|
var D = c[d + 3];
|
||
|
|
b[a + (0) + (3) * bf] = AVG3(J, K, L);
|
||
|
|
b[a + (0) + (2) * bf] = b[a + (1) + (3) * bf] = AVG3(I, J, K);
|
||
|
|
b[a + (0) + (1) * bf] = b[a + (1) + (2) * bf] = b[a + (2) + (3) * bf] = AVG3(X, I, J);
|
||
|
|
b[a + (0) + (0) * bf] = b[a + (1) + (1) * bf] = b[a + (2) + (2) * bf] = b[a + (3) + (3) * bf] = AVG3(A, X, I);
|
||
|
|
b[a + (1) + (0) * bf] = b[a + (2) + (1) * bf] = b[a + (3) + (2) * bf] = AVG3(B, A, X);
|
||
|
|
b[a + (2) + (0) * bf] = b[a + (3) + (1) * bf] = AVG3(C, B, A);
|
||
|
|
b[a + (3) + (0) * bf] = AVG3(D, C, B)
|
||
|
|
}
|
||
|
|
|
||
|
|
function LD4(a, b, c, d) {
|
||
|
|
var A = c[d + 0];
|
||
|
|
var B = c[d + 1];
|
||
|
|
var C = c[d + 2];
|
||
|
|
var D = c[d + 3];
|
||
|
|
var E = c[d + 4];
|
||
|
|
var F = c[d + 5];
|
||
|
|
var G = c[d + 6];
|
||
|
|
var H = c[d + 7];
|
||
|
|
b[a + (0) + (0) * bf] = AVG3(A, B, C);
|
||
|
|
b[a + (1) + (0) * bf] = b[a + (0) + (1) * bf] = AVG3(B, C, D);
|
||
|
|
b[a + (2) + (0) * bf] = b[a + (1) + (1) * bf] = b[a + (0) + (2) * bf] = AVG3(C, D, E);
|
||
|
|
b[a + (3) + (0) * bf] = b[a + (2) + (1) * bf] = b[a + (1) + (2) * bf] = b[a + (0) + (3) * bf] = AVG3(D, E, F);
|
||
|
|
b[a + (3) + (1) * bf] = b[a + (2) + (2) * bf] = b[a + (1) + (3) * bf] = AVG3(E, F, G);
|
||
|
|
b[a + (3) + (2) * bf] = b[a + (2) + (3) * bf] = AVG3(F, G, H);
|
||
|
|
b[a + (3) + (3) * bf] = AVG3(G, H, H)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VR4(a, b, c, d) {
|
||
|
|
var X = c[d - 1];
|
||
|
|
var I = c[d - 2];
|
||
|
|
var J = c[d - 3];
|
||
|
|
var K = c[d - 4];
|
||
|
|
var A = c[d + 0];
|
||
|
|
var B = c[d + 1];
|
||
|
|
var C = c[d + 2];
|
||
|
|
var D = c[d + 3];
|
||
|
|
b[a + (0) + (0) * bf] = b[a + (1) + (2) * bf] = AVG2(X, A);
|
||
|
|
b[a + (1) + (0) * bf] = b[a + (2) + (2) * bf] = AVG2(A, B);
|
||
|
|
b[a + (2) + (0) * bf] = b[a + (3) + (2) * bf] = AVG2(B, C);
|
||
|
|
b[a + (3) + (0) * bf] = AVG2(C, D);
|
||
|
|
b[a + (0) + (3) * bf] = AVG3(K, J, I);
|
||
|
|
b[a + (0) + (2) * bf] = AVG3(J, I, X);
|
||
|
|
b[a + (0) + (1) * bf] = b[a + (1) + (3) * bf] = AVG3(I, X, A);
|
||
|
|
b[a + (1) + (1) * bf] = b[a + (2) + (3) * bf] = AVG3(X, A, B);
|
||
|
|
b[a + (2) + (1) * bf] = b[a + (3) + (3) * bf] = AVG3(A, B, C);
|
||
|
|
b[a + (3) + (1) * bf] = AVG3(B, C, D)
|
||
|
|
}
|
||
|
|
|
||
|
|
function VL4(a, b, c, d) {
|
||
|
|
var A = c[d + 0];
|
||
|
|
var B = c[d + 1];
|
||
|
|
var C = c[d + 2];
|
||
|
|
var D = c[d + 3];
|
||
|
|
var E = c[d + 4];
|
||
|
|
var F = c[d + 5];
|
||
|
|
var G = c[d + 6];
|
||
|
|
var H = c[d + 7];
|
||
|
|
b[a + (0) + (0) * bf] = AVG2(A, B);
|
||
|
|
b[a + (1) + (0) * bf] = b[a + (0) + (2) * bf] = AVG2(B, C);
|
||
|
|
b[a + (2) + (0) * bf] = b[a + (1) + (2) * bf] = AVG2(C, D);
|
||
|
|
b[a + (3) + (0) * bf] = b[a + (2) + (2) * bf] = AVG2(D, E);
|
||
|
|
b[a + (0) + (1) * bf] = AVG3(A, B, C);
|
||
|
|
b[a + (1) + (1) * bf] = b[a + (0) + (3) * bf] = AVG3(B, C, D);
|
||
|
|
b[a + (2) + (1) * bf] = b[a + (1) + (3) * bf] = AVG3(C, D, E);
|
||
|
|
b[a + (3) + (1) * bf] = b[a + (2) + (3) * bf] = AVG3(D, E, F);
|
||
|
|
b[a + (3) + (2) * bf] = AVG3(E, F, G);
|
||
|
|
b[a + (3) + (3) * bf] = AVG3(F, G, H)
|
||
|
|
}
|
||
|
|
|
||
|
|
function HU4(a, b, c, d) {
|
||
|
|
var I = c[d - 2];
|
||
|
|
var J = c[d - 3];
|
||
|
|
var K = c[d - 4];
|
||
|
|
var L = c[d - 5];
|
||
|
|
b[a + (0) + (0) * bf] = AVG2(I, J);
|
||
|
|
b[a + (2) + (0) * bf] = b[a + (0) + (1) * bf] = AVG2(J, K);
|
||
|
|
b[a + (2) + (1) * bf] = b[a + (0) + (2) * bf] = AVG2(K, L);
|
||
|
|
b[a + (1) + (0) * bf] = AVG3(I, J, K);
|
||
|
|
b[a + (3) + (0) * bf] = b[a + (1) + (1) * bf] = AVG3(J, K, L);
|
||
|
|
b[a + (3) + (1) * bf] = b[a + (1) + (2) * bf] = AVG3(K, L, L);
|
||
|
|
b[a + (3) + (2) * bf] = b[a + (2) + (2) * bf] = b[a + (0) + (3) * bf] = b[a + (1) + (3) * bf] = b[a + (2) + (3) * bf] = b[a + (3) + (3) * bf] = L
|
||
|
|
}
|
||
|
|
|
||
|
|
function HD4(a, b, c, d) {
|
||
|
|
var X = c[d - 1];
|
||
|
|
var I = c[d - 2];
|
||
|
|
var J = c[d - 3];
|
||
|
|
var K = c[d - 4];
|
||
|
|
var L = c[d - 5];
|
||
|
|
var A = c[d + 0];
|
||
|
|
var B = c[d + 1];
|
||
|
|
var C = c[d + 2];
|
||
|
|
b[a + (0) + (0) * bf] = b[a + (2) + (1) * bf] = AVG2(I, X);
|
||
|
|
b[a + (0) + (1) * bf] = b[a + (2) + (2) * bf] = AVG2(J, I);
|
||
|
|
b[a + (0) + (2) * bf] = b[a + (2) + (3) * bf] = AVG2(K, J);
|
||
|
|
b[a + (0) + (3) * bf] = AVG2(L, K);
|
||
|
|
b[a + (3) + (0) * bf] = AVG3(A, B, C);
|
||
|
|
b[a + (2) + (0) * bf] = AVG3(X, A, B);
|
||
|
|
b[a + (1) + (0) * bf] = b[a + (3) + (1) * bf] = AVG3(I, X, A);
|
||
|
|
b[a + (1) + (1) * bf] = b[a + (3) + (2) * bf] = AVG3(J, I, X);
|
||
|
|
b[a + (1) + (2) * bf] = b[a + (3) + (3) * bf] = AVG3(K, J, I);
|
||
|
|
b[a + (1) + (3) * bf] = AVG3(L, K, J)
|
||
|
|
}
|
||
|
|
|
||
|
|
function TM4(a, b, c, d) {
|
||
|
|
var x, y;
|
||
|
|
var e = cj;
|
||
|
|
var f = +255 - c[d - 1];
|
||
|
|
for (y = 0; y < 4; ++y) {
|
||
|
|
var g = e;
|
||
|
|
var h = f + c[d - 2 - y];
|
||
|
|
for (x = 0; x < 4; ++x) {
|
||
|
|
b[a + x] = g[h + c[d + x]]
|
||
|
|
}
|
||
|
|
a += bf
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function Intra4Preds(a, b, c, d) {
|
||
|
|
DC4(bw + b, a, c, d);
|
||
|
|
TM4(bx + b, a, c, d);
|
||
|
|
VE4(by + b, a, c, d);
|
||
|
|
HE4(bz + b, a, c, d);
|
||
|
|
RD4(bA + b, a, c, d);
|
||
|
|
VR4(bB + b, a, c, d);
|
||
|
|
LD4(bC + b, a, c, d);
|
||
|
|
VL4(bD + b, a, c, d);
|
||
|
|
HD4(bE + b, a, c, d);
|
||
|
|
HU4(bF + b, a, c, d)
|
||
|
|
}
|
||
|
|
|
||
|
|
function GetSSE(a, c, b, d, w, h) {
|
||
|
|
var e = 0;
|
||
|
|
var y, x;
|
||
|
|
for (y = 0; y < h; ++y) {
|
||
|
|
for (x = 0; x < w; ++x) {
|
||
|
|
var f = a[c + x] - b[d + x];
|
||
|
|
e += f * f
|
||
|
|
}
|
||
|
|
c += bf;
|
||
|
|
d += bf
|
||
|
|
}
|
||
|
|
return e
|
||
|
|
}
|
||
|
|
|
||
|
|
function SSE16x16(a, c, b, d) {
|
||
|
|
return GetSSE(a, c, b, d, 16, 16)
|
||
|
|
}
|
||
|
|
|
||
|
|
function SSE16x8(a, c, b, d) {
|
||
|
|
return GetSSE(a, c, b, d, 16, 8)
|
||
|
|
}
|
||
|
|
|
||
|
|
function SSE8x8(a, c, b, d) {
|
||
|
|
return GetSSE(a, c, b, d, 8, 8)
|
||
|
|
}
|
||
|
|
|
||
|
|
function SSE4x4(a, c, b, d) {
|
||
|
|
return GetSSE(a, c, b, d, 4, 4)
|
||
|
|
}
|
||
|
|
var dD = Arr(16, int);
|
||
|
|
|
||
|
|
function TTransform(a, b, w) {
|
||
|
|
var c = 0;
|
||
|
|
var i;
|
||
|
|
var d = 0;
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var e = (a[b + 0] + a[b + 2]) << 2;
|
||
|
|
var f = (a[b + 1] + a[b + 3]) << 2;
|
||
|
|
var g = (a[b + 1] - a[b + 3]) << 2;
|
||
|
|
var h = (a[b + 0] - a[b + 2]) << 2;
|
||
|
|
dD[0 + i * 4] = e + f + (e != 0) + 0;
|
||
|
|
dD[1 + i * 4] = h + g;
|
||
|
|
dD[2 + i * 4] = h - g;
|
||
|
|
dD[3 + i * 4] = e - f;
|
||
|
|
b += bf
|
||
|
|
}
|
||
|
|
for (i = 0; i < 4; ++i) {
|
||
|
|
var e = (dD[0 + i] + dD[8 + i]);
|
||
|
|
var f = (dD[4 + i] + dD[12 + i]);
|
||
|
|
var g = (dD[4 + i] - dD[12 + i]);
|
||
|
|
var h = (dD[0 + i] - dD[8 + i]);
|
||
|
|
var j = e + f;
|
||
|
|
var k = h + g;
|
||
|
|
var l = h - g;
|
||
|
|
var m = e - f;
|
||
|
|
c += w[d + 0] * ((Math.abs(j) + 3) >> 3);
|
||
|
|
c += w[d + 4] * ((Math.abs(k) + 3) >> 3);
|
||
|
|
c += w[d + 8] * ((Math.abs(l) + 3) >> 3);
|
||
|
|
c += w[d + 12] * ((Math.abs(m) + 3) >> 3);
|
||
|
|
++d
|
||
|
|
}
|
||
|
|
return c
|
||
|
|
}
|
||
|
|
|
||
|
|
function Disto4x4(a, c, b, d, w) {
|
||
|
|
var e = TTransform(a, c, w);
|
||
|
|
var f = TTransform(b, d, w);
|
||
|
|
return (Math.abs(f - e) + 8) >> 4
|
||
|
|
}
|
||
|
|
|
||
|
|
function Disto16x16(a, c, b, d, w) {
|
||
|
|
var D = 0;
|
||
|
|
var x, y = int;
|
||
|
|
for (y = 0; y < 16 * bf; y += 4 * bf) {
|
||
|
|
for (x = 0; x < 16; x += 4) {
|
||
|
|
D += Disto4x4(a, c + x + y, b, d + x + y, w)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return D
|
||
|
|
}
|
||
|
|
|
||
|
|
function QuantizeBlock(a, b, n, c) {
|
||
|
|
var d = -1;
|
||
|
|
for (; n < 16; ++n) {
|
||
|
|
var j = cV[n];
|
||
|
|
var e = (a[j] < 0);
|
||
|
|
var f = (e ? -a[j] : a[j]) + c.sharpen_[j];
|
||
|
|
if (f > 2047) f = 2047;
|
||
|
|
if (f > c.zthresh_[j]) {
|
||
|
|
var Q = c.q_[j];
|
||
|
|
var g = c.iq_[j];
|
||
|
|
var B = c.bias_[j];
|
||
|
|
b[n] = QUANTDIV(f, g, B);
|
||
|
|
if (e) b[n] = -b[n];
|
||
|
|
a[j] = b[n] * Q;
|
||
|
|
if (b[n]) d = n
|
||
|
|
} else {
|
||
|
|
b[n] = 0;
|
||
|
|
a[j] = 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return (d >= 0) + 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function Copy(a, b, c, d, e) {
|
||
|
|
var y;
|
||
|
|
for (y = 0; y < e; ++y) {
|
||
|
|
memcpy(c, d, a, b, e);
|
||
|
|
b += bf;
|
||
|
|
d += bf
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function Copy4x4(a, b, c, d) {
|
||
|
|
Copy(a, b, c, d, 4)
|
||
|
|
}
|
||
|
|
|
||
|
|
function Copy8x8(a, b, c, d) {
|
||
|
|
Copy(a, b, c, d, 8)
|
||
|
|
}
|
||
|
|
|
||
|
|
function Copy16x16(a, b, c, d) {
|
||
|
|
Copy(a, b, c, d, 16)
|
||
|
|
}
|
||
|
|
var dE;
|
||
|
|
var dF;
|
||
|
|
var dG;
|
||
|
|
var dH;
|
||
|
|
var dI;
|
||
|
|
var dJ;
|
||
|
|
var dK;
|
||
|
|
var dL;
|
||
|
|
var dM;
|
||
|
|
var dN;
|
||
|
|
var dO;
|
||
|
|
var dP;
|
||
|
|
var dQ;
|
||
|
|
var dR;
|
||
|
|
var dS;
|
||
|
|
var dT;
|
||
|
|
var dU;
|
||
|
|
var dV;
|
||
|
|
|
||
|
|
function VP8EncDspInit(a) {
|
||
|
|
InitTables();
|
||
|
|
dE = CollectHistogram;
|
||
|
|
dF = ITransform;
|
||
|
|
dG = FTransform;
|
||
|
|
dH = ITransformWHT;
|
||
|
|
dI = FTransformWHT;
|
||
|
|
dJ = Intra4Preds;
|
||
|
|
dK = Intra16Preds;
|
||
|
|
dL = IntraChromaPreds;
|
||
|
|
dM = SSE16x16;
|
||
|
|
dN = SSE8x8;
|
||
|
|
dO = SSE16x8;
|
||
|
|
dP = SSE4x4;
|
||
|
|
dQ = Disto4x4;
|
||
|
|
dR = Disto16x16;
|
||
|
|
dS = QuantizeBlock;
|
||
|
|
dT = Copy4x4;
|
||
|
|
dU = Copy8x8;
|
||
|
|
dV = Copy16x16
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPConfigInitInternal(a, b, c, d) {
|
||
|
|
if (d != N) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (a == null) return 0;
|
||
|
|
a.quality = c;
|
||
|
|
a.target_size = 0;
|
||
|
|
a.target_PSNR = 0.;
|
||
|
|
a.method = 3;
|
||
|
|
a.sns_strength = 50;
|
||
|
|
a.filter_strength = 20;
|
||
|
|
a.filter_sharpness = 0;
|
||
|
|
a.filter_type = 0;
|
||
|
|
a.partitions = 0;
|
||
|
|
a.segments = 4;
|
||
|
|
a.pass = 1;
|
||
|
|
a.show_compressed = 0;
|
||
|
|
a.preprocessing = 0;
|
||
|
|
a.autofilter = 0;
|
||
|
|
a.alpha_compression = 0;
|
||
|
|
a.partition_limit = 0;
|
||
|
|
if (ea) {
|
||
|
|
a.quality = ea.quality ? ea.quality : c;
|
||
|
|
a.target_size = ea.target_size ? ea.target_size : 0;
|
||
|
|
a.target_PSNR = ea.target_PSNR ? ea.target_PSNR : 0.;
|
||
|
|
a.method = ea.method ? ea.method : 0;
|
||
|
|
a.sns_strength = ea.sns_strength ? ea.sns_strength : 50;
|
||
|
|
a.filter_strength = ea.filter_strength ? ea.filter_strength : 20;
|
||
|
|
a.filter_sharpness = ea.filter_sharpness ? ea.filter_sharpness : 0;
|
||
|
|
a.filter_type = ea.filter_type ? ea.filter_type : 0;
|
||
|
|
a.partitions = ea.partitions ? ea.partitions : 0;
|
||
|
|
a.segments = ea.segments ? ea.segments : 4;
|
||
|
|
a.pass = ea.pass ? ea.pass : 1;
|
||
|
|
a.show_compressed = ea.show_compressed ? ea.show_compressed : 0;
|
||
|
|
a.preprocessing = ea.preprocessing ? ea.preprocessing : 0;
|
||
|
|
a.autofilter = ea.autofilter ? ea.autofilter : 0;
|
||
|
|
a.alpha_compression = ea.alpha_compression ? ea.alpha_compression : 0;
|
||
|
|
a.partition_limit = ea.partition_limit ? ea.partition_limit : 0;
|
||
|
|
b = ea.Preset ? ea.preset : P.WEBP_PRESET_DEFAULT
|
||
|
|
}
|
||
|
|
switch (b) {
|
||
|
|
case P.WEBP_PRESET_PICTURE:
|
||
|
|
a.sns_strength = 80;
|
||
|
|
a.filter_sharpness = 4;
|
||
|
|
a.filter_strength = 35;
|
||
|
|
break;
|
||
|
|
case P.WEBP_PRESET_PHOTO:
|
||
|
|
a.sns_strength = 80;
|
||
|
|
a.filter_sharpness = 3;
|
||
|
|
a.filter_strength = 30;
|
||
|
|
break;
|
||
|
|
case P.WEBP_PRESET_DRAWING:
|
||
|
|
a.sns_strength = 25;
|
||
|
|
a.filter_sharpness = 6;
|
||
|
|
a.filter_strength = 10;
|
||
|
|
break;
|
||
|
|
case P.WEBP_PRESET_ICON:
|
||
|
|
a.sns_strength = 0;
|
||
|
|
a.filter_strength = 0;
|
||
|
|
break;
|
||
|
|
case P.WEBP_PRESET_TEXT:
|
||
|
|
a.sns_strength = 0;
|
||
|
|
a.filter_strength = 0;
|
||
|
|
a.segments = 2;
|
||
|
|
break;
|
||
|
|
case P.WEBP_PRESET_DEFAULT:
|
||
|
|
default:
|
||
|
|
break
|
||
|
|
}
|
||
|
|
return WebPValidateConfig(a)
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPValidateConfig(a) {
|
||
|
|
if (a == null) return 0;
|
||
|
|
if (a.quality < 0 || a.quality > 100) return 0;
|
||
|
|
if (a.target_size < 0) return 0;
|
||
|
|
if (a.target_PSNR < 0) return 0;
|
||
|
|
if (a.method < 0 || a.method > 6) return 0;
|
||
|
|
if (a.segments < 1 || a.segments > 4) return 0;
|
||
|
|
if (a.sns_strength < 0 || a.sns_strength > 100) return 0;
|
||
|
|
if (a.filter_strength < 0 || a.filter_strength > 100) return 0;
|
||
|
|
if (a.filter_sharpness < 0 || a.filter_sharpness > 7) return 0;
|
||
|
|
if (a.filter_type < 0 || a.filter_type > 1) return 0;
|
||
|
|
if (a.autofilter < 0 || a.autofilter > 1) return 0;
|
||
|
|
if (a.pass < 1 || a.pass > 10) return 0;
|
||
|
|
if (a.show_compressed < 0 || a.show_compressed > 1) return 0;
|
||
|
|
if (a.preprocessing < 0 || a.preprocessing > 1) return 0;
|
||
|
|
if (a.partitions < 0 || a.partitions > 3) return 0;
|
||
|
|
if (a.partition_limit < 0 || a.partition_limit > 100) return 0;
|
||
|
|
if (a.alpha_compression < 0) return 0;
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
var dW = 16384;
|
||
|
|
this.WebPGetEncoderVersion = function(a) {
|
||
|
|
return (Z << 16) | (ba << 8) | bb
|
||
|
|
};
|
||
|
|
|
||
|
|
function DummyWriter(a, b, c) {
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPPictureInitInternal(d, e) {
|
||
|
|
if (e != N) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if (d) {
|
||
|
|
d = newObjectIt(V);
|
||
|
|
d.writer = function DummyWriter(a, b, c) {};
|
||
|
|
WebPEncodingSetError(d, U)
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function ResetSegmentHeader(a) {
|
||
|
|
var b = a.segment_hdr_;
|
||
|
|
b.num_segments_ = a.config_.segments;
|
||
|
|
b.update_map_ = (b.num_segments_ > 1) + 0;
|
||
|
|
b.size_ = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function ResetFilterHeader(a) {
|
||
|
|
var b = a.filter_hdr_;
|
||
|
|
b.simple_ = 1;
|
||
|
|
b.level_ = 0;
|
||
|
|
b.sharpness_ = 0;
|
||
|
|
b.i4x4_lf_delta_ = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function ResetBoundaryPredictions(a) {
|
||
|
|
var i;
|
||
|
|
var b = a.preds_;
|
||
|
|
var c = a.preds_off - a.preds_w_;
|
||
|
|
var d = a.preds_;
|
||
|
|
var e = a.preds_off - 1;
|
||
|
|
for (i = -1; i < 4 * a.mb_w_; ++i) {
|
||
|
|
b[c + i] = bd
|
||
|
|
}
|
||
|
|
for (i = 0; i < 4 * a.mb_h_; ++i) {
|
||
|
|
d[e + i * a.preds_w_] = bd
|
||
|
|
}
|
||
|
|
a.nz_[1 - 1] = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function MapConfigToTools(a) {
|
||
|
|
var b = a.config_.method;
|
||
|
|
var c = 100 - a.config_.partition_limit;
|
||
|
|
a.method_ = b;
|
||
|
|
a.rd_opt_level_ = (b >= 6) ? 3 : (b >= 5) ? 2 : (b >= 3) ? 1 : 0;
|
||
|
|
a.max_i4_header_bits_ = parseInt(256 * 16 * 16 * (c * c) / (100 * 100))
|
||
|
|
}
|
||
|
|
|
||
|
|
function InitEncoder(a, b) {
|
||
|
|
var c = (a.filter_strength > 0) || (a.autofilter > 0);
|
||
|
|
var d = (b.width + 15) >> 4;
|
||
|
|
var e = (b.height + 15) >> 4;
|
||
|
|
var f = 4 * d + 1;
|
||
|
|
var g = 4 * e + 1;
|
||
|
|
var h = f * g * sizeof(uint8_t);
|
||
|
|
var i = d * 16;
|
||
|
|
var j = (d + 1) * sizeof(uint32_t);
|
||
|
|
var k = (3 * bi + bj) * sizeof(uint8_t);
|
||
|
|
var l = d * e * sizeof(bQ);
|
||
|
|
var m = (2 * i + 16 + 16 + 16 + 8 + 1 + 2 * bn) * sizeof(uint8_t);
|
||
|
|
var n = a.autofilter ? sizeof(bM) + bn : 0;
|
||
|
|
var o = newObjectIt(bT);
|
||
|
|
var p = uint8_t;
|
||
|
|
var q = sizeof(bT) + bn + k + l + h + m + j + n;
|
||
|
|
p = malloc(q, uint8_t);
|
||
|
|
if (p == null) {
|
||
|
|
WebPEncodingSetError(b, VP8_ENC_ERROR_OUT_OF_MEMORY);
|
||
|
|
return null
|
||
|
|
}
|
||
|
|
o.num_parts_ = 1 << a.partitions;
|
||
|
|
o.mb_w_ = d;
|
||
|
|
o.mb_h_ = e;
|
||
|
|
o.preds_w_ = f;
|
||
|
|
o.yuv_in_ = membuild(uint8_t, bi);
|
||
|
|
o.yuv_out_ = membuild(uint8_t, bi);
|
||
|
|
o.yuv_out2_ = membuild(uint8_t, bi);
|
||
|
|
o.yuv_p_ = membuild(uint8_t, bj);
|
||
|
|
o.mb_info_ = Arr_nOI(l, bQ);
|
||
|
|
o.preds_ = Arr((f * g * sizeof(uint8_t) + 1 + o.preds_w_), uint8_t);
|
||
|
|
o.preds_off = +1 + o.preds_w_;
|
||
|
|
o.nz_ = Arr(1 + j, uint8_t);
|
||
|
|
o.nz_off = 1;
|
||
|
|
o.lf_stats_ = n ? newObjectIt(bM) : null;
|
||
|
|
o.y_top_ = Arr((2 * i + (16) + (16 + 16) + (16) + (8)), uint8_t);
|
||
|
|
o.y_top_off = 0;
|
||
|
|
o.uv_top_ = o.y_top_;
|
||
|
|
o.uv_top_off = o.y_top_off + i;
|
||
|
|
o.y_left_ = o.uv_top_;
|
||
|
|
o.y_left_off = (2 * i) + (16);
|
||
|
|
o.u_left_ = o.y_left_;
|
||
|
|
o.u_left_off = o.y_left_off + (16 + 16);
|
||
|
|
o.v_left_ = o.u_left_;
|
||
|
|
o.v_left_off = o.u_left_off + (16);
|
||
|
|
o.config_ = a;
|
||
|
|
o.profile_ = c ? ((a.filter_type == 1) ? 0 : 1) : 2;
|
||
|
|
o.pic_ = b;
|
||
|
|
MapConfigToTools(o);
|
||
|
|
VP8EncDspInit();
|
||
|
|
VP8DefaultProbas(o);
|
||
|
|
ResetSegmentHeader(o);
|
||
|
|
ResetFilterHeader(o);
|
||
|
|
ResetBoundaryPredictions(o);
|
||
|
|
VP8EncInitAlpha(o);
|
||
|
|
VP8EncInitLayer(o);
|
||
|
|
return o
|
||
|
|
}
|
||
|
|
|
||
|
|
function DeleteEncoder(a) {
|
||
|
|
if (a) {
|
||
|
|
VP8EncDeleteAlpha(a);
|
||
|
|
VP8EncDeleteLayer(a);
|
||
|
|
a = ''
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function GetPSNR(a, b) {
|
||
|
|
return a ? 10. * (Math.LOG10E * Math.log(255. * 255. * b / a)) : 99.
|
||
|
|
}
|
||
|
|
|
||
|
|
function FinalizePSNR(a) {
|
||
|
|
var b = a.pic_.stats;
|
||
|
|
var c = a.sse_count_;
|
||
|
|
var d = a.sse_;
|
||
|
|
b.PSNR[0] = parseFloat(GetPSNR(d[0], c));
|
||
|
|
b.PSNR[1] = parseFloat(GetPSNR(d[1], c / 4));
|
||
|
|
b.PSNR[2] = parseFloat(GetPSNR(d[2], c / 4));
|
||
|
|
b.PSNR[3] = parseFloat(GetPSNR(d[0] + d[1] + d[2], c * 3 / 2))
|
||
|
|
}
|
||
|
|
|
||
|
|
function StoreStats(a) {
|
||
|
|
var b = a.pic_.stats;
|
||
|
|
var c = a.pic_.stats_nozero;
|
||
|
|
if (c) {
|
||
|
|
var i, s;
|
||
|
|
for (i = 0; i < be; ++i) {
|
||
|
|
b.segment_level[i] = a.dqm_[i].fstrength_;
|
||
|
|
b.segment_quant[i] = a.dqm_[i].quant_;
|
||
|
|
for (s = 0; s <= 2; ++s) {
|
||
|
|
b.residual_bytes[s][i] = a.residual_bytes_[s][i]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
FinalizePSNR(a);
|
||
|
|
b.coded_size = a.coded_size_;
|
||
|
|
for (i = 0; i < 3; ++i) {
|
||
|
|
b.block_count[i] = a.block_count_[i]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPEncodingSetError(a, b) {
|
||
|
|
assert(b <= VP8_ENC_ERROR_BAD_WRITE);
|
||
|
|
assert(b >= U);
|
||
|
|
a.error_code = b;
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPEncode(a, b) {
|
||
|
|
var c = newObjectIt(bT);
|
||
|
|
var d = int;
|
||
|
|
if (b == null) return 0;
|
||
|
|
WebPEncodingSetError(b, U);
|
||
|
|
if (a == null) return WebPEncodingSetError(b, VP8_ENC_ERROR_NULL_PARAMETER);
|
||
|
|
if (!WebPValidateConfig(a)) return WebPEncodingSetError(b, VP8_ENC_ERROR_INVALID_CONFIGURATION);
|
||
|
|
if (b.width <= 0 || b.height <= 0) return WebPEncodingSetError(b, VP8_ENC_ERROR_BAD_DIMENSION);
|
||
|
|
if (b.y == null || b.u == null || b.v == null) return WebPEncodingSetError(b, VP8_ENC_ERROR_NULL_PARAMETER);
|
||
|
|
if (b.width >= dW || b.height >= dW) return WebPEncodingSetError(b, VP8_ENC_ERROR_BAD_DIMENSION);
|
||
|
|
c = InitEncoder(a, b);
|
||
|
|
if (c == null) return 0;
|
||
|
|
d = VP8EncAnalyze(c) && VP8StatLoop(c) && VP8EncLoop(c) && VP8EncFinishAlpha(c) && VP8EncFinishLayer(c) && VP8EncWrite(c);
|
||
|
|
StoreStats(c);
|
||
|
|
DeleteEncoder(c);
|
||
|
|
return d
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPPictureAlloc(a) {
|
||
|
|
if (a.extra_info_type) AllocExtraInfo(a);
|
||
|
|
if (a) {
|
||
|
|
var b = a.colorspace & WEBP_CSP_UV_MASK;
|
||
|
|
var c = a.colorspace & WEBP_CSP_ALPHA_BIT;
|
||
|
|
var d = a.width;
|
||
|
|
var e = a.height;
|
||
|
|
var f = d;
|
||
|
|
var g = parseInt((d + 1) / 2);
|
||
|
|
var h = parseInt((e + 1) / 2);
|
||
|
|
var i = g;
|
||
|
|
var j = 0;
|
||
|
|
var k = int,
|
||
|
|
a_stride = int;
|
||
|
|
var l = uint64_t,
|
||
|
|
uv_size = uint64_t,
|
||
|
|
uv0_size = uint64_t,
|
||
|
|
a_size = uint64_t,
|
||
|
|
total_size = uint64_t;
|
||
|
|
var m = uint8_t;
|
||
|
|
var n = 0;
|
||
|
|
switch (b) {
|
||
|
|
case T:
|
||
|
|
break;
|
||
|
|
case WEBP_YUV400:
|
||
|
|
break;
|
||
|
|
case WEBP_YUV422:
|
||
|
|
j = g;
|
||
|
|
break;
|
||
|
|
case WEBP_YUV444:
|
||
|
|
j = d;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
uv0_size = e * j;
|
||
|
|
k = c ? d : 0;
|
||
|
|
a_stride = k;
|
||
|
|
l = f * e;
|
||
|
|
uv_size = i * h;
|
||
|
|
a_size = a_stride * e;
|
||
|
|
total_size = l + a_size + 2 * uv_size + 2 * uv0_size;
|
||
|
|
if (d <= 0 || e <= 0 || g < 0 || h < 0 || l >= (64 * 64 * 64 * 16 << 40) || total_size != total_size) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
a.y_stride = f;
|
||
|
|
a.uv_stride = i;
|
||
|
|
a.a_stride = a_stride;
|
||
|
|
a.uv0_stride = j;
|
||
|
|
WebPPictureFree(a);
|
||
|
|
a.y = malloc(total_size, uint8_t);
|
||
|
|
a.y_off = 0;
|
||
|
|
if (a.y == null) return 0;
|
||
|
|
a.u = a.y;
|
||
|
|
a.u_off = a.y_off + l;
|
||
|
|
a.v = a.u;
|
||
|
|
a.v_off = a.u_off + uv_size;
|
||
|
|
m = malloc(total_size, uint8_t);
|
||
|
|
if (m == null) return 0;
|
||
|
|
a.y = m;
|
||
|
|
a.y_off = n;
|
||
|
|
n += l;
|
||
|
|
a.u = m;
|
||
|
|
a.u_off = n;
|
||
|
|
n += uv_size;
|
||
|
|
a.v = m;
|
||
|
|
a.v_off = n;
|
||
|
|
n += uv_size;
|
||
|
|
if (a_size) {
|
||
|
|
a.a = malloc(a_size, uint8_t);
|
||
|
|
a.a_off = 0
|
||
|
|
}
|
||
|
|
if (uv0_size) {
|
||
|
|
a.u0 = m;
|
||
|
|
a.u0_off = n;
|
||
|
|
n += uv0_size;
|
||
|
|
a.v0 = m;
|
||
|
|
a.v0_off = n;
|
||
|
|
n += uv0_size
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPPictureGrabSpecs(a, b) {
|
||
|
|
if (a) b = a;
|
||
|
|
b.y = b.u = b.v = null;
|
||
|
|
b.y_off = b.u_off = b.v_off = null;
|
||
|
|
b.u0 = b.v0 = null;
|
||
|
|
b.u0_off = b.v0_off = null;
|
||
|
|
b.a = null;
|
||
|
|
b.a_off = null
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPPictureFree(a) {
|
||
|
|
if (a) {
|
||
|
|
a.y = '';
|
||
|
|
a.y = a.u = a.v = null;
|
||
|
|
a.y_off = a.u_off = a.v_off = 0;
|
||
|
|
WebPPictureGrabSpecs(null, a)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var dX = {
|
||
|
|
mem: uint8_t,
|
||
|
|
mem_off: 0,
|
||
|
|
max_size: size_t,
|
||
|
|
size: size_t,
|
||
|
|
size_off: 0
|
||
|
|
};
|
||
|
|
|
||
|
|
function InitMemoryWriter(a) {
|
||
|
|
a.mem = null;
|
||
|
|
a.mem_off = 0;
|
||
|
|
a.size = 0;
|
||
|
|
a.max_size = 0
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPMemoryWrite(a, b, c) {
|
||
|
|
var w = c.custom_ptr;
|
||
|
|
var d = size_t;
|
||
|
|
if (w == null) {
|
||
|
|
alert('w is null');
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
d = (w.size) + b;
|
||
|
|
if (d > w.max_size) {
|
||
|
|
var e = uint8_t;
|
||
|
|
var f = 0;
|
||
|
|
var g = w.max_size * 2;
|
||
|
|
if (g < d) g = d;
|
||
|
|
if (g < 8192) g = 8192;
|
||
|
|
e = malloc(g, uint8_t);
|
||
|
|
if (e == null) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
if ((w.size) > 0) {
|
||
|
|
memcpy(e, f, w.mem, 0, w.size)
|
||
|
|
}
|
||
|
|
w.mem = '';
|
||
|
|
w.mem = e;
|
||
|
|
w.max_size = g
|
||
|
|
}
|
||
|
|
if (b) {
|
||
|
|
memcpy((w.mem), +(w.size), a, 0, b);
|
||
|
|
w.size += b
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
var dY = 16;
|
||
|
|
|
||
|
|
function clip_uv(v) {
|
||
|
|
v = (v + (257 << (dY + 2 - 1))) >> (dY + 2);
|
||
|
|
return ((v & ~0xff) == 0) ? v : (v < 0) ? 0 : 255
|
||
|
|
}
|
||
|
|
|
||
|
|
function rgb_to_y(r, g, b) {
|
||
|
|
var a = (1 << (dY - 1)) + (16 << dY);
|
||
|
|
var c = 16839 * r + 33059 * g + 6420 * b;
|
||
|
|
return (c + a) >> dY
|
||
|
|
}
|
||
|
|
|
||
|
|
function rgb_to_u(r, g, b) {
|
||
|
|
return clip_uv(-9719 * r - 19081 * g + 28800 * b)
|
||
|
|
}
|
||
|
|
|
||
|
|
function rgb_to_v(r, g, b) {
|
||
|
|
return clip_uv(+28800 * r - 24116 * g - 4684 * b)
|
||
|
|
}
|
||
|
|
|
||
|
|
function MakeGray(a) {
|
||
|
|
var y;
|
||
|
|
var b = (a.width + 1) >> 1;
|
||
|
|
for (y = 0; y < ((a.height + 1) >> 1); ++y) {
|
||
|
|
memset_(a.u, a.u_off + y * a.uv_stride, 128, b);
|
||
|
|
memset_(a.v, a.v_off + y * a.uv_stride, 128, b)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function Import(h, i, j, k, l, m) {
|
||
|
|
var n = h.colorspace & WEBP_CSP_UV_MASK;
|
||
|
|
var x, y = int;
|
||
|
|
var o = i;
|
||
|
|
var p = +(l ? 2 : 0);
|
||
|
|
var q = i;
|
||
|
|
var s = +1;
|
||
|
|
var t = i;
|
||
|
|
var u = +(l ? 0 : 2);
|
||
|
|
var v = h.width;
|
||
|
|
var w = h.height;
|
||
|
|
|
||
|
|
function SUM4(a, b) {
|
||
|
|
return (a[b + 0] + a[b + k] + a[b + j] + a[b + j + k])
|
||
|
|
}
|
||
|
|
|
||
|
|
function SUM2H(a, b) {
|
||
|
|
return (2 * a[b + 0] + 2 * a[b + k])
|
||
|
|
}
|
||
|
|
|
||
|
|
function SUM2V(a, b) {
|
||
|
|
return (2 * a[b + 0] + 2 * a[b + j])
|
||
|
|
}
|
||
|
|
|
||
|
|
function SUM1(a, b) {
|
||
|
|
return (4 * a[b + 0])
|
||
|
|
}
|
||
|
|
|
||
|
|
function RGB_TO_UV(x, y, a) {
|
||
|
|
var c = (2 * (k * (x) + (y) * j));
|
||
|
|
var d = (x) + (y) * h.uv_stride;
|
||
|
|
var r = a(o, p + c);
|
||
|
|
var g = a(q, s + c);
|
||
|
|
var b = a(t, u + c);
|
||
|
|
h.u[h.u_off + d] = rgb_to_u(r, g, b);
|
||
|
|
h.v[h.v_off + d] = rgb_to_v(r, g, b)
|
||
|
|
}
|
||
|
|
|
||
|
|
function RGB_TO_UV0(a, c, y, d) {
|
||
|
|
var e = (k * (a) + (y) * j);
|
||
|
|
var f = (c) + (y) * h.uv0_stride;
|
||
|
|
var r = d(o, p + e);
|
||
|
|
var g = d(q, s + e);
|
||
|
|
var b = d(t, u + e);
|
||
|
|
h.u0[h.u0_off + f] = rgb_to_u(r, g, b);
|
||
|
|
h.v0[h.v0_off + f] = rgb_to_v(r, g, b)
|
||
|
|
}
|
||
|
|
for (y = 0; y < w; ++y) {
|
||
|
|
for (x = 0; x < v; ++x) {
|
||
|
|
var z = k * x + y * j;
|
||
|
|
h.y[h.y_off + x + y * h.y_stride] = rgb_to_y(o[p + z], q[s + z], t[u + z])
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (n != WEBP_YUV400) {
|
||
|
|
for (y = 0; y < (w >> 1); ++y) {
|
||
|
|
for (x = 0; x < (v >> 1); ++x) {
|
||
|
|
RGB_TO_UV(x, y, SUM4)
|
||
|
|
}
|
||
|
|
if (h.width & 1) {
|
||
|
|
RGB_TO_UV(x, y, SUM2V)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (w & 1) {
|
||
|
|
for (x = 0; x < (v >> 1); ++x) {
|
||
|
|
RGB_TO_UV(x, y, SUM2H)
|
||
|
|
}
|
||
|
|
if (v & 1) {
|
||
|
|
RGB_TO_UV(x, y, SUM1)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (n == WEBP_YUV422) {
|
||
|
|
for (y = 0; y < w; ++y) {
|
||
|
|
for (x = 0; x < (v >> 1); ++x) {
|
||
|
|
RGB_TO_UV0(2 * x, x, y, SUM2H)
|
||
|
|
}
|
||
|
|
if (v & 1) {
|
||
|
|
RGB_TO_UV0(2 * x, x, y, SUM1)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if (n == WEBP_YUV444) {
|
||
|
|
for (y = 0; y < w; ++y) {
|
||
|
|
for (x = 0; x < v; ++x) {
|
||
|
|
RGB_TO_UV0(x, x, y, SUM1)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
MakeGray(h)
|
||
|
|
}
|
||
|
|
if (m) {
|
||
|
|
var A = i;
|
||
|
|
var B = +3;
|
||
|
|
assert(k >= 4);
|
||
|
|
for (y = 0; y < w; ++y) {
|
||
|
|
for (x = 0; x < v; ++x) {
|
||
|
|
h.a[h.a_off + x + y * h.a_stride] = A[B + k * x + y * j]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return 1
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPPictureImportRGB(a, b, c) {
|
||
|
|
a.colorspace &= ~WEBP_CSP_ALPHA_BIT;
|
||
|
|
if (!WebPPictureAlloc(a)) return 0;
|
||
|
|
return Import(a, b, c, 3, 0, 0)
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPPictureImportBGR(a, b, c) {
|
||
|
|
a.colorspace &= ~WEBP_CSP_ALPHA_BIT;
|
||
|
|
if (!WebPPictureAlloc(a)) return 0;
|
||
|
|
return Import(a, b, c, 3, 1, 0)
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPPictureImportRGBA(a, b, c) {
|
||
|
|
a.colorspace |= WEBP_CSP_ALPHA_BIT;
|
||
|
|
if (!WebPPictureAlloc(a)) return 0;
|
||
|
|
return Import(a, b, c, 4, 0, 1)
|
||
|
|
}
|
||
|
|
|
||
|
|
function WebPPictureImportBGRA(a, b, c) {
|
||
|
|
a.colorspace |= WEBP_CSP_ALPHA_BIT;
|
||
|
|
if (!WebPPictureAlloc(a)) return 0;
|
||
|
|
return Import(a, b, c, 4, 1, 1)
|
||
|
|
}
|
||
|
|
var dZ, pic_tmp;
|
||
|
|
|
||
|
|
function Encode(e, f, g, h, j, k, l) {
|
||
|
|
var m = 0;
|
||
|
|
var n = newObjectIt(V);
|
||
|
|
var o = newObjectIt(O);
|
||
|
|
var p = newObjectIt(dX);
|
||
|
|
var q = int;
|
||
|
|
n.extra_info_type = ea.extra_info_type ? ea.extra_info_type : 0;
|
||
|
|
if (!WebPConfigPreset(o, P.WEBP_PRESET_DEFAULT, k) || !WebPPictureInit(n)) {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
n.width = f;
|
||
|
|
n.height = g;
|
||
|
|
n.writer = function(a, b, c, d) {
|
||
|
|
return WebPMemoryWrite(a, b, c, d)
|
||
|
|
};
|
||
|
|
n.custom_ptr = p;
|
||
|
|
p.mem = l.output;
|
||
|
|
p.size = m;
|
||
|
|
InitMemoryWriter(p);
|
||
|
|
q = j(n, e, h) && WebPEncode(o, n);
|
||
|
|
if (q) pic_stats = newObjectIt(n.stats);
|
||
|
|
else pic_stats = null;
|
||
|
|
if (q) pic_tmp = newObjectIt(n);
|
||
|
|
else pic_tmp = null;
|
||
|
|
WebPPictureFree(n);
|
||
|
|
if (!q) {
|
||
|
|
l = '';
|
||
|
|
l = null;
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
var r = new Array();
|
||
|
|
for (var i = 0; i < p.size; ++i) r.push(String.fromCharCode(p.mem[i]));
|
||
|
|
r = r.join("");
|
||
|
|
l.output = r;
|
||
|
|
m = p.size;
|
||
|
|
return m
|
||
|
|
}
|
||
|
|
this.WebPEncodeRGB = function(a, w, h, b, q, c) {
|
||
|
|
return Encode(a, w, h, b, WebPPictureImportRGB, q, c)
|
||
|
|
};
|
||
|
|
this.WebPEncodeBGR = function(a, w, h, b, q, c) {
|
||
|
|
return Encode(a, w, h, b, WebPPictureImportBGR, q, c)
|
||
|
|
};
|
||
|
|
this.WebPEncodeRGBA = function(a, w, h, b, q, c) {
|
||
|
|
return Encode(a, w, h, b, WebPPictureImportRGBA, q, c)
|
||
|
|
};
|
||
|
|
this.WebPEncodeBGRA = function(a, w, h, b, q, c) {
|
||
|
|
return Encode(a, w, h, b, WebPPictureImportBGRA, q, c)
|
||
|
|
};
|
||
|
|
var ea = null;
|
||
|
|
this.WebPEncodeConfig = function(a) {
|
||
|
|
ea = a
|
||
|
|
};
|
||
|
|
|
||
|
|
function AllocExtraInfo(a) {
|
||
|
|
var b = parseInt((a.width + 15) / 16);
|
||
|
|
var c = parseInt((a.height + 15) / 16);
|
||
|
|
a.extra_info = malloc(b * c * sizeof(a.extra_info), uint8_t)
|
||
|
|
}
|
||
|
|
this.ReturnExtraInfo = function() {
|
||
|
|
function l(b, l) {
|
||
|
|
b = b + '';
|
||
|
|
var a = '',
|
||
|
|
i;
|
||
|
|
var c = l - (typeof b.length !== 'undefined' ? b.length : 1);
|
||
|
|
c = l < 0 ? 0 : c;
|
||
|
|
for (i = 0; i < c; ++i) a += ' ';
|
||
|
|
return a + b
|
||
|
|
};
|
||
|
|
|
||
|
|
function PrintByteCount(a, b, c) {
|
||
|
|
var s, str = '';
|
||
|
|
var d = 0;
|
||
|
|
for (s = 0; s < 4; ++s) {
|
||
|
|
str += "| " + l(a[s], 7) + " ";
|
||
|
|
d += a[s];
|
||
|
|
if (c) c[s] += a[s]
|
||
|
|
}
|
||
|
|
return str + "| " + l(d, 7) + " (" + ((100. * d / b).toFixed(1)) + "%)\n"
|
||
|
|
};
|
||
|
|
|
||
|
|
function PrintPercents(a, b) {
|
||
|
|
var s, str = '';
|
||
|
|
for (s = 0; s < 4; ++s) {
|
||
|
|
str += "| " + l(parseInt(100 * a[s] / b), 3) + "%"
|
||
|
|
}
|
||
|
|
return str + "| " + l(b, 7) + "\n"
|
||
|
|
};
|
||
|
|
|
||
|
|
function PrintValues(a) {
|
||
|
|
var s, str = '';
|
||
|
|
for (s = 0; s < 4; ++s) {
|
||
|
|
str += "| " + l(a[s], 7) + " "
|
||
|
|
}
|
||
|
|
return str + "|\n"
|
||
|
|
};
|
||
|
|
if (!pic_stats) return '';
|
||
|
|
var e = pic_stats;
|
||
|
|
var f = e.block_count[0];
|
||
|
|
var g = e.block_count[1];
|
||
|
|
var h = e.block_count[2];
|
||
|
|
var j = f + g;
|
||
|
|
str = "" + l(e.coded_size, 7) + " bytes Y-U-V-All-PSNR " + (e.PSNR[0].toFixed(2)) + " " + (e.PSNR[1].toFixed(2)) + " " + (e.PSNR[2].toFixed(2)) + " " + (e.PSNR[3].toFixed(2)) + " dB\n";
|
||
|
|
if (j > 0) {
|
||
|
|
var k = new Array(0, 0, 0, 0);
|
||
|
|
str += "block count: intra4: " + f + "\n" + " intra16: " + g + " (-> " + ((100. * g / j).toFixed(2)) + "%)\n" + " skipped block: " + h + " (" + ((100. * h / j).toFixed(2)) + "%)\n" + "bytes used: header: " + l(e.header_bytes[0], 6) + " (" + ((100. * e.header_bytes[0] / e.coded_size).toFixed(1)) + "%)\n" + " mode-partition: " + l(e.header_bytes[1], 6) + " (" + ((100. * e.header_bytes[1] / e.coded_size).toFixed(1)) + "%)\n" + " Residuals bytes |segment 1|segment 2|segment 3|segment 4| total\n" + " intra4-coeffs: " + PrintByteCount(e.residual_bytes[0], e.coded_size, k) + "" + " intra16-coeffs: " + PrintByteCount(e.residual_bytes[1], e.coded_size, k) + "" + " chroma coeffs: " + PrintByteCount(e.residual_bytes[2], e.coded_size, k) + "" + " macroblocks: " + PrintPercents(e.segment_size, j) + "" + " quantizer: " + PrintValues(e.segment_quant) + "" + " filter level: " + PrintValues(e.segment_level) + "" + "------------------+---------+---------+---------+---------+-----------------\n" + " segments total: " + PrintByteCount(k, e.coded_size, null) + ""
|
||
|
|
}
|
||
|
|
str += "";
|
||
|
|
if (pic_tmp.extra_info) {
|
||
|
|
var m = parseInt((pic_tmp.width + 15) / 16);
|
||
|
|
var n = parseInt((pic_tmp.height + 15) / 16);
|
||
|
|
var o = pic_tmp.extra_info_type;
|
||
|
|
var x, y;
|
||
|
|
for (y = 0; y < n; ++y) {
|
||
|
|
for (x = 0; x < m; ++x) {
|
||
|
|
var c = pic_tmp.extra_info[x + y * m];
|
||
|
|
if (o == 1) {
|
||
|
|
var p = "+.";
|
||
|
|
str += p[c % 2]
|
||
|
|
} else if (o == 2) {
|
||
|
|
var q = ".-*X";
|
||
|
|
str += q[c % 4]
|
||
|
|
} else if (o == 3) {
|
||
|
|
str += l(c, 2) + " "
|
||
|
|
} else if (o == 6 || o == 7) {
|
||
|
|
str += l(c, 3) + " "
|
||
|
|
} else {
|
||
|
|
str += "0x" + (c < 16 ? "0" : "") + c.toString(16) + " "
|
||
|
|
}
|
||
|
|
}
|
||
|
|
str += "\n"
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return str
|
||
|
|
}
|
||
|
|
}
|