@vitessce/all 3.9.10 → 4.0.0-test.1

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