@vitessce/all 2.0.3-beta.0 → 2.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,1935 @@
1
+ import { i as inflate_1 } from "./pako.esm.4b234125.mjs";
2
+ import { B as BaseDecoder, L as LercParameters, a as LercAddCompression } from "./index.7dac8670.mjs";
3
+ import "react";
4
+ import "@vitessce/vit-s";
5
+ import "react-dom";
6
+ var LercDecode = { exports: {} };
7
+ (function(module) {
8
+ /* Copyright 2015-2021 Esri. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 @preserve */
9
+ (function() {
10
+ var LercDecode2 = function() {
11
+ var CntZImage = {};
12
+ CntZImage.defaultNoDataValue = -34027999387901484e22;
13
+ CntZImage.decode = function(input, options) {
14
+ options = options || {};
15
+ var skipMask = options.encodedMaskData || options.encodedMaskData === null;
16
+ var parsedData = parse(input, options.inputOffset || 0, skipMask);
17
+ var noDataValue = options.noDataValue !== null ? options.noDataValue : CntZImage.defaultNoDataValue;
18
+ var uncompressedData = uncompressPixelValues(
19
+ parsedData,
20
+ options.pixelType || Float32Array,
21
+ options.encodedMaskData,
22
+ noDataValue,
23
+ options.returnMask
24
+ );
25
+ var result = {
26
+ width: parsedData.width,
27
+ height: parsedData.height,
28
+ pixelData: uncompressedData.resultPixels,
29
+ minValue: uncompressedData.minValue,
30
+ maxValue: parsedData.pixels.maxValue,
31
+ noDataValue
32
+ };
33
+ if (uncompressedData.resultMask) {
34
+ result.maskData = uncompressedData.resultMask;
35
+ }
36
+ if (options.returnEncodedMask && parsedData.mask) {
37
+ result.encodedMaskData = parsedData.mask.bitset ? parsedData.mask.bitset : null;
38
+ }
39
+ if (options.returnFileInfo) {
40
+ result.fileInfo = formatFileInfo(parsedData);
41
+ if (options.computeUsedBitDepths) {
42
+ result.fileInfo.bitDepths = computeUsedBitDepths(parsedData);
43
+ }
44
+ }
45
+ return result;
46
+ };
47
+ var uncompressPixelValues = function(data, TypedArrayClass, maskBitset, noDataValue, storeDecodedMask) {
48
+ var blockIdx = 0;
49
+ var numX = data.pixels.numBlocksX;
50
+ var numY = data.pixels.numBlocksY;
51
+ var blockWidth = Math.floor(data.width / numX);
52
+ var blockHeight = Math.floor(data.height / numY);
53
+ var scale = 2 * data.maxZError;
54
+ var minValue = Number.MAX_VALUE, currentValue;
55
+ maskBitset = maskBitset || (data.mask ? data.mask.bitset : null);
56
+ var resultPixels, resultMask;
57
+ resultPixels = new TypedArrayClass(data.width * data.height);
58
+ if (storeDecodedMask && maskBitset) {
59
+ resultMask = new Uint8Array(data.width * data.height);
60
+ }
61
+ var blockDataBuffer = new Float32Array(blockWidth * blockHeight);
62
+ var xx, yy;
63
+ for (var y = 0; y <= numY; y++) {
64
+ var thisBlockHeight = y !== numY ? blockHeight : data.height % numY;
65
+ if (thisBlockHeight === 0) {
66
+ continue;
67
+ }
68
+ for (var x = 0; x <= numX; x++) {
69
+ var thisBlockWidth = x !== numX ? blockWidth : data.width % numX;
70
+ if (thisBlockWidth === 0) {
71
+ continue;
72
+ }
73
+ var outPtr = y * data.width * blockHeight + x * blockWidth;
74
+ var outStride = data.width - thisBlockWidth;
75
+ var block = data.pixels.blocks[blockIdx];
76
+ var blockData, blockPtr, constValue;
77
+ if (block.encoding < 2) {
78
+ if (block.encoding === 0) {
79
+ blockData = block.rawData;
80
+ } else {
81
+ unstuff(block.stuffedData, block.bitsPerPixel, block.numValidPixels, block.offset, scale, blockDataBuffer, data.pixels.maxValue);
82
+ blockData = blockDataBuffer;
83
+ }
84
+ blockPtr = 0;
85
+ } else if (block.encoding === 2) {
86
+ constValue = 0;
87
+ } else {
88
+ constValue = block.offset;
89
+ }
90
+ var maskByte;
91
+ if (maskBitset) {
92
+ for (yy = 0; yy < thisBlockHeight; yy++) {
93
+ if (outPtr & 7) {
94
+ maskByte = maskBitset[outPtr >> 3];
95
+ maskByte <<= outPtr & 7;
96
+ }
97
+ for (xx = 0; xx < thisBlockWidth; xx++) {
98
+ if (!(outPtr & 7)) {
99
+ maskByte = maskBitset[outPtr >> 3];
100
+ }
101
+ if (maskByte & 128) {
102
+ if (resultMask) {
103
+ resultMask[outPtr] = 1;
104
+ }
105
+ currentValue = block.encoding < 2 ? blockData[blockPtr++] : constValue;
106
+ minValue = minValue > currentValue ? currentValue : minValue;
107
+ resultPixels[outPtr++] = currentValue;
108
+ } else {
109
+ if (resultMask) {
110
+ resultMask[outPtr] = 0;
111
+ }
112
+ resultPixels[outPtr++] = noDataValue;
113
+ }
114
+ maskByte <<= 1;
115
+ }
116
+ outPtr += outStride;
117
+ }
118
+ } else {
119
+ if (block.encoding < 2) {
120
+ for (yy = 0; yy < thisBlockHeight; yy++) {
121
+ for (xx = 0; xx < thisBlockWidth; xx++) {
122
+ currentValue = blockData[blockPtr++];
123
+ minValue = minValue > currentValue ? currentValue : minValue;
124
+ resultPixels[outPtr++] = currentValue;
125
+ }
126
+ outPtr += outStride;
127
+ }
128
+ } else {
129
+ minValue = minValue > constValue ? constValue : minValue;
130
+ for (yy = 0; yy < thisBlockHeight; yy++) {
131
+ for (xx = 0; xx < thisBlockWidth; xx++) {
132
+ resultPixels[outPtr++] = constValue;
133
+ }
134
+ outPtr += outStride;
135
+ }
136
+ }
137
+ }
138
+ if (block.encoding === 1 && blockPtr !== block.numValidPixels) {
139
+ throw "Block and Mask do not match";
140
+ }
141
+ blockIdx++;
142
+ }
143
+ }
144
+ return {
145
+ resultPixels,
146
+ resultMask,
147
+ minValue
148
+ };
149
+ };
150
+ var formatFileInfo = function(data) {
151
+ return {
152
+ "fileIdentifierString": data.fileIdentifierString,
153
+ "fileVersion": data.fileVersion,
154
+ "imageType": data.imageType,
155
+ "height": data.height,
156
+ "width": data.width,
157
+ "maxZError": data.maxZError,
158
+ "eofOffset": data.eofOffset,
159
+ "mask": data.mask ? {
160
+ "numBlocksX": data.mask.numBlocksX,
161
+ "numBlocksY": data.mask.numBlocksY,
162
+ "numBytes": data.mask.numBytes,
163
+ "maxValue": data.mask.maxValue
164
+ } : null,
165
+ "pixels": {
166
+ "numBlocksX": data.pixels.numBlocksX,
167
+ "numBlocksY": data.pixels.numBlocksY,
168
+ "numBytes": data.pixels.numBytes,
169
+ "maxValue": data.pixels.maxValue,
170
+ "noDataValue": data.noDataValue
171
+ }
172
+ };
173
+ };
174
+ var computeUsedBitDepths = function(data) {
175
+ var numBlocks = data.pixels.numBlocksX * data.pixels.numBlocksY;
176
+ var bitDepths = {};
177
+ for (var i = 0; i < numBlocks; i++) {
178
+ var block = data.pixels.blocks[i];
179
+ if (block.encoding === 0) {
180
+ bitDepths.float32 = true;
181
+ } else if (block.encoding === 1) {
182
+ bitDepths[block.bitsPerPixel] = true;
183
+ } else {
184
+ bitDepths[0] = true;
185
+ }
186
+ }
187
+ return Object.keys(bitDepths);
188
+ };
189
+ var parse = function(input, fp, skipMask) {
190
+ var data = {};
191
+ var fileIdView = new Uint8Array(input, fp, 10);
192
+ data.fileIdentifierString = String.fromCharCode.apply(null, fileIdView);
193
+ if (data.fileIdentifierString.trim() !== "CntZImage") {
194
+ throw "Unexpected file identifier string: " + data.fileIdentifierString;
195
+ }
196
+ fp += 10;
197
+ var view = new DataView(input, fp, 24);
198
+ data.fileVersion = view.getInt32(0, true);
199
+ data.imageType = view.getInt32(4, true);
200
+ data.height = view.getUint32(8, true);
201
+ data.width = view.getUint32(12, true);
202
+ data.maxZError = view.getFloat64(16, true);
203
+ fp += 24;
204
+ if (!skipMask) {
205
+ view = new DataView(input, fp, 16);
206
+ data.mask = {};
207
+ data.mask.numBlocksY = view.getUint32(0, true);
208
+ data.mask.numBlocksX = view.getUint32(4, true);
209
+ data.mask.numBytes = view.getUint32(8, true);
210
+ data.mask.maxValue = view.getFloat32(12, true);
211
+ fp += 16;
212
+ if (data.mask.numBytes > 0) {
213
+ var bitset = new Uint8Array(Math.ceil(data.width * data.height / 8));
214
+ view = new DataView(input, fp, data.mask.numBytes);
215
+ var cnt = view.getInt16(0, true);
216
+ var ip = 2, op = 0;
217
+ do {
218
+ if (cnt > 0) {
219
+ while (cnt--) {
220
+ bitset[op++] = view.getUint8(ip++);
221
+ }
222
+ } else {
223
+ var val = view.getUint8(ip++);
224
+ cnt = -cnt;
225
+ while (cnt--) {
226
+ bitset[op++] = val;
227
+ }
228
+ }
229
+ cnt = view.getInt16(ip, true);
230
+ ip += 2;
231
+ } while (ip < data.mask.numBytes);
232
+ if (cnt !== -32768 || op < bitset.length) {
233
+ throw "Unexpected end of mask RLE encoding";
234
+ }
235
+ data.mask.bitset = bitset;
236
+ fp += data.mask.numBytes;
237
+ } else if ((data.mask.numBytes | data.mask.numBlocksY | data.mask.maxValue) === 0) {
238
+ data.mask.bitset = new Uint8Array(Math.ceil(data.width * data.height / 8));
239
+ }
240
+ }
241
+ view = new DataView(input, fp, 16);
242
+ data.pixels = {};
243
+ data.pixels.numBlocksY = view.getUint32(0, true);
244
+ data.pixels.numBlocksX = view.getUint32(4, true);
245
+ data.pixels.numBytes = view.getUint32(8, true);
246
+ data.pixels.maxValue = view.getFloat32(12, true);
247
+ fp += 16;
248
+ var numBlocksX = data.pixels.numBlocksX;
249
+ var numBlocksY = data.pixels.numBlocksY;
250
+ var actualNumBlocksX = numBlocksX + (data.width % numBlocksX > 0 ? 1 : 0);
251
+ var actualNumBlocksY = numBlocksY + (data.height % numBlocksY > 0 ? 1 : 0);
252
+ data.pixels.blocks = new Array(actualNumBlocksX * actualNumBlocksY);
253
+ var blockI = 0;
254
+ for (var blockY = 0; blockY < actualNumBlocksY; blockY++) {
255
+ for (var blockX = 0; blockX < actualNumBlocksX; blockX++) {
256
+ var size = 0;
257
+ var bytesLeft = input.byteLength - fp;
258
+ view = new DataView(input, fp, Math.min(10, bytesLeft));
259
+ var block = {};
260
+ data.pixels.blocks[blockI++] = block;
261
+ var headerByte = view.getUint8(0);
262
+ size++;
263
+ block.encoding = headerByte & 63;
264
+ if (block.encoding > 3) {
265
+ throw "Invalid block encoding (" + block.encoding + ")";
266
+ }
267
+ if (block.encoding === 2) {
268
+ fp++;
269
+ continue;
270
+ }
271
+ if (headerByte !== 0 && headerByte !== 2) {
272
+ headerByte >>= 6;
273
+ block.offsetType = headerByte;
274
+ if (headerByte === 2) {
275
+ block.offset = view.getInt8(1);
276
+ size++;
277
+ } else if (headerByte === 1) {
278
+ block.offset = view.getInt16(1, true);
279
+ size += 2;
280
+ } else if (headerByte === 0) {
281
+ block.offset = view.getFloat32(1, true);
282
+ size += 4;
283
+ } else {
284
+ throw "Invalid block offset type";
285
+ }
286
+ if (block.encoding === 1) {
287
+ headerByte = view.getUint8(size);
288
+ size++;
289
+ block.bitsPerPixel = headerByte & 63;
290
+ headerByte >>= 6;
291
+ block.numValidPixelsType = headerByte;
292
+ if (headerByte === 2) {
293
+ block.numValidPixels = view.getUint8(size);
294
+ size++;
295
+ } else if (headerByte === 1) {
296
+ block.numValidPixels = view.getUint16(size, true);
297
+ size += 2;
298
+ } else if (headerByte === 0) {
299
+ block.numValidPixels = view.getUint32(size, true);
300
+ size += 4;
301
+ } else {
302
+ throw "Invalid valid pixel count type";
303
+ }
304
+ }
305
+ }
306
+ fp += size;
307
+ if (block.encoding === 3) {
308
+ continue;
309
+ }
310
+ var arrayBuf, store8;
311
+ if (block.encoding === 0) {
312
+ var numPixels = (data.pixels.numBytes - 1) / 4;
313
+ if (numPixels !== Math.floor(numPixels)) {
314
+ throw "uncompressed block has invalid length";
315
+ }
316
+ arrayBuf = new ArrayBuffer(numPixels * 4);
317
+ store8 = new Uint8Array(arrayBuf);
318
+ store8.set(new Uint8Array(input, fp, numPixels * 4));
319
+ var rawData = new Float32Array(arrayBuf);
320
+ block.rawData = rawData;
321
+ fp += numPixels * 4;
322
+ } else if (block.encoding === 1) {
323
+ var dataBytes = Math.ceil(block.numValidPixels * block.bitsPerPixel / 8);
324
+ var dataWords = Math.ceil(dataBytes / 4);
325
+ arrayBuf = new ArrayBuffer(dataWords * 4);
326
+ store8 = new Uint8Array(arrayBuf);
327
+ store8.set(new Uint8Array(input, fp, dataBytes));
328
+ block.stuffedData = new Uint32Array(arrayBuf);
329
+ fp += dataBytes;
330
+ }
331
+ }
332
+ }
333
+ data.eofOffset = fp;
334
+ return data;
335
+ };
336
+ var unstuff = function(src, bitsPerPixel, numPixels, offset, scale, dest, maxValue) {
337
+ var bitMask = (1 << bitsPerPixel) - 1;
338
+ var i = 0, o;
339
+ var bitsLeft = 0;
340
+ var n, buffer;
341
+ var nmax = Math.ceil((maxValue - offset) / scale);
342
+ var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
343
+ src[src.length - 1] <<= 8 * numInvalidTailBytes;
344
+ for (o = 0; o < numPixels; o++) {
345
+ if (bitsLeft === 0) {
346
+ buffer = src[i++];
347
+ bitsLeft = 32;
348
+ }
349
+ if (bitsLeft >= bitsPerPixel) {
350
+ n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
351
+ bitsLeft -= bitsPerPixel;
352
+ } else {
353
+ var missingBits = bitsPerPixel - bitsLeft;
354
+ n = (buffer & bitMask) << missingBits & bitMask;
355
+ buffer = src[i++];
356
+ bitsLeft = 32 - missingBits;
357
+ n += buffer >>> bitsLeft;
358
+ }
359
+ dest[o] = n < nmax ? offset + n * scale : maxValue;
360
+ }
361
+ return dest;
362
+ };
363
+ return CntZImage;
364
+ }();
365
+ var Lerc2Decode = function() {
366
+ var BitStuffer = {
367
+ unstuff: function(src, dest, bitsPerPixel, numPixels, lutArr, offset, scale, maxValue) {
368
+ var bitMask = (1 << bitsPerPixel) - 1;
369
+ var i = 0, o;
370
+ var bitsLeft = 0;
371
+ var n, buffer, missingBits, nmax;
372
+ var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
373
+ src[src.length - 1] <<= 8 * numInvalidTailBytes;
374
+ if (lutArr) {
375
+ for (o = 0; o < numPixels; o++) {
376
+ if (bitsLeft === 0) {
377
+ buffer = src[i++];
378
+ bitsLeft = 32;
379
+ }
380
+ if (bitsLeft >= bitsPerPixel) {
381
+ n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
382
+ bitsLeft -= bitsPerPixel;
383
+ } else {
384
+ missingBits = bitsPerPixel - bitsLeft;
385
+ n = (buffer & bitMask) << missingBits & bitMask;
386
+ buffer = src[i++];
387
+ bitsLeft = 32 - missingBits;
388
+ n += buffer >>> bitsLeft;
389
+ }
390
+ dest[o] = lutArr[n];
391
+ }
392
+ } else {
393
+ nmax = Math.ceil((maxValue - offset) / scale);
394
+ for (o = 0; o < numPixels; o++) {
395
+ if (bitsLeft === 0) {
396
+ buffer = src[i++];
397
+ bitsLeft = 32;
398
+ }
399
+ if (bitsLeft >= bitsPerPixel) {
400
+ n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
401
+ bitsLeft -= bitsPerPixel;
402
+ } else {
403
+ missingBits = bitsPerPixel - bitsLeft;
404
+ n = (buffer & bitMask) << missingBits & bitMask;
405
+ buffer = src[i++];
406
+ bitsLeft = 32 - missingBits;
407
+ n += buffer >>> bitsLeft;
408
+ }
409
+ dest[o] = n < nmax ? offset + n * scale : maxValue;
410
+ }
411
+ }
412
+ },
413
+ unstuffLUT: function(src, bitsPerPixel, numPixels, offset, scale, maxValue) {
414
+ var bitMask = (1 << bitsPerPixel) - 1;
415
+ var i = 0, o = 0, missingBits = 0, bitsLeft = 0, n = 0;
416
+ var buffer;
417
+ var dest = [];
418
+ var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
419
+ src[src.length - 1] <<= 8 * numInvalidTailBytes;
420
+ var nmax = Math.ceil((maxValue - offset) / scale);
421
+ for (o = 0; o < numPixels; o++) {
422
+ if (bitsLeft === 0) {
423
+ buffer = src[i++];
424
+ bitsLeft = 32;
425
+ }
426
+ if (bitsLeft >= bitsPerPixel) {
427
+ n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
428
+ bitsLeft -= bitsPerPixel;
429
+ } else {
430
+ missingBits = bitsPerPixel - bitsLeft;
431
+ n = (buffer & bitMask) << missingBits & bitMask;
432
+ buffer = src[i++];
433
+ bitsLeft = 32 - missingBits;
434
+ n += buffer >>> bitsLeft;
435
+ }
436
+ dest[o] = n < nmax ? offset + n * scale : maxValue;
437
+ }
438
+ dest.unshift(offset);
439
+ return dest;
440
+ },
441
+ unstuff2: function(src, dest, bitsPerPixel, numPixels, lutArr, offset, scale, maxValue) {
442
+ var bitMask = (1 << bitsPerPixel) - 1;
443
+ var i = 0, o;
444
+ var bitsLeft = 0, bitPos = 0;
445
+ var n, buffer, missingBits;
446
+ if (lutArr) {
447
+ for (o = 0; o < numPixels; o++) {
448
+ if (bitsLeft === 0) {
449
+ buffer = src[i++];
450
+ bitsLeft = 32;
451
+ bitPos = 0;
452
+ }
453
+ if (bitsLeft >= bitsPerPixel) {
454
+ n = buffer >>> bitPos & bitMask;
455
+ bitsLeft -= bitsPerPixel;
456
+ bitPos += bitsPerPixel;
457
+ } else {
458
+ missingBits = bitsPerPixel - bitsLeft;
459
+ n = buffer >>> bitPos & bitMask;
460
+ buffer = src[i++];
461
+ bitsLeft = 32 - missingBits;
462
+ n |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
463
+ bitPos = missingBits;
464
+ }
465
+ dest[o] = lutArr[n];
466
+ }
467
+ } else {
468
+ var nmax = Math.ceil((maxValue - offset) / scale);
469
+ for (o = 0; o < numPixels; o++) {
470
+ if (bitsLeft === 0) {
471
+ buffer = src[i++];
472
+ bitsLeft = 32;
473
+ bitPos = 0;
474
+ }
475
+ if (bitsLeft >= bitsPerPixel) {
476
+ n = buffer >>> bitPos & bitMask;
477
+ bitsLeft -= bitsPerPixel;
478
+ bitPos += bitsPerPixel;
479
+ } else {
480
+ missingBits = bitsPerPixel - bitsLeft;
481
+ n = buffer >>> bitPos & bitMask;
482
+ buffer = src[i++];
483
+ bitsLeft = 32 - missingBits;
484
+ n |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
485
+ bitPos = missingBits;
486
+ }
487
+ dest[o] = n < nmax ? offset + n * scale : maxValue;
488
+ }
489
+ }
490
+ return dest;
491
+ },
492
+ unstuffLUT2: function(src, bitsPerPixel, numPixels, offset, scale, maxValue) {
493
+ var bitMask = (1 << bitsPerPixel) - 1;
494
+ var i = 0, o = 0, missingBits = 0, bitsLeft = 0, n = 0, bitPos = 0;
495
+ var buffer;
496
+ var dest = [];
497
+ var nmax = Math.ceil((maxValue - offset) / scale);
498
+ for (o = 0; o < numPixels; o++) {
499
+ if (bitsLeft === 0) {
500
+ buffer = src[i++];
501
+ bitsLeft = 32;
502
+ bitPos = 0;
503
+ }
504
+ if (bitsLeft >= bitsPerPixel) {
505
+ n = buffer >>> bitPos & bitMask;
506
+ bitsLeft -= bitsPerPixel;
507
+ bitPos += bitsPerPixel;
508
+ } else {
509
+ missingBits = bitsPerPixel - bitsLeft;
510
+ n = buffer >>> bitPos & bitMask;
511
+ buffer = src[i++];
512
+ bitsLeft = 32 - missingBits;
513
+ n |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
514
+ bitPos = missingBits;
515
+ }
516
+ dest[o] = n < nmax ? offset + n * scale : maxValue;
517
+ }
518
+ dest.unshift(offset);
519
+ return dest;
520
+ },
521
+ originalUnstuff: function(src, dest, bitsPerPixel, numPixels) {
522
+ var bitMask = (1 << bitsPerPixel) - 1;
523
+ var i = 0, o;
524
+ var bitsLeft = 0;
525
+ var n, buffer, missingBits;
526
+ var numInvalidTailBytes = src.length * 4 - Math.ceil(bitsPerPixel * numPixels / 8);
527
+ src[src.length - 1] <<= 8 * numInvalidTailBytes;
528
+ for (o = 0; o < numPixels; o++) {
529
+ if (bitsLeft === 0) {
530
+ buffer = src[i++];
531
+ bitsLeft = 32;
532
+ }
533
+ if (bitsLeft >= bitsPerPixel) {
534
+ n = buffer >>> bitsLeft - bitsPerPixel & bitMask;
535
+ bitsLeft -= bitsPerPixel;
536
+ } else {
537
+ missingBits = bitsPerPixel - bitsLeft;
538
+ n = (buffer & bitMask) << missingBits & bitMask;
539
+ buffer = src[i++];
540
+ bitsLeft = 32 - missingBits;
541
+ n += buffer >>> bitsLeft;
542
+ }
543
+ dest[o] = n;
544
+ }
545
+ return dest;
546
+ },
547
+ originalUnstuff2: function(src, dest, bitsPerPixel, numPixels) {
548
+ var bitMask = (1 << bitsPerPixel) - 1;
549
+ var i = 0, o;
550
+ var bitsLeft = 0, bitPos = 0;
551
+ var n, buffer, missingBits;
552
+ for (o = 0; o < numPixels; o++) {
553
+ if (bitsLeft === 0) {
554
+ buffer = src[i++];
555
+ bitsLeft = 32;
556
+ bitPos = 0;
557
+ }
558
+ if (bitsLeft >= bitsPerPixel) {
559
+ n = buffer >>> bitPos & bitMask;
560
+ bitsLeft -= bitsPerPixel;
561
+ bitPos += bitsPerPixel;
562
+ } else {
563
+ missingBits = bitsPerPixel - bitsLeft;
564
+ n = buffer >>> bitPos & bitMask;
565
+ buffer = src[i++];
566
+ bitsLeft = 32 - missingBits;
567
+ n |= (buffer & (1 << missingBits) - 1) << bitsPerPixel - missingBits;
568
+ bitPos = missingBits;
569
+ }
570
+ dest[o] = n;
571
+ }
572
+ return dest;
573
+ }
574
+ };
575
+ var Lerc2Helpers = {
576
+ HUFFMAN_LUT_BITS_MAX: 12,
577
+ computeChecksumFletcher32: function(input) {
578
+ var sum1 = 65535, sum2 = 65535;
579
+ var len = input.length;
580
+ var words = Math.floor(len / 2);
581
+ var i = 0;
582
+ while (words) {
583
+ var tlen = words >= 359 ? 359 : words;
584
+ words -= tlen;
585
+ do {
586
+ sum1 += input[i++] << 8;
587
+ sum2 += sum1 += input[i++];
588
+ } while (--tlen);
589
+ sum1 = (sum1 & 65535) + (sum1 >>> 16);
590
+ sum2 = (sum2 & 65535) + (sum2 >>> 16);
591
+ }
592
+ if (len & 1) {
593
+ sum2 += sum1 += input[i] << 8;
594
+ }
595
+ sum1 = (sum1 & 65535) + (sum1 >>> 16);
596
+ sum2 = (sum2 & 65535) + (sum2 >>> 16);
597
+ return (sum2 << 16 | sum1) >>> 0;
598
+ },
599
+ readHeaderInfo: function(input, data) {
600
+ var ptr = data.ptr;
601
+ var fileIdView = new Uint8Array(input, ptr, 6);
602
+ var headerInfo = {};
603
+ headerInfo.fileIdentifierString = String.fromCharCode.apply(null, fileIdView);
604
+ if (headerInfo.fileIdentifierString.lastIndexOf("Lerc2", 0) !== 0) {
605
+ throw "Unexpected file identifier string (expect Lerc2 ): " + headerInfo.fileIdentifierString;
606
+ }
607
+ ptr += 6;
608
+ var view = new DataView(input, ptr, 8);
609
+ var fileVersion = view.getInt32(0, true);
610
+ headerInfo.fileVersion = fileVersion;
611
+ ptr += 4;
612
+ if (fileVersion >= 3) {
613
+ headerInfo.checksum = view.getUint32(4, true);
614
+ ptr += 4;
615
+ }
616
+ view = new DataView(input, ptr, 12);
617
+ headerInfo.height = view.getUint32(0, true);
618
+ headerInfo.width = view.getUint32(4, true);
619
+ ptr += 8;
620
+ if (fileVersion >= 4) {
621
+ headerInfo.numDims = view.getUint32(8, true);
622
+ ptr += 4;
623
+ } else {
624
+ headerInfo.numDims = 1;
625
+ }
626
+ view = new DataView(input, ptr, 40);
627
+ headerInfo.numValidPixel = view.getUint32(0, true);
628
+ headerInfo.microBlockSize = view.getInt32(4, true);
629
+ headerInfo.blobSize = view.getInt32(8, true);
630
+ headerInfo.imageType = view.getInt32(12, true);
631
+ headerInfo.maxZError = view.getFloat64(16, true);
632
+ headerInfo.zMin = view.getFloat64(24, true);
633
+ headerInfo.zMax = view.getFloat64(32, true);
634
+ ptr += 40;
635
+ data.headerInfo = headerInfo;
636
+ data.ptr = ptr;
637
+ var checksum, keyLength;
638
+ if (fileVersion >= 3) {
639
+ keyLength = fileVersion >= 4 ? 52 : 48;
640
+ checksum = this.computeChecksumFletcher32(new Uint8Array(input, ptr - keyLength, headerInfo.blobSize - 14));
641
+ if (checksum !== headerInfo.checksum) {
642
+ throw "Checksum failed.";
643
+ }
644
+ }
645
+ return true;
646
+ },
647
+ checkMinMaxRanges: function(input, data) {
648
+ var headerInfo = data.headerInfo;
649
+ var OutPixelTypeArray = this.getDataTypeArray(headerInfo.imageType);
650
+ var rangeBytes = headerInfo.numDims * this.getDataTypeSize(headerInfo.imageType);
651
+ var minValues = this.readSubArray(input, data.ptr, OutPixelTypeArray, rangeBytes);
652
+ var maxValues = this.readSubArray(input, data.ptr + rangeBytes, OutPixelTypeArray, rangeBytes);
653
+ data.ptr += 2 * rangeBytes;
654
+ var i, equal = true;
655
+ for (i = 0; i < headerInfo.numDims; i++) {
656
+ if (minValues[i] !== maxValues[i]) {
657
+ equal = false;
658
+ break;
659
+ }
660
+ }
661
+ headerInfo.minValues = minValues;
662
+ headerInfo.maxValues = maxValues;
663
+ return equal;
664
+ },
665
+ readSubArray: function(input, ptr, OutPixelTypeArray, numBytes) {
666
+ var rawData;
667
+ if (OutPixelTypeArray === Uint8Array) {
668
+ rawData = new Uint8Array(input, ptr, numBytes);
669
+ } else {
670
+ var arrayBuf = new ArrayBuffer(numBytes);
671
+ var store8 = new Uint8Array(arrayBuf);
672
+ store8.set(new Uint8Array(input, ptr, numBytes));
673
+ rawData = new OutPixelTypeArray(arrayBuf);
674
+ }
675
+ return rawData;
676
+ },
677
+ readMask: function(input, data) {
678
+ var ptr = data.ptr;
679
+ var headerInfo = data.headerInfo;
680
+ var numPixels = headerInfo.width * headerInfo.height;
681
+ var numValidPixel = headerInfo.numValidPixel;
682
+ var view = new DataView(input, ptr, 4);
683
+ var mask = {};
684
+ mask.numBytes = view.getUint32(0, true);
685
+ ptr += 4;
686
+ if ((0 === numValidPixel || numPixels === numValidPixel) && 0 !== mask.numBytes) {
687
+ throw "invalid mask";
688
+ }
689
+ var bitset, resultMask;
690
+ if (numValidPixel === 0) {
691
+ bitset = new Uint8Array(Math.ceil(numPixels / 8));
692
+ mask.bitset = bitset;
693
+ resultMask = new Uint8Array(numPixels);
694
+ data.pixels.resultMask = resultMask;
695
+ ptr += mask.numBytes;
696
+ } else if (mask.numBytes > 0) {
697
+ bitset = new Uint8Array(Math.ceil(numPixels / 8));
698
+ view = new DataView(input, ptr, mask.numBytes);
699
+ var cnt = view.getInt16(0, true);
700
+ var ip = 2, op = 0, val = 0;
701
+ do {
702
+ if (cnt > 0) {
703
+ while (cnt--) {
704
+ bitset[op++] = view.getUint8(ip++);
705
+ }
706
+ } else {
707
+ val = view.getUint8(ip++);
708
+ cnt = -cnt;
709
+ while (cnt--) {
710
+ bitset[op++] = val;
711
+ }
712
+ }
713
+ cnt = view.getInt16(ip, true);
714
+ ip += 2;
715
+ } while (ip < mask.numBytes);
716
+ if (cnt !== -32768 || op < bitset.length) {
717
+ throw "Unexpected end of mask RLE encoding";
718
+ }
719
+ resultMask = new Uint8Array(numPixels);
720
+ var mb = 0, k = 0;
721
+ for (k = 0; k < numPixels; k++) {
722
+ if (k & 7) {
723
+ mb = bitset[k >> 3];
724
+ mb <<= k & 7;
725
+ } else {
726
+ mb = bitset[k >> 3];
727
+ }
728
+ if (mb & 128) {
729
+ resultMask[k] = 1;
730
+ }
731
+ }
732
+ data.pixels.resultMask = resultMask;
733
+ mask.bitset = bitset;
734
+ ptr += mask.numBytes;
735
+ }
736
+ data.ptr = ptr;
737
+ data.mask = mask;
738
+ return true;
739
+ },
740
+ readDataOneSweep: function(input, data, OutPixelTypeArray, useBSQForOutputDim) {
741
+ var ptr = data.ptr;
742
+ var headerInfo = data.headerInfo;
743
+ var numDims = headerInfo.numDims;
744
+ var numPixels = headerInfo.width * headerInfo.height;
745
+ var imageType = headerInfo.imageType;
746
+ var numBytes = headerInfo.numValidPixel * Lerc2Helpers.getDataTypeSize(imageType) * numDims;
747
+ var rawData;
748
+ var mask = data.pixels.resultMask;
749
+ if (OutPixelTypeArray === Uint8Array) {
750
+ rawData = new Uint8Array(input, ptr, numBytes);
751
+ } else {
752
+ var arrayBuf = new ArrayBuffer(numBytes);
753
+ var store8 = new Uint8Array(arrayBuf);
754
+ store8.set(new Uint8Array(input, ptr, numBytes));
755
+ rawData = new OutPixelTypeArray(arrayBuf);
756
+ }
757
+ if (rawData.length === numPixels * numDims) {
758
+ if (useBSQForOutputDim) {
759
+ data.pixels.resultPixels = Lerc2Helpers.swapDimensionOrder(rawData, numPixels, numDims, OutPixelTypeArray, true);
760
+ } else {
761
+ data.pixels.resultPixels = rawData;
762
+ }
763
+ } else {
764
+ data.pixels.resultPixels = new OutPixelTypeArray(numPixels * numDims);
765
+ var z = 0, k = 0, i = 0, nStart = 0;
766
+ if (numDims > 1) {
767
+ if (useBSQForOutputDim) {
768
+ for (k = 0; k < numPixels; k++) {
769
+ if (mask[k]) {
770
+ nStart = k;
771
+ for (i = 0; i < numDims; i++, nStart += numPixels) {
772
+ data.pixels.resultPixels[nStart] = rawData[z++];
773
+ }
774
+ }
775
+ }
776
+ } else {
777
+ for (k = 0; k < numPixels; k++) {
778
+ if (mask[k]) {
779
+ nStart = k * numDims;
780
+ for (i = 0; i < numDims; i++) {
781
+ data.pixels.resultPixels[nStart + i] = rawData[z++];
782
+ }
783
+ }
784
+ }
785
+ }
786
+ } else {
787
+ for (k = 0; k < numPixels; k++) {
788
+ if (mask[k]) {
789
+ data.pixels.resultPixels[k] = rawData[z++];
790
+ }
791
+ }
792
+ }
793
+ }
794
+ ptr += numBytes;
795
+ data.ptr = ptr;
796
+ return true;
797
+ },
798
+ readHuffmanTree: function(input, data) {
799
+ var BITS_MAX = this.HUFFMAN_LUT_BITS_MAX;
800
+ var view = new DataView(input, data.ptr, 16);
801
+ data.ptr += 16;
802
+ var version = view.getInt32(0, true);
803
+ if (version < 2) {
804
+ throw "unsupported Huffman version";
805
+ }
806
+ var size = view.getInt32(4, true);
807
+ var i0 = view.getInt32(8, true);
808
+ var i1 = view.getInt32(12, true);
809
+ if (i0 >= i1) {
810
+ return false;
811
+ }
812
+ var blockDataBuffer = new Uint32Array(i1 - i0);
813
+ Lerc2Helpers.decodeBits(input, data, blockDataBuffer);
814
+ var codeTable = [];
815
+ var i, j, k, len;
816
+ for (i = i0; i < i1; i++) {
817
+ j = i - (i < size ? 0 : size);
818
+ codeTable[j] = { first: blockDataBuffer[i - i0], second: null };
819
+ }
820
+ var dataBytes = input.byteLength - data.ptr;
821
+ var dataWords = Math.ceil(dataBytes / 4);
822
+ var arrayBuf = new ArrayBuffer(dataWords * 4);
823
+ var store8 = new Uint8Array(arrayBuf);
824
+ store8.set(new Uint8Array(input, data.ptr, dataBytes));
825
+ var stuffedData = new Uint32Array(arrayBuf);
826
+ var bitPos = 0, word, srcPtr = 0;
827
+ word = stuffedData[0];
828
+ for (i = i0; i < i1; i++) {
829
+ j = i - (i < size ? 0 : size);
830
+ len = codeTable[j].first;
831
+ if (len > 0) {
832
+ codeTable[j].second = word << bitPos >>> 32 - len;
833
+ if (32 - bitPos >= len) {
834
+ bitPos += len;
835
+ if (bitPos === 32) {
836
+ bitPos = 0;
837
+ srcPtr++;
838
+ word = stuffedData[srcPtr];
839
+ }
840
+ } else {
841
+ bitPos += len - 32;
842
+ srcPtr++;
843
+ word = stuffedData[srcPtr];
844
+ codeTable[j].second |= word >>> 32 - bitPos;
845
+ }
846
+ }
847
+ }
848
+ var numBitsLUT = 0, numBitsLUTQick = 0;
849
+ var tree = new TreeNode();
850
+ for (i = 0; i < codeTable.length; i++) {
851
+ if (codeTable[i] !== void 0) {
852
+ numBitsLUT = Math.max(numBitsLUT, codeTable[i].first);
853
+ }
854
+ }
855
+ if (numBitsLUT >= BITS_MAX) {
856
+ numBitsLUTQick = BITS_MAX;
857
+ } else {
858
+ numBitsLUTQick = numBitsLUT;
859
+ }
860
+ var decodeLut = [], entry, code, numEntries, jj, currentBit, node;
861
+ for (i = i0; i < i1; i++) {
862
+ j = i - (i < size ? 0 : size);
863
+ len = codeTable[j].first;
864
+ if (len > 0) {
865
+ entry = [len, j];
866
+ if (len <= numBitsLUTQick) {
867
+ code = codeTable[j].second << numBitsLUTQick - len;
868
+ numEntries = 1 << numBitsLUTQick - len;
869
+ for (k = 0; k < numEntries; k++) {
870
+ decodeLut[code | k] = entry;
871
+ }
872
+ } else {
873
+ code = codeTable[j].second;
874
+ node = tree;
875
+ for (jj = len - 1; jj >= 0; jj--) {
876
+ currentBit = code >>> jj & 1;
877
+ if (currentBit) {
878
+ if (!node.right) {
879
+ node.right = new TreeNode();
880
+ }
881
+ node = node.right;
882
+ } else {
883
+ if (!node.left) {
884
+ node.left = new TreeNode();
885
+ }
886
+ node = node.left;
887
+ }
888
+ if (jj === 0 && !node.val) {
889
+ node.val = entry[1];
890
+ }
891
+ }
892
+ }
893
+ }
894
+ }
895
+ return {
896
+ decodeLut,
897
+ numBitsLUTQick,
898
+ numBitsLUT,
899
+ tree,
900
+ stuffedData,
901
+ srcPtr,
902
+ bitPos
903
+ };
904
+ },
905
+ readHuffman: function(input, data, OutPixelTypeArray, useBSQForOutputDim) {
906
+ var headerInfo = data.headerInfo;
907
+ var numDims = headerInfo.numDims;
908
+ var height = data.headerInfo.height;
909
+ var width = data.headerInfo.width;
910
+ var numPixels = width * height;
911
+ var huffmanInfo = this.readHuffmanTree(input, data);
912
+ var decodeLut = huffmanInfo.decodeLut;
913
+ var tree = huffmanInfo.tree;
914
+ var stuffedData = huffmanInfo.stuffedData;
915
+ var srcPtr = huffmanInfo.srcPtr;
916
+ var bitPos = huffmanInfo.bitPos;
917
+ var numBitsLUTQick = huffmanInfo.numBitsLUTQick;
918
+ var numBitsLUT = huffmanInfo.numBitsLUT;
919
+ var offset = data.headerInfo.imageType === 0 ? 128 : 0;
920
+ var node, val, delta, mask = data.pixels.resultMask, valTmp, valTmpQuick, currentBit;
921
+ var i, j, k, ii;
922
+ var prevVal = 0;
923
+ if (bitPos > 0) {
924
+ srcPtr++;
925
+ bitPos = 0;
926
+ }
927
+ var word = stuffedData[srcPtr];
928
+ var deltaEncode = data.encodeMode === 1;
929
+ var resultPixelsAllDim = new OutPixelTypeArray(numPixels * numDims);
930
+ var resultPixels = resultPixelsAllDim;
931
+ var iDim;
932
+ if (numDims < 2 || deltaEncode) {
933
+ for (iDim = 0; iDim < numDims; iDim++) {
934
+ if (numDims > 1) {
935
+ resultPixels = new OutPixelTypeArray(resultPixelsAllDim.buffer, numPixels * iDim, numPixels);
936
+ prevVal = 0;
937
+ }
938
+ if (data.headerInfo.numValidPixel === width * height) {
939
+ for (k = 0, i = 0; i < height; i++) {
940
+ for (j = 0; j < width; j++, k++) {
941
+ val = 0;
942
+ valTmp = word << bitPos >>> 32 - numBitsLUTQick;
943
+ valTmpQuick = valTmp;
944
+ if (32 - bitPos < numBitsLUTQick) {
945
+ valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUTQick;
946
+ valTmpQuick = valTmp;
947
+ }
948
+ if (decodeLut[valTmpQuick]) {
949
+ val = decodeLut[valTmpQuick][1];
950
+ bitPos += decodeLut[valTmpQuick][0];
951
+ } else {
952
+ valTmp = word << bitPos >>> 32 - numBitsLUT;
953
+ valTmpQuick = valTmp;
954
+ if (32 - bitPos < numBitsLUT) {
955
+ valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUT;
956
+ valTmpQuick = valTmp;
957
+ }
958
+ node = tree;
959
+ for (ii = 0; ii < numBitsLUT; ii++) {
960
+ currentBit = valTmp >>> numBitsLUT - ii - 1 & 1;
961
+ node = currentBit ? node.right : node.left;
962
+ if (!(node.left || node.right)) {
963
+ val = node.val;
964
+ bitPos = bitPos + ii + 1;
965
+ break;
966
+ }
967
+ }
968
+ }
969
+ if (bitPos >= 32) {
970
+ bitPos -= 32;
971
+ srcPtr++;
972
+ word = stuffedData[srcPtr];
973
+ }
974
+ delta = val - offset;
975
+ if (deltaEncode) {
976
+ if (j > 0) {
977
+ delta += prevVal;
978
+ } else if (i > 0) {
979
+ delta += resultPixels[k - width];
980
+ } else {
981
+ delta += prevVal;
982
+ }
983
+ delta &= 255;
984
+ resultPixels[k] = delta;
985
+ prevVal = delta;
986
+ } else {
987
+ resultPixels[k] = delta;
988
+ }
989
+ }
990
+ }
991
+ } else {
992
+ for (k = 0, i = 0; i < height; i++) {
993
+ for (j = 0; j < width; j++, k++) {
994
+ if (mask[k]) {
995
+ val = 0;
996
+ valTmp = word << bitPos >>> 32 - numBitsLUTQick;
997
+ valTmpQuick = valTmp;
998
+ if (32 - bitPos < numBitsLUTQick) {
999
+ valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUTQick;
1000
+ valTmpQuick = valTmp;
1001
+ }
1002
+ if (decodeLut[valTmpQuick]) {
1003
+ val = decodeLut[valTmpQuick][1];
1004
+ bitPos += decodeLut[valTmpQuick][0];
1005
+ } else {
1006
+ valTmp = word << bitPos >>> 32 - numBitsLUT;
1007
+ valTmpQuick = valTmp;
1008
+ if (32 - bitPos < numBitsLUT) {
1009
+ valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUT;
1010
+ valTmpQuick = valTmp;
1011
+ }
1012
+ node = tree;
1013
+ for (ii = 0; ii < numBitsLUT; ii++) {
1014
+ currentBit = valTmp >>> numBitsLUT - ii - 1 & 1;
1015
+ node = currentBit ? node.right : node.left;
1016
+ if (!(node.left || node.right)) {
1017
+ val = node.val;
1018
+ bitPos = bitPos + ii + 1;
1019
+ break;
1020
+ }
1021
+ }
1022
+ }
1023
+ if (bitPos >= 32) {
1024
+ bitPos -= 32;
1025
+ srcPtr++;
1026
+ word = stuffedData[srcPtr];
1027
+ }
1028
+ delta = val - offset;
1029
+ if (deltaEncode) {
1030
+ if (j > 0 && mask[k - 1]) {
1031
+ delta += prevVal;
1032
+ } else if (i > 0 && mask[k - width]) {
1033
+ delta += resultPixels[k - width];
1034
+ } else {
1035
+ delta += prevVal;
1036
+ }
1037
+ delta &= 255;
1038
+ resultPixels[k] = delta;
1039
+ prevVal = delta;
1040
+ } else {
1041
+ resultPixels[k] = delta;
1042
+ }
1043
+ }
1044
+ }
1045
+ }
1046
+ }
1047
+ }
1048
+ } else {
1049
+ for (k = 0, i = 0; i < height; i++) {
1050
+ for (j = 0; j < width; j++) {
1051
+ k = i * width + j;
1052
+ if (!mask || mask[k]) {
1053
+ for (iDim = 0; iDim < numDims; iDim++, k += numPixels) {
1054
+ val = 0;
1055
+ valTmp = word << bitPos >>> 32 - numBitsLUTQick;
1056
+ valTmpQuick = valTmp;
1057
+ if (32 - bitPos < numBitsLUTQick) {
1058
+ valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUTQick;
1059
+ valTmpQuick = valTmp;
1060
+ }
1061
+ if (decodeLut[valTmpQuick]) {
1062
+ val = decodeLut[valTmpQuick][1];
1063
+ bitPos += decodeLut[valTmpQuick][0];
1064
+ } else {
1065
+ valTmp = word << bitPos >>> 32 - numBitsLUT;
1066
+ valTmpQuick = valTmp;
1067
+ if (32 - bitPos < numBitsLUT) {
1068
+ valTmp |= stuffedData[srcPtr + 1] >>> 64 - bitPos - numBitsLUT;
1069
+ valTmpQuick = valTmp;
1070
+ }
1071
+ node = tree;
1072
+ for (ii = 0; ii < numBitsLUT; ii++) {
1073
+ currentBit = valTmp >>> numBitsLUT - ii - 1 & 1;
1074
+ node = currentBit ? node.right : node.left;
1075
+ if (!(node.left || node.right)) {
1076
+ val = node.val;
1077
+ bitPos = bitPos + ii + 1;
1078
+ break;
1079
+ }
1080
+ }
1081
+ }
1082
+ if (bitPos >= 32) {
1083
+ bitPos -= 32;
1084
+ srcPtr++;
1085
+ word = stuffedData[srcPtr];
1086
+ }
1087
+ delta = val - offset;
1088
+ resultPixels[k] = delta;
1089
+ }
1090
+ }
1091
+ }
1092
+ }
1093
+ }
1094
+ data.ptr = data.ptr + (srcPtr + 1) * 4 + (bitPos > 0 ? 4 : 0);
1095
+ data.pixels.resultPixels = resultPixelsAllDim;
1096
+ if (numDims > 1 && !useBSQForOutputDim) {
1097
+ data.pixels.resultPixels = Lerc2Helpers.swapDimensionOrder(resultPixelsAllDim, numPixels, numDims, OutPixelTypeArray);
1098
+ }
1099
+ },
1100
+ decodeBits: function(input, data, blockDataBuffer, offset, iDim) {
1101
+ {
1102
+ var headerInfo = data.headerInfo;
1103
+ var fileVersion = headerInfo.fileVersion;
1104
+ var blockPtr = 0;
1105
+ var viewByteLength = input.byteLength - data.ptr >= 5 ? 5 : input.byteLength - data.ptr;
1106
+ var view = new DataView(input, data.ptr, viewByteLength);
1107
+ var headerByte = view.getUint8(0);
1108
+ blockPtr++;
1109
+ var bits67 = headerByte >> 6;
1110
+ var n = bits67 === 0 ? 4 : 3 - bits67;
1111
+ var doLut = (headerByte & 32) > 0 ? true : false;
1112
+ var numBits = headerByte & 31;
1113
+ var numElements = 0;
1114
+ if (n === 1) {
1115
+ numElements = view.getUint8(blockPtr);
1116
+ blockPtr++;
1117
+ } else if (n === 2) {
1118
+ numElements = view.getUint16(blockPtr, true);
1119
+ blockPtr += 2;
1120
+ } else if (n === 4) {
1121
+ numElements = view.getUint32(blockPtr, true);
1122
+ blockPtr += 4;
1123
+ } else {
1124
+ throw "Invalid valid pixel count type";
1125
+ }
1126
+ var scale = 2 * headerInfo.maxZError;
1127
+ var stuffedData, arrayBuf, store8, dataBytes, dataWords;
1128
+ var lutArr, lutData, lutBytes, bitsPerPixel;
1129
+ var zMax = headerInfo.numDims > 1 ? headerInfo.maxValues[iDim] : headerInfo.zMax;
1130
+ if (doLut) {
1131
+ data.counter.lut++;
1132
+ lutBytes = view.getUint8(blockPtr);
1133
+ blockPtr++;
1134
+ dataBytes = Math.ceil((lutBytes - 1) * numBits / 8);
1135
+ dataWords = Math.ceil(dataBytes / 4);
1136
+ arrayBuf = new ArrayBuffer(dataWords * 4);
1137
+ store8 = new Uint8Array(arrayBuf);
1138
+ data.ptr += blockPtr;
1139
+ store8.set(new Uint8Array(input, data.ptr, dataBytes));
1140
+ lutData = new Uint32Array(arrayBuf);
1141
+ data.ptr += dataBytes;
1142
+ bitsPerPixel = 0;
1143
+ while (lutBytes - 1 >>> bitsPerPixel) {
1144
+ bitsPerPixel++;
1145
+ }
1146
+ dataBytes = Math.ceil(numElements * bitsPerPixel / 8);
1147
+ dataWords = Math.ceil(dataBytes / 4);
1148
+ arrayBuf = new ArrayBuffer(dataWords * 4);
1149
+ store8 = new Uint8Array(arrayBuf);
1150
+ store8.set(new Uint8Array(input, data.ptr, dataBytes));
1151
+ stuffedData = new Uint32Array(arrayBuf);
1152
+ data.ptr += dataBytes;
1153
+ if (fileVersion >= 3) {
1154
+ lutArr = BitStuffer.unstuffLUT2(lutData, numBits, lutBytes - 1, offset, scale, zMax);
1155
+ } else {
1156
+ lutArr = BitStuffer.unstuffLUT(lutData, numBits, lutBytes - 1, offset, scale, zMax);
1157
+ }
1158
+ if (fileVersion >= 3) {
1159
+ BitStuffer.unstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements, lutArr);
1160
+ } else {
1161
+ BitStuffer.unstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements, lutArr);
1162
+ }
1163
+ } else {
1164
+ data.counter.bitstuffer++;
1165
+ bitsPerPixel = numBits;
1166
+ data.ptr += blockPtr;
1167
+ if (bitsPerPixel > 0) {
1168
+ dataBytes = Math.ceil(numElements * bitsPerPixel / 8);
1169
+ dataWords = Math.ceil(dataBytes / 4);
1170
+ arrayBuf = new ArrayBuffer(dataWords * 4);
1171
+ store8 = new Uint8Array(arrayBuf);
1172
+ store8.set(new Uint8Array(input, data.ptr, dataBytes));
1173
+ stuffedData = new Uint32Array(arrayBuf);
1174
+ data.ptr += dataBytes;
1175
+ if (fileVersion >= 3) {
1176
+ if (offset == null) {
1177
+ BitStuffer.originalUnstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements);
1178
+ } else {
1179
+ BitStuffer.unstuff2(stuffedData, blockDataBuffer, bitsPerPixel, numElements, false, offset, scale, zMax);
1180
+ }
1181
+ } else {
1182
+ if (offset == null) {
1183
+ BitStuffer.originalUnstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements);
1184
+ } else {
1185
+ BitStuffer.unstuff(stuffedData, blockDataBuffer, bitsPerPixel, numElements, false, offset, scale, zMax);
1186
+ }
1187
+ }
1188
+ }
1189
+ }
1190
+ }
1191
+ },
1192
+ readTiles: function(input, data, OutPixelTypeArray, useBSQForOutputDim) {
1193
+ var headerInfo = data.headerInfo;
1194
+ var width = headerInfo.width;
1195
+ var height = headerInfo.height;
1196
+ var numPixels = width * height;
1197
+ var microBlockSize = headerInfo.microBlockSize;
1198
+ var imageType = headerInfo.imageType;
1199
+ var dataTypeSize = Lerc2Helpers.getDataTypeSize(imageType);
1200
+ var numBlocksX = Math.ceil(width / microBlockSize);
1201
+ var numBlocksY = Math.ceil(height / microBlockSize);
1202
+ data.pixels.numBlocksY = numBlocksY;
1203
+ data.pixels.numBlocksX = numBlocksX;
1204
+ data.pixels.ptr = 0;
1205
+ var row = 0, col = 0, blockY = 0, blockX = 0, thisBlockHeight = 0, thisBlockWidth = 0, bytesLeft = 0, headerByte = 0, bits67 = 0, testCode = 0, outPtr = 0, outStride = 0, numBytes = 0, bytesleft = 0, z = 0, blockPtr = 0;
1206
+ var view, block, arrayBuf, store8, rawData;
1207
+ var blockEncoding;
1208
+ var blockDataBuffer = new OutPixelTypeArray(microBlockSize * microBlockSize);
1209
+ var lastBlockHeight = height % microBlockSize || microBlockSize;
1210
+ var lastBlockWidth = width % microBlockSize || microBlockSize;
1211
+ var offsetType, offset;
1212
+ var numDims = headerInfo.numDims, iDim;
1213
+ var mask = data.pixels.resultMask;
1214
+ var resultPixels = data.pixels.resultPixels;
1215
+ var fileVersion = headerInfo.fileVersion;
1216
+ var fileVersionCheckNum = fileVersion >= 5 ? 14 : 15;
1217
+ var isDiffEncoding;
1218
+ var zMax = headerInfo.zMax;
1219
+ var resultPixelsPrevDim;
1220
+ for (blockY = 0; blockY < numBlocksY; blockY++) {
1221
+ thisBlockHeight = blockY !== numBlocksY - 1 ? microBlockSize : lastBlockHeight;
1222
+ for (blockX = 0; blockX < numBlocksX; blockX++) {
1223
+ thisBlockWidth = blockX !== numBlocksX - 1 ? microBlockSize : lastBlockWidth;
1224
+ outPtr = blockY * width * microBlockSize + blockX * microBlockSize;
1225
+ outStride = width - thisBlockWidth;
1226
+ for (iDim = 0; iDim < numDims; iDim++) {
1227
+ if (numDims > 1) {
1228
+ resultPixelsPrevDim = resultPixels;
1229
+ outPtr = blockY * width * microBlockSize + blockX * microBlockSize;
1230
+ resultPixels = new OutPixelTypeArray(data.pixels.resultPixels.buffer, numPixels * iDim * dataTypeSize, numPixels);
1231
+ zMax = headerInfo.maxValues[iDim];
1232
+ } else {
1233
+ resultPixelsPrevDim = null;
1234
+ }
1235
+ bytesLeft = input.byteLength - data.ptr;
1236
+ view = new DataView(input, data.ptr, Math.min(10, bytesLeft));
1237
+ block = {};
1238
+ blockPtr = 0;
1239
+ headerByte = view.getUint8(0);
1240
+ blockPtr++;
1241
+ isDiffEncoding = headerInfo.fileVersion >= 5 ? headerByte & 4 : 0;
1242
+ bits67 = headerByte >> 6 & 255;
1243
+ testCode = headerByte >> 2 & fileVersionCheckNum;
1244
+ if (testCode !== (blockX * microBlockSize >> 3 & fileVersionCheckNum)) {
1245
+ throw "integrity issue";
1246
+ }
1247
+ if (isDiffEncoding && iDim === 0) {
1248
+ throw "integrity issue";
1249
+ }
1250
+ blockEncoding = headerByte & 3;
1251
+ if (blockEncoding > 3) {
1252
+ data.ptr += blockPtr;
1253
+ throw "Invalid block encoding (" + blockEncoding + ")";
1254
+ } else if (blockEncoding === 2) {
1255
+ if (isDiffEncoding) {
1256
+ if (mask) {
1257
+ for (row = 0; row < thisBlockHeight; row++) {
1258
+ for (col = 0; col < thisBlockWidth; col++) {
1259
+ if (mask[outPtr]) {
1260
+ resultPixels[outPtr] = resultPixelsPrevDim[outPtr];
1261
+ }
1262
+ outPtr++;
1263
+ }
1264
+ }
1265
+ } else {
1266
+ for (row = 0; row < thisBlockHeight; row++) {
1267
+ for (col = 0; col < thisBlockWidth; col++) {
1268
+ resultPixels[outPtr] = resultPixelsPrevDim[outPtr];
1269
+ outPtr++;
1270
+ }
1271
+ }
1272
+ }
1273
+ }
1274
+ data.counter.constant++;
1275
+ data.ptr += blockPtr;
1276
+ continue;
1277
+ } else if (blockEncoding === 0) {
1278
+ if (isDiffEncoding) {
1279
+ throw "integrity issue";
1280
+ }
1281
+ data.counter.uncompressed++;
1282
+ data.ptr += blockPtr;
1283
+ numBytes = thisBlockHeight * thisBlockWidth * dataTypeSize;
1284
+ bytesleft = input.byteLength - data.ptr;
1285
+ numBytes = numBytes < bytesleft ? numBytes : bytesleft;
1286
+ arrayBuf = new ArrayBuffer(numBytes % dataTypeSize === 0 ? numBytes : numBytes + dataTypeSize - numBytes % dataTypeSize);
1287
+ store8 = new Uint8Array(arrayBuf);
1288
+ store8.set(new Uint8Array(input, data.ptr, numBytes));
1289
+ rawData = new OutPixelTypeArray(arrayBuf);
1290
+ z = 0;
1291
+ if (mask) {
1292
+ for (row = 0; row < thisBlockHeight; row++) {
1293
+ for (col = 0; col < thisBlockWidth; col++) {
1294
+ if (mask[outPtr]) {
1295
+ resultPixels[outPtr] = rawData[z++];
1296
+ }
1297
+ outPtr++;
1298
+ }
1299
+ outPtr += outStride;
1300
+ }
1301
+ } else {
1302
+ for (row = 0; row < thisBlockHeight; row++) {
1303
+ for (col = 0; col < thisBlockWidth; col++) {
1304
+ resultPixels[outPtr++] = rawData[z++];
1305
+ }
1306
+ outPtr += outStride;
1307
+ }
1308
+ }
1309
+ data.ptr += z * dataTypeSize;
1310
+ } else {
1311
+ offsetType = Lerc2Helpers.getDataTypeUsed(isDiffEncoding && imageType < 6 ? 4 : imageType, bits67);
1312
+ offset = Lerc2Helpers.getOnePixel(block, blockPtr, offsetType, view);
1313
+ blockPtr += Lerc2Helpers.getDataTypeSize(offsetType);
1314
+ if (blockEncoding === 3) {
1315
+ data.ptr += blockPtr;
1316
+ data.counter.constantoffset++;
1317
+ if (mask) {
1318
+ for (row = 0; row < thisBlockHeight; row++) {
1319
+ for (col = 0; col < thisBlockWidth; col++) {
1320
+ if (mask[outPtr]) {
1321
+ resultPixels[outPtr] = isDiffEncoding ? Math.min(zMax, resultPixelsPrevDim[outPtr] + offset) : offset;
1322
+ }
1323
+ outPtr++;
1324
+ }
1325
+ outPtr += outStride;
1326
+ }
1327
+ } else {
1328
+ for (row = 0; row < thisBlockHeight; row++) {
1329
+ for (col = 0; col < thisBlockWidth; col++) {
1330
+ resultPixels[outPtr] = isDiffEncoding ? Math.min(zMax, resultPixelsPrevDim[outPtr] + offset) : offset;
1331
+ outPtr++;
1332
+ }
1333
+ outPtr += outStride;
1334
+ }
1335
+ }
1336
+ } else {
1337
+ data.ptr += blockPtr;
1338
+ Lerc2Helpers.decodeBits(input, data, blockDataBuffer, offset, iDim);
1339
+ blockPtr = 0;
1340
+ if (isDiffEncoding) {
1341
+ if (mask) {
1342
+ for (row = 0; row < thisBlockHeight; row++) {
1343
+ for (col = 0; col < thisBlockWidth; col++) {
1344
+ if (mask[outPtr]) {
1345
+ resultPixels[outPtr] = blockDataBuffer[blockPtr++] + resultPixelsPrevDim[outPtr];
1346
+ }
1347
+ outPtr++;
1348
+ }
1349
+ outPtr += outStride;
1350
+ }
1351
+ } else {
1352
+ for (row = 0; row < thisBlockHeight; row++) {
1353
+ for (col = 0; col < thisBlockWidth; col++) {
1354
+ resultPixels[outPtr] = blockDataBuffer[blockPtr++] + resultPixelsPrevDim[outPtr];
1355
+ outPtr++;
1356
+ }
1357
+ outPtr += outStride;
1358
+ }
1359
+ }
1360
+ } else if (mask) {
1361
+ for (row = 0; row < thisBlockHeight; row++) {
1362
+ for (col = 0; col < thisBlockWidth; col++) {
1363
+ if (mask[outPtr]) {
1364
+ resultPixels[outPtr] = blockDataBuffer[blockPtr++];
1365
+ }
1366
+ outPtr++;
1367
+ }
1368
+ outPtr += outStride;
1369
+ }
1370
+ } else {
1371
+ for (row = 0; row < thisBlockHeight; row++) {
1372
+ for (col = 0; col < thisBlockWidth; col++) {
1373
+ resultPixels[outPtr++] = blockDataBuffer[blockPtr++];
1374
+ }
1375
+ outPtr += outStride;
1376
+ }
1377
+ }
1378
+ }
1379
+ }
1380
+ }
1381
+ }
1382
+ }
1383
+ if (numDims > 1 && !useBSQForOutputDim) {
1384
+ data.pixels.resultPixels = Lerc2Helpers.swapDimensionOrder(data.pixels.resultPixels, numPixels, numDims, OutPixelTypeArray);
1385
+ }
1386
+ },
1387
+ formatFileInfo: function(data) {
1388
+ return {
1389
+ "fileIdentifierString": data.headerInfo.fileIdentifierString,
1390
+ "fileVersion": data.headerInfo.fileVersion,
1391
+ "imageType": data.headerInfo.imageType,
1392
+ "height": data.headerInfo.height,
1393
+ "width": data.headerInfo.width,
1394
+ "numValidPixel": data.headerInfo.numValidPixel,
1395
+ "microBlockSize": data.headerInfo.microBlockSize,
1396
+ "blobSize": data.headerInfo.blobSize,
1397
+ "maxZError": data.headerInfo.maxZError,
1398
+ "pixelType": Lerc2Helpers.getPixelType(data.headerInfo.imageType),
1399
+ "eofOffset": data.eofOffset,
1400
+ "mask": data.mask ? {
1401
+ "numBytes": data.mask.numBytes
1402
+ } : null,
1403
+ "pixels": {
1404
+ "numBlocksX": data.pixels.numBlocksX,
1405
+ "numBlocksY": data.pixels.numBlocksY,
1406
+ "maxValue": data.headerInfo.zMax,
1407
+ "minValue": data.headerInfo.zMin,
1408
+ "noDataValue": data.noDataValue
1409
+ }
1410
+ };
1411
+ },
1412
+ constructConstantSurface: function(data, useBSQForOutputDim) {
1413
+ var val = data.headerInfo.zMax;
1414
+ var valMin = data.headerInfo.zMin;
1415
+ var maxValues = data.headerInfo.maxValues;
1416
+ var numDims = data.headerInfo.numDims;
1417
+ var numPixels = data.headerInfo.height * data.headerInfo.width;
1418
+ var i = 0, k = 0, nStart = 0;
1419
+ var mask = data.pixels.resultMask;
1420
+ var resultPixels = data.pixels.resultPixels;
1421
+ if (mask) {
1422
+ if (numDims > 1) {
1423
+ if (useBSQForOutputDim) {
1424
+ for (i = 0; i < numDims; i++) {
1425
+ nStart = i * numPixels;
1426
+ val = maxValues[i];
1427
+ for (k = 0; k < numPixels; k++) {
1428
+ if (mask[k]) {
1429
+ resultPixels[nStart + k] = val;
1430
+ }
1431
+ }
1432
+ }
1433
+ } else {
1434
+ for (k = 0; k < numPixels; k++) {
1435
+ if (mask[k]) {
1436
+ nStart = k * numDims;
1437
+ for (i = 0; i < numDims; i++) {
1438
+ resultPixels[nStart + numDims] = maxValues[i];
1439
+ }
1440
+ }
1441
+ }
1442
+ }
1443
+ } else {
1444
+ for (k = 0; k < numPixels; k++) {
1445
+ if (mask[k]) {
1446
+ resultPixels[k] = val;
1447
+ }
1448
+ }
1449
+ }
1450
+ } else {
1451
+ if (numDims > 1 && valMin !== val) {
1452
+ if (useBSQForOutputDim) {
1453
+ for (i = 0; i < numDims; i++) {
1454
+ nStart = i * numPixels;
1455
+ val = maxValues[i];
1456
+ for (k = 0; k < numPixels; k++) {
1457
+ resultPixels[nStart + k] = val;
1458
+ }
1459
+ }
1460
+ } else {
1461
+ for (k = 0; k < numPixels; k++) {
1462
+ nStart = k * numDims;
1463
+ for (i = 0; i < numDims; i++) {
1464
+ resultPixels[nStart + i] = maxValues[i];
1465
+ }
1466
+ }
1467
+ }
1468
+ } else {
1469
+ for (k = 0; k < numPixels * numDims; k++) {
1470
+ resultPixels[k] = val;
1471
+ }
1472
+ }
1473
+ }
1474
+ return;
1475
+ },
1476
+ getDataTypeArray: function(t) {
1477
+ var tp;
1478
+ switch (t) {
1479
+ case 0:
1480
+ tp = Int8Array;
1481
+ break;
1482
+ case 1:
1483
+ tp = Uint8Array;
1484
+ break;
1485
+ case 2:
1486
+ tp = Int16Array;
1487
+ break;
1488
+ case 3:
1489
+ tp = Uint16Array;
1490
+ break;
1491
+ case 4:
1492
+ tp = Int32Array;
1493
+ break;
1494
+ case 5:
1495
+ tp = Uint32Array;
1496
+ break;
1497
+ case 6:
1498
+ tp = Float32Array;
1499
+ break;
1500
+ case 7:
1501
+ tp = Float64Array;
1502
+ break;
1503
+ default:
1504
+ tp = Float32Array;
1505
+ }
1506
+ return tp;
1507
+ },
1508
+ getPixelType: function(t) {
1509
+ var tp;
1510
+ switch (t) {
1511
+ case 0:
1512
+ tp = "S8";
1513
+ break;
1514
+ case 1:
1515
+ tp = "U8";
1516
+ break;
1517
+ case 2:
1518
+ tp = "S16";
1519
+ break;
1520
+ case 3:
1521
+ tp = "U16";
1522
+ break;
1523
+ case 4:
1524
+ tp = "S32";
1525
+ break;
1526
+ case 5:
1527
+ tp = "U32";
1528
+ break;
1529
+ case 6:
1530
+ tp = "F32";
1531
+ break;
1532
+ case 7:
1533
+ tp = "F64";
1534
+ break;
1535
+ default:
1536
+ tp = "F32";
1537
+ }
1538
+ return tp;
1539
+ },
1540
+ isValidPixelValue: function(t, val) {
1541
+ if (val == null) {
1542
+ return false;
1543
+ }
1544
+ var isValid;
1545
+ switch (t) {
1546
+ case 0:
1547
+ isValid = val >= -128 && val <= 127;
1548
+ break;
1549
+ case 1:
1550
+ isValid = val >= 0 && val <= 255;
1551
+ break;
1552
+ case 2:
1553
+ isValid = val >= -32768 && val <= 32767;
1554
+ break;
1555
+ case 3:
1556
+ isValid = val >= 0 && val <= 65536;
1557
+ break;
1558
+ case 4:
1559
+ isValid = val >= -2147483648 && val <= 2147483647;
1560
+ break;
1561
+ case 5:
1562
+ isValid = val >= 0 && val <= 4294967296;
1563
+ break;
1564
+ case 6:
1565
+ isValid = val >= -34027999387901484e22 && val <= 34027999387901484e22;
1566
+ break;
1567
+ case 7:
1568
+ isValid = val >= -17976931348623157e292 && val <= 17976931348623157e292;
1569
+ break;
1570
+ default:
1571
+ isValid = false;
1572
+ }
1573
+ return isValid;
1574
+ },
1575
+ getDataTypeSize: function(t) {
1576
+ var s = 0;
1577
+ switch (t) {
1578
+ case 0:
1579
+ case 1:
1580
+ s = 1;
1581
+ break;
1582
+ case 2:
1583
+ case 3:
1584
+ s = 2;
1585
+ break;
1586
+ case 4:
1587
+ case 5:
1588
+ case 6:
1589
+ s = 4;
1590
+ break;
1591
+ case 7:
1592
+ s = 8;
1593
+ break;
1594
+ default:
1595
+ s = t;
1596
+ }
1597
+ return s;
1598
+ },
1599
+ getDataTypeUsed: function(dt, tc) {
1600
+ var t = dt;
1601
+ switch (dt) {
1602
+ case 2:
1603
+ case 4:
1604
+ t = dt - tc;
1605
+ break;
1606
+ case 3:
1607
+ case 5:
1608
+ t = dt - 2 * tc;
1609
+ break;
1610
+ case 6:
1611
+ if (0 === tc) {
1612
+ t = dt;
1613
+ } else if (1 === tc) {
1614
+ t = 2;
1615
+ } else {
1616
+ t = 1;
1617
+ }
1618
+ break;
1619
+ case 7:
1620
+ if (0 === tc) {
1621
+ t = dt;
1622
+ } else {
1623
+ t = dt - 2 * tc + 1;
1624
+ }
1625
+ break;
1626
+ default:
1627
+ t = dt;
1628
+ break;
1629
+ }
1630
+ return t;
1631
+ },
1632
+ getOnePixel: function(block, blockPtr, offsetType, view) {
1633
+ var temp = 0;
1634
+ switch (offsetType) {
1635
+ case 0:
1636
+ temp = view.getInt8(blockPtr);
1637
+ break;
1638
+ case 1:
1639
+ temp = view.getUint8(blockPtr);
1640
+ break;
1641
+ case 2:
1642
+ temp = view.getInt16(blockPtr, true);
1643
+ break;
1644
+ case 3:
1645
+ temp = view.getUint16(blockPtr, true);
1646
+ break;
1647
+ case 4:
1648
+ temp = view.getInt32(blockPtr, true);
1649
+ break;
1650
+ case 5:
1651
+ temp = view.getUInt32(blockPtr, true);
1652
+ break;
1653
+ case 6:
1654
+ temp = view.getFloat32(blockPtr, true);
1655
+ break;
1656
+ case 7:
1657
+ temp = view.getFloat64(blockPtr, true);
1658
+ break;
1659
+ default:
1660
+ throw "the decoder does not understand this pixel type";
1661
+ }
1662
+ return temp;
1663
+ },
1664
+ swapDimensionOrder: function(pixels, numPixels, numDims, OutPixelTypeArray, inputIsBIP) {
1665
+ var i = 0, j = 0, iDim = 0, temp = 0, swap = pixels;
1666
+ if (numDims > 1) {
1667
+ swap = new OutPixelTypeArray(numPixels * numDims);
1668
+ if (inputIsBIP) {
1669
+ for (i = 0; i < numPixels; i++) {
1670
+ temp = i;
1671
+ for (iDim = 0; iDim < numDims; iDim++, temp += numPixels) {
1672
+ swap[temp] = pixels[j++];
1673
+ }
1674
+ }
1675
+ } else {
1676
+ for (i = 0; i < numPixels; i++) {
1677
+ temp = i;
1678
+ for (iDim = 0; iDim < numDims; iDim++, temp += numPixels) {
1679
+ swap[j++] = pixels[temp];
1680
+ }
1681
+ }
1682
+ }
1683
+ }
1684
+ return swap;
1685
+ }
1686
+ };
1687
+ var TreeNode = function(val, left, right) {
1688
+ this.val = val;
1689
+ this.left = left;
1690
+ this.right = right;
1691
+ };
1692
+ var Lerc2Decode2 = {
1693
+ decode: function(input, options) {
1694
+ options = options || {};
1695
+ var noDataValue = options.noDataValue;
1696
+ var i = 0, data = {};
1697
+ data.ptr = options.inputOffset || 0;
1698
+ data.pixels = {};
1699
+ if (!Lerc2Helpers.readHeaderInfo(input, data))
1700
+ ;
1701
+ var headerInfo = data.headerInfo;
1702
+ var fileVersion = headerInfo.fileVersion;
1703
+ var OutPixelTypeArray = Lerc2Helpers.getDataTypeArray(headerInfo.imageType);
1704
+ if (fileVersion > 5) {
1705
+ throw "unsupported lerc version 2." + fileVersion;
1706
+ }
1707
+ Lerc2Helpers.readMask(input, data);
1708
+ if (headerInfo.numValidPixel !== headerInfo.width * headerInfo.height && !data.pixels.resultMask) {
1709
+ data.pixels.resultMask = options.maskData;
1710
+ }
1711
+ var numPixels = headerInfo.width * headerInfo.height;
1712
+ data.pixels.resultPixels = new OutPixelTypeArray(numPixels * headerInfo.numDims);
1713
+ data.counter = {
1714
+ onesweep: 0,
1715
+ uncompressed: 0,
1716
+ lut: 0,
1717
+ bitstuffer: 0,
1718
+ constant: 0,
1719
+ constantoffset: 0
1720
+ };
1721
+ var useBSQForOutputDim = !options.returnPixelInterleavedDims;
1722
+ if (headerInfo.numValidPixel !== 0) {
1723
+ if (headerInfo.zMax === headerInfo.zMin) {
1724
+ Lerc2Helpers.constructConstantSurface(data, useBSQForOutputDim);
1725
+ } else if (fileVersion >= 4 && Lerc2Helpers.checkMinMaxRanges(input, data)) {
1726
+ Lerc2Helpers.constructConstantSurface(data, useBSQForOutputDim);
1727
+ } else {
1728
+ var view = new DataView(input, data.ptr, 2);
1729
+ var bReadDataOneSweep = view.getUint8(0);
1730
+ data.ptr++;
1731
+ if (bReadDataOneSweep) {
1732
+ Lerc2Helpers.readDataOneSweep(input, data, OutPixelTypeArray, useBSQForOutputDim);
1733
+ } else {
1734
+ if (fileVersion > 1 && headerInfo.imageType <= 1 && Math.abs(headerInfo.maxZError - 0.5) < 1e-5) {
1735
+ var flagHuffman = view.getUint8(1);
1736
+ data.ptr++;
1737
+ data.encodeMode = flagHuffman;
1738
+ if (flagHuffman > 2 || fileVersion < 4 && flagHuffman > 1) {
1739
+ throw "Invalid Huffman flag " + flagHuffman;
1740
+ }
1741
+ if (flagHuffman) {
1742
+ Lerc2Helpers.readHuffman(input, data, OutPixelTypeArray, useBSQForOutputDim);
1743
+ } else {
1744
+ Lerc2Helpers.readTiles(input, data, OutPixelTypeArray, useBSQForOutputDim);
1745
+ }
1746
+ } else {
1747
+ Lerc2Helpers.readTiles(input, data, OutPixelTypeArray, useBSQForOutputDim);
1748
+ }
1749
+ }
1750
+ }
1751
+ }
1752
+ data.eofOffset = data.ptr;
1753
+ var diff;
1754
+ if (options.inputOffset) {
1755
+ diff = data.headerInfo.blobSize + options.inputOffset - data.ptr;
1756
+ if (Math.abs(diff) >= 1) {
1757
+ data.eofOffset = options.inputOffset + data.headerInfo.blobSize;
1758
+ }
1759
+ } else {
1760
+ diff = data.headerInfo.blobSize - data.ptr;
1761
+ if (Math.abs(diff) >= 1) {
1762
+ data.eofOffset = data.headerInfo.blobSize;
1763
+ }
1764
+ }
1765
+ var result = {
1766
+ width: headerInfo.width,
1767
+ height: headerInfo.height,
1768
+ pixelData: data.pixels.resultPixels,
1769
+ minValue: headerInfo.zMin,
1770
+ maxValue: headerInfo.zMax,
1771
+ validPixelCount: headerInfo.numValidPixel,
1772
+ dimCount: headerInfo.numDims,
1773
+ dimStats: {
1774
+ minValues: headerInfo.minValues,
1775
+ maxValues: headerInfo.maxValues
1776
+ },
1777
+ maskData: data.pixels.resultMask
1778
+ };
1779
+ if (data.pixels.resultMask && Lerc2Helpers.isValidPixelValue(headerInfo.imageType, noDataValue)) {
1780
+ var mask = data.pixels.resultMask;
1781
+ for (i = 0; i < numPixels; i++) {
1782
+ if (!mask[i]) {
1783
+ result.pixelData[i] = noDataValue;
1784
+ }
1785
+ }
1786
+ result.noDataValue = noDataValue;
1787
+ }
1788
+ data.noDataValue = noDataValue;
1789
+ if (options.returnFileInfo) {
1790
+ result.fileInfo = Lerc2Helpers.formatFileInfo(data);
1791
+ }
1792
+ return result;
1793
+ },
1794
+ getBandCount: function(input) {
1795
+ var count = 0;
1796
+ var i = 0;
1797
+ var temp = {};
1798
+ temp.ptr = 0;
1799
+ temp.pixels = {};
1800
+ while (i < input.byteLength - 58) {
1801
+ Lerc2Helpers.readHeaderInfo(input, temp);
1802
+ i += temp.headerInfo.blobSize;
1803
+ count++;
1804
+ temp.ptr = i;
1805
+ }
1806
+ return count;
1807
+ }
1808
+ };
1809
+ return Lerc2Decode2;
1810
+ }();
1811
+ var isPlatformLittleEndian = function() {
1812
+ var a = new ArrayBuffer(4);
1813
+ var b = new Uint8Array(a);
1814
+ var c = new Uint32Array(a);
1815
+ c[0] = 1;
1816
+ return b[0] === 1;
1817
+ }();
1818
+ var Lerc2 = {
1819
+ decode: function(encodedData, options) {
1820
+ if (!isPlatformLittleEndian) {
1821
+ throw "Big endian system is not supported.";
1822
+ }
1823
+ options = options || {};
1824
+ var inputOffset = options.inputOffset || 0;
1825
+ var fileIdView = new Uint8Array(encodedData, inputOffset, 10);
1826
+ var fileIdentifierString = String.fromCharCode.apply(null, fileIdView);
1827
+ var lerc, majorVersion;
1828
+ if (fileIdentifierString.trim() === "CntZImage") {
1829
+ lerc = LercDecode2;
1830
+ majorVersion = 1;
1831
+ } else if (fileIdentifierString.substring(0, 5) === "Lerc2") {
1832
+ lerc = Lerc2Decode;
1833
+ majorVersion = 2;
1834
+ } else {
1835
+ throw "Unexpected file identifier string: " + fileIdentifierString;
1836
+ }
1837
+ var iPlane = 0, eof = encodedData.byteLength - 10, encodedMaskData, bandMasks = [], bandMask, maskData;
1838
+ var decodedPixelBlock = {
1839
+ width: 0,
1840
+ height: 0,
1841
+ pixels: [],
1842
+ pixelType: options.pixelType,
1843
+ mask: null,
1844
+ statistics: []
1845
+ };
1846
+ var uniqueBandMaskCount = 0;
1847
+ while (inputOffset < eof) {
1848
+ var result = lerc.decode(encodedData, {
1849
+ inputOffset,
1850
+ encodedMaskData,
1851
+ maskData,
1852
+ returnMask: iPlane === 0 ? true : false,
1853
+ returnEncodedMask: iPlane === 0 ? true : false,
1854
+ returnFileInfo: true,
1855
+ returnPixelInterleavedDims: options.returnPixelInterleavedDims,
1856
+ pixelType: options.pixelType || null,
1857
+ noDataValue: options.noDataValue || null
1858
+ });
1859
+ inputOffset = result.fileInfo.eofOffset;
1860
+ maskData = result.maskData;
1861
+ if (iPlane === 0) {
1862
+ encodedMaskData = result.encodedMaskData;
1863
+ decodedPixelBlock.width = result.width;
1864
+ decodedPixelBlock.height = result.height;
1865
+ decodedPixelBlock.dimCount = result.dimCount || 1;
1866
+ decodedPixelBlock.pixelType = result.pixelType || result.fileInfo.pixelType;
1867
+ decodedPixelBlock.mask = maskData;
1868
+ }
1869
+ if (majorVersion > 1) {
1870
+ if (maskData) {
1871
+ bandMasks.push(maskData);
1872
+ }
1873
+ if (result.fileInfo.mask && result.fileInfo.mask.numBytes > 0) {
1874
+ uniqueBandMaskCount++;
1875
+ }
1876
+ }
1877
+ iPlane++;
1878
+ decodedPixelBlock.pixels.push(result.pixelData);
1879
+ decodedPixelBlock.statistics.push({
1880
+ minValue: result.minValue,
1881
+ maxValue: result.maxValue,
1882
+ noDataValue: result.noDataValue,
1883
+ dimStats: result.dimStats
1884
+ });
1885
+ }
1886
+ var i, j, numPixels;
1887
+ if (majorVersion > 1 && uniqueBandMaskCount > 1) {
1888
+ numPixels = decodedPixelBlock.width * decodedPixelBlock.height;
1889
+ decodedPixelBlock.bandMasks = bandMasks;
1890
+ maskData = new Uint8Array(numPixels);
1891
+ maskData.set(bandMasks[0]);
1892
+ for (i = 1; i < bandMasks.length; i++) {
1893
+ bandMask = bandMasks[i];
1894
+ for (j = 0; j < numPixels; j++) {
1895
+ maskData[j] = maskData[j] & bandMask[j];
1896
+ }
1897
+ }
1898
+ decodedPixelBlock.maskData = maskData;
1899
+ }
1900
+ return decodedPixelBlock;
1901
+ }
1902
+ };
1903
+ if (module.exports) {
1904
+ module.exports = Lerc2;
1905
+ } else {
1906
+ this.Lerc = Lerc2;
1907
+ }
1908
+ })();
1909
+ })(LercDecode);
1910
+ const Lerc = LercDecode.exports;
1911
+ class LercDecoder extends BaseDecoder {
1912
+ constructor(fileDirectory) {
1913
+ super();
1914
+ this.planarConfiguration = typeof fileDirectory.PlanarConfiguration !== "undefined" ? fileDirectory.PlanarConfiguration : 1;
1915
+ this.samplesPerPixel = typeof fileDirectory.SamplesPerPixel !== "undefined" ? fileDirectory.SamplesPerPixel : 1;
1916
+ this.addCompression = fileDirectory.LercParameters[LercParameters.AddCompression];
1917
+ }
1918
+ decodeBlock(buffer) {
1919
+ switch (this.addCompression) {
1920
+ case LercAddCompression.None:
1921
+ break;
1922
+ case LercAddCompression.Deflate:
1923
+ buffer = inflate_1(new Uint8Array(buffer)).buffer;
1924
+ break;
1925
+ default:
1926
+ throw new Error(`Unsupported LERC additional compression method identifier: ${this.addCompression}`);
1927
+ }
1928
+ const lercResult = Lerc.decode(buffer, { returnPixelInterleavedDims: this.planarConfiguration === 1 });
1929
+ const lercData = lercResult.pixels[0];
1930
+ return lercData.buffer;
1931
+ }
1932
+ }
1933
+ export {
1934
+ LercDecoder as default
1935
+ };