mirror of
https://github.com/sorenisanerd/gotty.git
synced 2024-11-14 01:14:25 +00:00
3364 lines
99 KiB
JavaScript
3364 lines
99 KiB
JavaScript
|
/*
|
||
|
|
eyeOS Spice Web Client
|
||
|
|
Copyright (c) 2015 eyeOS S.L.
|
||
|
|
|
||
|
|
Contact Jose Carlos Norte (jose@eyeos.com) for more information about this software.
|
||
|
|
|
||
|
|
This program is free software; you can redistribute it and/or modify it under
|
||
|
|
the terms of the GNU Affero General Public License version 3 as published by the
|
||
|
|
Free Software Foundation.
|
||
|
|
|
||
|
|
This program 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 Affero General Public License for more
|
||
|
|
details.
|
||
|
|
|
||
|
|
You should have received a copy of the GNU Affero General Public License
|
||
|
|
version 3 along with this program in the file "LICENSE". If not, see
|
||
|
|
<http://www.gnu.org/licenses/agpl-3.0.txt>.
|
||
|
|
|
||
|
|
See www.eyeos.org for more details. All requests should be sent to licensing@eyeos.org
|
||
|
|
|
||
|
|
The interactive user interfaces in modified source and object code versions
|
||
|
|
of this program must display Appropriate Legal Notices, as required under
|
||
|
|
Section 5 of the GNU Affero General Public License version 3.
|
||
|
|
|
||
|
|
In accordance with Section 7(b) of the GNU Affero General Public License version 3,
|
||
|
|
these Appropriate Legal Notices must retain the display of the "Powered by
|
||
|
|
eyeos" logo and retain the original copyright notice. If the display of the
|
||
|
|
logo is not reasonably feasible for technical reasons, the Appropriate Legal Notices
|
||
|
|
must display the words "Powered by eyeos" and retain the original copyright notice.
|
||
|
|
*/
|
||
|
|
|
||
|
|
//Sandboxed script without access to other external functions, objects or anything.
|
||
|
|
//used for webworkers.
|
||
|
|
//includes: quic and lz_rgb
|
||
|
|
|
||
|
|
window = this;
|
||
|
|
if (!window['wdi']) {
|
||
|
|
window['wdi'] = {};
|
||
|
|
}
|
||
|
|
|
||
|
|
window['wdi'].WorkerOperations = {
|
||
|
|
quic: 0,
|
||
|
|
lz_rgb: 1,
|
||
|
|
bytesToUriJpeg: 2,
|
||
|
|
bytesToUriPng: 3
|
||
|
|
};
|
||
|
|
|
||
|
|
function dispatch(arr, useMessage) {
|
||
|
|
|
||
|
|
var u8 = new Uint8Array(arr);
|
||
|
|
var postMessageW3CCompilant = u8[3];
|
||
|
|
|
||
|
|
|
||
|
|
var result = null;
|
||
|
|
var operation = u8[0];
|
||
|
|
|
||
|
|
if (operation === wdi.WorkerOperations.quic) {
|
||
|
|
try {
|
||
|
|
result = wdi.JSQuic.quic_decode(arr);
|
||
|
|
} catch (e) {
|
||
|
|
|
||
|
|
}
|
||
|
|
} else if (operation === wdi.WorkerOperations.lz_rgb) { //lz?
|
||
|
|
try {
|
||
|
|
result = wdi.LZSS.lz_rgb32_decompress_rgb(arr);
|
||
|
|
} catch (e) {
|
||
|
|
|
||
|
|
}
|
||
|
|
} else if (operation === wdi.WorkerOperations.bytesToUriJpeg) {
|
||
|
|
try {
|
||
|
|
result = bytesToURI(u8, 'jpeg');
|
||
|
|
self.postMessage(result);
|
||
|
|
return; //string is not transferable!
|
||
|
|
} catch (e) {
|
||
|
|
|
||
|
|
}
|
||
|
|
} else if (operation === wdi.WorkerOperations.bytesToUriPng) {
|
||
|
|
try {
|
||
|
|
result = bytesToURI(u8, 'png');
|
||
|
|
self.postMessage(result);
|
||
|
|
return; //string is not transferable!
|
||
|
|
} catch (e) {
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (useMessage && result) {
|
||
|
|
|
||
|
|
if (postMessageW3CCompilant) {
|
||
|
|
self.postMessage(result, [result]);
|
||
|
|
} else {
|
||
|
|
self.postMessage(result);
|
||
|
|
}
|
||
|
|
|
||
|
|
} else {
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
window['workerDispatch'] = dispatch;
|
||
|
|
|
||
|
|
self.addEventListener('message', function(e) {
|
||
|
|
return dispatch(e.data, true);
|
||
|
|
}, false);
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
//bytes to uri
|
||
|
|
function bytesToURI(data, type) {
|
||
|
|
var tmpstr = 'data:image/'+type+',';
|
||
|
|
var len = data.length;
|
||
|
|
for (var i = 4; i < len; i++) {
|
||
|
|
if (data[i] < 16) {
|
||
|
|
tmpstr += '%0';
|
||
|
|
} else {
|
||
|
|
tmpstr += '%';
|
||
|
|
}
|
||
|
|
tmpstr += data[i].toString(16);
|
||
|
|
}
|
||
|
|
|
||
|
|
return tmpstr;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//quic
|
||
|
|
|
||
|
|
|
||
|
|
wdi.QuicImageType = {
|
||
|
|
QUIC_IMAGE_TYPE_INVALID: 0,
|
||
|
|
QUIC_IMAGE_TYPE_GRAY: 1,
|
||
|
|
QUIC_IMAGE_TYPE_RGB16: 2,
|
||
|
|
QUIC_IMAGE_TYPE_RGB24: 3,
|
||
|
|
QUIC_IMAGE_TYPE_RGB32: 4,
|
||
|
|
QUIC_IMAGE_TYPE_RGBA: 5
|
||
|
|
};
|
||
|
|
|
||
|
|
function bytesToInt16(bytes) {
|
||
|
|
var low = bytes.shift();
|
||
|
|
var high = bytes.shift();
|
||
|
|
|
||
|
|
return high * Math.pow(16, 2) + low;
|
||
|
|
}
|
||
|
|
|
||
|
|
function bytesToInt32(bytes) {
|
||
|
|
var low = bytesToInt16(bytes);
|
||
|
|
var high = bytesToInt16(bytes);
|
||
|
|
|
||
|
|
return high * Math.pow(16, 4) + low;
|
||
|
|
}
|
||
|
|
|
||
|
|
wdi.quic = {};
|
||
|
|
|
||
|
|
function wdi_quic_QuicFamily() {
|
||
|
|
this.notGRcwlen = [];
|
||
|
|
this.nGRcodewords = [];
|
||
|
|
this.notGRprefixmask = [];
|
||
|
|
this.notGRsuffixlen = [];
|
||
|
|
this.xlatU2L = [];
|
||
|
|
this.xlatL2U = [];
|
||
|
|
}
|
||
|
|
|
||
|
|
function wdi_quic_s_bucket() {
|
||
|
|
this.pcounters = null;
|
||
|
|
this.bestcode = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
function wdi_quic_CommonState() {
|
||
|
|
this.wm_trigger = this;
|
||
|
|
this.encoder = null;
|
||
|
|
this.waitcnt = 0;
|
||
|
|
this.tabrand_seed = wdi.JSQuic.stabrand();
|
||
|
|
this.wmidx = wdi.JSQuic.DEFwmistart;
|
||
|
|
this.wmileft = wdi.JSQuic.wminext;
|
||
|
|
wdi.JSQuic.set_wm_trigger(this);
|
||
|
|
|
||
|
|
|
||
|
|
this.melcstate = 0;
|
||
|
|
this.melclen = wdi.JSQuic.J[0];
|
||
|
|
this.melcorder = (1 << this.melclen) >>> 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
function wdi_quic_FamilyStat() {
|
||
|
|
this.buckets_buf = null;
|
||
|
|
this.buckets_ptrs = null;
|
||
|
|
this.counters = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
function wdi_quic_Channel() {
|
||
|
|
this.encoder = null;
|
||
|
|
this.correlate_row_width = 0;
|
||
|
|
this.correlate_row = null;
|
||
|
|
|
||
|
|
this._buckets_ptrs = null;
|
||
|
|
|
||
|
|
this.family_stat_8bpc = new wdi_quic_FamilyStat();
|
||
|
|
this.family_stat_5bpc = new wdi_quic_FamilyStat();
|
||
|
|
|
||
|
|
this.state = new wdi_quic_CommonState();
|
||
|
|
this.oldFirst = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
wdi.JSQuic = {
|
||
|
|
QUIC_MAGIC: 1364543811, //"QUIC"
|
||
|
|
MAXNUMCODES: 8,
|
||
|
|
|
||
|
|
DEFevol: 3,
|
||
|
|
MINevol: 0,
|
||
|
|
MAXevol: 5,
|
||
|
|
|
||
|
|
DEFwmistart: 0,
|
||
|
|
MINwmistart: 0,
|
||
|
|
|
||
|
|
DEFmaxclen: 26,
|
||
|
|
|
||
|
|
DEFwmimax: 6,
|
||
|
|
|
||
|
|
DEFwminext: 2048,
|
||
|
|
MINwminext: 1,
|
||
|
|
MAXwminext: 100000000,
|
||
|
|
MAX_CHANNELS: 4,
|
||
|
|
|
||
|
|
wmimax: 6,
|
||
|
|
|
||
|
|
wminext: 2048,
|
||
|
|
|
||
|
|
evol: 3,
|
||
|
|
family_8bpc: new wdi_quic_QuicFamily(),
|
||
|
|
family_5bpc: new wdi_quic_QuicFamily(),
|
||
|
|
|
||
|
|
bppmask: new Int32Array([
|
||
|
|
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
|
||
|
|
]),
|
||
|
|
|
||
|
|
bitat: new Int32Array([
|
||
|
|
0x00000001, 0x00000002, 0x00000004, 0x00000008,
|
||
|
|
0x00000010, 0x00000020, 0x00000040, 0x00000080,
|
||
|
|
0x00000100, 0x00000200, 0x00000400, 0x00000800,
|
||
|
|
0x00001000, 0x00002000, 0x00004000, 0x00008000,
|
||
|
|
0x00010000, 0x00020000, 0x00040000, 0x00080000,
|
||
|
|
0x00100000, 0x00200000, 0x00400000, 0x00800000,
|
||
|
|
0x01000000, 0x02000000, 0x04000000, 0x08000000,
|
||
|
|
0x10000000, 0x20000000, 0x40000000, 0x80000000
|
||
|
|
]),
|
||
|
|
|
||
|
|
TABRAND_TABSIZE: 256,
|
||
|
|
TABRAND_SEEDMASK: 0x0ff,
|
||
|
|
|
||
|
|
tabrand_chaos: new Int32Array([
|
||
|
|
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
|
||
|
|
]),
|
||
|
|
|
||
|
|
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]
|
||
|
|
],
|
||
|
|
|
||
|
|
lzeroes: new Int32Array([
|
||
|
|
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
|
||
|
|
]),
|
||
|
|
|
||
|
|
J: new Int32Array([
|
||
|
|
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
|
||
|
|
]),
|
||
|
|
|
||
|
|
zeroLUT: null,
|
||
|
|
|
||
|
|
BPC_MASK: {
|
||
|
|
4: 0xff,
|
||
|
|
5: 0xff,
|
||
|
|
24: 0xff,
|
||
|
|
16: 0x1f
|
||
|
|
},
|
||
|
|
|
||
|
|
stabrand: function() {
|
||
|
|
return this.TABRAND_SEEDMASK;
|
||
|
|
},
|
||
|
|
|
||
|
|
tabrand: function(rgb_state) {
|
||
|
|
rgb_state.tabrand_seed++;
|
||
|
|
return this.tabrand_chaos[rgb_state.tabrand_seed & this.TABRAND_SEEDMASK];
|
||
|
|
},
|
||
|
|
|
||
|
|
set_wm_trigger: function(state) {
|
||
|
|
var wm = state.wmidx;
|
||
|
|
if (wm > 10) {
|
||
|
|
wm = 10;
|
||
|
|
}
|
||
|
|
|
||
|
|
//>> 1 == / 2
|
||
|
|
state.wm_trigger = wdi.JSQuic.besttrigtab[Math.floor(wdi.JSQuic.evol >> 1)][wm];
|
||
|
|
},
|
||
|
|
|
||
|
|
ceil_log_2: function(val) {
|
||
|
|
var result;
|
||
|
|
|
||
|
|
if (val === 1) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
result = 1;
|
||
|
|
val -= 1;
|
||
|
|
while ((val >>>= 1)) {
|
||
|
|
result++;
|
||
|
|
}
|
||
|
|
|
||
|
|
return result;
|
||
|
|
},
|
||
|
|
|
||
|
|
decorelate_init: function(family, bpc) {
|
||
|
|
var pixelbitmask = this.bppmask[bpc];
|
||
|
|
var pixelbitmaskshr = pixelbitmask >>> 1;
|
||
|
|
var s;
|
||
|
|
|
||
|
|
for (s = 0; s <= pixelbitmask; s++) {
|
||
|
|
if (s <= pixelbitmaskshr) {
|
||
|
|
family.xlatU2L[s] = (s << 1) >>> 0;
|
||
|
|
} else {
|
||
|
|
family.xlatU2L[s] = (((pixelbitmask - s) << 1) >>> 0) + 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
corelate_init: function(family, bpc) {
|
||
|
|
var pixelbitmask = this.bppmask[bpc];
|
||
|
|
var s;
|
||
|
|
|
||
|
|
for (s = 0; s <= pixelbitmask; s++) {
|
||
|
|
if (s & 0x01) {
|
||
|
|
family.xlatL2U[s] = pixelbitmask - (s >>> 1);
|
||
|
|
} else {
|
||
|
|
family.xlatL2U[s] = (s >>> 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
family_init: function(family, bpc, limit) {
|
||
|
|
var l;
|
||
|
|
|
||
|
|
for (l = 0; l < bpc; l++) {
|
||
|
|
var altprefixlen, altcodewords;
|
||
|
|
|
||
|
|
altprefixlen = limit - bpc;
|
||
|
|
if (altprefixlen > parseInt(this.bppmask[bpc - l])) {
|
||
|
|
altprefixlen = this.bppmask[bpc - l];
|
||
|
|
}
|
||
|
|
|
||
|
|
altcodewords = this.bppmask[bpc] + 1 - ((altprefixlen << l) >>> 0);
|
||
|
|
|
||
|
|
family.nGRcodewords[l] = ((altprefixlen << l) >>> 0);
|
||
|
|
family.notGRcwlen[l] = altprefixlen + this.ceil_log_2(altcodewords);
|
||
|
|
family.notGRprefixmask[l] = this.bppmask[32 - altprefixlen];
|
||
|
|
family.notGRsuffixlen[l] = this.ceil_log_2(altcodewords);
|
||
|
|
}
|
||
|
|
|
||
|
|
//this.decorelate_init(family, bpc);
|
||
|
|
this.corelate_init(family, bpc);
|
||
|
|
},
|
||
|
|
|
||
|
|
init_zeroLUT: function() {
|
||
|
|
|
||
|
|
this.zeroLUT = new Int32Array(256);
|
||
|
|
|
||
|
|
var i, j, k, l;
|
||
|
|
|
||
|
|
j = k = 1;
|
||
|
|
l = 8;
|
||
|
|
for (i = 0; i < 256; ++i) {
|
||
|
|
this.zeroLUT[i] = l;
|
||
|
|
--k;
|
||
|
|
if (k === 0) {
|
||
|
|
k = j;
|
||
|
|
--l;
|
||
|
|
j *= 2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
|
||
|
|
quic_init: function() {
|
||
|
|
this.family_init(this.family_8bpc, 8, this.DEFmaxclen);
|
||
|
|
//this.family_init(this.family_5bpc, 5, this.DEFmaxclen);
|
||
|
|
this.init_zeroLUT();
|
||
|
|
|
||
|
|
//perf improvment
|
||
|
|
wdi.xlatL2U = new Int32Array(this.family_8bpc.xlatL2U.length);
|
||
|
|
wdi.xlatL2U.set(this.family_8bpc.xlatL2U);
|
||
|
|
|
||
|
|
wdi.notGRprefixmask = new Int32Array(this.family_8bpc.notGRprefixmask.length);
|
||
|
|
wdi.notGRprefixmask.set(this.family_8bpc.notGRprefixmask);
|
||
|
|
|
||
|
|
wdi.nGRcodewords = new Int32Array(this.family_8bpc.nGRcodewords.length);
|
||
|
|
wdi.nGRcodewords.set(this.family_8bpc.nGRcodewords);
|
||
|
|
|
||
|
|
|
||
|
|
wdi.notGRcwlen = new Int32Array(this.family_8bpc.notGRcwlen.length);
|
||
|
|
wdi.notGRcwlen.set(this.family_8bpc.notGRcwlen);
|
||
|
|
|
||
|
|
wdi.notGRsuffixlen = new Int32Array(this.family_8bpc.notGRsuffixlen.length);
|
||
|
|
wdi.notGRsuffixlen.set(this.family_8bpc.notGRsuffixlen);
|
||
|
|
|
||
|
|
|
||
|
|
//prepare precomputed lzeroes tables
|
||
|
|
var lzeroes = wdi.JSQuic.lzeroes;
|
||
|
|
var lzeroes8 = new Int32Array(lzeroes);
|
||
|
|
var len = lzeroes.length;
|
||
|
|
for (var i = 0; i < len; i++) {
|
||
|
|
lzeroes8[i] = lzeroes[i] + 8;
|
||
|
|
}
|
||
|
|
wdi.JSQuic.lzeroes8 = lzeroes8;
|
||
|
|
|
||
|
|
//prepare precomputed lzeroes tables
|
||
|
|
var lzeroes16 = new Int32Array(lzeroes);
|
||
|
|
for (var i = 0; i < len; i++) {
|
||
|
|
lzeroes16[i] = lzeroes[i] + 16;
|
||
|
|
}
|
||
|
|
wdi.JSQuic.lzeroes16 = lzeroes16;
|
||
|
|
|
||
|
|
//prepare precomputed lzeroes tables
|
||
|
|
var lzeroes24 = new Int32Array(lzeroes);
|
||
|
|
for (var i = 0; i < len; i++) {
|
||
|
|
lzeroes24[i] = lzeroes[i] + 24;
|
||
|
|
}
|
||
|
|
wdi.JSQuic.lzeroes24 = lzeroes24;
|
||
|
|
},
|
||
|
|
|
||
|
|
quic_image_params: function(encoder, type) {
|
||
|
|
var channels, bpc;
|
||
|
|
switch (type) {
|
||
|
|
case wdi.QuicImageType.QUIC_IMAGE_TYPE_GRAY:
|
||
|
|
channels = 1;
|
||
|
|
bpc = 8;
|
||
|
|
break;
|
||
|
|
case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGB16:
|
||
|
|
channels = 3;
|
||
|
|
bpc = 5;
|
||
|
|
break;
|
||
|
|
case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGB24:
|
||
|
|
channels = 3;
|
||
|
|
bpc = 8;
|
||
|
|
break;
|
||
|
|
case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGB32:
|
||
|
|
channels = 3;
|
||
|
|
bpc = 8;
|
||
|
|
break;
|
||
|
|
case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGBA:
|
||
|
|
channels = 4;
|
||
|
|
bpc = 8;
|
||
|
|
break;
|
||
|
|
case wdi.QuicImageType.QUIC_IMAGE_TYPE_INVALID:
|
||
|
|
default:
|
||
|
|
channels = 0;
|
||
|
|
bpc = 0;
|
||
|
|
}
|
||
|
|
return [channels, bpc];
|
||
|
|
},
|
||
|
|
|
||
|
|
find_model_params: function(encoder, bpc) {
|
||
|
|
var bsize = 0;
|
||
|
|
var bstart = 0;
|
||
|
|
var bend = 0;
|
||
|
|
var repcntr = 0;
|
||
|
|
|
||
|
|
var result = {};
|
||
|
|
|
||
|
|
result.ncounters = 8;
|
||
|
|
|
||
|
|
result.levels = 0x1 << bpc;
|
||
|
|
|
||
|
|
result.n_buckets_ptrs = 0;
|
||
|
|
|
||
|
|
switch (this.evol) {
|
||
|
|
case 1:
|
||
|
|
result.repfirst = 3;
|
||
|
|
result.firstsize = 1;
|
||
|
|
result.repnext = 2;
|
||
|
|
result.mulsize = 2;
|
||
|
|
break;
|
||
|
|
case 3:
|
||
|
|
result.repfirst = 1;
|
||
|
|
result.firstsize = 1;
|
||
|
|
result.repnext = 1;
|
||
|
|
result.mulsize = 2;
|
||
|
|
break;
|
||
|
|
case 5:
|
||
|
|
result.repfirst = 1;
|
||
|
|
result.firstsize = 1;
|
||
|
|
result.repnext = 1;
|
||
|
|
result.mulsize = 4;
|
||
|
|
break;
|
||
|
|
case 0:
|
||
|
|
case 2:
|
||
|
|
case 4:
|
||
|
|
default:
|
||
|
|
wdi.Debug.error('fund model params: invalid evol');
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
result.nbuckets = 0;
|
||
|
|
repcntr = result.repfirst + 1;
|
||
|
|
bsize = result.firstsize;
|
||
|
|
|
||
|
|
do { /* other buckets */
|
||
|
|
if (result.nbuckets) {
|
||
|
|
bstart = bend + 1;
|
||
|
|
} else {
|
||
|
|
bstart = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!--repcntr) {
|
||
|
|
repcntr = result.repnext;
|
||
|
|
bsize *= result.mulsize;
|
||
|
|
}
|
||
|
|
|
||
|
|
bend = bstart + bsize - 1;
|
||
|
|
if (bend + bsize >= result.levels) {
|
||
|
|
bend = result.levels - 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!result.n_buckets_ptrs) {
|
||
|
|
result.n_buckets_ptrs = result.levels;
|
||
|
|
}
|
||
|
|
|
||
|
|
result.nbuckets++;
|
||
|
|
} while (bend < result.levels - 1);
|
||
|
|
return result;
|
||
|
|
},
|
||
|
|
|
||
|
|
init_model_structures: function(encoder, family, params) {
|
||
|
|
family.buckets_buf = [];
|
||
|
|
for (var i = 0; i < params.nbuckets; i++) {
|
||
|
|
family.buckets_buf[i] = new wdi_quic_s_bucket();
|
||
|
|
}
|
||
|
|
family.buckets_ptrs = [];
|
||
|
|
family.counters = [];
|
||
|
|
this.fill_model_structures(encoder, family, params);
|
||
|
|
},
|
||
|
|
|
||
|
|
fill_model_structures: function(encoder, family, params) {
|
||
|
|
var bsize, bstart, bend = 0,
|
||
|
|
repcntr, bnumber;
|
||
|
|
|
||
|
|
bnumber = 0;
|
||
|
|
|
||
|
|
repcntr = params.repfirst + 1;
|
||
|
|
bsize = params.firstsize;
|
||
|
|
|
||
|
|
|
||
|
|
do {
|
||
|
|
if (bnumber) {
|
||
|
|
bstart = bend + 1;
|
||
|
|
} else {
|
||
|
|
bstart = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!--repcntr) {
|
||
|
|
repcntr = params.repnext;
|
||
|
|
bsize *= params.mulsize;
|
||
|
|
}
|
||
|
|
|
||
|
|
bend = bstart + bsize - 1;
|
||
|
|
if (bend + bsize >= params.levels) {
|
||
|
|
bend = params.levels - 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
family.buckets_buf[bnumber].pcounters = new Int32Array(params.ncounters);
|
||
|
|
for (var x = 0; x < params.ncounters; x++) {
|
||
|
|
family.buckets_buf[bnumber].pcounters[x] = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (var i = bstart; i <= bend; i++) {
|
||
|
|
family.buckets_ptrs[i] = family.buckets_buf[bnumber];
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
bnumber++;
|
||
|
|
} while (bend < params.levels - 1);
|
||
|
|
},
|
||
|
|
|
||
|
|
initChannel: function(encoder, channel) {
|
||
|
|
channel.encoder = encoder;
|
||
|
|
channel.state.encoder = encoder;
|
||
|
|
channel.correlate_row_width = 0;
|
||
|
|
channel.correlate_row = null;
|
||
|
|
|
||
|
|
var params = this.find_model_params(encoder, 8);
|
||
|
|
encoder.n_buckets_8bpc = params.nbuckets;
|
||
|
|
this.init_model_structures(encoder, channel.family_stat_8bpc, params);
|
||
|
|
|
||
|
|
params = this.find_model_params(encoder, 5);
|
||
|
|
encoder.n_buckets_5bpc = params.nbuckets;
|
||
|
|
this.init_model_structures(encoder, channel.family_stat_5bpc, params);
|
||
|
|
},
|
||
|
|
|
||
|
|
encoder_reste_channels: function(encoder, channels, width, bpc) {
|
||
|
|
encoder.num_channels = channels;
|
||
|
|
for (var i = 0; i < channels; i++) {
|
||
|
|
var bucket, end_bucket;
|
||
|
|
|
||
|
|
if (encoder.channels[i].correlate_row_width < width) {
|
||
|
|
encoder.channels[i].correlate_row = new Array(width);
|
||
|
|
encoder.channels[i].correlate_row_width = width;
|
||
|
|
}
|
||
|
|
encoder.channels[i].num_channel = i;
|
||
|
|
if (bpc === 8) {
|
||
|
|
bucket = encoder.channels[i].family_stat_8bpc.buckets_buf;
|
||
|
|
end_bucket = encoder.n_buckets_8bpc;
|
||
|
|
for (var x = 0; x < end_bucket; x++) {
|
||
|
|
bucket[x].bestcode = 8 - 1;
|
||
|
|
}
|
||
|
|
encoder.channels[i]._buckets_ptrs = encoder.channels[i].family_stat_8bpc.buckets_ptrs;
|
||
|
|
} else if (bpc === 5) {
|
||
|
|
bucket = encoder.channels[i].family_stat_5bpc.buckets_buf;
|
||
|
|
end_bucket = encoder.n_buckets_5bpc;
|
||
|
|
for (var x = 0; x < end_bucket; x++) {
|
||
|
|
bucket[x].bestcode = /*BPC*/ 5 - 1;
|
||
|
|
}
|
||
|
|
encoder.channels[i]._buckets_ptrs = encoder.channels[i].family_stat_5bpc.buckets_ptrs;
|
||
|
|
} else {
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
encoder.channels[i].state.waitcnt = 0;
|
||
|
|
encoder.channels[i].state.tabrand_seed = wdi.JSQuic.stabrand();
|
||
|
|
encoder.channels[i].state.wmidx = wdi.JSQuic.DEFwmistart;
|
||
|
|
encoder.channels[i].state.wmileft = wdi.JSQuic.wminext;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
},
|
||
|
|
|
||
|
|
decode_channel_run: function(encoder, channel) {
|
||
|
|
var runlen = 0;
|
||
|
|
|
||
|
|
do {
|
||
|
|
var temp, hits;
|
||
|
|
//TODO: casting needed?
|
||
|
|
temp = wdi.JSQuic.zeroLUT[(~(encoder.io_word >>> 24) >>> 0) % 256];
|
||
|
|
|
||
|
|
for (hits = 1; hits <= temp; hits++) {
|
||
|
|
runlen += channel.state.melcorder;
|
||
|
|
|
||
|
|
if (channel.state.melcstate < 32) {
|
||
|
|
channel.state.melclen = wdi.JSQuic.J[++channel.state.melcstate];
|
||
|
|
channel.state.melcorder = (1 << channel.state.melclen) >>> 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (temp !== 8) {
|
||
|
|
encoder.eatbits(temp + 1, encoder);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
encoder.eatbits(8, encoder);
|
||
|
|
} while (1);
|
||
|
|
|
||
|
|
/* read the length of the remainder */
|
||
|
|
if (channel.state.melclen) {
|
||
|
|
runlen += encoder.io_word >>> (32 - channel.state.melclen);
|
||
|
|
encoder.eatbits(channel.state.melclen, encoder);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* adjust melcoder parameters */
|
||
|
|
if (channel.state.melcstate) {
|
||
|
|
channel.state.melclen = wdi.JSQuic.J[--channel.state.melcstate];
|
||
|
|
channel.state.melcorder = (1 << channel.state.melclen) >>> 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return runlen;
|
||
|
|
},
|
||
|
|
|
||
|
|
decode_run: function(encoder) {
|
||
|
|
var runlen = 0;
|
||
|
|
var temp, hits, tempadd;
|
||
|
|
var zeroLUT = wdi.JSQuic.zeroLUT;
|
||
|
|
var rgb_state = encoder.rgb_state;
|
||
|
|
var J = wdi.JSQuic.J;
|
||
|
|
var eatbits = encoder.eatbits;
|
||
|
|
do {
|
||
|
|
|
||
|
|
//TODO: casting needed?
|
||
|
|
temp = zeroLUT[(~(encoder.io_word >>> 24) >>> 0) % 256];
|
||
|
|
tempadd = temp + 1;
|
||
|
|
for (hits = 1; hits < tempadd; hits++) {
|
||
|
|
runlen += encoder.rgb_state.melcorder;
|
||
|
|
|
||
|
|
if (rgb_state.melcstate < 32) {
|
||
|
|
rgb_state.melclen = J[++rgb_state.melcstate];
|
||
|
|
rgb_state.melcorder = (1 << rgb_state.melclen) >>> 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (temp !== 8) {
|
||
|
|
eatbits(tempadd, encoder);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
encoder.eatbits(8, encoder);
|
||
|
|
} while (1);
|
||
|
|
|
||
|
|
if (rgb_state.melclen) {
|
||
|
|
runlen += encoder.io_word >>> (32 - rgb_state.melclen);
|
||
|
|
eatbits(rgb_state.melclen, encoder);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (rgb_state.melcstate) {
|
||
|
|
rgb_state.melclen = J[--rgb_state.melcstate];
|
||
|
|
rgb_state.melcorder = (1 << rgb_state.melclen) >>> 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return runlen;
|
||
|
|
},
|
||
|
|
|
||
|
|
quic_decode: function(data) {
|
||
|
|
//console.time("test");
|
||
|
|
var view = new Uint32Array(data);
|
||
|
|
var encoder = new wdi_quic_Encoder(view);
|
||
|
|
var opaque = encoder.io_word & 0x0000FF00;
|
||
|
|
var format = (encoder.io_word >>> 24) & 0xFF;
|
||
|
|
|
||
|
|
|
||
|
|
encoder.eat32bits(); //skip quic size
|
||
|
|
|
||
|
|
encoder.eat32bits();
|
||
|
|
var magic = encoder.io_word;
|
||
|
|
encoder.eat32bits();
|
||
|
|
|
||
|
|
var version = encoder.io_word;
|
||
|
|
encoder.eat32bits();
|
||
|
|
|
||
|
|
var type = encoder.io_word;
|
||
|
|
encoder.eat32bits();
|
||
|
|
|
||
|
|
encoder.type = type; //here?
|
||
|
|
|
||
|
|
var width = encoder.io_word;
|
||
|
|
encoder.width = width; //here?
|
||
|
|
encoder.eat32bits();
|
||
|
|
|
||
|
|
var height = encoder.io_word;
|
||
|
|
encoder.height = height; //here?
|
||
|
|
encoder.eat32bits();
|
||
|
|
|
||
|
|
var result = wdi.JSQuic.quic_image_params(encoder, type);
|
||
|
|
var channels = result[0];
|
||
|
|
var bpc = result[1];
|
||
|
|
|
||
|
|
this.encoder_reste_channels(encoder, channels, width, bpc);
|
||
|
|
|
||
|
|
var buf = new ArrayBuffer(width * height * 4);
|
||
|
|
var buf8 = new Uint8Array(buf);
|
||
|
|
var data = new Uint32Array(buf);
|
||
|
|
encoder.result = buf8;
|
||
|
|
encoder.resultData = data;
|
||
|
|
encoder.setComputedWidth(width);
|
||
|
|
|
||
|
|
switch (type) {
|
||
|
|
case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGB32:
|
||
|
|
case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGB24:
|
||
|
|
//ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 4);
|
||
|
|
QUIC_UNCOMPRESS_RGB(encoder, channels, bpc, type);
|
||
|
|
break;
|
||
|
|
case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGB16:
|
||
|
|
// if (type == QUIC_IMAGE_TYPE_RGB16) {
|
||
|
|
// //ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 2);
|
||
|
|
// QUIC_UNCOMPRESS_RGB(16, rgb16_pixel_t);
|
||
|
|
// } else if (type == QUIC_IMAGE_TYPE_RGB32) {
|
||
|
|
// //ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 4);
|
||
|
|
// QUIC_UNCOMPRESS_RGB(16_to_32, rgb32_pixel_t);
|
||
|
|
// } else {
|
||
|
|
// //encoder->usr->warn(encoder->usr, "unsupported output format\n");
|
||
|
|
// return QUIC_ERROR;
|
||
|
|
// }
|
||
|
|
|
||
|
|
break;
|
||
|
|
case wdi.QuicImageType.QUIC_IMAGE_TYPE_RGBA:
|
||
|
|
QUIC_UNCOMPRESS_RGBA(encoder, channels, bpc, type);
|
||
|
|
if (opaque) {
|
||
|
|
var len = buf8.length - 1;
|
||
|
|
while (len > 0) {
|
||
|
|
buf8[len] = 255;
|
||
|
|
len -= 4;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
//QUIC_UNCOMPRESS_RGBA(encoder, channels, bpc, type);
|
||
|
|
//
|
||
|
|
// if (type != QUIC_IMAGE_TYPE_RGBA) {
|
||
|
|
// //encoder->usr->warn(encoder->usr, "unsupported output format\n");
|
||
|
|
// return QUIC_ERROR;
|
||
|
|
// }
|
||
|
|
// //ASSERT(encoder->usr, ABS(stride) >= (int)encoder->width * 4);
|
||
|
|
// uncompress_rgba(encoder, buf, stride);
|
||
|
|
// break;
|
||
|
|
}
|
||
|
|
// var len = encoder.result.length;
|
||
|
|
// while(len--) {
|
||
|
|
// imgData.data[len] = encoder.result[len];
|
||
|
|
// }
|
||
|
|
//console.timeEnd("test");
|
||
|
|
|
||
|
|
//imgData.data.set(buf8);
|
||
|
|
return buf;
|
||
|
|
}
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
wdi.JSQuic.quic_init();
|
||
|
|
|
||
|
|
function wdi_quic_Encoder(data) {
|
||
|
|
this.computedWidth = 0;
|
||
|
|
this.result = [];
|
||
|
|
this.cnt = 0;
|
||
|
|
this.pxCnt = 0,
|
||
|
|
this.usr = data;
|
||
|
|
this.type = null;
|
||
|
|
this.width = null;
|
||
|
|
this.height = null;
|
||
|
|
this.num_channels = null;
|
||
|
|
|
||
|
|
this.n_buckets_8bpc = null;
|
||
|
|
this.n_buckets_5bpc = null;
|
||
|
|
|
||
|
|
this.io_available_bits = 32;
|
||
|
|
this.io_now = 0;
|
||
|
|
|
||
|
|
this.io_next_word = null;
|
||
|
|
this.io_now = null;
|
||
|
|
|
||
|
|
this.read_io_word();
|
||
|
|
this.io_word = this.io_next_word;
|
||
|
|
|
||
|
|
this.read_io_word();
|
||
|
|
|
||
|
|
this.io_words_count = data.length;
|
||
|
|
|
||
|
|
this.rows_completed = 0; //??
|
||
|
|
|
||
|
|
this.channels = [];
|
||
|
|
|
||
|
|
this.alphaPos = 3; //first alpha
|
||
|
|
|
||
|
|
this.rgb_state = new wdi_quic_CommonState();
|
||
|
|
for (var i = 0; i < 4; i++) {
|
||
|
|
this.channels[i] = new wdi_quic_Channel();
|
||
|
|
wdi.JSQuic.initChannel(this, this.channels[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
wdi_quic_Encoder.prototype.append = function(databyte) {
|
||
|
|
this.result[this.cnt++] = databyte;
|
||
|
|
}
|
||
|
|
|
||
|
|
wdi_quic_Encoder.prototype.appendPixel = function(r, g, b) {
|
||
|
|
this.resultData[this.pxCnt++] =
|
||
|
|
(255 << 24) | // alpha
|
||
|
|
(b << 16) | // blue
|
||
|
|
(g << 8) | // green
|
||
|
|
r; // red
|
||
|
|
this.cnt += 4;
|
||
|
|
}
|
||
|
|
|
||
|
|
wdi_quic_Encoder.prototype.eatbits = function(len, encoder) {
|
||
|
|
var available_bits = encoder.io_available_bits;
|
||
|
|
var io_word = encoder.io_word;
|
||
|
|
|
||
|
|
var delta = available_bits - len;
|
||
|
|
|
||
|
|
io_word = io_word << len;
|
||
|
|
|
||
|
|
//enough bits
|
||
|
|
if (delta >= 0) {
|
||
|
|
io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
|
||
|
|
encoder.io_available_bits = delta;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
var io_next_word = encoder.io_next_word;
|
||
|
|
//not enough bits
|
||
|
|
delta = -delta; //bits missing
|
||
|
|
io_word = (io_word | (io_next_word << delta) >>> 0);
|
||
|
|
|
||
|
|
///////////////////
|
||
|
|
//read io word (inlined for perforemance)
|
||
|
|
|
||
|
|
io_next_word = encoder.usr[encoder.io_now++];
|
||
|
|
//end read io_word
|
||
|
|
/////////////////
|
||
|
|
|
||
|
|
available_bits = 32 - delta;
|
||
|
|
io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
|
||
|
|
|
||
|
|
encoder.io_available_bits = available_bits;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
encoder.io_next_word = io_next_word;
|
||
|
|
}
|
||
|
|
|
||
|
|
wdi_quic_Encoder.prototype.eat32bits = function() {
|
||
|
|
this.eatbits(16, this);
|
||
|
|
this.eatbits(16, this);
|
||
|
|
}
|
||
|
|
|
||
|
|
wdi_quic_Encoder.prototype.read_io_word = function() {
|
||
|
|
this.io_next_word = this.usr[this.io_now++];
|
||
|
|
}
|
||
|
|
|
||
|
|
wdi_quic_Encoder.prototype.row_completed = function() {
|
||
|
|
this.rows_completed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
wdi_quic_Encoder.prototype.setComputedWidth = function(width) {
|
||
|
|
this.computedWidth = width * 4;
|
||
|
|
}
|
||
|
|
|
||
|
|
wdi_quic_Encoder.prototype.appendAlpha = function(databyte) {
|
||
|
|
this.result[this.alphaPos] = databyte;
|
||
|
|
this.alphaPos += 4;
|
||
|
|
}
|
||
|
|
|
||
|
|
function cnt_l_zeroes(bits) {
|
||
|
|
if (bits > 0x007FFFFF) {
|
||
|
|
return wdi.JSQuic.lzeroes[bits >>> 24];
|
||
|
|
} else if (bits > 0x00007FFF) {
|
||
|
|
return 8 + wdi.JSQuic.lzeroes[((bits >>> 16) & 0x000000ff)];
|
||
|
|
} else if (bits > 0x0000007F) {
|
||
|
|
return 16 + wdi.JSQuic.lzeroes[((bits >>> 8) & 0x000000ff)];
|
||
|
|
} else {
|
||
|
|
return 24 + wdi.JSQuic.lzeroes[(bits & 0x000000ff)];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
*
|
||
|
|
*
|
||
|
|
* JSQUIC FAMILY
|
||
|
|
*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
function golomb_code_len(n, l) {
|
||
|
|
if (n < wdi.nGRcodewords[l]) {
|
||
|
|
return (n >>> l) + 1 + l;
|
||
|
|
} else {
|
||
|
|
return wdi.notGRcwlen[l];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function golomb_decoding(l, bits, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen) {
|
||
|
|
var cwlen;
|
||
|
|
var result;
|
||
|
|
//its better to check first for bigger, tested for performance
|
||
|
|
if (bits > notGRprefixmask[l]) {
|
||
|
|
var zeroprefix = cnt_l_zeroes(bits);
|
||
|
|
cwlen = zeroprefix + 1 + l;
|
||
|
|
result = ((zeroprefix << l)) | ((bits >>> (32 - cwlen)) & bppmask[l]);
|
||
|
|
} else {
|
||
|
|
cwlen = notGRcwlen[l];
|
||
|
|
result = nGRcodewords[l] + ((bits) >>> (32 - cwlen) & bppmask[notGRsuffixlen[l]]);
|
||
|
|
}
|
||
|
|
return [result, cwlen];
|
||
|
|
}
|
||
|
|
|
||
|
|
/* update the bucket using just encoded curval */
|
||
|
|
function real_update_model(state, bucket, curval, bpp, wm_trigger) {
|
||
|
|
var i;
|
||
|
|
var bestcode;
|
||
|
|
var bestcodelen;
|
||
|
|
var ithcodelen;
|
||
|
|
|
||
|
|
var pcounters = bucket.pcounters;
|
||
|
|
bestcode = bpp - 1;
|
||
|
|
bestcodelen = (pcounters[bestcode] += golomb_code_len(curval, bestcode));
|
||
|
|
|
||
|
|
for (i = bpp - 2; i >= 0; i--) {
|
||
|
|
ithcodelen = (pcounters[i] += golomb_code_len(curval, i));
|
||
|
|
|
||
|
|
if (ithcodelen < bestcodelen) {
|
||
|
|
bestcode = i;
|
||
|
|
bestcodelen = ithcodelen;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bucket.bestcode = bestcode;
|
||
|
|
if (bestcodelen > state.wm_trigger) {
|
||
|
|
while (bpp-- > 0) {
|
||
|
|
pcounters[bpp] >>>= 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function UPDATE_MODEL(index, encoder, bpp, correlate_row_r, correlate_row_g, correlate_row_b) {
|
||
|
|
real_update_model(encoder.rgb_state, find_bucket(encoder.channels[0],
|
||
|
|
correlate_row_r[index - 1]), correlate_row_r[index], bpp);
|
||
|
|
real_update_model(encoder.rgb_state, find_bucket(encoder.channels[1],
|
||
|
|
correlate_row_g[index - 1]), correlate_row_g[index], bpp);
|
||
|
|
real_update_model(encoder.rgb_state, find_bucket(encoder.channels[2],
|
||
|
|
correlate_row_b[index - 1]), correlate_row_b[index], bpp);
|
||
|
|
}
|
||
|
|
|
||
|
|
function find_bucket(channel, val) {
|
||
|
|
if (val === undefined) {
|
||
|
|
val = channel.oldFirst;
|
||
|
|
}
|
||
|
|
return channel._buckets_ptrs[val];
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
*
|
||
|
|
*
|
||
|
|
* JSQUIC RGBA
|
||
|
|
*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
function QUIC_UNCOMPRESS_RGBA(encoder, channels, bpc, type) {
|
||
|
|
quic_uncompress_row0(encoder, channels, bpc, type);
|
||
|
|
quic_four_uncompress_row0(encoder, encoder.channels[3], bpc, type);
|
||
|
|
encoder.row_completed();
|
||
|
|
var height = encoder.height;
|
||
|
|
var rgb_state = encoder.rgb_state;
|
||
|
|
for (var row = 1; row < height; row++) {
|
||
|
|
quic_uncompress_row_a(encoder, channels, bpc, type, rgb_state);
|
||
|
|
quic_four_uncompress_row(encoder, encoder.channels[3], bpc, type);
|
||
|
|
encoder.row_completed();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function quic_four_uncompress_row(encoder, channel, bpc, type) {
|
||
|
|
var bpc_mask = wdi.JSQuic.BPC_MASK[type];
|
||
|
|
var pos = 0;
|
||
|
|
var width = encoder.width;
|
||
|
|
while ((wdi.JSQuic.wmimax > channel.state.wmidx) && (channel.state.wmileft <= width)) {
|
||
|
|
if (channel.state.wmileft) {
|
||
|
|
uncompress_four_row_seg(
|
||
|
|
encoder,
|
||
|
|
channel,
|
||
|
|
pos,
|
||
|
|
pos + channel.state.wmileft,
|
||
|
|
bpc,
|
||
|
|
bpc_mask,
|
||
|
|
type
|
||
|
|
);
|
||
|
|
pos += channel.state.wmileft;
|
||
|
|
width -= channel.state.wmileft;
|
||
|
|
}
|
||
|
|
|
||
|
|
channel.state.wmidx++;
|
||
|
|
wdi.JSQuic.set_wm_trigger(channel.state);
|
||
|
|
channel.state.wmileft = wdi.JSQuic.wminext;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (width) {
|
||
|
|
uncompress_four_row_seg(
|
||
|
|
encoder,
|
||
|
|
channel,
|
||
|
|
pos,
|
||
|
|
pos + width,
|
||
|
|
bpc,
|
||
|
|
bpc_mask,
|
||
|
|
type
|
||
|
|
);
|
||
|
|
if (wdi.JSQuic.wmimax > channel.state.wmidx) {
|
||
|
|
channel.state.wmileft -= width;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function uncompress_four_row_seg(encoder, channel, i, end, bpc, bpc_mask, type) {
|
||
|
|
var correlate_row = channel.correlate_row;
|
||
|
|
|
||
|
|
var stopidx = 0;
|
||
|
|
|
||
|
|
var waitmask = wdi.JSQuic.bppmask[channel.state.wmidx];
|
||
|
|
|
||
|
|
var run_index = 0;
|
||
|
|
var run_end = 0;
|
||
|
|
|
||
|
|
var rle = false;
|
||
|
|
|
||
|
|
var computedWidth = encoder.computedWidth;
|
||
|
|
|
||
|
|
var rows_completed = encoder.rows_completed;
|
||
|
|
|
||
|
|
var offset = ((encoder.rows_completed - 1) * computedWidth);
|
||
|
|
|
||
|
|
var data;
|
||
|
|
|
||
|
|
var eatbits = encoder.eatbits;
|
||
|
|
var appendAlpha = encoder.appendAlpha;
|
||
|
|
|
||
|
|
var alpha;
|
||
|
|
|
||
|
|
var ret, codewordlen;
|
||
|
|
var bppmask = wdi.JSQuic.bppmask;
|
||
|
|
|
||
|
|
var notGRprefixmask = wdi.notGRprefixmask;
|
||
|
|
var notGRcwlen = wdi.notGRcwlen;
|
||
|
|
var nGRcodewords = wdi.nGRcodewords;
|
||
|
|
var notGRsuffixlen = wdi.notGRsuffixlen;
|
||
|
|
|
||
|
|
if (!i) {
|
||
|
|
alpha = UNCOMPRESS_ONE_0_A(channel, encoder, bpc_mask, offset);
|
||
|
|
|
||
|
|
if (channel.state.waitcnt) {
|
||
|
|
--channel.state.waitcnt;
|
||
|
|
} else {
|
||
|
|
channel.state.waitcnt = (wdi.JSQuic.tabrand(channel.state) & waitmask);
|
||
|
|
real_update_model(channel.state, find_bucket(channel,
|
||
|
|
correlate_row[-1]), correlate_row[0], bpc);
|
||
|
|
}
|
||
|
|
stopidx = ++i + channel.state.waitcnt;
|
||
|
|
} else {
|
||
|
|
stopidx = i + channel.state.waitcnt;
|
||
|
|
alpha = encoder.result[encoder.alphaPos - 4];
|
||
|
|
}
|
||
|
|
|
||
|
|
for (;;) {
|
||
|
|
while (stopidx < end) {
|
||
|
|
for (; i <= stopidx; i++) {
|
||
|
|
rle = RLE_PRED_A(i, encoder, run_index, computedWidth, rows_completed);
|
||
|
|
if (rle) break;
|
||
|
|
|
||
|
|
ret = golomb_decoding(find_bucket(channel, correlate_row[i - 1]).bestcode,
|
||
|
|
encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
|
||
|
|
data = ret[0];
|
||
|
|
codewordlen = ret[1];
|
||
|
|
|
||
|
|
correlate_row[i] = data;
|
||
|
|
alpha = (((wdi.xlatL2U[data] +
|
||
|
|
((alpha + PIXEL_B(channel, encoder, i, offset)) >>> 1)) & bpc_mask) >>> 0);
|
||
|
|
|
||
|
|
appendAlpha.call(encoder, alpha);
|
||
|
|
eatbits(codewordlen, encoder);
|
||
|
|
}
|
||
|
|
if (!rle) {
|
||
|
|
real_update_model(channel.state, find_bucket(channel,
|
||
|
|
correlate_row[stopidx - 1]), correlate_row[stopidx], bpc);
|
||
|
|
stopidx = i + (wdi.JSQuic.tabrand(channel.state) & waitmask);
|
||
|
|
} else {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!rle) {
|
||
|
|
for (; i < end; i++) {
|
||
|
|
rle = RLE_PRED_A(i, encoder, run_index, computedWidth, rows_completed);
|
||
|
|
if (rle) break;
|
||
|
|
|
||
|
|
ret = golomb_decoding(find_bucket(channel, correlate_row[i - 1]).bestcode,
|
||
|
|
encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
|
||
|
|
data = ret[0];
|
||
|
|
codewordlen = ret[1];
|
||
|
|
correlate_row[i] = data;
|
||
|
|
alpha = (((wdi.xlatL2U[data] +
|
||
|
|
((alpha + PIXEL_B(channel, encoder, i, offset)) >>> 1)) & bpc_mask) >>> 0);
|
||
|
|
|
||
|
|
appendAlpha.call(encoder, alpha);
|
||
|
|
eatbits(codewordlen, encoder);
|
||
|
|
}
|
||
|
|
if (!rle) {
|
||
|
|
channel.state.waitcnt = stopidx - end;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//RLE
|
||
|
|
channel.state.waitcnt = stopidx - i;
|
||
|
|
run_index = i;
|
||
|
|
run_end = i + wdi.JSQuic.decode_channel_run(encoder, channel);
|
||
|
|
|
||
|
|
var cpos = ((encoder.rows_completed) * (encoder.width * 4)) + (i * 4);
|
||
|
|
var a = encoder.result[cpos - 1];
|
||
|
|
|
||
|
|
for (; i < run_end; i++) {
|
||
|
|
//TODO: how to append?
|
||
|
|
appendAlpha.call(encoder, a);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (i === end) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
stopidx = i + channel.state.waitcnt;
|
||
|
|
rle = false;
|
||
|
|
//END RLE
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
function quic_four_uncompress_row0(encoder, channel, bpc, type) {
|
||
|
|
var bpc_mask = wdi.JSQuic.BPC_MASK[type];
|
||
|
|
var pos = 0;
|
||
|
|
var width = encoder.width;
|
||
|
|
while ((wdi.JSQuic.wmimax > channel.state.wmidx) && (channel.state.wmileft <= width)) {
|
||
|
|
if (channel.state.wmileft) {
|
||
|
|
uncompress_four_row0_seg(
|
||
|
|
encoder,
|
||
|
|
channel,
|
||
|
|
pos,
|
||
|
|
pos + channel.wmileft,
|
||
|
|
wdi.JSQuic.bppmask[channel.state.wmidx],
|
||
|
|
bpc,
|
||
|
|
bpc_mask,
|
||
|
|
type
|
||
|
|
);
|
||
|
|
pos += channel.state.wmileft;
|
||
|
|
width -= channel.state.wmileft;
|
||
|
|
}
|
||
|
|
|
||
|
|
channel.state.wmidx++;
|
||
|
|
wdi.JSQuic.set_wm_trigger(channel.state);
|
||
|
|
channel.state.wmileft = wdi.JSQuic.wminext;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (width) {
|
||
|
|
uncompress_four_row0_seg(
|
||
|
|
encoder,
|
||
|
|
channel,
|
||
|
|
pos,
|
||
|
|
pos + width,
|
||
|
|
wdi.JSQuic.bppmask[channel.state.wmidx],
|
||
|
|
bpc,
|
||
|
|
bpc_mask,
|
||
|
|
type
|
||
|
|
);
|
||
|
|
if (wdi.JSQuic.wmimax > channel.state.wmidx) {
|
||
|
|
channel.state.wmileft -= width;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function uncompress_four_row0_seg(encoder, channel, i, end, waitmask, bpc, bpc_mask, type) {
|
||
|
|
var correlate_row = channel.correlate_row;
|
||
|
|
|
||
|
|
var stopidx = 0;
|
||
|
|
|
||
|
|
if (!i) {
|
||
|
|
UNCOMPRESS_ONE_ROW0_0_A(channel);
|
||
|
|
|
||
|
|
if (channel.state.waitcnt) {
|
||
|
|
--channel.state.waitcnt;
|
||
|
|
} else {
|
||
|
|
channel.state.waitcnt = (wdi.JSQuic.tabrand(channel.state) & waitmask);
|
||
|
|
real_update_model(channel.state, find_bucket(channel,
|
||
|
|
correlate_row[-1]), correlate_row[0], bpc);
|
||
|
|
}
|
||
|
|
stopidx = ++i + channel.state.waitcnt;
|
||
|
|
} else {
|
||
|
|
stopidx = i + channel.state.waitcnt;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (stopidx < end) {
|
||
|
|
for (; i <= stopidx; i++) {
|
||
|
|
UNCOMPRESS_ONE_ROW0_A(channel, i, bpc_mask, encoder, correlate_row);
|
||
|
|
}
|
||
|
|
real_update_model(channel.state, find_bucket(channel,
|
||
|
|
correlate_row[stopidx - 1]), correlate_row[stopidx], bpc);
|
||
|
|
stopidx = i + (wdi.JSQuic.tabrand(channel.state) & waitmask);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (; i < end; i++) {
|
||
|
|
UNCOMPRESS_ONE_ROW0_A(channel, i, bpc_mask, encoder, correlate_row);
|
||
|
|
}
|
||
|
|
channel.state.waitcnt = stopidx - end;
|
||
|
|
}
|
||
|
|
|
||
|
|
function SAME_PIXEL_A(i, result) {
|
||
|
|
if (result[i - 1] === result[i + 3]) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
function RLE_PRED_A(i, encoder, run_index, width, rows_completed) {
|
||
|
|
var pr = ((rows_completed - 1) * width) + (i * 4); //prev r
|
||
|
|
if (run_index !== i && i > 2) {
|
||
|
|
if (SAME_PIXEL_A(pr, encoder.result)) {
|
||
|
|
pr = ((rows_completed) * width) + ((i - 1) * 4); // cur r
|
||
|
|
if (SAME_PIXEL_A(pr, encoder.result)) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
function UNCOMPRESS_ONE_0_A(channel, encoder, bpc_mask, offset) {
|
||
|
|
var ret, codewordlen;
|
||
|
|
channel.oldFirst = channel.correlate_row[0];
|
||
|
|
ret = golomb_decoding(find_bucket(channel,
|
||
|
|
channel.correlate_row[-1]).bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
|
||
|
|
channel.correlate_row[0] = ret[0];
|
||
|
|
codewordlen = ret[1];
|
||
|
|
var residuum = wdi.xlatL2U[channel.correlate_row[0]];
|
||
|
|
var prev = PIXEL_B(channel, encoder, 0, offset);
|
||
|
|
var resultpixel = ((residuum + prev) & bpc_mask) >>> 0;
|
||
|
|
encoder.appendAlpha(resultpixel);
|
||
|
|
encoder.eatbits(codewordlen, encoder);
|
||
|
|
return resultpixel;
|
||
|
|
}
|
||
|
|
|
||
|
|
function UNCOMPRESS_ONE_A(channel, i, bpc_mask, encoder, correlate_row, offset) {
|
||
|
|
var ret, codewordlen;
|
||
|
|
ret = golomb_decoding(find_bucket(channel, correlate_row[i - 1]).bestcode,
|
||
|
|
encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
|
||
|
|
var data = ret[0];
|
||
|
|
codewordlen = ret[1];
|
||
|
|
correlate_row[i] = data;
|
||
|
|
encoder.appendAlpha((((wdi.xlatL2U[data] +
|
||
|
|
((PIXEL_A_A(encoder) + PIXEL_B(channel, encoder, i, offset)) >>> 1)) & bpc_mask) >>> 0));
|
||
|
|
|
||
|
|
encoder.eatbits(codewordlen, encoder);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
function UNCOMPRESS_ONE_ROW0_0_A(channel) {
|
||
|
|
var ret, codewordlen;
|
||
|
|
var encoder = channel.encoder;
|
||
|
|
ret = golomb_decoding(find_bucket(channel, 0).bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
|
||
|
|
channel.correlate_row[0] = ret[0];
|
||
|
|
codewordlen = ret[1];
|
||
|
|
encoder.appendAlpha(wdi.xlatL2U[channel.correlate_row[0]]);
|
||
|
|
encoder.eatbits(codewordlen, encoder);
|
||
|
|
}
|
||
|
|
|
||
|
|
function UNCOMPRESS_ONE_ROW0_A(channel, i, bpc_mask, encoder, correlate_row) {
|
||
|
|
var ret, codewordlen;
|
||
|
|
ret = golomb_decoding(find_bucket(channel, correlate_row[i - 1]).bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
|
||
|
|
var data = ret[0];
|
||
|
|
codewordlen = ret[1];
|
||
|
|
correlate_row[i] = data;
|
||
|
|
encoder.appendAlpha(CORELATE_0_A(encoder, channel, i, bpc_mask, correlate_row));
|
||
|
|
encoder.eatbits(codewordlen, encoder);
|
||
|
|
}
|
||
|
|
|
||
|
|
function CORELATE_0_A(encoder, channel, curr, bpc_mask, correlate_row) {
|
||
|
|
return ((wdi.xlatL2U[correlate_row[curr]] + PIXEL_A_A(encoder)) & bpc_mask) >>> 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
function PIXEL_A_A(encoder) {
|
||
|
|
return encoder.result[encoder.alphaPos - 4];
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
*
|
||
|
|
*
|
||
|
|
* JSQUIC UNCOMPRESS
|
||
|
|
*
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
function QUIC_UNCOMPRESS_RGB(encoder, channels, bpc, type) {
|
||
|
|
quic_uncompress_row0(encoder, channels, bpc, type);
|
||
|
|
encoder.row_completed();
|
||
|
|
|
||
|
|
var rgb_state = encoder.rgb_state;
|
||
|
|
var height = encoder.height;
|
||
|
|
var computedAlpha = 255 << 24;
|
||
|
|
var result = encoder.result;
|
||
|
|
var resultData = encoder.resultData;
|
||
|
|
var width = encoder.width;
|
||
|
|
var bpc_mask = wdi.JSQuic.BPC_MASK[type];
|
||
|
|
var jsquic = wdi.JSQuic;
|
||
|
|
var channel_r = encoder.channels[0];
|
||
|
|
var channel_g = encoder.channels[1];
|
||
|
|
var channel_b = encoder.channels[2];
|
||
|
|
var buckets_ptrs_r = channel_r._buckets_ptrs;
|
||
|
|
var buckets_ptrs_g = channel_g._buckets_ptrs;
|
||
|
|
var buckets_ptrs_b = channel_b._buckets_ptrs;
|
||
|
|
var correlate_row_r = channel_r.correlate_row;
|
||
|
|
var correlate_row_g = channel_g.correlate_row;
|
||
|
|
var correlate_row_b = channel_b.correlate_row;
|
||
|
|
var computedWidth = encoder.computedWidth;
|
||
|
|
var xlatL2U = wdi.xlatL2U;
|
||
|
|
var lzeroes = wdi.JSQuic.lzeroes;
|
||
|
|
var lzeroes8 = wdi.JSQuic.lzeroes8;
|
||
|
|
var lzeroes16 = wdi.JSQuic.lzeroes16;
|
||
|
|
var lzeroes24 = wdi.JSQuic.lzeroes24;
|
||
|
|
var notGRprefixmask = wdi.notGRprefixmask;
|
||
|
|
var notGRcwlen = wdi.notGRcwlen;
|
||
|
|
var nGRcodewords = wdi.nGRcodewords;
|
||
|
|
var notGRsuffixlen = wdi.notGRsuffixlen;
|
||
|
|
var eatbits = encoder.eatbits;
|
||
|
|
var tabrand = wdi.JSQuic.tabrand;
|
||
|
|
var decode_run = wdi.JSQuic.decode_run;
|
||
|
|
var bppmask = wdi.JSQuic.bppmask;
|
||
|
|
var jsquic = wdi.JSQuic;
|
||
|
|
var tabrand_chaos = wdi.JSQuic.tabrand_chaos;
|
||
|
|
var tabrand_seedmask = jsquic.TABRAND_SEEDMASK;
|
||
|
|
var usr = encoder.usr;
|
||
|
|
|
||
|
|
for (var row = 1; row < height; row++) {
|
||
|
|
quic_uncompress_row(encoder, channels, bpc, type, rgb_state, computedAlpha, result, resultData, width, bpc_mask,
|
||
|
|
jsquic, channel_r, channel_g, channel_b, buckets_ptrs_r, buckets_ptrs_g, buckets_ptrs_b, correlate_row_r,
|
||
|
|
correlate_row_g, correlate_row_b, computedWidth, xlatL2U, lzeroes, lzeroes8, lzeroes16, lzeroes24,
|
||
|
|
notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen, eatbits, tabrand, decode_run, bppmask, tabrand_chaos,
|
||
|
|
tabrand_seedmask, usr);
|
||
|
|
encoder.rows_completed++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
function quic_uncompress_row(encoder, channels, bpc, type, rgb_state, computedAlpha, result, resultData, width, bpc_mask,
|
||
|
|
jsquic, channel_r, channel_g, channel_b, buckets_ptrs_r, buckets_ptrs_g, buckets_ptrs_b, correlate_row_r, correlate_row_g,
|
||
|
|
correlate_row_b, computedWidth, xlatL2U, lzeroes, lzeroes8, lzeroes16, lzeroes24,
|
||
|
|
notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen, eatbits, tabrand, decode_run, bppmask, tabrand_chaos,
|
||
|
|
tabrand_seedmask, usr) {
|
||
|
|
|
||
|
|
var pos = 0;
|
||
|
|
var rows_completed = encoder.rows_completed;
|
||
|
|
var currentOffset32 = ((rows_completed) * computedWidth / 4);
|
||
|
|
var offset = ((rows_completed - 1) * computedWidth);
|
||
|
|
while ((jsquic.wmimax > rgb_state.wmidx) && (rgb_state.wmileft <= width)) {
|
||
|
|
if (rgb_state.wmileft) {
|
||
|
|
uncompress_row_seg(
|
||
|
|
encoder,
|
||
|
|
pos,
|
||
|
|
pos + rgb_state.wmileft,
|
||
|
|
bpc,
|
||
|
|
bpc_mask,
|
||
|
|
type,
|
||
|
|
rgb_state,
|
||
|
|
computedAlpha,
|
||
|
|
result,
|
||
|
|
resultData,
|
||
|
|
channel_r,
|
||
|
|
channel_g,
|
||
|
|
channel_b,
|
||
|
|
buckets_ptrs_r,
|
||
|
|
buckets_ptrs_g,
|
||
|
|
buckets_ptrs_b,
|
||
|
|
correlate_row_r,
|
||
|
|
correlate_row_g,
|
||
|
|
correlate_row_b,
|
||
|
|
computedWidth,
|
||
|
|
xlatL2U,
|
||
|
|
lzeroes,
|
||
|
|
lzeroes8,
|
||
|
|
lzeroes16,
|
||
|
|
lzeroes24,
|
||
|
|
notGRprefixmask,
|
||
|
|
notGRcwlen,
|
||
|
|
nGRcodewords,
|
||
|
|
notGRsuffixlen,
|
||
|
|
eatbits,
|
||
|
|
tabrand,
|
||
|
|
decode_run,
|
||
|
|
bppmask,
|
||
|
|
jsquic,
|
||
|
|
tabrand_chaos,
|
||
|
|
rows_completed,
|
||
|
|
tabrand_seedmask,
|
||
|
|
offset,
|
||
|
|
currentOffset32,
|
||
|
|
usr
|
||
|
|
);
|
||
|
|
pos += rgb_state.wmileft;
|
||
|
|
width -= rgb_state.wmileft;
|
||
|
|
}
|
||
|
|
|
||
|
|
rgb_state.wmidx++;
|
||
|
|
jsquic.set_wm_trigger(rgb_state);
|
||
|
|
rgb_state.wmileft = jsquic.wminext;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (width) {
|
||
|
|
uncompress_row_seg(
|
||
|
|
encoder,
|
||
|
|
pos,
|
||
|
|
pos + width,
|
||
|
|
bpc,
|
||
|
|
bpc_mask,
|
||
|
|
type,
|
||
|
|
rgb_state,
|
||
|
|
computedAlpha,
|
||
|
|
result,
|
||
|
|
resultData,
|
||
|
|
channel_r,
|
||
|
|
channel_g,
|
||
|
|
channel_b,
|
||
|
|
buckets_ptrs_r,
|
||
|
|
buckets_ptrs_g,
|
||
|
|
buckets_ptrs_b,
|
||
|
|
correlate_row_r,
|
||
|
|
correlate_row_g,
|
||
|
|
correlate_row_b,
|
||
|
|
computedWidth,
|
||
|
|
xlatL2U,
|
||
|
|
lzeroes,
|
||
|
|
lzeroes8,
|
||
|
|
lzeroes16,
|
||
|
|
lzeroes24,
|
||
|
|
notGRprefixmask,
|
||
|
|
notGRcwlen,
|
||
|
|
nGRcodewords,
|
||
|
|
notGRsuffixlen,
|
||
|
|
eatbits,
|
||
|
|
tabrand,
|
||
|
|
decode_run,
|
||
|
|
bppmask,
|
||
|
|
jsquic,
|
||
|
|
tabrand_chaos,
|
||
|
|
rows_completed,
|
||
|
|
tabrand_seedmask,
|
||
|
|
offset,
|
||
|
|
currentOffset32,
|
||
|
|
usr
|
||
|
|
);
|
||
|
|
if (jsquic.wmimax > encoder.rgb_state.wmidx) {
|
||
|
|
rgb_state.wmileft -= width;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
function quic_uncompress_row_a(encoder, channels, bpc, type, rgb_state) {
|
||
|
|
var bpc_mask = wdi.JSQuic.BPC_MASK[type];
|
||
|
|
var pos = 0;
|
||
|
|
var width = encoder.width;
|
||
|
|
while ((wdi.JSQuic.wmimax > rgb_state.wmidx) && (rgb_state.wmileft <= width)) {
|
||
|
|
if (rgb_state.wmileft) {
|
||
|
|
uncompress_row_seg_a(
|
||
|
|
encoder,
|
||
|
|
pos,
|
||
|
|
pos + rgb_state.wmileft,
|
||
|
|
bpc,
|
||
|
|
bpc_mask,
|
||
|
|
type,
|
||
|
|
rgb_state
|
||
|
|
);
|
||
|
|
pos += rgb_state.wmileft;
|
||
|
|
width -= rgb_state.wmileft;
|
||
|
|
}
|
||
|
|
|
||
|
|
rgb_state.wmidx++;
|
||
|
|
wdi.JSQuic.set_wm_trigger(rgb_state);
|
||
|
|
rgb_state.wmileft = wdi.JSQuic.wminext;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (width) {
|
||
|
|
uncompress_row_seg_a(
|
||
|
|
encoder,
|
||
|
|
pos,
|
||
|
|
pos + width,
|
||
|
|
bpc,
|
||
|
|
bpc_mask,
|
||
|
|
type,
|
||
|
|
rgb_state
|
||
|
|
);
|
||
|
|
if (wdi.JSQuic.wmimax > encoder.rgb_state.wmidx) {
|
||
|
|
rgb_state.wmileft -= width;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function SAME_PIXEL_RGB_A(i, result) {
|
||
|
|
|
||
|
|
if (result[i - 4] === result[i] && result[i - 3] === result[i + 1] && result[i - 2] === result[i + 2])
|
||
|
|
return true;
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
function SAME_PIXEL(i, result) {
|
||
|
|
|
||
|
|
if (result[i - 1] === result[i])
|
||
|
|
return true;
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
function RLE_PRED_RGB_A(i, encoder, offset, currentOffset, run_index) {
|
||
|
|
if (run_index !== i && i > 2) {
|
||
|
|
if (SAME_PIXEL_RGB_A(offset, encoder.result)) { //fila de arriba
|
||
|
|
var pr = currentOffset + ((i - 1) * 4);
|
||
|
|
if (SAME_PIXEL_RGB_A(pr, encoder.result)) { //pixel de la izquierda
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
function RLE_PRED(i, encoder, offset, currentOffset, run_index) {
|
||
|
|
if (run_index !== i && i > 2) {
|
||
|
|
if (SAME_PIXEL(offset * 4, encoder.result)) { //fila de arriba
|
||
|
|
var pr = currentOffset + i - 1;
|
||
|
|
if (SAME_PIXEL(pr * 4, encoder.result)) { //pixel de la izquierda
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
function uncompress_row_seg(encoder, i, end, bpc, bpc_mask, type, rgb_state, computedAlpha, result, resultData,
|
||
|
|
channel_r, channel_g, channel_b, buckets_ptrs_r, buckets_ptrs_g, buckets_ptrs_b, correlate_row_r, correlate_row_g,
|
||
|
|
correlate_row_b, computedWidth, xlatL2U, lzeroes, lzeroes8, lzeroes16, lzeroes24, notGRprefixmask, notGRcwlen,
|
||
|
|
nGRcodewords, notGRsuffixlen, eatbits, tabrand, decode_run, bppmask, jsquic, tabrand_chaos, rows_completed,
|
||
|
|
tabrand_seedmask, offset, currentOffset32, usr) {
|
||
|
|
|
||
|
|
var stopidx = 0;
|
||
|
|
var waitmask = bppmask[rgb_state.wmidx];
|
||
|
|
var run_index = 0;
|
||
|
|
var rle = false;
|
||
|
|
|
||
|
|
//var offset = ((rows_completed-1) * computedWidth);
|
||
|
|
//var currentOffset32 = ((rows_completed) * computedWidth/4);
|
||
|
|
|
||
|
|
var i_1, i_4; //for performance improvments
|
||
|
|
|
||
|
|
var pr, pg, pb;
|
||
|
|
|
||
|
|
var prevCorrelatedR, prevCorrelatedG, prevCorrelatedB;
|
||
|
|
var ret, codewordlen, l, bits, zeroprefix;
|
||
|
|
|
||
|
|
var cnt = encoder.cnt;
|
||
|
|
var pxCnt = encoder.pxCnt;
|
||
|
|
|
||
|
|
var prev_row, i4sub, stopidx_sub1;
|
||
|
|
|
||
|
|
var available_bits, io_word, delta, io_next_word;
|
||
|
|
|
||
|
|
if (!i) {
|
||
|
|
pr = UNCOMPRESS_ONE_0(channel_r, encoder, bpc_mask, offset);
|
||
|
|
pg = UNCOMPRESS_ONE_0(channel_g, encoder, bpc_mask, offset);
|
||
|
|
pb = UNCOMPRESS_ONE_0(channel_b, encoder, bpc_mask, offset);
|
||
|
|
|
||
|
|
prevCorrelatedR = correlate_row_r[0];
|
||
|
|
prevCorrelatedG = correlate_row_g[0];
|
||
|
|
prevCorrelatedB = correlate_row_b[0];
|
||
|
|
//inlined appendPixel
|
||
|
|
resultData[pxCnt++] =
|
||
|
|
255 << 24 | // alpha
|
||
|
|
pb << 16 | // blue
|
||
|
|
pg << 8 | // green
|
||
|
|
pr; // red
|
||
|
|
//cnt += 4;
|
||
|
|
|
||
|
|
if (rgb_state.waitcnt) {
|
||
|
|
--rgb_state.waitcnt;
|
||
|
|
} else {
|
||
|
|
rgb_state.waitcnt = (tabrand.call(jsquic, rgb_state) & waitmask);
|
||
|
|
UPDATE_MODEL(0, encoder, bpc, correlate_row_r, correlate_row_g, correlate_row_b);
|
||
|
|
}
|
||
|
|
stopidx = ++i + rgb_state.waitcnt;
|
||
|
|
} else {
|
||
|
|
stopidx = i + rgb_state.waitcnt;
|
||
|
|
pr = result[cnt - 4];
|
||
|
|
pg = result[cnt - 3];
|
||
|
|
pb = result[cnt - 2];
|
||
|
|
|
||
|
|
prevCorrelatedR = correlate_row_r[i - 1];
|
||
|
|
prevCorrelatedG = correlate_row_g[i - 1];
|
||
|
|
prevCorrelatedB = correlate_row_b[i - 1];
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
while (true) {
|
||
|
|
while (stopidx < end) {
|
||
|
|
i_4 = offset + i * 4;
|
||
|
|
for (; i <= stopidx; i++) {
|
||
|
|
/////// critical part
|
||
|
|
//rle = RLE_PRED(i, encoder, ci, currentOffset32, run_index);
|
||
|
|
//RLE_PRED INLINE
|
||
|
|
//inlined same_pixel, see original rle_pred
|
||
|
|
i4sub = i_4 / 4;
|
||
|
|
if (resultData[i4sub - 1] === resultData[i4sub]) { //fila de arriba
|
||
|
|
prev_row = currentOffset32 + i - 1;
|
||
|
|
if (resultData[prev_row - 1] === resultData[prev_row]) { //pixel de la izquierda
|
||
|
|
if (run_index !== i && i > 2) {
|
||
|
|
rle = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/////////////////////// INLINING UNCOMPRESS_ONE
|
||
|
|
//r
|
||
|
|
/////////////////////// INLINING GOLOMB_DECODING
|
||
|
|
//ret = golomb_decoding(buckets_ptrs_r[prevCorrelatedR].bestcode,
|
||
|
|
// encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
l = buckets_ptrs_r[prevCorrelatedR].bestcode;
|
||
|
|
bits = encoder.io_word;
|
||
|
|
if (bits > notGRprefixmask[l]) {
|
||
|
|
//zeroprefix = cnt_l_zeroes(bits);
|
||
|
|
|
||
|
|
if (bits > 0x007FFFFF) {
|
||
|
|
zeroprefix = lzeroes[bits >>> 24];
|
||
|
|
} else if (bits > 0x00007FFF) {
|
||
|
|
zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
|
||
|
|
} else if (bits > 0x0000007F) {
|
||
|
|
zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff)];
|
||
|
|
} else {
|
||
|
|
zeroprefix = lzeroes24[(bits & 0x000000ff)];
|
||
|
|
}
|
||
|
|
|
||
|
|
codewordlen = zeroprefix + 1 + l;
|
||
|
|
prevCorrelatedR = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
|
||
|
|
} else {
|
||
|
|
codewordlen = notGRcwlen[l];
|
||
|
|
prevCorrelatedR = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
correlate_row_r[i] = prevCorrelatedR;
|
||
|
|
|
||
|
|
pr = ((((xlatL2U[prevCorrelatedR] +
|
||
|
|
((pr +
|
||
|
|
result[i_4++]) >>> 1)) & bpc_mask)));
|
||
|
|
|
||
|
|
//eatbits(codewordlen, encoder);
|
||
|
|
//INLINING EATBITS
|
||
|
|
available_bits = encoder.io_available_bits;
|
||
|
|
io_word = encoder.io_word;
|
||
|
|
|
||
|
|
delta = available_bits - codewordlen;
|
||
|
|
|
||
|
|
io_word = io_word << codewordlen;
|
||
|
|
|
||
|
|
//enough bits
|
||
|
|
if (delta >= 0) {
|
||
|
|
io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
|
||
|
|
encoder.io_available_bits = delta;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
} else {
|
||
|
|
io_next_word = encoder.io_next_word;
|
||
|
|
//not enough bits
|
||
|
|
delta = -delta; //bits missing
|
||
|
|
io_word = (io_word | (io_next_word << delta) >>> 0);
|
||
|
|
|
||
|
|
///////////////////
|
||
|
|
//read io word (inlined for perforemance)
|
||
|
|
|
||
|
|
io_next_word = usr[encoder.io_now++];
|
||
|
|
//end read io_word
|
||
|
|
/////////////////
|
||
|
|
|
||
|
|
available_bits = 32 - delta;
|
||
|
|
io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
|
||
|
|
|
||
|
|
encoder.io_available_bits = available_bits;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
encoder.io_next_word = io_next_word;
|
||
|
|
}
|
||
|
|
//END INLINING
|
||
|
|
|
||
|
|
//g
|
||
|
|
///////////////////////////////////////INLINING golomb_decoding
|
||
|
|
|
||
|
|
//ret = golomb_decoding(buckets_ptrs_g[prevCorrelatedG].bestcode,
|
||
|
|
// encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
l = buckets_ptrs_g[prevCorrelatedG].bestcode;
|
||
|
|
bits = encoder.io_word;
|
||
|
|
|
||
|
|
if (bits > notGRprefixmask[l]) {
|
||
|
|
//zeroprefix = cnt_l_zeroes(bits);
|
||
|
|
|
||
|
|
if (bits > 0x007FFFFF) {
|
||
|
|
zeroprefix = lzeroes[bits >>> 24];
|
||
|
|
} else if (bits > 0x00007FFF) {
|
||
|
|
zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
|
||
|
|
} else if (bits > 0x0000007F) {
|
||
|
|
zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff)];
|
||
|
|
} else {
|
||
|
|
zeroprefix = lzeroes24[(bits & 0x000000ff)];
|
||
|
|
}
|
||
|
|
|
||
|
|
codewordlen = zeroprefix + 1 + l;
|
||
|
|
prevCorrelatedG = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
|
||
|
|
} else {
|
||
|
|
codewordlen = notGRcwlen[l];
|
||
|
|
prevCorrelatedG = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
correlate_row_g[i] = prevCorrelatedG;
|
||
|
|
|
||
|
|
pg = ((((xlatL2U[prevCorrelatedG] +
|
||
|
|
((pg +
|
||
|
|
result[i_4++]) >>> 1)) & bpc_mask)));
|
||
|
|
|
||
|
|
//INLINING EATBITS
|
||
|
|
available_bits = encoder.io_available_bits;
|
||
|
|
io_word = encoder.io_word;
|
||
|
|
|
||
|
|
delta = available_bits - codewordlen;
|
||
|
|
|
||
|
|
io_word = io_word << codewordlen;
|
||
|
|
|
||
|
|
//enough bits
|
||
|
|
if (delta >= 0) {
|
||
|
|
io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
|
||
|
|
encoder.io_available_bits = delta;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
} else {
|
||
|
|
io_next_word = encoder.io_next_word;
|
||
|
|
//not enough bits
|
||
|
|
delta = -delta; //bits missing
|
||
|
|
io_word = (io_word | (io_next_word << delta) >>> 0);
|
||
|
|
|
||
|
|
///////////////////
|
||
|
|
//read io word (inlined for perforemance)
|
||
|
|
|
||
|
|
io_next_word = usr[encoder.io_now++];
|
||
|
|
//end read io_word
|
||
|
|
/////////////////
|
||
|
|
|
||
|
|
available_bits = 32 - delta;
|
||
|
|
io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
|
||
|
|
|
||
|
|
encoder.io_available_bits = available_bits;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
encoder.io_next_word = io_next_word;
|
||
|
|
}
|
||
|
|
//END INLINING
|
||
|
|
|
||
|
|
//b
|
||
|
|
////////////////////////////////// INLINING golomb_decoding
|
||
|
|
//ret = golomb_decoding(buckets_ptrs_b[prevCorrelatedB].bestcode,
|
||
|
|
// encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
l = buckets_ptrs_b[prevCorrelatedB].bestcode;
|
||
|
|
bits = encoder.io_word;
|
||
|
|
|
||
|
|
if (bits > notGRprefixmask[l]) {
|
||
|
|
//zeroprefix = cnt_l_zeroes(bits);
|
||
|
|
|
||
|
|
if (bits > 0x007FFFFF) {
|
||
|
|
zeroprefix = lzeroes[bits >>> 24];
|
||
|
|
} else if (bits > 0x00007FFF) {
|
||
|
|
zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
|
||
|
|
} else if (bits > 0x0000007F) {
|
||
|
|
zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff)];
|
||
|
|
} else {
|
||
|
|
zeroprefix = lzeroes24[(bits & 0x000000ff)];
|
||
|
|
}
|
||
|
|
|
||
|
|
codewordlen = zeroprefix + 1 + l;
|
||
|
|
prevCorrelatedB = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
|
||
|
|
} else {
|
||
|
|
codewordlen = notGRcwlen[l];
|
||
|
|
prevCorrelatedB = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
correlate_row_b[i] = prevCorrelatedB;
|
||
|
|
|
||
|
|
pb = ((((xlatL2U[prevCorrelatedB] +
|
||
|
|
((pb +
|
||
|
|
result[i_4++]) >>> 1)) & bpc_mask)));
|
||
|
|
|
||
|
|
//INLINING EATBITS
|
||
|
|
available_bits = encoder.io_available_bits;
|
||
|
|
io_word = encoder.io_word;
|
||
|
|
|
||
|
|
delta = available_bits - codewordlen;
|
||
|
|
|
||
|
|
io_word = io_word << codewordlen;
|
||
|
|
|
||
|
|
//enough bits
|
||
|
|
if (delta >= 0) {
|
||
|
|
io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
|
||
|
|
encoder.io_available_bits = delta;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
} else {
|
||
|
|
io_next_word = encoder.io_next_word;
|
||
|
|
//not enough bits
|
||
|
|
delta = -delta; //bits missing
|
||
|
|
io_word = (io_word | (io_next_word << delta) >>> 0);
|
||
|
|
|
||
|
|
///////////////////
|
||
|
|
//read io word (inlined for perforemance)
|
||
|
|
|
||
|
|
io_next_word = usr[encoder.io_now++];
|
||
|
|
//end read io_word
|
||
|
|
/////////////////
|
||
|
|
|
||
|
|
available_bits = 32 - delta;
|
||
|
|
io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
|
||
|
|
|
||
|
|
encoder.io_available_bits = available_bits;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
encoder.io_next_word = io_next_word;
|
||
|
|
}
|
||
|
|
//END INLINING
|
||
|
|
////////////////////// END INLINING
|
||
|
|
|
||
|
|
/**
|
||
|
|
pr = UNCOMPRESS_ONE(channel_r, i, i_1, i_4, bpc_mask, encoder, correlate_row_r, offset, result, 0, xlatL2U, buckets_ptrs_r, pr);
|
||
|
|
pg = UNCOMPRESS_ONE(channel_g, i, i_1, i_4, bpc_mask, encoder, correlate_row_g, offset, result, 1, xlatL2U, buckets_ptrs_g, pg);
|
||
|
|
pb = UNCOMPRESS_ONE(channel_b, i, i_1, i_4, bpc_mask, encoder, correlate_row_b, offset, result, 2, xlatL2U, buckets_ptrs_b, pb);
|
||
|
|
**/
|
||
|
|
|
||
|
|
|
||
|
|
//this is inlined appendPixel
|
||
|
|
resultData[pxCnt++] =
|
||
|
|
computedAlpha | // alpha
|
||
|
|
pb << 16 | // blue
|
||
|
|
pg << 8 | // green
|
||
|
|
pr; // red
|
||
|
|
//cnt += 4;
|
||
|
|
i_4++; //skip alpha
|
||
|
|
}
|
||
|
|
if (!rle) {
|
||
|
|
//UPDATE_MODEL(stopidx, encoder, bpc, correlate_row_r, correlate_row_g, correlate_row_b);
|
||
|
|
//inlining update_model
|
||
|
|
stopidx_sub1 = stopidx - 1;
|
||
|
|
real_update_model(rgb_state, buckets_ptrs_r[correlate_row_r[stopidx_sub1]],
|
||
|
|
correlate_row_r[stopidx], bpc);
|
||
|
|
real_update_model(rgb_state, buckets_ptrs_g[correlate_row_g[stopidx_sub1]],
|
||
|
|
correlate_row_g[stopidx], bpc);
|
||
|
|
real_update_model(rgb_state, buckets_ptrs_b[correlate_row_b[stopidx_sub1]],
|
||
|
|
correlate_row_b[stopidx], bpc);
|
||
|
|
//end inlining
|
||
|
|
|
||
|
|
rgb_state.tabrand_seed++;
|
||
|
|
stopidx = i + ((tabrand_chaos[rgb_state.tabrand_seed & tabrand_seedmask]) & waitmask);
|
||
|
|
|
||
|
|
|
||
|
|
} else {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!rle) {
|
||
|
|
i_4 = offset + i * 4;
|
||
|
|
for (; i < end; i++) {
|
||
|
|
//ci = offset32+i;
|
||
|
|
//rle = RLE_PRED(i, encoder, ci, currentOffset32, run_index);
|
||
|
|
//RLE_PRED INLINE
|
||
|
|
//inlined same_pixel, see original rle_pred
|
||
|
|
i4sub = i_4 / 4;
|
||
|
|
if (resultData[i4sub - 1] === resultData[i4sub]) { //fila de arriba
|
||
|
|
prev_row = currentOffset32 + i - 1;
|
||
|
|
if (resultData[prev_row - 1] === resultData[prev_row]) { //pixel de la izquierda
|
||
|
|
if (run_index !== i && i > 2) {
|
||
|
|
rle = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//END INLINE*/
|
||
|
|
|
||
|
|
|
||
|
|
////////////////////// INLINING UNCOMPRESS_ONE
|
||
|
|
//r
|
||
|
|
//ret = golomb_decoding(buckets_ptrs_r[prevCorrelatedR].bestcode, encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
//prevCorrelatedR = ret[0];
|
||
|
|
//codewordlen = ret[1];
|
||
|
|
l = buckets_ptrs_r[prevCorrelatedR].bestcode;
|
||
|
|
bits = encoder.io_word;
|
||
|
|
|
||
|
|
if (bits > notGRprefixmask[l]) {
|
||
|
|
//zeroprefix = cnt_l_zeroes(bits);
|
||
|
|
|
||
|
|
if (bits > 0x007FFFFF) {
|
||
|
|
zeroprefix = lzeroes[bits >>> 24];
|
||
|
|
} else if (bits > 0x00007FFF) {
|
||
|
|
zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
|
||
|
|
} else if (bits > 0x0000007F) {
|
||
|
|
zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff)];
|
||
|
|
} else {
|
||
|
|
zeroprefix = lzeroes24[(bits & 0x000000ff)];
|
||
|
|
}
|
||
|
|
|
||
|
|
codewordlen = zeroprefix + 1 + l;
|
||
|
|
prevCorrelatedR = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
|
||
|
|
} else {
|
||
|
|
codewordlen = notGRcwlen[l];
|
||
|
|
prevCorrelatedR = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
correlate_row_r[i] = prevCorrelatedR;
|
||
|
|
|
||
|
|
pr = ((((xlatL2U[prevCorrelatedR] +
|
||
|
|
((pr +
|
||
|
|
result[i_4++]) >>> 1)) & bpc_mask)));
|
||
|
|
|
||
|
|
//INLINING EATBITS
|
||
|
|
available_bits = encoder.io_available_bits;
|
||
|
|
io_word = encoder.io_word;
|
||
|
|
|
||
|
|
delta = available_bits - codewordlen;
|
||
|
|
|
||
|
|
io_word = io_word << codewordlen;
|
||
|
|
|
||
|
|
//enough bits
|
||
|
|
if (delta >= 0) {
|
||
|
|
io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
|
||
|
|
encoder.io_available_bits = delta;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
} else {
|
||
|
|
io_next_word = encoder.io_next_word;
|
||
|
|
//not enough bits
|
||
|
|
delta = -delta; //bits missing
|
||
|
|
io_word = (io_word | (io_next_word << delta) >>> 0);
|
||
|
|
|
||
|
|
///////////////////
|
||
|
|
//read io word (inlined for perforemance)
|
||
|
|
|
||
|
|
io_next_word = usr[encoder.io_now++];
|
||
|
|
//end read io_word
|
||
|
|
/////////////////
|
||
|
|
|
||
|
|
available_bits = 32 - delta;
|
||
|
|
io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
|
||
|
|
|
||
|
|
encoder.io_available_bits = available_bits;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
encoder.io_next_word = io_next_word;
|
||
|
|
}
|
||
|
|
//END INLINING
|
||
|
|
|
||
|
|
//g
|
||
|
|
// ret = golomb_decoding(buckets_ptrs_g[prevCorrelatedG].bestcode, encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
// prevCorrelatedG = ret[0];
|
||
|
|
// codewordlen = ret[1];
|
||
|
|
|
||
|
|
l = buckets_ptrs_g[prevCorrelatedG].bestcode;
|
||
|
|
bits = encoder.io_word;
|
||
|
|
|
||
|
|
if (bits > notGRprefixmask[l]) {
|
||
|
|
//zeroprefix = cnt_l_zeroes(bits);
|
||
|
|
|
||
|
|
if (bits > 0x007FFFFF) {
|
||
|
|
zeroprefix = lzeroes[bits >>> 24];
|
||
|
|
} else if (bits > 0x00007FFF) {
|
||
|
|
zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
|
||
|
|
} else if (bits > 0x0000007F) {
|
||
|
|
zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff)];
|
||
|
|
} else {
|
||
|
|
zeroprefix = lzeroes24[(bits & 0x000000ff)];
|
||
|
|
}
|
||
|
|
|
||
|
|
codewordlen = zeroprefix + 1 + l;
|
||
|
|
prevCorrelatedG = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
|
||
|
|
} else {
|
||
|
|
codewordlen = notGRcwlen[l];
|
||
|
|
prevCorrelatedG = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
correlate_row_g[i] = prevCorrelatedG;
|
||
|
|
|
||
|
|
pg = ((((xlatL2U[prevCorrelatedG] +
|
||
|
|
((pg +
|
||
|
|
result[i_4++]) >>> 1)) & bpc_mask)));
|
||
|
|
|
||
|
|
//INLINING EATBITS
|
||
|
|
available_bits = encoder.io_available_bits;
|
||
|
|
io_word = encoder.io_word;
|
||
|
|
|
||
|
|
delta = available_bits - codewordlen;
|
||
|
|
|
||
|
|
io_word = io_word << codewordlen;
|
||
|
|
|
||
|
|
//enough bits
|
||
|
|
if (delta >= 0) {
|
||
|
|
io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
|
||
|
|
encoder.io_available_bits = delta;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
} else {
|
||
|
|
io_next_word = encoder.io_next_word;
|
||
|
|
//not enough bits
|
||
|
|
delta = -delta; //bits missing
|
||
|
|
io_word = (io_word | (io_next_word << delta) >>> 0);
|
||
|
|
|
||
|
|
///////////////////
|
||
|
|
//read io word (inlined for perforemance)
|
||
|
|
|
||
|
|
io_next_word = usr[encoder.io_now++];
|
||
|
|
//end read io_word
|
||
|
|
/////////////////
|
||
|
|
|
||
|
|
available_bits = 32 - delta;
|
||
|
|
io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
|
||
|
|
|
||
|
|
encoder.io_available_bits = available_bits;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
encoder.io_next_word = io_next_word;
|
||
|
|
}
|
||
|
|
//END INLINING
|
||
|
|
|
||
|
|
//b
|
||
|
|
// ret = golomb_decoding(buckets_ptrs_b[prevCorrelatedB].bestcode, encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
// prevCorrelatedB = ret[0];
|
||
|
|
// codewordlen = ret[1];
|
||
|
|
//
|
||
|
|
|
||
|
|
l = buckets_ptrs_b[prevCorrelatedB].bestcode;
|
||
|
|
bits = encoder.io_word;
|
||
|
|
|
||
|
|
if (bits > notGRprefixmask[l]) {
|
||
|
|
//zeroprefix = cnt_l_zeroes(bits);
|
||
|
|
|
||
|
|
if (bits > 0x007FFFFF) {
|
||
|
|
zeroprefix = lzeroes[bits >>> 24];
|
||
|
|
} else if (bits > 0x00007FFF) {
|
||
|
|
zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
|
||
|
|
} else if (bits > 0x0000007F) {
|
||
|
|
zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff)];
|
||
|
|
} else {
|
||
|
|
zeroprefix = lzeroes24[(bits & 0x000000ff)];
|
||
|
|
}
|
||
|
|
|
||
|
|
codewordlen = zeroprefix + 1 + l;
|
||
|
|
prevCorrelatedB = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
|
||
|
|
} else {
|
||
|
|
codewordlen = notGRcwlen[l];
|
||
|
|
prevCorrelatedB = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
|
||
|
|
}
|
||
|
|
correlate_row_b[i] = prevCorrelatedB;
|
||
|
|
|
||
|
|
pb = ((((xlatL2U[prevCorrelatedB] +
|
||
|
|
((pb +
|
||
|
|
result[i_4++]) >>> 1)) & bpc_mask)));
|
||
|
|
|
||
|
|
//INLINING EATBITS
|
||
|
|
available_bits = encoder.io_available_bits;
|
||
|
|
io_word = encoder.io_word;
|
||
|
|
|
||
|
|
delta = available_bits - codewordlen;
|
||
|
|
|
||
|
|
io_word = io_word << codewordlen;
|
||
|
|
|
||
|
|
//enough bits
|
||
|
|
if (delta >= 0) {
|
||
|
|
io_word = (io_word | encoder.io_next_word >>> delta) >>> 0;
|
||
|
|
encoder.io_available_bits = delta;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
} else {
|
||
|
|
io_next_word = encoder.io_next_word;
|
||
|
|
//not enough bits
|
||
|
|
delta = -delta; //bits missing
|
||
|
|
io_word = (io_word | (io_next_word << delta) >>> 0);
|
||
|
|
|
||
|
|
///////////////////
|
||
|
|
//read io word (inlined for perforemance)
|
||
|
|
|
||
|
|
io_next_word = usr[encoder.io_now++];
|
||
|
|
//end read io_word
|
||
|
|
/////////////////
|
||
|
|
|
||
|
|
available_bits = 32 - delta;
|
||
|
|
io_word = (io_word | (io_next_word >>> available_bits)) >>> 0;
|
||
|
|
|
||
|
|
encoder.io_available_bits = available_bits;
|
||
|
|
encoder.io_word = io_word;
|
||
|
|
encoder.io_next_word = io_next_word;
|
||
|
|
}
|
||
|
|
//END INLINING
|
||
|
|
///////////////////// END INLINING
|
||
|
|
|
||
|
|
/**
|
||
|
|
pr = UNCOMPRESS_ONE(channel_r, i, i_1, i_4, bpc_mask, encoder, correlate_row_r, offset, result, 0, xlatL2U, buckets_ptrs_r, pr);
|
||
|
|
pg = UNCOMPRESS_ONE(channel_g, i, i_1, i_4, bpc_mask, encoder, correlate_row_g, offset, result, 1, xlatL2U, buckets_ptrs_g, pg);
|
||
|
|
pb = UNCOMPRESS_ONE(channel_b, i, i_1, i_4, bpc_mask, encoder, correlate_row_b, offset, result, 2, xlatL2U, buckets_ptrs_b, pb);
|
||
|
|
**/
|
||
|
|
|
||
|
|
//this is inlined apendPixel
|
||
|
|
resultData[pxCnt++] =
|
||
|
|
(255 << 24) | // alpha
|
||
|
|
(pb << 16) | // blue
|
||
|
|
(pg << 8) | // green
|
||
|
|
pr; // red
|
||
|
|
//cnt += 4;
|
||
|
|
i_4++;
|
||
|
|
}
|
||
|
|
if (!rle) {
|
||
|
|
rgb_state.waitcnt = stopidx - end;
|
||
|
|
encoder.cnt = pxCnt * 4;
|
||
|
|
encoder.pxCnt = pxCnt;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
///END of critical part
|
||
|
|
|
||
|
|
//RLE
|
||
|
|
rgb_state.waitcnt = stopidx - i;
|
||
|
|
run_index = i;
|
||
|
|
run_end = decode_run(encoder);
|
||
|
|
|
||
|
|
i = run_end + i;
|
||
|
|
while (run_end-- > 0) {
|
||
|
|
//this is inlined appendPixel
|
||
|
|
resultData[pxCnt++] =
|
||
|
|
computedAlpha | // alpha
|
||
|
|
pb << 16 | // blue
|
||
|
|
pg << 8 | // green
|
||
|
|
pr; // red
|
||
|
|
//cnt += 4;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
if (i === end) {
|
||
|
|
encoder.cnt = pxCnt * 4;
|
||
|
|
encoder.pxCnt = pxCnt;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
i_1 = i - 1;
|
||
|
|
prevCorrelatedR = correlate_row_r[i_1];
|
||
|
|
prevCorrelatedG = correlate_row_g[i_1];
|
||
|
|
prevCorrelatedB = correlate_row_b[i_1];
|
||
|
|
|
||
|
|
stopidx = i + rgb_state.waitcnt;
|
||
|
|
rle = false;
|
||
|
|
//END RLE
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function uncompress_row_seg_a(encoder, i, end, bpc, bpc_mask, type, rgb_state) {
|
||
|
|
var channel_r = encoder.channels[0];
|
||
|
|
var channel_g = encoder.channels[1];
|
||
|
|
var channel_b = encoder.channels[2];
|
||
|
|
|
||
|
|
var buckets_ptrs_r = channel_r._buckets_ptrs;
|
||
|
|
var buckets_ptrs_g = channel_g._buckets_ptrs;
|
||
|
|
var buckets_ptrs_b = channel_b._buckets_ptrs;
|
||
|
|
|
||
|
|
var correlate_row_r = channel_r.correlate_row;
|
||
|
|
var correlate_row_g = channel_g.correlate_row;
|
||
|
|
var correlate_row_b = channel_b.correlate_row;
|
||
|
|
|
||
|
|
var stopidx = 0;
|
||
|
|
|
||
|
|
var waitmask = wdi.JSQuic.bppmask[rgb_state.wmidx];
|
||
|
|
|
||
|
|
var run_index = 0;
|
||
|
|
var run_end = 0;
|
||
|
|
|
||
|
|
var rle = false;
|
||
|
|
|
||
|
|
var computedWidth = encoder.computedWidth;
|
||
|
|
|
||
|
|
var offset = ((encoder.rows_completed - 1) * computedWidth);
|
||
|
|
var currentOffset = ((encoder.rows_completed) * computedWidth);
|
||
|
|
|
||
|
|
var offset32 = ((encoder.rows_completed - 1) * computedWidth / 4);
|
||
|
|
var currentOffset32 = ((encoder.rows_completed) * computedWidth / 4);
|
||
|
|
|
||
|
|
var result = encoder.result;
|
||
|
|
var resultData = encoder.resultData;
|
||
|
|
|
||
|
|
var i_1, i_4; //for performance improvments
|
||
|
|
|
||
|
|
var xlatL2U = wdi.xlatL2U;
|
||
|
|
|
||
|
|
var pr, pg, pb;
|
||
|
|
|
||
|
|
var prevCorrelatedR, prevCorrelatedG, prevCorrelatedB;
|
||
|
|
|
||
|
|
var eatbits = encoder.eatbits;
|
||
|
|
var tabrand = wdi.JSQuic.tabrand;
|
||
|
|
var decode_run = wdi.JSQuic.decode_run;
|
||
|
|
|
||
|
|
var ret, codewordlen, l, bits, zeroprefix;
|
||
|
|
var lzeroes = wdi.JSQuic.lzeroes;
|
||
|
|
var lzeroes8 = wdi.JSQuic.lzeroes8;
|
||
|
|
var lzeroes16 = wdi.JSQuic.lzeroes16;
|
||
|
|
var lzeroes24 = wdi.JSQuic.lzeroes24;
|
||
|
|
|
||
|
|
var cnt = encoder.cnt;
|
||
|
|
var pxCnt = encoder.pxCnt;
|
||
|
|
|
||
|
|
var bppmask = wdi.JSQuic.bppmask;
|
||
|
|
|
||
|
|
var notGRprefixmask = wdi.notGRprefixmask;
|
||
|
|
var notGRcwlen = wdi.notGRcwlen;
|
||
|
|
var nGRcodewords = wdi.nGRcodewords;
|
||
|
|
var notGRsuffixlen = wdi.notGRsuffixlen;
|
||
|
|
|
||
|
|
var prev_row, i4sub, ci;
|
||
|
|
|
||
|
|
var computedAlpha = 255 << 24;
|
||
|
|
|
||
|
|
if (!i) {
|
||
|
|
pr = UNCOMPRESS_ONE_0(channel_r, encoder, bpc_mask, offset);
|
||
|
|
pg = UNCOMPRESS_ONE_0(channel_g, encoder, bpc_mask, offset);
|
||
|
|
pb = UNCOMPRESS_ONE_0(channel_b, encoder, bpc_mask, offset);
|
||
|
|
|
||
|
|
prevCorrelatedR = correlate_row_r[0];
|
||
|
|
prevCorrelatedG = correlate_row_g[0];
|
||
|
|
prevCorrelatedB = correlate_row_b[0];
|
||
|
|
//inlined appendPixel
|
||
|
|
resultData[pxCnt++] =
|
||
|
|
(255 << 24) | // alpha
|
||
|
|
(pb << 16) | // blue
|
||
|
|
(pg << 8) | // green
|
||
|
|
pr; // red
|
||
|
|
//cnt += 4;
|
||
|
|
|
||
|
|
if (rgb_state.waitcnt) {
|
||
|
|
--rgb_state.waitcnt;
|
||
|
|
} else {
|
||
|
|
rgb_state.waitcnt = (tabrand.call(wdi.JSQuic, rgb_state) & waitmask);
|
||
|
|
UPDATE_MODEL(0, encoder, bpc, correlate_row_r, correlate_row_g, correlate_row_b);
|
||
|
|
}
|
||
|
|
stopidx = ++i + rgb_state.waitcnt;
|
||
|
|
} else {
|
||
|
|
stopidx = i + rgb_state.waitcnt;
|
||
|
|
pr = result[cnt - 4];
|
||
|
|
pg = result[cnt - 3];
|
||
|
|
pb = result[cnt - 2];
|
||
|
|
|
||
|
|
prevCorrelatedR = correlate_row_r[i - 1];
|
||
|
|
prevCorrelatedG = correlate_row_g[i - 1];
|
||
|
|
prevCorrelatedB = correlate_row_b[i - 1];
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
while (true) {
|
||
|
|
while (stopidx < end) {
|
||
|
|
i_4 = offset + i * 4;
|
||
|
|
for (; i <= stopidx; i++) {
|
||
|
|
/////// critical part
|
||
|
|
rle = RLE_PRED_RGB_A(i, encoder, i_4, currentOffset, run_index);
|
||
|
|
//RLE_PRED INLINE
|
||
|
|
/*if(run_index !== i && i > 2) {
|
||
|
|
//inlined same_pixel, see original rle_pred
|
||
|
|
i4sub = i_4/4;
|
||
|
|
if(encoder.resultData[i4sub-1] === encoder.resultData[i4sub]) { //fila de arriba
|
||
|
|
var prev_row = currentOffset32 + i-1;
|
||
|
|
if(encoder.resultData[prev_row-1] === encoder.resultData[prev_row]) { //pixel de la izquierda
|
||
|
|
rle = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}*/
|
||
|
|
//END INLINE
|
||
|
|
if (rle) break;
|
||
|
|
|
||
|
|
|
||
|
|
/////////////////////// INLINING UNCOMPRESS_ONE
|
||
|
|
//r
|
||
|
|
/////////////////////// INLINING GOLOMB_DECODING
|
||
|
|
//ret = golomb_decoding(buckets_ptrs_r[prevCorrelatedR].bestcode,
|
||
|
|
// encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
l = buckets_ptrs_r[prevCorrelatedR].bestcode;
|
||
|
|
bits = encoder.io_word;
|
||
|
|
if (bits > notGRprefixmask[l]) {
|
||
|
|
zeroprefix = cnt_l_zeroes(bits);
|
||
|
|
/*
|
||
|
|
if (bits > 0x007FFFFF) {
|
||
|
|
zeroprefix = lzeroes[bits >>> 24];
|
||
|
|
} else if (bits > 0x00007FFF) {
|
||
|
|
zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
|
||
|
|
} else if (bits > 0x0000007F) {
|
||
|
|
zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff) ];
|
||
|
|
} else {
|
||
|
|
zeroprefix = lzeroes24[(bits & 0x000000ff) ];
|
||
|
|
}*/
|
||
|
|
|
||
|
|
codewordlen = zeroprefix + 1 + l;
|
||
|
|
prevCorrelatedR = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
|
||
|
|
} else {
|
||
|
|
codewordlen = notGRcwlen[l];
|
||
|
|
prevCorrelatedR = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
correlate_row_r[i] = prevCorrelatedR;
|
||
|
|
|
||
|
|
pr = ((((xlatL2U[prevCorrelatedR] +
|
||
|
|
((pr +
|
||
|
|
result[i_4++]) >>> 1)) & bpc_mask)));
|
||
|
|
|
||
|
|
eatbits(codewordlen, encoder);
|
||
|
|
|
||
|
|
//g
|
||
|
|
///////////////////////////////////////INLINING golomb_decoding
|
||
|
|
|
||
|
|
//ret = golomb_decoding(buckets_ptrs_g[prevCorrelatedG].bestcode,
|
||
|
|
// encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
l = buckets_ptrs_g[prevCorrelatedG].bestcode;
|
||
|
|
bits = encoder.io_word;
|
||
|
|
|
||
|
|
if (bits > notGRprefixmask[l]) {
|
||
|
|
zeroprefix = cnt_l_zeroes(bits);
|
||
|
|
/*
|
||
|
|
if (bits > 0x007FFFFF) {
|
||
|
|
zeroprefix = lzeroes[bits >>> 24];
|
||
|
|
} else if (bits > 0x00007FFF) {
|
||
|
|
zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
|
||
|
|
} else if (bits > 0x0000007F) {
|
||
|
|
zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff) ];
|
||
|
|
} else {
|
||
|
|
zeroprefix = lzeroes24[(bits & 0x000000ff) ];
|
||
|
|
}*/
|
||
|
|
|
||
|
|
codewordlen = zeroprefix + 1 + l;
|
||
|
|
prevCorrelatedG = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
|
||
|
|
} else {
|
||
|
|
codewordlen = notGRcwlen[l];
|
||
|
|
prevCorrelatedG = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
correlate_row_g[i] = prevCorrelatedG;
|
||
|
|
|
||
|
|
pg = ((((xlatL2U[prevCorrelatedG] +
|
||
|
|
((pg +
|
||
|
|
result[i_4++]) >>> 1)) & bpc_mask)));
|
||
|
|
|
||
|
|
eatbits(codewordlen, encoder);
|
||
|
|
|
||
|
|
//b
|
||
|
|
////////////////////////////////// INLINING golomb_decoding
|
||
|
|
//ret = golomb_decoding(buckets_ptrs_b[prevCorrelatedB].bestcode,
|
||
|
|
// encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
l = buckets_ptrs_b[prevCorrelatedB].bestcode;
|
||
|
|
bits = encoder.io_word;
|
||
|
|
|
||
|
|
if (bits > notGRprefixmask[l]) {
|
||
|
|
zeroprefix = cnt_l_zeroes(bits);
|
||
|
|
/*
|
||
|
|
if (bits > 0x007FFFFF) {
|
||
|
|
zeroprefix = lzeroes[bits >>> 24];
|
||
|
|
} else if (bits > 0x00007FFF) {
|
||
|
|
zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
|
||
|
|
} else if (bits > 0x0000007F) {
|
||
|
|
zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff) ];
|
||
|
|
} else {
|
||
|
|
zeroprefix = lzeroes24[(bits & 0x000000ff) ];
|
||
|
|
}*/
|
||
|
|
|
||
|
|
codewordlen = zeroprefix + 1 + l;
|
||
|
|
prevCorrelatedB = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
|
||
|
|
} else {
|
||
|
|
codewordlen = notGRcwlen[l];
|
||
|
|
prevCorrelatedB = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
correlate_row_b[i] = prevCorrelatedB;
|
||
|
|
|
||
|
|
pb = ((((xlatL2U[prevCorrelatedB] +
|
||
|
|
((pb +
|
||
|
|
result[i_4++]) >>> 1)) & bpc_mask)));
|
||
|
|
|
||
|
|
eatbits(codewordlen, encoder);
|
||
|
|
////////////////////// END INLINING
|
||
|
|
|
||
|
|
/**
|
||
|
|
pr = UNCOMPRESS_ONE(channel_r, i, i_1, i_4, bpc_mask, encoder, correlate_row_r, offset, result, 0, xlatL2U, buckets_ptrs_r, pr);
|
||
|
|
pg = UNCOMPRESS_ONE(channel_g, i, i_1, i_4, bpc_mask, encoder, correlate_row_g, offset, result, 1, xlatL2U, buckets_ptrs_g, pg);
|
||
|
|
pb = UNCOMPRESS_ONE(channel_b, i, i_1, i_4, bpc_mask, encoder, correlate_row_b, offset, result, 2, xlatL2U, buckets_ptrs_b, pb);
|
||
|
|
**/
|
||
|
|
|
||
|
|
|
||
|
|
//this is inlined appendPixel
|
||
|
|
resultData[pxCnt++] =
|
||
|
|
computedAlpha | // alpha
|
||
|
|
pb << 16 | // blue
|
||
|
|
pg << 8 | // green
|
||
|
|
pr; // red
|
||
|
|
//cnt += 4;
|
||
|
|
i_4++; //skip alpha
|
||
|
|
}
|
||
|
|
if (!rle) {
|
||
|
|
UPDATE_MODEL(stopidx, encoder, bpc, correlate_row_r, correlate_row_g, correlate_row_b);
|
||
|
|
stopidx = i + (tabrand.call(wdi.JSQuic, rgb_state) & waitmask);
|
||
|
|
} else {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!rle) {
|
||
|
|
i_4 = offset + i * 4;
|
||
|
|
for (; i < end; i++) {
|
||
|
|
rle = RLE_PRED_RGB_A(i, encoder, i_4, currentOffset, run_index);
|
||
|
|
//RLE_PRED INLINE
|
||
|
|
/*if(run_index !== i && i > 2) {
|
||
|
|
//inlined same_pixel, see original rle_pred
|
||
|
|
i4sub = i_4/4;
|
||
|
|
if(encoder.resultData[i4sub-1] === encoder.resultData[i4sub]) { //fila de arriba
|
||
|
|
var prev_row = currentOffset32 + i-1;
|
||
|
|
if(encoder.resultData[prev_row-1] === encoder.resultData[prev_row]) { //pixel de la izquierda
|
||
|
|
rle = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//END INLINE*/
|
||
|
|
if (rle) break;
|
||
|
|
|
||
|
|
|
||
|
|
////////////////////// INLINING UNCOMPRESS_ONE
|
||
|
|
//r
|
||
|
|
//ret = golomb_decoding(buckets_ptrs_r[prevCorrelatedR].bestcode, encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
//prevCorrelatedR = ret[0];
|
||
|
|
//codewordlen = ret[1];
|
||
|
|
l = buckets_ptrs_r[prevCorrelatedR].bestcode;
|
||
|
|
bits = encoder.io_word;
|
||
|
|
|
||
|
|
if (bits > notGRprefixmask[l]) {
|
||
|
|
zeroprefix = cnt_l_zeroes(bits);
|
||
|
|
/*
|
||
|
|
if (bits > 0x007FFFFF) {
|
||
|
|
zeroprefix = lzeroes[bits >>> 24];
|
||
|
|
} else if (bits > 0x00007FFF) {
|
||
|
|
zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
|
||
|
|
} else if (bits > 0x0000007F) {
|
||
|
|
zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff) ];
|
||
|
|
} else {
|
||
|
|
zeroprefix = lzeroes24[(bits & 0x000000ff) ];
|
||
|
|
}*/
|
||
|
|
|
||
|
|
codewordlen = zeroprefix + 1 + l;
|
||
|
|
prevCorrelatedR = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
|
||
|
|
} else {
|
||
|
|
codewordlen = notGRcwlen[l];
|
||
|
|
prevCorrelatedR = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
correlate_row_r[i] = prevCorrelatedR;
|
||
|
|
|
||
|
|
pr = ((((xlatL2U[prevCorrelatedR] +
|
||
|
|
((pr +
|
||
|
|
result[i_4++]) >>> 1)) & bpc_mask)));
|
||
|
|
|
||
|
|
eatbits(codewordlen, encoder);
|
||
|
|
|
||
|
|
//g
|
||
|
|
// ret = golomb_decoding(buckets_ptrs_g[prevCorrelatedG].bestcode, encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
// prevCorrelatedG = ret[0];
|
||
|
|
// codewordlen = ret[1];
|
||
|
|
|
||
|
|
l = buckets_ptrs_g[prevCorrelatedG].bestcode;
|
||
|
|
bits = encoder.io_word;
|
||
|
|
|
||
|
|
if (bits > notGRprefixmask[l]) {
|
||
|
|
zeroprefix = cnt_l_zeroes(bits);
|
||
|
|
/*
|
||
|
|
if (bits > 0x007FFFFF) {
|
||
|
|
zeroprefix = lzeroes[bits >>> 24];
|
||
|
|
} else if (bits > 0x00007FFF) {
|
||
|
|
zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
|
||
|
|
} else if (bits > 0x0000007F) {
|
||
|
|
zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff) ];
|
||
|
|
} else {
|
||
|
|
zeroprefix = lzeroes24[(bits & 0x000000ff) ];
|
||
|
|
}*/
|
||
|
|
|
||
|
|
codewordlen = zeroprefix + 1 + l;
|
||
|
|
prevCorrelatedG = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
|
||
|
|
} else {
|
||
|
|
codewordlen = notGRcwlen[l];
|
||
|
|
prevCorrelatedG = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
correlate_row_g[i] = prevCorrelatedG;
|
||
|
|
|
||
|
|
pg = ((((xlatL2U[prevCorrelatedG] +
|
||
|
|
((pg +
|
||
|
|
result[i_4++]) >>> 1)) & bpc_mask)));
|
||
|
|
|
||
|
|
eatbits(codewordlen, encoder);
|
||
|
|
|
||
|
|
//b
|
||
|
|
// ret = golomb_decoding(buckets_ptrs_b[prevCorrelatedB].bestcode, encoder.io_word, bppmask, notGRprefixmask, notGRcwlen, nGRcodewords, notGRsuffixlen);
|
||
|
|
// prevCorrelatedB = ret[0];
|
||
|
|
// codewordlen = ret[1];
|
||
|
|
//
|
||
|
|
|
||
|
|
l = buckets_ptrs_b[prevCorrelatedB].bestcode;
|
||
|
|
bits = encoder.io_word;
|
||
|
|
|
||
|
|
if (bits > notGRprefixmask[l]) {
|
||
|
|
zeroprefix = cnt_l_zeroes(bits);
|
||
|
|
/*
|
||
|
|
if (bits > 0x007FFFFF) {
|
||
|
|
zeroprefix = lzeroes[bits >>> 24];
|
||
|
|
} else if (bits > 0x00007FFF) {
|
||
|
|
zeroprefix = lzeroes8[((bits >>> 16) & 0x000000ff)];
|
||
|
|
} else if (bits > 0x0000007F) {
|
||
|
|
zeroprefix = lzeroes16[((bits >>> 8) & 0x000000ff) ];
|
||
|
|
} else {
|
||
|
|
zeroprefix = lzeroes24[(bits & 0x000000ff) ];
|
||
|
|
}*/
|
||
|
|
|
||
|
|
codewordlen = zeroprefix + 1 + l;
|
||
|
|
prevCorrelatedB = ((zeroprefix << l)) | ((bits >>> (32 - codewordlen)) & bppmask[l]);
|
||
|
|
} else {
|
||
|
|
codewordlen = notGRcwlen[l];
|
||
|
|
prevCorrelatedB = nGRcodewords[l] + ((bits) >>> (32 - codewordlen) & bppmask[notGRsuffixlen[l]]);
|
||
|
|
}
|
||
|
|
correlate_row_b[i] = prevCorrelatedB;
|
||
|
|
|
||
|
|
pb = ((((xlatL2U[prevCorrelatedB] +
|
||
|
|
((pb +
|
||
|
|
result[i_4++]) >>> 1)) & bpc_mask)));
|
||
|
|
|
||
|
|
eatbits(codewordlen, encoder);
|
||
|
|
///////////////////// END INLINING
|
||
|
|
|
||
|
|
/**
|
||
|
|
pr = UNCOMPRESS_ONE(channel_r, i, i_1, i_4, bpc_mask, encoder, correlate_row_r, offset, result, 0, xlatL2U, buckets_ptrs_r, pr);
|
||
|
|
pg = UNCOMPRESS_ONE(channel_g, i, i_1, i_4, bpc_mask, encoder, correlate_row_g, offset, result, 1, xlatL2U, buckets_ptrs_g, pg);
|
||
|
|
pb = UNCOMPRESS_ONE(channel_b, i, i_1, i_4, bpc_mask, encoder, correlate_row_b, offset, result, 2, xlatL2U, buckets_ptrs_b, pb);
|
||
|
|
**/
|
||
|
|
|
||
|
|
//this is inlined apendPixel
|
||
|
|
resultData[pxCnt++] =
|
||
|
|
(255 << 24) | // alpha
|
||
|
|
(pb << 16) | // blue
|
||
|
|
(pg << 8) | // green
|
||
|
|
pr; // red
|
||
|
|
//cnt += 4;
|
||
|
|
i_4++;
|
||
|
|
}
|
||
|
|
if (!rle) {
|
||
|
|
rgb_state.waitcnt = stopidx - end;
|
||
|
|
encoder.cnt = pxCnt * 4;
|
||
|
|
encoder.pxCnt = pxCnt;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
///END of critical part
|
||
|
|
|
||
|
|
//RLE
|
||
|
|
rgb_state.waitcnt = stopidx - i;
|
||
|
|
run_index = i;
|
||
|
|
run_end = decode_run(encoder);
|
||
|
|
|
||
|
|
i = run_end + i;
|
||
|
|
while (run_end-- > 0) {
|
||
|
|
//this is inlined appendPixel
|
||
|
|
resultData[pxCnt++] =
|
||
|
|
computedAlpha | // alpha
|
||
|
|
pb << 16 | // blue
|
||
|
|
pg << 8 | // green
|
||
|
|
pr; // red
|
||
|
|
//cnt += 4;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
if (i === end) {
|
||
|
|
encoder.cnt = pxCnt * 4;
|
||
|
|
encoder.pxCnt = pxCnt;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
i_1 = i - 1;
|
||
|
|
prevCorrelatedR = correlate_row_r[i_1];
|
||
|
|
prevCorrelatedG = correlate_row_g[i_1];
|
||
|
|
prevCorrelatedB = correlate_row_b[i_1];
|
||
|
|
|
||
|
|
stopidx = i + rgb_state.waitcnt;
|
||
|
|
rle = false;
|
||
|
|
//END RLE
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
function quic_uncompress_row0(encoder, channels, bpc, type) {
|
||
|
|
var bpc_mask = wdi.JSQuic.BPC_MASK[type];
|
||
|
|
var pos = 0;
|
||
|
|
var width = encoder.width;
|
||
|
|
while ((wdi.JSQuic.wmimax > encoder.rgb_state.wmidx) && (encoder.rgb_state.wmileft <= width)) {
|
||
|
|
if (encoder.rgb_state.wmileft) {
|
||
|
|
uncompress_row0_seg(
|
||
|
|
encoder,
|
||
|
|
pos,
|
||
|
|
pos + encoder.rgb_state.wmileft,
|
||
|
|
wdi.JSQuic.bppmask[encoder.rgb_state.wmidx],
|
||
|
|
bpc,
|
||
|
|
bpc_mask,
|
||
|
|
type
|
||
|
|
);
|
||
|
|
pos += encoder.rgb_state.wmileft;
|
||
|
|
width -= encoder.rgb_state.wmileft;
|
||
|
|
}
|
||
|
|
|
||
|
|
encoder.rgb_state.wmidx++;
|
||
|
|
wdi.JSQuic.set_wm_trigger(encoder.rgb_state);
|
||
|
|
encoder.rgb_state.wmileft = wdi.JSQuic.wminext;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (width) {
|
||
|
|
uncompress_row0_seg(
|
||
|
|
encoder,
|
||
|
|
pos,
|
||
|
|
pos + width,
|
||
|
|
wdi.JSQuic.bppmask[encoder.rgb_state.wmidx],
|
||
|
|
bpc,
|
||
|
|
bpc_mask,
|
||
|
|
type
|
||
|
|
);
|
||
|
|
if (wdi.JSQuic.wmimax > encoder.rgb_state.wmidx) {
|
||
|
|
encoder.rgb_state.wmileft -= width;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function uncompress_row0_seg(encoder, i, end, waitmask, bpc, bpc_mask, type) {
|
||
|
|
var channel_r = encoder.channels[0];
|
||
|
|
var channel_g = encoder.channels[1];
|
||
|
|
var channel_b = encoder.channels[2];
|
||
|
|
|
||
|
|
var correlate_row_r = channel_r.correlate_row;
|
||
|
|
var correlate_row_g = channel_g.correlate_row;
|
||
|
|
var correlate_row_b = channel_b.correlate_row;
|
||
|
|
|
||
|
|
var stopidx = 0;
|
||
|
|
|
||
|
|
var pr, pg, pb;
|
||
|
|
|
||
|
|
if (!i) {
|
||
|
|
pr = UNCOMPRESS_ONE_ROW0_0(channel_r);
|
||
|
|
pg = UNCOMPRESS_ONE_ROW0_0(channel_g);
|
||
|
|
pb = UNCOMPRESS_ONE_ROW0_0(channel_b);
|
||
|
|
|
||
|
|
encoder.appendPixel(pr, pg, pb);
|
||
|
|
|
||
|
|
if (encoder.rgb_state.waitcnt) {
|
||
|
|
--encoder.rgb_state.waitcnt;
|
||
|
|
} else {
|
||
|
|
encoder.rgb_state.waitcnt = (wdi.JSQuic.tabrand(encoder.rgb_state) & waitmask);
|
||
|
|
UPDATE_MODEL(0, encoder, bpc, correlate_row_r, correlate_row_g, correlate_row_b);
|
||
|
|
}
|
||
|
|
stopidx = ++i + encoder.rgb_state.waitcnt;
|
||
|
|
} else {
|
||
|
|
stopidx = i + encoder.rgb_state.waitcnt;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (stopidx < end) {
|
||
|
|
for (; i <= stopidx; i++) {
|
||
|
|
pr = UNCOMPRESS_ONE_ROW0(channel_r, i, bpc_mask, encoder, correlate_row_r, pr);
|
||
|
|
pg = UNCOMPRESS_ONE_ROW0(channel_g, i, bpc_mask, encoder, correlate_row_g, pg);
|
||
|
|
pb = UNCOMPRESS_ONE_ROW0(channel_b, i, bpc_mask, encoder, correlate_row_b, pb);
|
||
|
|
|
||
|
|
encoder.appendPixel(pr, pg, pb);
|
||
|
|
}
|
||
|
|
UPDATE_MODEL(stopidx, encoder, bpc, correlate_row_r, correlate_row_g, correlate_row_b);
|
||
|
|
stopidx = i + (wdi.JSQuic.tabrand(encoder.rgb_state) & waitmask);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (; i < end; i++) {
|
||
|
|
pr = UNCOMPRESS_ONE_ROW0(channel_r, i, bpc_mask, encoder, correlate_row_r, pr);
|
||
|
|
pg = UNCOMPRESS_ONE_ROW0(channel_g, i, bpc_mask, encoder, correlate_row_g, pg);
|
||
|
|
pb = UNCOMPRESS_ONE_ROW0(channel_b, i, bpc_mask, encoder, correlate_row_b, pb);
|
||
|
|
encoder.appendPixel(pr, pg, pb);
|
||
|
|
}
|
||
|
|
encoder.rgb_state.waitcnt = stopidx - end;
|
||
|
|
}
|
||
|
|
|
||
|
|
function UNCOMPRESS_ONE_0(channel, encoder, bpc_mask, offset) {
|
||
|
|
var ret, codewordlen;
|
||
|
|
channel.oldFirst = channel.correlate_row[0];
|
||
|
|
ret = golomb_decoding(find_bucket(channel,
|
||
|
|
channel.correlate_row[0]).bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
|
||
|
|
channel.correlate_row[0] = ret[0];
|
||
|
|
codewordlen = ret[1];
|
||
|
|
var residuum = wdi.xlatL2U[channel.correlate_row[0]];
|
||
|
|
var prev = encoder.result[offset + channel.num_channel]; //PIXEL_B
|
||
|
|
var resultpixel = ((residuum + prev) & bpc_mask);
|
||
|
|
encoder.eatbits(codewordlen, encoder);
|
||
|
|
return resultpixel;
|
||
|
|
}
|
||
|
|
|
||
|
|
function UNCOMPRESS_ONE(channel, i, i_1, i_4, bpc_mask, encoder, correlate_row, offset, result, num_channel, xlatL2U, buckets_ptrs, prev_pixel) {
|
||
|
|
var ret, codewordlen;
|
||
|
|
ret = golomb_decoding(buckets_ptrs[correlate_row[i_1]].bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
|
||
|
|
|
||
|
|
var data = ret[0];
|
||
|
|
codewordlen = ret[1];
|
||
|
|
correlate_row[i] = data;
|
||
|
|
|
||
|
|
var ret = ((((xlatL2U[data] +
|
||
|
|
((prev_pixel +
|
||
|
|
result[offset + (i_4) + num_channel]) >>> 1)) & bpc_mask)));
|
||
|
|
|
||
|
|
encoder.eatbits(codewordlen, encoder);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
function UNCOMPRESS_ONE_ROW0_0(channel) {
|
||
|
|
var ret, codewordlen;
|
||
|
|
var encoder = channel.encoder;
|
||
|
|
ret = golomb_decoding(find_bucket(channel, 0).bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
|
||
|
|
channel.correlate_row[0] = ret[0]
|
||
|
|
codewordlen = ret[1];
|
||
|
|
var ret = wdi.xlatL2U[channel.correlate_row[0]];
|
||
|
|
encoder.eatbits(codewordlen, encoder);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
function UNCOMPRESS_ONE_ROW0(channel, i, bpc_mask, encoder, correlate_row, prev_pixel) {
|
||
|
|
var ret, codewordlen;
|
||
|
|
ret = golomb_decoding(find_bucket(channel, correlate_row[i - 1]).bestcode, encoder.io_word, wdi.JSQuic.bppmask, wdi.notGRprefixmask, wdi.notGRcwlen, wdi.nGRcodewords, wdi.notGRsuffixlen);
|
||
|
|
correlate_row[i] = ret[0];
|
||
|
|
codewordlen = ret[1];
|
||
|
|
var ret = CORELATE_0(encoder, channel, i, bpc_mask, correlate_row, prev_pixel);
|
||
|
|
encoder.eatbits(codewordlen, encoder);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
function CORELATE_0(encoder, channel, curr, bpc_mask, correlate_row, prev_pixel) {
|
||
|
|
return ((wdi.xlatL2U[correlate_row[curr]] + prev_pixel) & bpc_mask);
|
||
|
|
}
|
||
|
|
|
||
|
|
function PIXEL_A(encoder) {
|
||
|
|
return encoder.result[encoder.cnt - 4];
|
||
|
|
}
|
||
|
|
|
||
|
|
function PIXEL_B(channel, encoder, pos, offset) {
|
||
|
|
return encoder.result[offset + (pos * 4) + channel.num_channel];
|
||
|
|
}
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////
|
||
|
|
//LZ
|
||
|
|
|
||
|
|
var lzDecompress = {
|
||
|
|
LZ_IMAGE_TYPE_INVALID: 0,
|
||
|
|
LZ_IMAGE_TYPE_PLT1_LE: 1,
|
||
|
|
LZ_IMAGE_TYPE_PLT1_BE: 2,
|
||
|
|
LZ_IMAGE_TYPE_PLT4_LE: 3,
|
||
|
|
LZ_IMAGE_TYPE_PLT4_BE: 4,
|
||
|
|
LZ_IMAGE_TYPE_PLT8: 5,
|
||
|
|
LZ_IMAGE_TYPE_RGB16: 6,
|
||
|
|
LZ_IMAGE_TYPE_RGB24: 7,
|
||
|
|
LZ_IMAGE_TYPE_RGB32: 8,
|
||
|
|
LZ_IMAGE_TYPE_RGBA: 9,
|
||
|
|
LZ_IMAGE_TYPE_XXXA: 10,
|
||
|
|
LZPALETTE_FLAG_PAL_CACHE_ME: 1,
|
||
|
|
LZPALETTE_FLAG_PAL_FROM_CACHE: 2,
|
||
|
|
LZPALETTE_FLAG_TOP_DOWN: 4,
|
||
|
|
PLT_PIXELS_PER_BYTE: [0, 8, 8, 2, 2, 1],
|
||
|
|
PLT1_MASK: [1, 2, 4, 8, 16, 32, 64, 128],
|
||
|
|
|
||
|
|
lz_rgb32_decompress_rgb_opaque_reverse: function(arr) {
|
||
|
|
//TODO: global alpha and uncouple code
|
||
|
|
|
||
|
|
var in_buf = new Uint8Array(arr);
|
||
|
|
|
||
|
|
var type = in_buf[2];
|
||
|
|
var low = in_buf[5] * 256 + in_buf[4]; // 256 = Math.pow(16, 2)
|
||
|
|
var high = in_buf[7] * 256 + in_buf[6]; // 256 = Math.pow(16, 2)
|
||
|
|
var len = high * 65536 + low; // 65536 = Math.pow(16,4)
|
||
|
|
var buf = new ArrayBuffer(len);
|
||
|
|
var data = new Uint32Array(buf);
|
||
|
|
var view = new DataView(arr);
|
||
|
|
var width = view.getUint32(8);
|
||
|
|
var height = view.getUint32(12);
|
||
|
|
var out_buf_len = len / 4 -1;
|
||
|
|
var op = out_buf_len;
|
||
|
|
var code, ref, ofs, b;
|
||
|
|
var aux;
|
||
|
|
var ctrl = in_buf[16];
|
||
|
|
var encoder = 16; //padding
|
||
|
|
|
||
|
|
while (op >= 0) {
|
||
|
|
|
||
|
|
ctrl = in_buf[encoder++];
|
||
|
|
//if ctrl is 0, there is no way for len to be > 0
|
||
|
|
if (ctrl != 0 && (len = ctrl >> 5)!=0) { //>=32
|
||
|
|
ref = op; //there is a reference to past bytes, the reference will be
|
||
|
|
//provided as an offset to our position
|
||
|
|
ofs = (ctrl & 31) << 8; //get the last 5 bits from ctrl
|
||
|
|
|
||
|
|
if (len == 7) {
|
||
|
|
do {
|
||
|
|
code = in_buf[encoder++];
|
||
|
|
len += code;
|
||
|
|
} while (code == 255);
|
||
|
|
}
|
||
|
|
|
||
|
|
ofs += in_buf[encoder++];
|
||
|
|
if (ofs == 0) {
|
||
|
|
aux = data[ref+1]; //if osset is 0...it means just the prior pixel copied over and over....
|
||
|
|
//in reverse mode, the prior pixel is just the next pixel to the right
|
||
|
|
while(len > 9) {
|
||
|
|
data[op] = aux;
|
||
|
|
data[op-1] = aux;
|
||
|
|
data[op-2] = aux;
|
||
|
|
data[op-3] = aux;
|
||
|
|
data[op-4] = aux;
|
||
|
|
data[op-5] = aux;
|
||
|
|
data[op-6] = aux;
|
||
|
|
data[op-7] = aux;
|
||
|
|
data[op-8] = aux;
|
||
|
|
data[op-9] = aux;
|
||
|
|
op-=10;
|
||
|
|
len -= 10;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (len-- != 0) {
|
||
|
|
data[op--] = aux;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (ofs == 8191) { //check if all the bits in ofs are 1, then get two more bytes
|
||
|
|
ofs += (in_buf[encoder] << 8) + in_buf[encoder+1];
|
||
|
|
encoder += 2;
|
||
|
|
}
|
||
|
|
|
||
|
|
ref += ofs + 1;
|
||
|
|
|
||
|
|
while(len > 9) {
|
||
|
|
data[op] = data[ref];
|
||
|
|
data[op-1] = data[ref-1];
|
||
|
|
data[op-2] = data[ref-2];
|
||
|
|
data[op-3] = data[ref-3];
|
||
|
|
data[op-4] = data[ref-4];
|
||
|
|
data[op-5] = data[ref-5];
|
||
|
|
data[op-6] = data[ref-6];
|
||
|
|
data[op-7] = data[ref-7];
|
||
|
|
data[op-8] = data[ref-8];
|
||
|
|
data[op-9] = data[ref-9];
|
||
|
|
op-=10;
|
||
|
|
len -= 10;
|
||
|
|
ref -= 10;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (len-- !== 0) {
|
||
|
|
data[op--] = data[ref--];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
while(ctrl > 9) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op-1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op-2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op-3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
data[op-4] = 4278190080 | in_buf[encoder+12] << 16 | in_buf[encoder+13] << 8 | in_buf[encoder+14];
|
||
|
|
data[op-5] = 4278190080 | in_buf[encoder+15] << 16 | in_buf[encoder+16] << 8 | in_buf[encoder+17];
|
||
|
|
data[op-6] = 4278190080 | in_buf[encoder+18] << 16 | in_buf[encoder+19] << 8 | in_buf[encoder+20];
|
||
|
|
data[op-7] = 4278190080 | in_buf[encoder+21] << 16 | in_buf[encoder+22] << 8 | in_buf[encoder+23];
|
||
|
|
data[op-8] = 4278190080 | in_buf[encoder+24] << 16 | in_buf[encoder+25] << 8 | in_buf[encoder+26];
|
||
|
|
data[op-9] = 4278190080 | in_buf[encoder+27] << 16 | in_buf[encoder+28] << 8 | in_buf[encoder+29];
|
||
|
|
encoder += 30;
|
||
|
|
op -= 10;
|
||
|
|
ctrl -= 10;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(ctrl != 0) {
|
||
|
|
if(ctrl == 9) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op-1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op-2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op-3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
data[op-4] = 4278190080 | in_buf[encoder+12] << 16 | in_buf[encoder+13] << 8 | in_buf[encoder+14];
|
||
|
|
data[op-5] = 4278190080 | in_buf[encoder+15] << 16 | in_buf[encoder+16] << 8 | in_buf[encoder+17];
|
||
|
|
data[op-6] = 4278190080 | in_buf[encoder+18] << 16 | in_buf[encoder+19] << 8 | in_buf[encoder+20];
|
||
|
|
data[op-7] = 4278190080 | in_buf[encoder+21] << 16 | in_buf[encoder+22] << 8 | in_buf[encoder+23];
|
||
|
|
data[op-8] = 4278190080 | in_buf[encoder+24] << 16 | in_buf[encoder+25] << 8 | in_buf[encoder+26];
|
||
|
|
encoder += 27;
|
||
|
|
op -= 9;
|
||
|
|
} else if(ctrl == 8) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op-1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op-2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op-3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
data[op-4] = 4278190080 | in_buf[encoder+12] << 16 | in_buf[encoder+13] << 8 | in_buf[encoder+14];
|
||
|
|
data[op-5] = 4278190080 | in_buf[encoder+15] << 16 | in_buf[encoder+16] << 8 | in_buf[encoder+17];
|
||
|
|
data[op-6] = 4278190080 | in_buf[encoder+18] << 16 | in_buf[encoder+19] << 8 | in_buf[encoder+20];
|
||
|
|
data[op-7] = 4278190080 | in_buf[encoder+21] << 16 | in_buf[encoder+22] << 8 | in_buf[encoder+23];
|
||
|
|
encoder += 24;
|
||
|
|
op -= 8;
|
||
|
|
} else if(ctrl == 7) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op-1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op-2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op-3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
data[op-4] = 4278190080 | in_buf[encoder+12] << 16 | in_buf[encoder+13] << 8 | in_buf[encoder+14];
|
||
|
|
data[op-5] = 4278190080 | in_buf[encoder+15] << 16 | in_buf[encoder+16] << 8 | in_buf[encoder+17];
|
||
|
|
data[op-6] = 4278190080 | in_buf[encoder+18] << 16 | in_buf[encoder+19] << 8 | in_buf[encoder+20];
|
||
|
|
encoder += 21;
|
||
|
|
op -= 7;
|
||
|
|
} else if(ctrl == 6) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op-1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op-2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op-3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
data[op-4] = 4278190080 | in_buf[encoder+12] << 16 | in_buf[encoder+13] << 8 | in_buf[encoder+14];
|
||
|
|
data[op-5] = 4278190080 | in_buf[encoder+15] << 16 | in_buf[encoder+16] << 8 | in_buf[encoder+17];
|
||
|
|
encoder += 18;
|
||
|
|
op -= 6;
|
||
|
|
} else if(ctrl == 5) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op-1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op-2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op-3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
data[op-4] = 4278190080 | in_buf[encoder+12] << 16 | in_buf[encoder+13] << 8 | in_buf[encoder+14];
|
||
|
|
encoder += 15;
|
||
|
|
op -= 5;
|
||
|
|
} else if(ctrl == 4) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op-1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op-2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op-3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
encoder += 12;
|
||
|
|
op -= 4;
|
||
|
|
} else if(ctrl == 3) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op-1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op-2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
encoder += 9;
|
||
|
|
op -= 3;
|
||
|
|
} else if(ctrl == 2) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op-1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
encoder += 6;
|
||
|
|
op -= 2;
|
||
|
|
} else if(ctrl == 1) {
|
||
|
|
data[op--] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
encoder += 3;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
data[op--] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
encoder+=3;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//reverse buf
|
||
|
|
//while, line by line
|
||
|
|
var left, right, line, temporary;
|
||
|
|
var length = width-1;
|
||
|
|
while(height--) {
|
||
|
|
line = new Uint32Array(buf,height*width*4, width);
|
||
|
|
left = 0;
|
||
|
|
right = length;
|
||
|
|
while (left < right)
|
||
|
|
{
|
||
|
|
var temporary = line[left];
|
||
|
|
line[left++] = line[right];
|
||
|
|
line[right--] = temporary;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return buf;
|
||
|
|
},
|
||
|
|
|
||
|
|
lz_rgb32_decompress_rgb: function(arr) {
|
||
|
|
//TODO: global alpha and uncouple code
|
||
|
|
var op = 0;
|
||
|
|
var in_buf = new Uint8Array(arr);
|
||
|
|
|
||
|
|
var opaque = in_buf[1];
|
||
|
|
var type = in_buf[2];
|
||
|
|
var top_down = in_buf[3];
|
||
|
|
if(opaque && !top_down) {
|
||
|
|
return lzDecompress.lz_rgb32_decompress_rgb_opaque_reverse(arr);
|
||
|
|
}
|
||
|
|
var low = in_buf[5] * 256 + in_buf[4]; // 256 = Math.pow(16, 2)
|
||
|
|
var high = in_buf[7] * 256 + in_buf[6]; // 256 = Math.pow(16, 2)
|
||
|
|
var len = high * 65536 + low; // 65536 = Math.pow(16,4)
|
||
|
|
var buf = new ArrayBuffer(len);
|
||
|
|
var data = new Uint32Array(buf);
|
||
|
|
var out_buf_len = len / 4;
|
||
|
|
var code, ref, ofs, b;
|
||
|
|
var op_4, aux;
|
||
|
|
var ctrl = in_buf[16];
|
||
|
|
var offsetView;
|
||
|
|
var encoder = 16; //padding
|
||
|
|
|
||
|
|
while (op != out_buf_len) {
|
||
|
|
|
||
|
|
ctrl = in_buf[encoder++];
|
||
|
|
//if ctrl is 0, there is no way for len to be > 0
|
||
|
|
if (ctrl != 0 && (len = ctrl >> 5)!=0) { //>=32
|
||
|
|
ref = op;
|
||
|
|
ofs = (ctrl & 31) << 8; //get the last 5 bits from ctrl
|
||
|
|
|
||
|
|
if (len == 7) {
|
||
|
|
do {
|
||
|
|
code = in_buf[encoder++];
|
||
|
|
len += code;
|
||
|
|
} while (code == 255);
|
||
|
|
}
|
||
|
|
|
||
|
|
ofs += in_buf[encoder++];
|
||
|
|
|
||
|
|
if (ofs == 0) {
|
||
|
|
aux = data[--ref];
|
||
|
|
while(len > 9) {
|
||
|
|
data[op] = aux;
|
||
|
|
data[op+1] = aux;
|
||
|
|
data[op+2] = aux;
|
||
|
|
data[op+3] = aux;
|
||
|
|
data[op+4] = aux;
|
||
|
|
data[op+5] = aux;
|
||
|
|
data[op+6] = aux;
|
||
|
|
data[op+7] = aux;
|
||
|
|
data[op+8] = aux;
|
||
|
|
data[op+9] = aux;
|
||
|
|
op+=10;
|
||
|
|
len -= 10;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
while (len-- != 0) {
|
||
|
|
data[op++] = aux;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
} else {
|
||
|
|
if (ofs == 8191) { //check if all the bits in ofs are 1, then get two more bytes
|
||
|
|
ofs += (in_buf[encoder] << 8) + in_buf[encoder+1];
|
||
|
|
encoder += 2;
|
||
|
|
}
|
||
|
|
|
||
|
|
ref -= ofs + 1;
|
||
|
|
//if the copy from array to array is bigger than 100 (tested using benchmark) its cheaper to
|
||
|
|
//create a view and copy with set. If the copy is less than 100, then its cheaper
|
||
|
|
//to just iterate it.
|
||
|
|
if(len > 100 && ref+len < op) {
|
||
|
|
offsetView = new Uint32Array(buf, ref*4, len);
|
||
|
|
data.set(offsetView,op);
|
||
|
|
op += len;
|
||
|
|
ref += len;
|
||
|
|
} else {
|
||
|
|
while(len > 9) {
|
||
|
|
data[op] = data[ref];
|
||
|
|
data[op+1] = data[ref+1];
|
||
|
|
data[op+2] = data[ref+2];
|
||
|
|
data[op+3] = data[ref+3];
|
||
|
|
data[op+4] = data[ref+4];
|
||
|
|
data[op+5] = data[ref+5];
|
||
|
|
data[op+6] = data[ref+6];
|
||
|
|
data[op+7] = data[ref+7];
|
||
|
|
data[op+8] = data[ref+8];
|
||
|
|
data[op+9] = data[ref+9];
|
||
|
|
op+=10;
|
||
|
|
len -= 10;
|
||
|
|
ref += 10;
|
||
|
|
}
|
||
|
|
|
||
|
|
while (len-- !== 0) {
|
||
|
|
data[op++] = data[ref++];
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
while(ctrl > 9) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op+1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op+2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op+3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
data[op+4] = 4278190080 | in_buf[encoder+12] << 16 | in_buf[encoder+13] << 8 | in_buf[encoder+14];
|
||
|
|
data[op+5] = 4278190080 | in_buf[encoder+15] << 16 | in_buf[encoder+16] << 8 | in_buf[encoder+17];
|
||
|
|
data[op+6] = 4278190080 | in_buf[encoder+18] << 16 | in_buf[encoder+19] << 8 | in_buf[encoder+20];
|
||
|
|
data[op+7] = 4278190080 | in_buf[encoder+21] << 16 | in_buf[encoder+22] << 8 | in_buf[encoder+23];
|
||
|
|
data[op+8] = 4278190080 | in_buf[encoder+24] << 16 | in_buf[encoder+25] << 8 | in_buf[encoder+26];
|
||
|
|
data[op+9] = 4278190080 | in_buf[encoder+27] << 16 | in_buf[encoder+28] << 8 | in_buf[encoder+29];
|
||
|
|
encoder += 30;
|
||
|
|
op += 10;
|
||
|
|
ctrl -= 10;
|
||
|
|
}
|
||
|
|
|
||
|
|
//if we are just out of the above loop, ctrl is 9, so do the 9 in a row
|
||
|
|
if(ctrl != 0) {
|
||
|
|
if(ctrl == 9) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op+1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op+2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op+3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
data[op+4] = 4278190080 | in_buf[encoder+12] << 16 | in_buf[encoder+13] << 8 | in_buf[encoder+14];
|
||
|
|
data[op+5] = 4278190080 | in_buf[encoder+15] << 16 | in_buf[encoder+16] << 8 | in_buf[encoder+17];
|
||
|
|
data[op+6] = 4278190080 | in_buf[encoder+18] << 16 | in_buf[encoder+19] << 8 | in_buf[encoder+20];
|
||
|
|
data[op+7] = 4278190080 | in_buf[encoder+21] << 16 | in_buf[encoder+22] << 8 | in_buf[encoder+23];
|
||
|
|
data[op+8] = 4278190080 | in_buf[encoder+24] << 16 | in_buf[encoder+25] << 8 | in_buf[encoder+26];
|
||
|
|
encoder += 27;
|
||
|
|
op += 9;
|
||
|
|
} else if(ctrl == 8) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op+1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op+2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op+3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
data[op+4] = 4278190080 | in_buf[encoder+12] << 16 | in_buf[encoder+13] << 8 | in_buf[encoder+14];
|
||
|
|
data[op+5] = 4278190080 | in_buf[encoder+15] << 16 | in_buf[encoder+16] << 8 | in_buf[encoder+17];
|
||
|
|
data[op+6] = 4278190080 | in_buf[encoder+18] << 16 | in_buf[encoder+19] << 8 | in_buf[encoder+20];
|
||
|
|
data[op+7] = 4278190080 | in_buf[encoder+21] << 16 | in_buf[encoder+22] << 8 | in_buf[encoder+23];
|
||
|
|
encoder += 24;
|
||
|
|
op += 8;
|
||
|
|
} else if(ctrl == 7) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op+1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op+2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op+3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
data[op+4] = 4278190080 | in_buf[encoder+12] << 16 | in_buf[encoder+13] << 8 | in_buf[encoder+14];
|
||
|
|
data[op+5] = 4278190080 | in_buf[encoder+15] << 16 | in_buf[encoder+16] << 8 | in_buf[encoder+17];
|
||
|
|
data[op+6] = 4278190080 | in_buf[encoder+18] << 16 | in_buf[encoder+19] << 8 | in_buf[encoder+20];
|
||
|
|
encoder += 21;
|
||
|
|
op += 7;
|
||
|
|
} else if(ctrl == 6) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op+1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op+2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op+3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
data[op+4] = 4278190080 | in_buf[encoder+12] << 16 | in_buf[encoder+13] << 8 | in_buf[encoder+14];
|
||
|
|
data[op+5] = 4278190080 | in_buf[encoder+15] << 16 | in_buf[encoder+16] << 8 | in_buf[encoder+17];
|
||
|
|
encoder += 18;
|
||
|
|
op += 6;
|
||
|
|
} else if(ctrl == 5) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op+1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op+2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op+3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
data[op+4] = 4278190080 | in_buf[encoder+12] << 16 | in_buf[encoder+13] << 8 | in_buf[encoder+14];
|
||
|
|
encoder += 15;
|
||
|
|
op += 5;
|
||
|
|
} else if(ctrl == 4) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op+1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op+2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
data[op+3] = 4278190080 | in_buf[encoder+9] << 16 | in_buf[encoder+10] << 8 | in_buf[encoder+11];
|
||
|
|
encoder += 12;
|
||
|
|
op += 4;
|
||
|
|
} else if(ctrl == 3) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op+1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
data[op+2] = 4278190080 | in_buf[encoder+6] << 16 | in_buf[encoder+7] << 8 | in_buf[encoder+8];
|
||
|
|
encoder += 9;
|
||
|
|
op += 3;
|
||
|
|
} else if(ctrl == 2) {
|
||
|
|
data[op] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
data[op+1] = 4278190080 | in_buf[encoder+3] << 16 | in_buf[encoder+4] << 8 | in_buf[encoder+5];
|
||
|
|
encoder += 6;
|
||
|
|
op += 2;
|
||
|
|
} else if(ctrl == 1) {
|
||
|
|
data[op++] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
encoder += 3;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
data[op++] = 4278190080 | in_buf[encoder] << 16 | in_buf[encoder+1] << 8 | in_buf[encoder+2];
|
||
|
|
encoder+=3;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (type === this.LZ_IMAGE_TYPE_RGBA && !opaque) {
|
||
|
|
var buf8 = new Uint8Array(buf);
|
||
|
|
|
||
|
|
op = 0;
|
||
|
|
ctrl = null;
|
||
|
|
//encoder--;
|
||
|
|
for (ctrl = in_buf[encoder++]; op < out_buf_len; ctrl = in_buf[encoder++]) {
|
||
|
|
ref = op;
|
||
|
|
len = ctrl >> 5;
|
||
|
|
ofs = ((ctrl & 31) << 8);
|
||
|
|
op_4 = op * 4;
|
||
|
|
|
||
|
|
if (ctrl >= 32) {
|
||
|
|
|
||
|
|
code;
|
||
|
|
len--;
|
||
|
|
|
||
|
|
if (len === 7 - 1) {
|
||
|
|
do {
|
||
|
|
code = in_buf[encoder++];
|
||
|
|
len += code;
|
||
|
|
} while (code === 255);
|
||
|
|
}
|
||
|
|
code = in_buf[encoder++];
|
||
|
|
ofs += code;
|
||
|
|
|
||
|
|
|
||
|
|
if (code === 255) {
|
||
|
|
if ((ofs - code) === (31 << 8)) {
|
||
|
|
ofs = in_buf[encoder++] << 8;
|
||
|
|
ofs += in_buf[encoder++];
|
||
|
|
ofs += 8191;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
len += 3;
|
||
|
|
|
||
|
|
ofs += 1;
|
||
|
|
|
||
|
|
ref -= ofs;
|
||
|
|
if (ref === (op - 1)) { //plt4/1 what?
|
||
|
|
b = ref;
|
||
|
|
|
||
|
|
for (; len; --len) {
|
||
|
|
op_4 = op * 4;
|
||
|
|
//COPY_PIXEL
|
||
|
|
buf8[(op_4) + 3] = buf8[(b * 4) + 3];
|
||
|
|
|
||
|
|
op++;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
|
||
|
|
for (; len; --len) {
|
||
|
|
//COPY_REF_PIXEL
|
||
|
|
op_4 = op * 4;
|
||
|
|
buf8[(op_4) + 3] = buf8[(ref * 4) + 3];
|
||
|
|
|
||
|
|
op++;
|
||
|
|
ref++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
//COPY_COMP_PIXEL
|
||
|
|
ctrl++;
|
||
|
|
buf8[(op_4) + 3] = in_buf[encoder++];
|
||
|
|
op++;
|
||
|
|
|
||
|
|
|
||
|
|
for (--ctrl; ctrl; ctrl--) {
|
||
|
|
//COPY_COMP_PIXEL
|
||
|
|
op_4 = op * 4; // faster?
|
||
|
|
buf8[(op_4) + 3] = in_buf[encoder++];
|
||
|
|
op++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return buf;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
if (wdi.LZSS) {
|
||
|
|
wdi.LZSS.lz_rgb32_decompress_rgb = lzDecompress.lz_rgb32_decompress_rgb
|
||
|
|
} else {
|
||
|
|
// if (!wdi.LZSS) {
|
||
|
|
wdi.LZSS = lzDecompress;
|
||
|
|
}
|