1337 lines
43 KiB
JavaScript
1337 lines
43 KiB
JavaScript
/*"use strict";*/
|
|
/* use strict is commented out because it results in a 5x slowdone in chrome */
|
|
/*
|
|
* Copyright (C) 2012 by Jeremy P. White <jwhite@codeweavers.com>
|
|
* Copyright (C) 2012 by Aric Stewart <aric@codeweavers.com>
|
|
*
|
|
* This file is part of spice-html5.
|
|
*
|
|
* spice-html5 is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* spice-html5 is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with spice-html5. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
var encoder;
|
|
|
|
var QUIC_IMAGE_TYPE_INVALID = 0;
|
|
var QUIC_IMAGE_TYPE_GRAY = 1;
|
|
var QUIC_IMAGE_TYPE_RGB16 = 2;
|
|
var QUIC_IMAGE_TYPE_RGB24 = 3;
|
|
var QUIC_IMAGE_TYPE_RGB32 = 4;
|
|
var QUIC_IMAGE_TYPE_RGBA = 5;
|
|
var DEFevol = 3;
|
|
var DEFwmimax = 6;
|
|
var DEFwminext = 2048;
|
|
var need_init = true;
|
|
var DEFmaxclen = 26;
|
|
var evol = DEFevol;
|
|
var wmimax = DEFwmimax;
|
|
var wminext = DEFwminext;
|
|
var family_5bpc = { nGRcodewords:[0,0,0,0,0,0,0,0],
|
|
notGRcwlen:[0,0,0,0,0,0,0,0],
|
|
notGRprefixmask:[0,0,0,0,0,0,0,0],
|
|
notGRsuffixlen:[0,0,0,0,0,0,0,0],
|
|
xlatU2L:[0,0,0,0,0,0,0,0],
|
|
xlatL2U:[0,0,0,0,0,0,0,0]
|
|
};
|
|
var family_8bpc = { nGRcodewords:[0,0,0,0,0,0,0,0],
|
|
notGRcwlen:[0,0,0,0,0,0,0,0],
|
|
notGRprefixmask:[0,0,0,0,0,0,0,0],
|
|
notGRsuffixlen:[0,0,0,0,0,0,0,0],
|
|
xlatU2L:[0,0,0,0,0,0,0,0],
|
|
xlatL2U:[0,0,0,0,0,0,0,0]
|
|
};
|
|
var bppmask = [ 0x00000000,
|
|
0x00000001, 0x00000003, 0x00000007, 0x0000000f,
|
|
0x0000001f, 0x0000003f, 0x0000007f, 0x000000ff,
|
|
0x000001ff, 0x000003ff, 0x000007ff, 0x00000fff,
|
|
0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff,
|
|
0x0001ffff, 0x0003ffff, 0x0007ffff, 0x000fffff,
|
|
0x001fffff, 0x003fffff, 0x007fffff, 0x00ffffff,
|
|
0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff,
|
|
0x1fffffff, 0x3fffffff, 0x7fffffff, 0xffffffff];
|
|
|
|
var zeroLUT = [];
|
|
|
|
var besttrigtab = [
|
|
[ 550, 900, 800, 700, 500, 350, 300, 200, 180, 180, 160],
|
|
[ 110, 550, 900, 800, 550, 400, 350, 250, 140, 160, 140],
|
|
[ 100, 120, 550, 900, 700, 500, 400, 300, 220, 250, 160]];
|
|
|
|
var J = [ 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 6, 6,
|
|
7, 7, 8, 9, 10, 11, 12, 13, 14, 15];
|
|
|
|
var lzeroes = [
|
|
8, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0];
|
|
|
|
var tabrand_chaos = [
|
|
0x02c57542, 0x35427717, 0x2f5a2153, 0x9244f155, 0x7bd26d07, 0x354c6052,
|
|
0x57329b28, 0x2993868e, 0x6cd8808c, 0x147b46e0, 0x99db66af, 0xe32b4cac,
|
|
0x1b671264, 0x9d433486, 0x62a4c192, 0x06089a4b, 0x9e3dce44, 0xdaabee13,
|
|
0x222425ea, 0xa46f331d, 0xcd589250, 0x8bb81d7f, 0xc8b736b9, 0x35948d33,
|
|
0xd7ac7fd0, 0x5fbe2803, 0x2cfbc105, 0x013dbc4e, 0x7a37820f, 0x39f88e9e,
|
|
0xedd58794, 0xc5076689, 0xfcada5a4, 0x64c2f46d, 0xb3ba3243, 0x8974b4f9,
|
|
0x5a05aebd, 0x20afcd00, 0x39e2b008, 0x88a18a45, 0x600bde29, 0xf3971ace,
|
|
0xf37b0a6b, 0x7041495b, 0x70b707ab, 0x06beffbb, 0x4206051f, 0xe13c4ee3,
|
|
0xc1a78327, 0x91aa067c, 0x8295f72a, 0x732917a6, 0x1d871b4d, 0x4048f136,
|
|
0xf1840e7e, 0x6a6048c1, 0x696cb71a, 0x7ff501c3, 0x0fc6310b, 0x57e0f83d,
|
|
0x8cc26e74, 0x11a525a2, 0x946934c7, 0x7cd888f0, 0x8f9d8604, 0x4f86e73b,
|
|
0x04520316, 0xdeeea20c, 0xf1def496, 0x67687288, 0xf540c5b2, 0x22401484,
|
|
0x3478658a, 0xc2385746, 0x01979c2c, 0x5dad73c8, 0x0321f58b, 0xf0fedbee,
|
|
0x92826ddf, 0x284bec73, 0x5b1a1975, 0x03df1e11, 0x20963e01, 0xa17cf12b,
|
|
0x740d776e, 0xa7a6bf3c, 0x01b5cce4, 0x1118aa76, 0xfc6fac0a, 0xce927e9b,
|
|
0x00bf2567, 0x806f216c, 0xbca69056, 0x795bd3e9, 0xc9dc4557, 0x8929b6c2,
|
|
0x789d52ec, 0x3f3fbf40, 0xb9197368, 0xa38c15b5, 0xc3b44fa8, 0xca8333b0,
|
|
0xb7e8d590, 0xbe807feb, 0xbf5f8360, 0xd99e2f5c, 0x372928e1, 0x7c757c4c,
|
|
0x0db5b154, 0xc01ede02, 0x1fc86e78, 0x1f3985be, 0xb4805c77, 0x00c880fa,
|
|
0x974c1b12, 0x35ab0214, 0xb2dc840d, 0x5b00ae37, 0xd313b026, 0xb260969d,
|
|
0x7f4c8879, 0x1734c4d3, 0x49068631, 0xb9f6a021, 0x6b863e6f, 0xcee5debf,
|
|
0x29f8c9fb, 0x53dd6880, 0x72b61223, 0x1f67a9fd, 0x0a0f6993, 0x13e59119,
|
|
0x11cca12e, 0xfe6b6766, 0x16b6effc, 0x97918fc4, 0xc2b8a563, 0x94f2f741,
|
|
0x0bfa8c9a, 0xd1537ae8, 0xc1da349c, 0x873c60ca, 0x95005b85, 0x9b5c080e,
|
|
0xbc8abbd9, 0xe1eab1d2, 0x6dac9070, 0x4ea9ebf1, 0xe0cf30d4, 0x1ef5bd7b,
|
|
0xd161043e, 0x5d2fa2e2, 0xff5d3cae, 0x86ed9f87, 0x2aa1daa1, 0xbd731a34,
|
|
0x9e8f4b22, 0xb1c2c67a, 0xc21758c9, 0xa182215d, 0xccb01948, 0x8d168df7,
|
|
0x04238cfe, 0x368c3dbc, 0x0aeadca5, 0xbad21c24, 0x0a71fee5, 0x9fc5d872,
|
|
0x54c152c6, 0xfc329483, 0x6783384a, 0xeddb3e1c, 0x65f90e30, 0x884ad098,
|
|
0xce81675a, 0x4b372f7d, 0x68bf9a39, 0x43445f1e, 0x40f8d8cb, 0x90d5acb6,
|
|
0x4cd07282, 0x349eeb06, 0x0c9d5332, 0x520b24ef, 0x80020447, 0x67976491,
|
|
0x2f931ca3, 0xfe9b0535, 0xfcd30220, 0x61a9e6cc, 0xa487d8d7, 0x3f7c5dd1,
|
|
0x7d0127c5, 0x48f51d15, 0x60dea871, 0xc9a91cb7, 0x58b53bb3, 0x9d5e0b2d,
|
|
0x624a78b4, 0x30dbee1b, 0x9bdf22e7, 0x1df5c299, 0x2d5643a7, 0xf4dd35ff,
|
|
0x03ca8fd6, 0x53b47ed8, 0x6f2c19aa, 0xfeb0c1f4, 0x49e54438, 0x2f2577e6,
|
|
0xbf876969, 0x72440ea9, 0xfa0bafb8, 0x74f5b3a0, 0x7dd357cd, 0x89ce1358,
|
|
0x6ef2cdda, 0x1e7767f3, 0xa6be9fdb, 0x4f5f88f8, 0xba994a3a, 0x08ca6b65,
|
|
0xe0893818, 0x9e00a16a, 0xf42bfc8f, 0x9972eedc, 0x749c8b51, 0x32c05f5e,
|
|
0xd706805f, 0x6bfbb7cf, 0xd9210a10, 0x31a1db97, 0x923a9559, 0x37a7a1f6,
|
|
0x059f8861, 0xca493e62, 0x65157e81, 0x8f6467dd, 0xab85ff9f, 0x9331aff2,
|
|
0x8616b9f5, 0xedbd5695, 0xee7e29b1, 0x313ac44f, 0xb903112f, 0x432ef649,
|
|
0xdc0a36c0, 0x61cf2bba, 0x81474925, 0xa8b6c7ad, 0xee5931de, 0xb2f8158d,
|
|
0x59fb7409, 0x2e3dfaed, 0x9af25a3f, 0xe1fed4d5 ];
|
|
|
|
var rgb32_pixel_pad = 3;
|
|
var rgb32_pixel_r = 2;
|
|
var rgb32_pixel_g = 1;
|
|
var rgb32_pixel_b = 0;
|
|
var rgb32_pixel_size = 4;
|
|
|
|
/* Helper Functions */
|
|
|
|
function ceil_log_2(val)
|
|
{
|
|
if (val === 1)
|
|
return 0;
|
|
|
|
var result = 1;
|
|
val -= 1;
|
|
while (val = val >>> 1)
|
|
result++;
|
|
|
|
return result;
|
|
}
|
|
|
|
function family_init(family, bpc, limit)
|
|
{
|
|
var l;
|
|
for (l = 0; l < bpc; l++)
|
|
{
|
|
var altprefixlen, altcodewords;
|
|
altprefixlen = limit - bpc;
|
|
if (altprefixlen > bppmask[bpc - l])
|
|
altprefixlen = bppmask[bpc - l];
|
|
|
|
altcodewords = bppmask[bpc] + 1 - (altprefixlen << l);
|
|
family.nGRcodewords[l] = (altprefixlen << l);
|
|
family.notGRcwlen[l] = altprefixlen + ceil_log_2(altcodewords);
|
|
family.notGRprefixmask[l] = bppmask[32 - altprefixlen]>>>0;
|
|
family.notGRsuffixlen[l] = ceil_log_2(altcodewords);
|
|
}
|
|
|
|
/* decorelate_init */
|
|
var pixelbitmask = bppmask[bpc];
|
|
var pixelbitmaskshr = pixelbitmask >>> 1;
|
|
var s;
|
|
for (s = 0; s <= pixelbitmask; s++) {
|
|
if (s <= pixelbitmaskshr) {
|
|
family.xlatU2L[s] = s << 1;
|
|
} else {
|
|
family.xlatU2L[s] = ((pixelbitmask - s) << 1) + 1;
|
|
}
|
|
}
|
|
|
|
/* corelate_init */
|
|
for (s = 0; s <= pixelbitmask; s++) {
|
|
if (s & 0x01) {
|
|
family.xlatL2U[s] = pixelbitmask - (s >>> 1);
|
|
} else {
|
|
family.xlatL2U[s] = (s >>> 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
function quic_image_bpc(type)
|
|
{
|
|
switch (type) {
|
|
case QUIC_IMAGE_TYPE_GRAY:
|
|
return 8;
|
|
case QUIC_IMAGE_TYPE_RGB16:
|
|
return 5;
|
|
case QUIC_IMAGE_TYPE_RGB24:
|
|
return 8;
|
|
case QUIC_IMAGE_TYPE_RGB32:
|
|
return 8;
|
|
case QUIC_IMAGE_TYPE_RGBA:
|
|
return 8;
|
|
case QUIC_IMAGE_TYPE_INVALID:
|
|
default:
|
|
console.log("quic: bad image type\n");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
function cnt_l_zeroes(bits)
|
|
{
|
|
if (bits & 0xff800000) {
|
|
return lzeroes[bits >>> 24];
|
|
} else if (bits & 0xffff8000) {
|
|
return 8 + lzeroes[(bits >>> 16) & 0x000000ff];
|
|
} else if (bits & 0xffffff80) {
|
|
return 16 + lzeroes[(bits >>> 8) & 0x000000ff];
|
|
} else {
|
|
return 24 + lzeroes[bits & 0x000000ff];
|
|
}
|
|
}
|
|
|
|
function golomb_decoding_8bpc(l, bits)
|
|
{
|
|
var rc;
|
|
var cwlen;
|
|
|
|
if (bits < 0 || bits > family_8bpc.notGRprefixmask[l])
|
|
{
|
|
var zeroprefix = cnt_l_zeroes(bits);
|
|
cwlen = zeroprefix + 1 + l;
|
|
rc = (zeroprefix << l) | (bits >> (32-cwlen)) & bppmask[l];
|
|
}
|
|
else
|
|
{
|
|
cwlen = family_8bpc.notGRcwlen[l];
|
|
rc = family_8bpc.nGRcodewords[l] + ((bits >> (32-cwlen)) & bppmask[family_8bpc.notGRsuffixlen[l]]);
|
|
}
|
|
return {'codewordlen':cwlen, 'rc':rc};
|
|
}
|
|
|
|
function golomb_code_len_8bpc(n, l)
|
|
{
|
|
if (n < family_8bpc.nGRcodewords[l]) {
|
|
return (n >>> l) + 1 + l;
|
|
} else {
|
|
return family_8bpc.notGRcwlen[l];
|
|
}
|
|
}
|
|
|
|
function QuicModel(bpc)
|
|
{
|
|
var bstart;
|
|
var bend = 0;
|
|
|
|
this.levels = 0x1 << bpc;
|
|
this.n_buckets_ptrs = 0;
|
|
|
|
switch (evol) {
|
|
case 1:
|
|
this.repfirst = 3;
|
|
this.firstsize = 1;
|
|
this.repnext = 2;
|
|
this.mulsize = 2;
|
|
break;
|
|
case 3:
|
|
this.repfirst = 1;
|
|
this.firstsize = 1;
|
|
this.repnext = 1;
|
|
this.mulsize = 2;
|
|
break;
|
|
case 5:
|
|
this.repfirst = 1;
|
|
this.firstsize = 1;
|
|
this.repnext = 1;
|
|
this.mulsize = 4;
|
|
break;
|
|
case 0:
|
|
case 2:
|
|
case 4:
|
|
console.log("quic: findmodelparams(): evol value obsolete!!!\n");
|
|
break;
|
|
default:
|
|
console.log("quic: findmodelparams(): evol out of range!!!\n");
|
|
}
|
|
|
|
this.n_buckets = 0;
|
|
var repcntr = this.repfirst + 1;
|
|
var bsize = this.firstsize;
|
|
|
|
do {
|
|
if (this.n_buckets) {
|
|
bstart = bend + 1;
|
|
} else {
|
|
bstart = 0;
|
|
}
|
|
|
|
if (!--repcntr) {
|
|
repcntr = this.repnext;
|
|
bsize *= this.mulsize;
|
|
}
|
|
|
|
bend = bstart + bsize - 1;
|
|
if (bend + bsize >= this.levels) {
|
|
bend = this.levels - 1;
|
|
}
|
|
|
|
if (!this.n_buckets_ptrs) {
|
|
this.n_buckets_ptrs = this.levels;
|
|
}
|
|
|
|
(this.n_buckets)++;
|
|
} while (bend < this.levels - 1);
|
|
}
|
|
|
|
QuicModel.prototype = {
|
|
n_buckets : 0,
|
|
n_buckets_ptrs : 0,
|
|
repfirst : 0,
|
|
firstsize : 0,
|
|
repnext : 0,
|
|
mulsize : 0,
|
|
levels :0
|
|
}
|
|
|
|
function QuicBucket()
|
|
{
|
|
this.counters = [0,0,0,0,0,0,0,0];
|
|
}
|
|
|
|
QuicBucket.prototype = {
|
|
bestcode: 0,
|
|
|
|
reste : function (bpp)
|
|
{
|
|
this.bestcode = bpp;
|
|
this.counters = [0,0,0,0,0,0,0,0];
|
|
},
|
|
|
|
update_model_8bpc : function (state, curval, bpp)
|
|
{
|
|
var i;
|
|
|
|
var bestcode = bpp - 1;
|
|
var bestcodelen = (this.counters[bestcode] += golomb_code_len_8bpc(curval, bestcode));
|
|
|
|
for (i = bpp - 2; i >= 0; i--) {
|
|
var ithcodelen = (this.counters[i] += golomb_code_len_8bpc(curval, i));
|
|
|
|
if (ithcodelen < bestcodelen) {
|
|
bestcode = i;
|
|
bestcodelen = ithcodelen;
|
|
}
|
|
}
|
|
|
|
this.bestcode = bestcode;
|
|
|
|
if (bestcodelen > state.wm_trigger) {
|
|
for (i = 0; i < bpp; i++) {
|
|
this.counters[i] = this.counters[i] >>> 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function QuicFamilyStat()
|
|
{
|
|
this.buckets_ptrs = [];
|
|
this.buckets_buf = [];
|
|
}
|
|
|
|
QuicFamilyStat.prototype = {
|
|
|
|
fill_model_structures : function(model)
|
|
{
|
|
var bstart;
|
|
var bend = 0;
|
|
var bnumber = 0;
|
|
|
|
var repcntr = model.repfirst + 1;
|
|
var bsize = model.firstsize;
|
|
|
|
do {
|
|
if (bnumber) {
|
|
bstart = bend + 1;
|
|
} else {
|
|
bstart = 0;
|
|
}
|
|
|
|
if (!--repcntr) {
|
|
repcntr = model.repnext;
|
|
bsize *= model.mulsize;
|
|
}
|
|
|
|
bend = bstart + bsize - 1;
|
|
if (bend + bsize >= model.levels) {
|
|
bend = model.levels - 1;
|
|
}
|
|
|
|
this.buckets_buf[bnumber] = new QuicBucket;
|
|
|
|
var i;
|
|
for (i = bstart; i <= bend; i++) {
|
|
this.buckets_ptrs[i] = this.buckets_buf[bnumber];
|
|
}
|
|
|
|
bnumber++;
|
|
} while (bend < model.levels - 1);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
function QuicChannel(model_8bpc, model_5bpc)
|
|
{
|
|
this.state = new CommonState;
|
|
this.family_stat_8bpc = new QuicFamilyStat;
|
|
this.family_stat_5bpc = new QuicFamilyStat;
|
|
this.correlate_row = { zero: 0 , row:[] };
|
|
this.model_8bpc = model_8bpc;
|
|
this.model_5bpc = model_5bpc;
|
|
this.buckets_ptrs = [];
|
|
|
|
if (!this.family_stat_8bpc.fill_model_structures(this.model_8bpc))
|
|
return undefined;
|
|
|
|
if (!this.family_stat_5bpc.fill_model_structures(this.model_5bpc))
|
|
return undefined;
|
|
}
|
|
|
|
QuicChannel.prototype = {
|
|
|
|
reste : function (bpc)
|
|
{
|
|
var j;
|
|
this.correlate_row = { zero: 0 , row: []};
|
|
|
|
if (bpc == 8) {
|
|
for (j = 0; j < this.model_8bpc.n_buckets; j++)
|
|
this.family_stat_8bpc.buckets_buf[j].reste(7);
|
|
this.buckets_ptrs = this.family_stat_8bpc.buckets_ptrs;
|
|
} else if (bpc == 5) {
|
|
for (j = 0; j < this.model_5bpc.n_buckets; j++)
|
|
this.family_stat_8bpc.buckets_buf[j].reste(4);
|
|
this.buckets_ptrs = this.family_stat_5bpc.buckets_ptrs;
|
|
} else {
|
|
console.log("quic: %s: bad bpc %d\n", __FUNCTION__, bpc);
|
|
return false;
|
|
}
|
|
|
|
this.state.reste();
|
|
return true;
|
|
}
|
|
}
|
|
|
|
function CommonState()
|
|
{
|
|
}
|
|
|
|
CommonState.prototype = {
|
|
waitcnt: 0,
|
|
tabrand_seed: 0xff,
|
|
wm_trigger: 0,
|
|
wmidx: 0,
|
|
wmileft: wminext,
|
|
melcstate: 0,
|
|
melclen: 0,
|
|
melcorder: 0,
|
|
|
|
set_wm_trigger : function()
|
|
{
|
|
var wm = this.wmidx;
|
|
if (wm > 10) {
|
|
wm = 10;
|
|
}
|
|
|
|
this.wm_trigger = besttrigtab[Math.floor(evol / 2)][wm];
|
|
},
|
|
|
|
reste : function()
|
|
{
|
|
this.waitcnt = 0;
|
|
this.tabrand_seed = 0x0ff;
|
|
this.wmidx = 0;
|
|
this.wmileft = wminext;
|
|
|
|
this.set_wm_trigger();
|
|
|
|
this.melcstate = 0;
|
|
this.melclen = J[0];
|
|
this.melcorder = 1 << this.melclen;
|
|
},
|
|
|
|
tabrand : function()
|
|
{
|
|
this.tabrand_seed++;
|
|
return tabrand_chaos[this.tabrand_seed & 0x0ff];
|
|
}
|
|
}
|
|
|
|
|
|
function QuicEncoder()
|
|
{
|
|
this.rgb_state = new CommonState;
|
|
this.model_8bpc = new QuicModel(8);
|
|
this.model_5bpc = new QuicModel(5);
|
|
this.channels = [];
|
|
|
|
var i;
|
|
for (i = 0; i < 4; i++) {
|
|
this.channels[i] = new QuicChannel(this.model_8bpc, this.model_5bpc);
|
|
if (!this.channels[i])
|
|
{
|
|
console.log("quic: failed to create channel");
|
|
return undefined;
|
|
}
|
|
}
|
|
}
|
|
|
|
QuicEncoder.prototype = {
|
|
type: 0,
|
|
width: 0,
|
|
height: 0,
|
|
io_idx: 0,
|
|
io_available_bits: 0,
|
|
io_word: 0,
|
|
io_next_word: 0,
|
|
io_now: 0,
|
|
io_end: 0,
|
|
rows_completed: 0,
|
|
};
|
|
|
|
QuicEncoder.prototype.reste = function(io_ptr)
|
|
{
|
|
this.rgb_state.reste();
|
|
|
|
this.io_now = io_ptr;
|
|
this.io_end = this.io_now.length;
|
|
this.io_idx = 0;
|
|
this.rows_completed = 0;
|
|
return true;
|
|
}
|
|
|
|
QuicEncoder.prototype.read_io_word = function()
|
|
{
|
|
if (this.io_idx >= this.io_end)
|
|
throw("quic: out of data");
|
|
this.io_next_word = this.io_now[this.io_idx++] | this.io_now[this.io_idx++]<<8 | this.io_now[this.io_idx++]<<16 | this.io_now[this.io_idx++]<<24;
|
|
}
|
|
|
|
QuicEncoder.prototype.decode_eatbits = function (len)
|
|
{
|
|
this.io_word = this.io_word << len;
|
|
|
|
var delta = (this.io_available_bits - len);
|
|
if (delta >= 0)
|
|
{
|
|
this.io_available_bits = delta;
|
|
this.io_word |= this.io_next_word >>> this.io_available_bits;
|
|
}
|
|
else
|
|
{
|
|
delta = -1 * delta;
|
|
this.io_word |= this.io_next_word << delta;
|
|
this.read_io_word();
|
|
this.io_available_bits = 32 - delta;
|
|
this.io_word |= this.io_next_word >>> this.io_available_bits;
|
|
}
|
|
}
|
|
|
|
QuicEncoder.prototype.decode_eat32bits = function()
|
|
{
|
|
this.decode_eatbits(16);
|
|
this.decode_eatbits(16);
|
|
}
|
|
|
|
QuicEncoder.prototype.reste_channels = function(bpc)
|
|
{
|
|
var i;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
if (!this.channels[i].reste(bpc))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
QuicEncoder.prototype.quic_decode_begin = function(io_ptr)
|
|
{
|
|
if (!this.reste(io_ptr)) {
|
|
return false;
|
|
}
|
|
|
|
this.io_idx = 0;
|
|
this.io_next_word = this.io_now[this.io_idx++] | this.io_now[this.io_idx++]<<8 | this.io_now[this.io_idx++]<<16 | this.io_now[this.io_idx++]<<24;
|
|
this.io_word = this.io_next_word;
|
|
this.io_available_bits = 0;
|
|
|
|
var magic = this.io_word;
|
|
this.decode_eat32bits();
|
|
if (magic != 0x43495551) /*QUIC*/ {
|
|
console.log("quic: bad magic "+magic.toString(16));
|
|
return false;
|
|
}
|
|
|
|
var version = this.io_word;
|
|
this.decode_eat32bits();
|
|
if (version != ((0 << 16) | (0 & 0xffff))) {
|
|
console.log("quic: bad version "+version.toString(16));
|
|
return false;
|
|
}
|
|
|
|
this.type = this.io_word;
|
|
this.decode_eat32bits();
|
|
|
|
this.width = this.io_word;
|
|
this.decode_eat32bits();
|
|
|
|
this.height = this.io_word;
|
|
this.decode_eat32bits();
|
|
|
|
var bpc = quic_image_bpc(this.type);
|
|
|
|
if (!this.reste_channels(bpc))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
QuicEncoder.prototype.quic_rgb32_uncompress_row0_seg = function (i, cur_row, end,
|
|
waitmask, bpc, bpc_mask)
|
|
{
|
|
var stopidx;
|
|
var n_channels = 3;
|
|
var c;
|
|
var a;
|
|
|
|
if (!i) {
|
|
cur_row[rgb32_pixel_pad] = 0;
|
|
c = 0;
|
|
do
|
|
{
|
|
a = golomb_decoding_8bpc(this.channels[c].buckets_ptrs[this.channels[c].correlate_row.zero].bestcode, this.io_word);
|
|
this.channels[c].correlate_row.row[0] = a.rc;
|
|
cur_row[2-c] = (family_8bpc.xlatL2U[a.rc]&0xFF);
|
|
this.decode_eatbits(a.codewordlen);
|
|
} while (++c < n_channels);
|
|
|
|
if (this.rgb_state.waitcnt) {
|
|
--this.rgb_state.waitcnt;
|
|
} else {
|
|
this.rgb_state.waitcnt = (this.rgb_state.tabrand() & waitmask);
|
|
c = 0;
|
|
do
|
|
{
|
|
this.channels[c].buckets_ptrs[this.channels[c].correlate_row.zero].update_model_8bpc(this.rgb_state, this.channels[c].correlate_row.row[0], bpc);
|
|
} while (++c < n_channels);
|
|
}
|
|
stopidx = ++i + this.rgb_state.waitcnt;
|
|
} else {
|
|
stopidx = i + this.rgb_state.waitcnt;
|
|
}
|
|
|
|
while (stopidx < end) {
|
|
for (; i <= stopidx; i++) {
|
|
cur_row[(i* rgb32_pixel_size)+rgb32_pixel_pad] = 0;
|
|
c = 0;
|
|
do
|
|
{
|
|
a = golomb_decoding_8bpc(this.channels[c].buckets_ptrs[this.channels[c].correlate_row.row[i - 1]].bestcode, this.io_word);
|
|
this.channels[c].correlate_row.row[i] = a.rc;
|
|
cur_row[(i* rgb32_pixel_size)+(2-c)] = (family_8bpc.xlatL2U[a.rc] + cur_row[((i-1) * rgb32_pixel_size) + (2-c)]) & bpc_mask;
|
|
this.decode_eatbits(a.codewordlen);
|
|
} while (++c < n_channels);
|
|
}
|
|
c = 0;
|
|
do
|
|
{
|
|
this.channels[c].buckets_ptrs[this.channels[c].correlate_row.row[stopidx - 1]].update_model_8bpc(this.rgb_state, this.channels[c].correlate_row.row[stopidx], bpc);
|
|
} while (++c < n_channels);
|
|
stopidx = i + (this.rgb_state.tabrand() & waitmask);
|
|
}
|
|
|
|
for (; i < end; i++) {
|
|
cur_row[(i* rgb32_pixel_size)+rgb32_pixel_pad] = 0;
|
|
c = 0;
|
|
do
|
|
{
|
|
a = golomb_decoding_8bpc(this.channels[c].buckets_ptrs[this.channels[c].correlate_row.row[i - 1]].bestcode, this.io_word);
|
|
this.channels[c].correlate_row.row[i] = a.rc;
|
|
cur_row[(i* rgb32_pixel_size)+(2-c)] = (family_8bpc.xlatL2U[a.rc] + cur_row[((i-1) * rgb32_pixel_size) + (2-c)]) & bpc_mask;
|
|
this.decode_eatbits(a.codewordlen);
|
|
} while (++c < n_channels);
|
|
}
|
|
this.rgb_state.waitcnt = stopidx - end;
|
|
}
|
|
|
|
QuicEncoder.prototype.quic_rgb32_uncompress_row0 = function (cur_row)
|
|
{
|
|
var bpc = 8;
|
|
var bpc_mask = 0xff;
|
|
var pos = 0;
|
|
var width = this.width;
|
|
|
|
while ((wmimax > this.rgb_state.wmidx) && (this.rgb_state.wmileft <= width)) {
|
|
if (this.rgb_state.wmileft) {
|
|
this.quic_rgb32_uncompress_row0_seg(pos, cur_row,
|
|
pos + this.rgb_state.wmileft,
|
|
bppmask[this.rgb_state.wmidx],
|
|
bpc, bpc_mask);
|
|
pos += this.rgb_state.wmileft;
|
|
width -= this.rgb_state.wmileft;
|
|
}
|
|
|
|
this.rgb_state.wmidx++;
|
|
this.rgb_state.set_wm_trigger();
|
|
this.rgb_state.wmileft = wminext;
|
|
}
|
|
|
|
if (width) {
|
|
this.quic_rgb32_uncompress_row0_seg(pos, cur_row, pos + width,
|
|
bppmask[this.rgb_state.wmidx], bpc, bpc_mask);
|
|
if (wmimax > this.rgb_state.wmidx) {
|
|
this.rgb_state.wmileft -= width;
|
|
}
|
|
}
|
|
}
|
|
|
|
QuicEncoder.prototype.quic_rgb32_uncompress_row_seg = function( prev_row, cur_row, i, end, bpc, bpc_mask)
|
|
{
|
|
var n_channels = 3;
|
|
var waitmask = bppmask[this.rgb_state.wmidx];
|
|
|
|
var a;
|
|
var run_index = 0;
|
|
var stopidx = 0;
|
|
var run_end = 0;
|
|
var c;
|
|
|
|
if (!i)
|
|
{
|
|
cur_row[rgb32_pixel_pad] = 0;
|
|
|
|
c = 0;
|
|
do {
|
|
a = golomb_decoding_8bpc(this.channels[c].buckets_ptrs[this.channels[c].correlate_row.zero].bestcode, this.io_word);
|
|
this.channels[c].correlate_row.row[0] = a.rc;
|
|
cur_row[2-c] = (family_8bpc.xlatL2U[this.channels[c].correlate_row.row[0]] + prev_row[2-c]) & bpc_mask;
|
|
this.decode_eatbits(a.codewordlen);
|
|
} while (++c < n_channels);
|
|
|
|
if (this.rgb_state.waitcnt) {
|
|
--this.rgb_state.waitcnt;
|
|
} else {
|
|
this.rgb_state.waitcnt = (this.rgb_state.tabrand() & waitmask);
|
|
c = 0;
|
|
do {
|
|
this.channels[c].buckets_ptrs[this.channels[c].correlate_row.zero].update_model_8bpc(this.rgb_state, this.channels[c].correlate_row.row[0], bpc);
|
|
} while (++c < n_channels);
|
|
}
|
|
stopidx = ++i + this.rgb_state.waitcnt;
|
|
} else {
|
|
stopidx = i + this.rgb_state.waitcnt;
|
|
}
|
|
for (;;) {
|
|
var rc = 0;
|
|
while (stopidx < end && !rc) {
|
|
for (; i <= stopidx && !rc; i++) {
|
|
var pixel = i * rgb32_pixel_size;
|
|
var pixelm1 = (i-1) * rgb32_pixel_size;
|
|
var pixelm2 = (i-2) * rgb32_pixel_size;
|
|
|
|
if ( prev_row[pixelm1+rgb32_pixel_r] == prev_row[pixel+rgb32_pixel_r] && prev_row[pixelm1+rgb32_pixel_g] == prev_row[pixel+rgb32_pixel_g] && prev_row[pixelm1 + rgb32_pixel_b] == prev_row[pixel+rgb32_pixel_b])
|
|
{
|
|
if (run_index != i && i > 2 && (cur_row[pixelm1+rgb32_pixel_r] == cur_row[pixelm2+rgb32_pixel_r] && cur_row[pixelm1+rgb32_pixel_g] == cur_row[pixelm2+rgb32_pixel_g] && cur_row[pixelm1+rgb32_pixel_b] == cur_row[pixelm2+rgb32_pixel_b]))
|
|
{
|
|
/* do run */
|
|
this.rgb_state.waitcnt = stopidx - i;
|
|
run_index = i;
|
|
run_end = i + this.decode_run(this.rgb_state);
|
|
|
|
for (; i < run_end; i++) {
|
|
var pixel = i * rgb32_pixel_size;
|
|
var pixelm1 = (i-1) * rgb32_pixel_size;
|
|
cur_row[pixel+rgb32_pixel_pad] = 0;
|
|
cur_row[pixel+rgb32_pixel_r] = cur_row[pixelm1+rgb32_pixel_r];
|
|
cur_row[pixel+rgb32_pixel_g] = cur_row[pixelm1+rgb32_pixel_g];
|
|
cur_row[pixel+rgb32_pixel_b] = cur_row[pixelm1+rgb32_pixel_b];
|
|
}
|
|
|
|
if (i == end) {
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
stopidx = i + this.rgb_state.waitcnt;
|
|
rc = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
c = 0;
|
|
cur_row[pixel+rgb32_pixel_pad] = 0;
|
|
do {
|
|
var cc = this.channels[c];
|
|
var cr = cc.correlate_row;
|
|
|
|
a = golomb_decoding_8bpc(cc.buckets_ptrs[cr.row[i-1]].bestcode, this.io_word);
|
|
cr.row[i] = a.rc;
|
|
cur_row[pixel+(2-c)] = (family_8bpc.xlatL2U[a.rc] + ((cur_row[pixelm1+(2-c)] + prev_row[pixel+(2-c)]) >> 1)) & bpc_mask;
|
|
this.decode_eatbits(a.codewordlen);
|
|
} while (++c < n_channels);
|
|
}
|
|
if (rc)
|
|
break;
|
|
|
|
c = 0;
|
|
do {
|
|
this.channels[c].buckets_ptrs[this.channels[c].correlate_row.row[stopidx - 1]].update_model_8bpc(this.rgb_state, this.channels[c].correlate_row.row[stopidx], bpc);
|
|
} while (++c < n_channels);
|
|
|
|
stopidx = i + (this.rgb_state.tabrand() & waitmask);
|
|
}
|
|
|
|
for (; i < end && !rc; i++) {
|
|
var pixel = i * rgb32_pixel_size;
|
|
var pixelm1 = (i-1) * rgb32_pixel_size;
|
|
var pixelm2 = (i-2) * rgb32_pixel_size;
|
|
|
|
if (prev_row[pixelm1+rgb32_pixel_r] == prev_row[pixel+rgb32_pixel_r] && prev_row[pixelm1+rgb32_pixel_g] == prev_row[pixel+rgb32_pixel_g] && prev_row[pixelm1+rgb32_pixel_b] == prev_row[pixel+rgb32_pixel_b])
|
|
{
|
|
if (run_index != i && i > 2 && (cur_row[pixelm1+rgb32_pixel_r] == cur_row[pixelm2+rgb32_pixel_r] && cur_row[pixelm1+rgb32_pixel_g] == cur_row[pixelm2+rgb32_pixel_g] && cur_row[pixelm1+rgb32_pixel_b] == cur_row[pixelm2+rgb32_pixel_b]))
|
|
{
|
|
/* do run */
|
|
this.rgb_state.waitcnt = stopidx - i;
|
|
run_index = i;
|
|
run_end = i + this.decode_run(this.rgb_state);
|
|
|
|
for (; i < run_end; i++) {
|
|
var pixel = i * rgb32_pixel_size;
|
|
var pixelm1 = (i-1) * rgb32_pixel_size;
|
|
cur_row[pixel+rgb32_pixel_pad] = 0;
|
|
cur_row[pixel+rgb32_pixel_r] = cur_row[pixelm1+rgb32_pixel_r];
|
|
cur_row[pixel+rgb32_pixel_g] = cur_row[pixelm1+rgb32_pixel_g];
|
|
cur_row[pixel+rgb32_pixel_b] = cur_row[pixelm1+rgb32_pixel_b];
|
|
}
|
|
|
|
if (i == end) {
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
stopidx = i + this.rgb_state.waitcnt;
|
|
rc = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
cur_row[pixel+rgb32_pixel_pad] = 0;
|
|
c = 0;
|
|
do
|
|
{
|
|
a = golomb_decoding_8bpc(this.channels[c].buckets_ptrs[this.channels[c].correlate_row.row[i-1]].bestcode, this.io_word);
|
|
this.channels[c].correlate_row.row[i] = a.rc;
|
|
cur_row[pixel+(2-c)] = (family_8bpc.xlatL2U[a.rc] + ((cur_row[pixelm1+(2-c)] + prev_row[pixel+(2-c)]) >> 1)) & bpc_mask;
|
|
this.decode_eatbits(a.codewordlen);
|
|
} while (++c < n_channels);
|
|
}
|
|
|
|
if (!rc)
|
|
{
|
|
this.rgb_state.waitcnt = stopidx - end;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
QuicEncoder.prototype.decode_run = function(state)
|
|
{
|
|
var runlen = 0;
|
|
|
|
do {
|
|
var hits;
|
|
var x = (~(this.io_word >>> 24)>>>0)&0xff;
|
|
var temp = zeroLUT[x];
|
|
|
|
for (hits = 1; hits <= temp; hits++) {
|
|
runlen += state.melcorder;
|
|
|
|
if (state.melcstate < 32) {
|
|
state.melclen = J[++state.melcstate];
|
|
state.melcorder = (1 << state.melclen);
|
|
}
|
|
}
|
|
if (temp != 8) {
|
|
this.decode_eatbits(temp + 1);
|
|
|
|
break;
|
|
}
|
|
this.decode_eatbits(8);
|
|
} while (true);
|
|
|
|
if (state.melclen) {
|
|
runlen += this.io_word >>> (32 - state.melclen);
|
|
this.decode_eatbits(state.melclen);
|
|
}
|
|
|
|
if (state.melcstate) {
|
|
state.melclen = J[--state.melcstate];
|
|
state.melcorder = (1 << state.melclen);
|
|
}
|
|
|
|
return runlen;
|
|
}
|
|
|
|
QuicEncoder.prototype.quic_rgb32_uncompress_row = function (prev_row, cur_row)
|
|
{
|
|
var bpc = 8;
|
|
var bpc_mask = 0xff;
|
|
var pos = 0;
|
|
var width = this.width;
|
|
|
|
while ((wmimax > this.rgb_state.wmidx) && (this.rgb_state.wmileft <= width)) {
|
|
if (this.rgb_state.wmileft) {
|
|
this.quic_rgb32_uncompress_row_seg(prev_row, cur_row, pos,
|
|
pos + this.rgb_state.wmileft, bpc, bpc_mask);
|
|
pos += this.rgb_state.wmileft;
|
|
width -= this.rgb_state.wmileft;
|
|
}
|
|
|
|
this.rgb_state.wmidx++;
|
|
this.rgb_state.set_wm_trigger();
|
|
this.rgb_state.wmileft = wminext;
|
|
}
|
|
|
|
if (width) {
|
|
this.quic_rgb32_uncompress_row_seg(prev_row, cur_row, pos,
|
|
pos + width, bpc, bpc_mask);
|
|
if (wmimax > this.rgb_state.wmidx) {
|
|
this.rgb_state.wmileft -= width;
|
|
}
|
|
}
|
|
}
|
|
|
|
QuicEncoder.prototype.quic_four_uncompress_row0_seg = function (channel, i,
|
|
correlate_row, cur_row, end, waitmask,
|
|
bpc, bpc_mask)
|
|
{
|
|
var stopidx;
|
|
var a;
|
|
|
|
if (i == 0) {
|
|
a = golomb_decoding_8bpc(channel.buckets_ptrs[correlate_row.zero].bestcode, this.io_word);
|
|
correlate_row.row[0] = a.rc;
|
|
cur_row[rgb32_pixel_pad] = family_8bpc.xlatL2U[a.rc];
|
|
this.decode_eatbits(a.codewordlen);
|
|
|
|
if (channel.state.waitcnt) {
|
|
--channel.state.waitcnt;
|
|
} else {
|
|
channel.state.waitcnt = (channel.state.tabrand() & waitmask);
|
|
channel.buckets_ptrs[correlate_row.zero].update_model_8bpc(channel.state, correlate_row.row[0], bpc);
|
|
}
|
|
stopidx = ++i + channel.state.waitcnt;
|
|
} else {
|
|
stopidx = i + channel.state.waitcnt;
|
|
}
|
|
|
|
while (stopidx < end) {
|
|
var pbucket;
|
|
|
|
for (; i <= stopidx; i++) {
|
|
pbucket = channel.buckets_ptrs[correlate_row.row[i - 1]];
|
|
|
|
a = golomb_decoding_8bpc(pbucket.bestcode, this.io_word);
|
|
correlate_row.row[i] = a.rc;
|
|
cur_row[(i*rgb32_pixel_size)+rgb32_pixel_pad] = (family_8bpc.xlatL2U[a.rc] + cur_row[((i-1)*rgb32_pixel_size)+rgb32_pixel_pad]) & bpc_mask;
|
|
this.decode_eatbits(a.codewordlen);
|
|
}
|
|
|
|
pbucket.update_model_8bpc(channel.state, correlate_row.row[stopidx], bpc);
|
|
|
|
stopidx = i + (channel.state.tabrand() & waitmask);
|
|
}
|
|
|
|
for (; i < end; i++) {
|
|
a = golomb_decoding_8bpc(channel.buckets_ptrs[correlate_row.row[i-1]].bestcode, this.io_word);
|
|
|
|
correlate_row.row[i] = a.rc;
|
|
cur_row[(i*rgb32_pixel_size)+rgb32_pixel_pad] = (family_8bpc.xlatL2U[a.rc] + cur_row[((i-1)*rgb32_pixel_size)+rgb32_pixel_pad]) & bpc_mask;
|
|
this.decode_eatbits(a.codewordlen);
|
|
}
|
|
channel.state.waitcnt = stopidx - end;
|
|
}
|
|
|
|
QuicEncoder.prototype.quic_four_uncompress_row0 = function(channel, cur_row)
|
|
{
|
|
var bpc = 8;
|
|
var bpc_mask = 0xff;
|
|
var correlate_row = channel.correlate_row;
|
|
var pos = 0;
|
|
var width = this.width;
|
|
|
|
while ((wmimax > channel.state.wmidx) && (channel.state.wmileft <= width)) {
|
|
if (channel.state.wmileft) {
|
|
this.quic_four_uncompress_row0_seg(channel, pos, correlate_row, cur_row,
|
|
pos + channel.state.wmileft, bppmask[channel.state.wmidx],
|
|
bpc, bpc_mask);
|
|
pos += channel.state.wmileft;
|
|
width -= channel.state.wmileft;
|
|
}
|
|
|
|
channel.state.wmidx++;
|
|
channel.state.set_wm_trigger();
|
|
channel.state.wmileft = wminext;
|
|
}
|
|
|
|
if (width) {
|
|
this.quic_four_uncompress_row0_seg(channel, pos, correlate_row, cur_row, pos + width,
|
|
bppmask[channel.state.wmidx], bpc, bpc_mask);
|
|
if (wmimax > channel.state.wmidx) {
|
|
channel.state.wmileft -= width;
|
|
}
|
|
}
|
|
}
|
|
|
|
QuicEncoder.prototype.quic_four_uncompress_row_seg = function (channel,
|
|
correlate_row, prev_row, cur_row, i,
|
|
end, bpc, bpc_mask)
|
|
{
|
|
var waitmask = bppmask[channel.state.wmidx];
|
|
var stopidx;
|
|
|
|
var run_index = 0;
|
|
var run_end;
|
|
|
|
var a;
|
|
|
|
if (i == 0) {
|
|
a = golomb_decoding_8bpc(channel.buckets_ptrs[correlate_row.zero].bestcode, this.io_word);
|
|
|
|
correlate_row.row[0] = a.rc
|
|
cur_row[rgb32_pixel_pad] = (family_8bpc.xlatL2U[a.rc] + prev_row[rgb32_pixel_pad]) & bpc_mask;
|
|
this.decode_eatbits(a.codewordlen);
|
|
|
|
if (channel.state.waitcnt) {
|
|
--channel.state.waitcnt;
|
|
} else {
|
|
channel.state.waitcnt = (channel.state.tabrand() & waitmask);
|
|
channel.buckets_ptrs[correlate_row.zero].update_model_8bpc(channel.state, correlate_row.row[0], bpc);
|
|
}
|
|
stopidx = ++i + channel.state.waitcnt;
|
|
} else {
|
|
stopidx = i + channel.state.waitcnt;
|
|
}
|
|
for (;;) {
|
|
var rc = 0;
|
|
while (stopidx < end && !rc) {
|
|
var pbucket;
|
|
for (; i <= stopidx && !rc; i++) {
|
|
var pixel = i * rgb32_pixel_size;
|
|
var pixelm1 = (i-1) * rgb32_pixel_size;
|
|
var pixelm2 = (i-2) * rgb32_pixel_size;
|
|
|
|
if (prev_row[pixelm1+rgb32_pixel_pad] == prev_row[pixel+rgb32_pixel_pad])
|
|
{
|
|
if (run_index != i && i > 2 && cur_row[pixelm1+rgb32_pixel_pad] == cur_row[pixelm2+rgb32_pixel_pad])
|
|
{
|
|
/* do run */
|
|
channel.state.waitcnt = stopidx - i;
|
|
run_index = i;
|
|
|
|
run_end = i + this.decode_run(channel.state);
|
|
|
|
for (; i < run_end; i++) {
|
|
var pixel = i * rgb32_pixel_size;
|
|
var pixelm1 = (i-1) * rgb32_pixel_size;
|
|
cur_row[pixel+rgb32_pixel_pad] = cur_row[pixelm1+rgb32_pixel_pad];
|
|
}
|
|
|
|
if (i == end) {
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
stopidx = i + channel.state.waitcnt;
|
|
rc = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
pbucket = channel.buckets_ptrs[correlate_row.row[i - 1]];
|
|
a = golomb_decoding_8bpc(pbucket.bestcode, this.io_word);
|
|
correlate_row.row[i] = a.rc
|
|
cur_row[pixel+rgb32_pixel_pad] = (family_8bpc.xlatL2U[a.rc] + ((cur_row[pixelm1+rgb32_pixel_pad] + prev_row[pixel+rgb32_pixel_pad]) >> 1)) & bpc_mask;
|
|
this.decode_eatbits(a.codewordlen);
|
|
}
|
|
if (rc)
|
|
break;
|
|
|
|
pbucket.update_model_8bpc(channel.state, correlate_row.row[stopidx], bpc);
|
|
|
|
stopidx = i + (channel.state.tabrand() & waitmask);
|
|
}
|
|
|
|
for (; i < end && !rc; i++) {
|
|
var pixel = i * rgb32_pixel_size;
|
|
var pixelm1 = (i-1) * rgb32_pixel_size;
|
|
var pixelm2 = (i-2) * rgb32_pixel_size;
|
|
if (prev_row[pixelm1+rgb32_pixel_pad] == prev_row[pixel+rgb32_pixel_pad])
|
|
{
|
|
if (run_index != i && i > 2 && cur_row[pixelm1+rgb32_pixel_pad] == cur_row[pixelm2+rgb32_pixel_pad])
|
|
{
|
|
/* do run */
|
|
channel.state.waitcnt = stopidx - i;
|
|
run_index = i;
|
|
|
|
run_end = i + this.decode_run(channel.state);
|
|
|
|
for (; i < run_end; i++) {
|
|
var pixel = i * rgb32_pixel_size;
|
|
var pixelm1 = (i-1) * rgb32_pixel_size;
|
|
cur_row[pixel+rgb32_pixel_pad] = cur_row[pixelm1+rgb32_pixel_pad];
|
|
}
|
|
|
|
if (i == end) {
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
stopidx = i + channel.state.waitcnt;
|
|
rc = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
a = golomb_decoding_8bpc(channel.buckets_ptrs[correlate_row.row[i-1]].bestcode, this.io_word);
|
|
correlate_row.row[i] = a.rc;
|
|
cur_row[pixel+rgb32_pixel_pad] = (family_8bpc.xlatL2U[a.rc] + ((cur_row[pixelm1+rgb32_pixel_pad] + prev_row[pixel+rgb32_pixel_pad]) >> 1)) & bpc_mask;
|
|
this.decode_eatbits(a.codewordlen);
|
|
}
|
|
|
|
if (!rc)
|
|
{
|
|
channel.state.waitcnt = stopidx - end;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
QuicEncoder.prototype.quic_four_uncompress_row = function(channel, prev_row,
|
|
cur_row)
|
|
{
|
|
var bpc = 8;
|
|
var bpc_mask = 0xff;
|
|
var correlate_row = channel.correlate_row;
|
|
var pos = 0;
|
|
var width = this.width;
|
|
|
|
while ((wmimax > channel.state.wmidx) && (channel.state.wmileft <= width)) {
|
|
if (channel.state.wmileft) {
|
|
this.quic_four_uncompress_row_seg(channel, correlate_row, prev_row, cur_row, pos,
|
|
pos + channel.state.wmileft, bpc, bpc_mask);
|
|
pos += channel.state.wmileft;
|
|
width -= channel.state.wmileft;
|
|
}
|
|
|
|
channel.state.wmidx++;
|
|
channel.state.set_wm_trigger();
|
|
channel.state.wmileft = wminext;
|
|
}
|
|
|
|
if (width) {
|
|
this.quic_four_uncompress_row_seg(channel, correlate_row, prev_row, cur_row, pos,
|
|
pos + width, bpc, bpc_mask);
|
|
if (wmimax > channel.state.wmidx) {
|
|
channel.state.wmileft -= width;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* We need to be generating rgb32 or rgba */
|
|
QuicEncoder.prototype.quic_decode = function(buf, stride)
|
|
{
|
|
var row;
|
|
|
|
switch (this.type)
|
|
{
|
|
case QUIC_IMAGE_TYPE_RGB32:
|
|
case QUIC_IMAGE_TYPE_RGB24:
|
|
this.channels[0].correlate_row.zero = 0;
|
|
this.channels[1].correlate_row.zero = 0;
|
|
this.channels[2].correlate_row.zero = 0;
|
|
this.quic_rgb32_uncompress_row0(buf);
|
|
|
|
this.rows_completed++;
|
|
for (row = 1; row < this.height; row++)
|
|
{
|
|
var prev = buf;
|
|
buf = prev.subarray(stride);
|
|
this.channels[0].correlate_row.zero = this.channels[0].correlate_row.row[0];
|
|
this.channels[1].correlate_row.zero = this.channels[1].correlate_row.row[0];
|
|
this.channels[2].correlate_row.zero = this.channels[2].correlate_row.row[0];
|
|
this.quic_rgb32_uncompress_row(prev, buf);
|
|
this.rows_completed++;
|
|
};
|
|
break;
|
|
case QUIC_IMAGE_TYPE_RGB16:
|
|
console.log("quic: unsupported output format\n");
|
|
return false;
|
|
break;
|
|
case QUIC_IMAGE_TYPE_RGBA:
|
|
this.channels[0].correlate_row.zero = 0;
|
|
this.channels[1].correlate_row.zero = 0;
|
|
this.channels[2].correlate_row.zero = 0;
|
|
this.quic_rgb32_uncompress_row0(buf);
|
|
|
|
this.channels[3].correlate_row.zero = 0;
|
|
this.quic_four_uncompress_row0(this.channels[3], buf);
|
|
|
|
this.rows_completed++;
|
|
for (row = 1; row < this.height; row++) {
|
|
var prev = buf;
|
|
buf = prev.subarray(stride);
|
|
|
|
this.channels[0].correlate_row.zero = this.channels[0].correlate_row.row[0];
|
|
this.channels[1].correlate_row.zero = this.channels[1].correlate_row.row[0];
|
|
this.channels[2].correlate_row.zero = this.channels[2].correlate_row.row[0];
|
|
this.quic_rgb32_uncompress_row(prev, buf);
|
|
|
|
this.channels[3].correlate_row.zero = this.channels[3].correlate_row.row[0];
|
|
this.quic_four_uncompress_row(encoder.channels[3], prev, buf);
|
|
this.rows_completed++;
|
|
}
|
|
break;
|
|
|
|
case QUIC_IMAGE_TYPE_GRAY:
|
|
console.log("quic: unsupported output format\n");
|
|
return false;
|
|
break;
|
|
|
|
case QUIC_IMAGE_TYPE_INVALID:
|
|
default:
|
|
console.log("quic: bad image type\n");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
QuicEncoder.prototype.simple_quic_decode = function(buf)
|
|
{
|
|
var stride = 4; /* FIXME - proper stride calc please */
|
|
if (!this.quic_decode_begin(buf))
|
|
return undefined;
|
|
if (this.type != QUIC_IMAGE_TYPE_RGB32 && this.type != QUIC_IMAGE_TYPE_RGB24
|
|
&& this.type != QUIC_IMAGE_TYPE_RGBA)
|
|
return undefined;
|
|
var out = new Uint8Array(this.width*this.height*4);
|
|
out[0] = 69;
|
|
if (this.quic_decode( out, (this.width * stride)))
|
|
return out;
|
|
return undefined;
|
|
}
|
|
|
|
function SpiceQuic()
|
|
{
|
|
}
|
|
|
|
SpiceQuic.prototype =
|
|
{
|
|
from_dv: function(dv, at, mb)
|
|
{
|
|
if (!encoder)
|
|
throw("quic: no quic encoder");
|
|
this.data_size = dv.getUint32(at, true);
|
|
at += 4;
|
|
var buf = new Uint8Array(mb.slice(at));
|
|
this.outptr = encoder.simple_quic_decode(buf);
|
|
if (this.outptr)
|
|
{
|
|
this.type = encoder.type;
|
|
this.width = encoder.width;
|
|
this.height = encoder.height;
|
|
}
|
|
at += buf.length;
|
|
return at;
|
|
},
|
|
}
|
|
|
|
function convert_spice_quic_to_web(context, spice_quic)
|
|
{
|
|
var ret = context.createImageData(spice_quic.width, spice_quic.height);
|
|
var i;
|
|
for (i = 0; i < (ret.width * ret.height * 4); i+=4)
|
|
{
|
|
ret.data[i + 0] = spice_quic.outptr[i + 2];
|
|
ret.data[i + 1] = spice_quic.outptr[i + 1];
|
|
ret.data[i + 2] = spice_quic.outptr[i + 0];
|
|
if (spice_quic.type !== QUIC_IMAGE_TYPE_RGBA)
|
|
ret.data[i + 3] = 255;
|
|
else
|
|
ret.data[i + 3] = 255 - spice_quic.outptr[i + 3];
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* Module initialization */
|
|
if (need_init)
|
|
{
|
|
need_init = false;
|
|
|
|
family_init(family_8bpc, 8, DEFmaxclen);
|
|
family_init(family_5bpc, 5, DEFmaxclen);
|
|
/* init_zeroLUT */
|
|
var i, j, k, l;
|
|
|
|
j = k = 1;
|
|
l = 8;
|
|
for (i = 0; i < 256; ++i) {
|
|
zeroLUT[i] = l;
|
|
--k;
|
|
if (k == 0) {
|
|
k = j;
|
|
--l;
|
|
j *= 2;
|
|
}
|
|
}
|
|
|
|
encoder = new QuicEncoder;
|
|
|
|
if (!encoder)
|
|
throw("quic: failed to create encoder");
|
|
}
|