@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,840 @@
1
+ import { B as BaseDecoder } from "./index.7dac8670.mjs";
2
+ import "react";
3
+ import "@vitessce/vit-s";
4
+ import "react-dom";
5
+ const dctZigZag = new Int32Array([
6
+ 0,
7
+ 1,
8
+ 8,
9
+ 16,
10
+ 9,
11
+ 2,
12
+ 3,
13
+ 10,
14
+ 17,
15
+ 24,
16
+ 32,
17
+ 25,
18
+ 18,
19
+ 11,
20
+ 4,
21
+ 5,
22
+ 12,
23
+ 19,
24
+ 26,
25
+ 33,
26
+ 40,
27
+ 48,
28
+ 41,
29
+ 34,
30
+ 27,
31
+ 20,
32
+ 13,
33
+ 6,
34
+ 7,
35
+ 14,
36
+ 21,
37
+ 28,
38
+ 35,
39
+ 42,
40
+ 49,
41
+ 56,
42
+ 57,
43
+ 50,
44
+ 43,
45
+ 36,
46
+ 29,
47
+ 22,
48
+ 15,
49
+ 23,
50
+ 30,
51
+ 37,
52
+ 44,
53
+ 51,
54
+ 58,
55
+ 59,
56
+ 52,
57
+ 45,
58
+ 38,
59
+ 31,
60
+ 39,
61
+ 46,
62
+ 53,
63
+ 60,
64
+ 61,
65
+ 54,
66
+ 47,
67
+ 55,
68
+ 62,
69
+ 63
70
+ ]);
71
+ const dctCos1 = 4017;
72
+ const dctSin1 = 799;
73
+ const dctCos3 = 3406;
74
+ const dctSin3 = 2276;
75
+ const dctCos6 = 1567;
76
+ const dctSin6 = 3784;
77
+ const dctSqrt2 = 5793;
78
+ const dctSqrt1d2 = 2896;
79
+ function buildHuffmanTable(codeLengths, values) {
80
+ let k = 0;
81
+ const code = [];
82
+ let length = 16;
83
+ while (length > 0 && !codeLengths[length - 1]) {
84
+ --length;
85
+ }
86
+ code.push({ children: [], index: 0 });
87
+ let p = code[0];
88
+ let q;
89
+ for (let i = 0; i < length; i++) {
90
+ for (let j = 0; j < codeLengths[i]; j++) {
91
+ p = code.pop();
92
+ p.children[p.index] = values[k];
93
+ while (p.index > 0) {
94
+ p = code.pop();
95
+ }
96
+ p.index++;
97
+ code.push(p);
98
+ while (code.length <= i) {
99
+ code.push(q = { children: [], index: 0 });
100
+ p.children[p.index] = q.children;
101
+ p = q;
102
+ }
103
+ k++;
104
+ }
105
+ if (i + 1 < length) {
106
+ code.push(q = { children: [], index: 0 });
107
+ p.children[p.index] = q.children;
108
+ p = q;
109
+ }
110
+ }
111
+ return code[0].children;
112
+ }
113
+ function decodeScan(data, initialOffset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive) {
114
+ const { mcusPerLine, progressive } = frame;
115
+ const startOffset = initialOffset;
116
+ let offset = initialOffset;
117
+ let bitsData = 0;
118
+ let bitsCount = 0;
119
+ function readBit() {
120
+ if (bitsCount > 0) {
121
+ bitsCount--;
122
+ return bitsData >> bitsCount & 1;
123
+ }
124
+ bitsData = data[offset++];
125
+ if (bitsData === 255) {
126
+ const nextByte = data[offset++];
127
+ if (nextByte) {
128
+ throw new Error(`unexpected marker: ${(bitsData << 8 | nextByte).toString(16)}`);
129
+ }
130
+ }
131
+ bitsCount = 7;
132
+ return bitsData >>> 7;
133
+ }
134
+ function decodeHuffman(tree) {
135
+ let node = tree;
136
+ let bit;
137
+ while ((bit = readBit()) !== null) {
138
+ node = node[bit];
139
+ if (typeof node === "number") {
140
+ return node;
141
+ }
142
+ if (typeof node !== "object") {
143
+ throw new Error("invalid huffman sequence");
144
+ }
145
+ }
146
+ return null;
147
+ }
148
+ function receive(initialLength) {
149
+ let length = initialLength;
150
+ let n2 = 0;
151
+ while (length > 0) {
152
+ const bit = readBit();
153
+ if (bit === null) {
154
+ return void 0;
155
+ }
156
+ n2 = n2 << 1 | bit;
157
+ --length;
158
+ }
159
+ return n2;
160
+ }
161
+ function receiveAndExtend(length) {
162
+ const n2 = receive(length);
163
+ if (n2 >= 1 << length - 1) {
164
+ return n2;
165
+ }
166
+ return n2 + (-1 << length) + 1;
167
+ }
168
+ function decodeBaseline(component2, zz) {
169
+ const t = decodeHuffman(component2.huffmanTableDC);
170
+ const diff = t === 0 ? 0 : receiveAndExtend(t);
171
+ component2.pred += diff;
172
+ zz[0] = component2.pred;
173
+ let k2 = 1;
174
+ while (k2 < 64) {
175
+ const rs = decodeHuffman(component2.huffmanTableAC);
176
+ const s = rs & 15;
177
+ const r = rs >> 4;
178
+ if (s === 0) {
179
+ if (r < 15) {
180
+ break;
181
+ }
182
+ k2 += 16;
183
+ } else {
184
+ k2 += r;
185
+ const z = dctZigZag[k2];
186
+ zz[z] = receiveAndExtend(s);
187
+ k2++;
188
+ }
189
+ }
190
+ }
191
+ function decodeDCFirst(component2, zz) {
192
+ const t = decodeHuffman(component2.huffmanTableDC);
193
+ const diff = t === 0 ? 0 : receiveAndExtend(t) << successive;
194
+ component2.pred += diff;
195
+ zz[0] = component2.pred;
196
+ }
197
+ function decodeDCSuccessive(component2, zz) {
198
+ zz[0] |= readBit() << successive;
199
+ }
200
+ let eobrun = 0;
201
+ function decodeACFirst(component2, zz) {
202
+ if (eobrun > 0) {
203
+ eobrun--;
204
+ return;
205
+ }
206
+ let k2 = spectralStart;
207
+ const e = spectralEnd;
208
+ while (k2 <= e) {
209
+ const rs = decodeHuffman(component2.huffmanTableAC);
210
+ const s = rs & 15;
211
+ const r = rs >> 4;
212
+ if (s === 0) {
213
+ if (r < 15) {
214
+ eobrun = receive(r) + (1 << r) - 1;
215
+ break;
216
+ }
217
+ k2 += 16;
218
+ } else {
219
+ k2 += r;
220
+ const z = dctZigZag[k2];
221
+ zz[z] = receiveAndExtend(s) * (1 << successive);
222
+ k2++;
223
+ }
224
+ }
225
+ }
226
+ let successiveACState = 0;
227
+ let successiveACNextValue;
228
+ function decodeACSuccessive(component2, zz) {
229
+ let k2 = spectralStart;
230
+ const e = spectralEnd;
231
+ let r = 0;
232
+ while (k2 <= e) {
233
+ const z = dctZigZag[k2];
234
+ const direction = zz[z] < 0 ? -1 : 1;
235
+ switch (successiveACState) {
236
+ case 0: {
237
+ const rs = decodeHuffman(component2.huffmanTableAC);
238
+ const s = rs & 15;
239
+ r = rs >> 4;
240
+ if (s === 0) {
241
+ if (r < 15) {
242
+ eobrun = receive(r) + (1 << r);
243
+ successiveACState = 4;
244
+ } else {
245
+ r = 16;
246
+ successiveACState = 1;
247
+ }
248
+ } else {
249
+ if (s !== 1) {
250
+ throw new Error("invalid ACn encoding");
251
+ }
252
+ successiveACNextValue = receiveAndExtend(s);
253
+ successiveACState = r ? 2 : 3;
254
+ }
255
+ continue;
256
+ }
257
+ case 1:
258
+ case 2:
259
+ if (zz[z]) {
260
+ zz[z] += (readBit() << successive) * direction;
261
+ } else {
262
+ r--;
263
+ if (r === 0) {
264
+ successiveACState = successiveACState === 2 ? 3 : 0;
265
+ }
266
+ }
267
+ break;
268
+ case 3:
269
+ if (zz[z]) {
270
+ zz[z] += (readBit() << successive) * direction;
271
+ } else {
272
+ zz[z] = successiveACNextValue << successive;
273
+ successiveACState = 0;
274
+ }
275
+ break;
276
+ case 4:
277
+ if (zz[z]) {
278
+ zz[z] += (readBit() << successive) * direction;
279
+ }
280
+ break;
281
+ }
282
+ k2++;
283
+ }
284
+ if (successiveACState === 4) {
285
+ eobrun--;
286
+ if (eobrun === 0) {
287
+ successiveACState = 0;
288
+ }
289
+ }
290
+ }
291
+ function decodeMcu(component2, decodeFunction, mcu2, row, col) {
292
+ const mcuRow = mcu2 / mcusPerLine | 0;
293
+ const mcuCol = mcu2 % mcusPerLine;
294
+ const blockRow = mcuRow * component2.v + row;
295
+ const blockCol = mcuCol * component2.h + col;
296
+ decodeFunction(component2, component2.blocks[blockRow][blockCol]);
297
+ }
298
+ function decodeBlock(component2, decodeFunction, mcu2) {
299
+ const blockRow = mcu2 / component2.blocksPerLine | 0;
300
+ const blockCol = mcu2 % component2.blocksPerLine;
301
+ decodeFunction(component2, component2.blocks[blockRow][blockCol]);
302
+ }
303
+ const componentsLength = components.length;
304
+ let component;
305
+ let i;
306
+ let j;
307
+ let k;
308
+ let n;
309
+ let decodeFn;
310
+ if (progressive) {
311
+ if (spectralStart === 0) {
312
+ decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
313
+ } else {
314
+ decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;
315
+ }
316
+ } else {
317
+ decodeFn = decodeBaseline;
318
+ }
319
+ let mcu = 0;
320
+ let marker;
321
+ let mcuExpected;
322
+ if (componentsLength === 1) {
323
+ mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;
324
+ } else {
325
+ mcuExpected = mcusPerLine * frame.mcusPerColumn;
326
+ }
327
+ const usedResetInterval = resetInterval || mcuExpected;
328
+ while (mcu < mcuExpected) {
329
+ for (i = 0; i < componentsLength; i++) {
330
+ components[i].pred = 0;
331
+ }
332
+ eobrun = 0;
333
+ if (componentsLength === 1) {
334
+ component = components[0];
335
+ for (n = 0; n < usedResetInterval; n++) {
336
+ decodeBlock(component, decodeFn, mcu);
337
+ mcu++;
338
+ }
339
+ } else {
340
+ for (n = 0; n < usedResetInterval; n++) {
341
+ for (i = 0; i < componentsLength; i++) {
342
+ component = components[i];
343
+ const { h, v } = component;
344
+ for (j = 0; j < v; j++) {
345
+ for (k = 0; k < h; k++) {
346
+ decodeMcu(component, decodeFn, mcu, j, k);
347
+ }
348
+ }
349
+ }
350
+ mcu++;
351
+ if (mcu === mcuExpected) {
352
+ break;
353
+ }
354
+ }
355
+ }
356
+ bitsCount = 0;
357
+ marker = data[offset] << 8 | data[offset + 1];
358
+ if (marker < 65280) {
359
+ throw new Error("marker was not found");
360
+ }
361
+ if (marker >= 65488 && marker <= 65495) {
362
+ offset += 2;
363
+ } else {
364
+ break;
365
+ }
366
+ }
367
+ return offset - startOffset;
368
+ }
369
+ function buildComponentData(frame, component) {
370
+ const lines = [];
371
+ const { blocksPerLine, blocksPerColumn } = component;
372
+ const samplesPerLine = blocksPerLine << 3;
373
+ const R = new Int32Array(64);
374
+ const r = new Uint8Array(64);
375
+ function quantizeAndInverse(zz, dataOut, dataIn) {
376
+ const qt = component.quantizationTable;
377
+ let v0;
378
+ let v1;
379
+ let v2;
380
+ let v3;
381
+ let v4;
382
+ let v5;
383
+ let v6;
384
+ let v7;
385
+ let t;
386
+ const p = dataIn;
387
+ let i;
388
+ for (i = 0; i < 64; i++) {
389
+ p[i] = zz[i] * qt[i];
390
+ }
391
+ for (i = 0; i < 8; ++i) {
392
+ const row = 8 * i;
393
+ if (p[1 + row] === 0 && p[2 + row] === 0 && p[3 + row] === 0 && p[4 + row] === 0 && p[5 + row] === 0 && p[6 + row] === 0 && p[7 + row] === 0) {
394
+ t = dctSqrt2 * p[0 + row] + 512 >> 10;
395
+ p[0 + row] = t;
396
+ p[1 + row] = t;
397
+ p[2 + row] = t;
398
+ p[3 + row] = t;
399
+ p[4 + row] = t;
400
+ p[5 + row] = t;
401
+ p[6 + row] = t;
402
+ p[7 + row] = t;
403
+ continue;
404
+ }
405
+ v0 = dctSqrt2 * p[0 + row] + 128 >> 8;
406
+ v1 = dctSqrt2 * p[4 + row] + 128 >> 8;
407
+ v2 = p[2 + row];
408
+ v3 = p[6 + row];
409
+ v4 = dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128 >> 8;
410
+ v7 = dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128 >> 8;
411
+ v5 = p[3 + row] << 4;
412
+ v6 = p[5 + row] << 4;
413
+ t = v0 - v1 + 1 >> 1;
414
+ v0 = v0 + v1 + 1 >> 1;
415
+ v1 = t;
416
+ t = v2 * dctSin6 + v3 * dctCos6 + 128 >> 8;
417
+ v2 = v2 * dctCos6 - v3 * dctSin6 + 128 >> 8;
418
+ v3 = t;
419
+ t = v4 - v6 + 1 >> 1;
420
+ v4 = v4 + v6 + 1 >> 1;
421
+ v6 = t;
422
+ t = v7 + v5 + 1 >> 1;
423
+ v5 = v7 - v5 + 1 >> 1;
424
+ v7 = t;
425
+ t = v0 - v3 + 1 >> 1;
426
+ v0 = v0 + v3 + 1 >> 1;
427
+ v3 = t;
428
+ t = v1 - v2 + 1 >> 1;
429
+ v1 = v1 + v2 + 1 >> 1;
430
+ v2 = t;
431
+ t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
432
+ v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
433
+ v7 = t;
434
+ t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
435
+ v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
436
+ v6 = t;
437
+ p[0 + row] = v0 + v7;
438
+ p[7 + row] = v0 - v7;
439
+ p[1 + row] = v1 + v6;
440
+ p[6 + row] = v1 - v6;
441
+ p[2 + row] = v2 + v5;
442
+ p[5 + row] = v2 - v5;
443
+ p[3 + row] = v3 + v4;
444
+ p[4 + row] = v3 - v4;
445
+ }
446
+ for (i = 0; i < 8; ++i) {
447
+ const col = i;
448
+ if (p[1 * 8 + col] === 0 && p[2 * 8 + col] === 0 && p[3 * 8 + col] === 0 && p[4 * 8 + col] === 0 && p[5 * 8 + col] === 0 && p[6 * 8 + col] === 0 && p[7 * 8 + col] === 0) {
449
+ t = dctSqrt2 * dataIn[i + 0] + 8192 >> 14;
450
+ p[0 * 8 + col] = t;
451
+ p[1 * 8 + col] = t;
452
+ p[2 * 8 + col] = t;
453
+ p[3 * 8 + col] = t;
454
+ p[4 * 8 + col] = t;
455
+ p[5 * 8 + col] = t;
456
+ p[6 * 8 + col] = t;
457
+ p[7 * 8 + col] = t;
458
+ continue;
459
+ }
460
+ v0 = dctSqrt2 * p[0 * 8 + col] + 2048 >> 12;
461
+ v1 = dctSqrt2 * p[4 * 8 + col] + 2048 >> 12;
462
+ v2 = p[2 * 8 + col];
463
+ v3 = p[6 * 8 + col];
464
+ v4 = dctSqrt1d2 * (p[1 * 8 + col] - p[7 * 8 + col]) + 2048 >> 12;
465
+ v7 = dctSqrt1d2 * (p[1 * 8 + col] + p[7 * 8 + col]) + 2048 >> 12;
466
+ v5 = p[3 * 8 + col];
467
+ v6 = p[5 * 8 + col];
468
+ t = v0 - v1 + 1 >> 1;
469
+ v0 = v0 + v1 + 1 >> 1;
470
+ v1 = t;
471
+ t = v2 * dctSin6 + v3 * dctCos6 + 2048 >> 12;
472
+ v2 = v2 * dctCos6 - v3 * dctSin6 + 2048 >> 12;
473
+ v3 = t;
474
+ t = v4 - v6 + 1 >> 1;
475
+ v4 = v4 + v6 + 1 >> 1;
476
+ v6 = t;
477
+ t = v7 + v5 + 1 >> 1;
478
+ v5 = v7 - v5 + 1 >> 1;
479
+ v7 = t;
480
+ t = v0 - v3 + 1 >> 1;
481
+ v0 = v0 + v3 + 1 >> 1;
482
+ v3 = t;
483
+ t = v1 - v2 + 1 >> 1;
484
+ v1 = v1 + v2 + 1 >> 1;
485
+ v2 = t;
486
+ t = v4 * dctSin3 + v7 * dctCos3 + 2048 >> 12;
487
+ v4 = v4 * dctCos3 - v7 * dctSin3 + 2048 >> 12;
488
+ v7 = t;
489
+ t = v5 * dctSin1 + v6 * dctCos1 + 2048 >> 12;
490
+ v5 = v5 * dctCos1 - v6 * dctSin1 + 2048 >> 12;
491
+ v6 = t;
492
+ p[0 * 8 + col] = v0 + v7;
493
+ p[7 * 8 + col] = v0 - v7;
494
+ p[1 * 8 + col] = v1 + v6;
495
+ p[6 * 8 + col] = v1 - v6;
496
+ p[2 * 8 + col] = v2 + v5;
497
+ p[5 * 8 + col] = v2 - v5;
498
+ p[3 * 8 + col] = v3 + v4;
499
+ p[4 * 8 + col] = v3 - v4;
500
+ }
501
+ for (i = 0; i < 64; ++i) {
502
+ const sample = 128 + (p[i] + 8 >> 4);
503
+ if (sample < 0) {
504
+ dataOut[i] = 0;
505
+ } else if (sample > 255) {
506
+ dataOut[i] = 255;
507
+ } else {
508
+ dataOut[i] = sample;
509
+ }
510
+ }
511
+ }
512
+ for (let blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
513
+ const scanLine = blockRow << 3;
514
+ for (let i = 0; i < 8; i++) {
515
+ lines.push(new Uint8Array(samplesPerLine));
516
+ }
517
+ for (let blockCol = 0; blockCol < blocksPerLine; blockCol++) {
518
+ quantizeAndInverse(component.blocks[blockRow][blockCol], r, R);
519
+ let offset = 0;
520
+ const sample = blockCol << 3;
521
+ for (let j = 0; j < 8; j++) {
522
+ const line = lines[scanLine + j];
523
+ for (let i = 0; i < 8; i++) {
524
+ line[sample + i] = r[offset++];
525
+ }
526
+ }
527
+ }
528
+ }
529
+ return lines;
530
+ }
531
+ class JpegStreamReader {
532
+ constructor() {
533
+ this.jfif = null;
534
+ this.adobe = null;
535
+ this.quantizationTables = [];
536
+ this.huffmanTablesAC = [];
537
+ this.huffmanTablesDC = [];
538
+ this.resetFrames();
539
+ }
540
+ resetFrames() {
541
+ this.frames = [];
542
+ }
543
+ parse(data) {
544
+ let offset = 0;
545
+ function readUint16() {
546
+ const value = data[offset] << 8 | data[offset + 1];
547
+ offset += 2;
548
+ return value;
549
+ }
550
+ function readDataBlock() {
551
+ const length = readUint16();
552
+ const array = data.subarray(offset, offset + length - 2);
553
+ offset += array.length;
554
+ return array;
555
+ }
556
+ function prepareComponents(frame) {
557
+ let maxH = 0;
558
+ let maxV = 0;
559
+ let component;
560
+ let componentId;
561
+ for (componentId in frame.components) {
562
+ if (frame.components.hasOwnProperty(componentId)) {
563
+ component = frame.components[componentId];
564
+ if (maxH < component.h) {
565
+ maxH = component.h;
566
+ }
567
+ if (maxV < component.v) {
568
+ maxV = component.v;
569
+ }
570
+ }
571
+ }
572
+ const mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / maxH);
573
+ const mcusPerColumn = Math.ceil(frame.scanLines / 8 / maxV);
574
+ for (componentId in frame.components) {
575
+ if (frame.components.hasOwnProperty(componentId)) {
576
+ component = frame.components[componentId];
577
+ const blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / maxH);
578
+ const blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines / 8) * component.v / maxV);
579
+ const blocksPerLineForMcu = mcusPerLine * component.h;
580
+ const blocksPerColumnForMcu = mcusPerColumn * component.v;
581
+ const blocks = [];
582
+ for (let i = 0; i < blocksPerColumnForMcu; i++) {
583
+ const row = [];
584
+ for (let j = 0; j < blocksPerLineForMcu; j++) {
585
+ row.push(new Int32Array(64));
586
+ }
587
+ blocks.push(row);
588
+ }
589
+ component.blocksPerLine = blocksPerLine;
590
+ component.blocksPerColumn = blocksPerColumn;
591
+ component.blocks = blocks;
592
+ }
593
+ }
594
+ frame.maxH = maxH;
595
+ frame.maxV = maxV;
596
+ frame.mcusPerLine = mcusPerLine;
597
+ frame.mcusPerColumn = mcusPerColumn;
598
+ }
599
+ let fileMarker = readUint16();
600
+ if (fileMarker !== 65496) {
601
+ throw new Error("SOI not found");
602
+ }
603
+ fileMarker = readUint16();
604
+ while (fileMarker !== 65497) {
605
+ switch (fileMarker) {
606
+ case 65280:
607
+ break;
608
+ case 65504:
609
+ case 65505:
610
+ case 65506:
611
+ case 65507:
612
+ case 65508:
613
+ case 65509:
614
+ case 65510:
615
+ case 65511:
616
+ case 65512:
617
+ case 65513:
618
+ case 65514:
619
+ case 65515:
620
+ case 65516:
621
+ case 65517:
622
+ case 65518:
623
+ case 65519:
624
+ case 65534: {
625
+ const appData = readDataBlock();
626
+ if (fileMarker === 65504) {
627
+ if (appData[0] === 74 && appData[1] === 70 && appData[2] === 73 && appData[3] === 70 && appData[4] === 0) {
628
+ this.jfif = {
629
+ version: { major: appData[5], minor: appData[6] },
630
+ densityUnits: appData[7],
631
+ xDensity: appData[8] << 8 | appData[9],
632
+ yDensity: appData[10] << 8 | appData[11],
633
+ thumbWidth: appData[12],
634
+ thumbHeight: appData[13],
635
+ thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13])
636
+ };
637
+ }
638
+ }
639
+ if (fileMarker === 65518) {
640
+ if (appData[0] === 65 && appData[1] === 100 && appData[2] === 111 && appData[3] === 98 && appData[4] === 101 && appData[5] === 0) {
641
+ this.adobe = {
642
+ version: appData[6],
643
+ flags0: appData[7] << 8 | appData[8],
644
+ flags1: appData[9] << 8 | appData[10],
645
+ transformCode: appData[11]
646
+ };
647
+ }
648
+ }
649
+ break;
650
+ }
651
+ case 65499: {
652
+ const quantizationTablesLength = readUint16();
653
+ const quantizationTablesEnd = quantizationTablesLength + offset - 2;
654
+ while (offset < quantizationTablesEnd) {
655
+ const quantizationTableSpec = data[offset++];
656
+ const tableData = new Int32Array(64);
657
+ if (quantizationTableSpec >> 4 === 0) {
658
+ for (let j = 0; j < 64; j++) {
659
+ const z = dctZigZag[j];
660
+ tableData[z] = data[offset++];
661
+ }
662
+ } else if (quantizationTableSpec >> 4 === 1) {
663
+ for (let j = 0; j < 64; j++) {
664
+ const z = dctZigZag[j];
665
+ tableData[z] = readUint16();
666
+ }
667
+ } else {
668
+ throw new Error("DQT: invalid table spec");
669
+ }
670
+ this.quantizationTables[quantizationTableSpec & 15] = tableData;
671
+ }
672
+ break;
673
+ }
674
+ case 65472:
675
+ case 65473:
676
+ case 65474: {
677
+ readUint16();
678
+ const frame = {
679
+ extended: fileMarker === 65473,
680
+ progressive: fileMarker === 65474,
681
+ precision: data[offset++],
682
+ scanLines: readUint16(),
683
+ samplesPerLine: readUint16(),
684
+ components: {},
685
+ componentsOrder: []
686
+ };
687
+ const componentsCount = data[offset++];
688
+ let componentId;
689
+ for (let i = 0; i < componentsCount; i++) {
690
+ componentId = data[offset];
691
+ const h = data[offset + 1] >> 4;
692
+ const v = data[offset + 1] & 15;
693
+ const qId = data[offset + 2];
694
+ frame.componentsOrder.push(componentId);
695
+ frame.components[componentId] = {
696
+ h,
697
+ v,
698
+ quantizationIdx: qId
699
+ };
700
+ offset += 3;
701
+ }
702
+ prepareComponents(frame);
703
+ this.frames.push(frame);
704
+ break;
705
+ }
706
+ case 65476: {
707
+ const huffmanLength = readUint16();
708
+ for (let i = 2; i < huffmanLength; ) {
709
+ const huffmanTableSpec = data[offset++];
710
+ const codeLengths = new Uint8Array(16);
711
+ let codeLengthSum = 0;
712
+ for (let j = 0; j < 16; j++, offset++) {
713
+ codeLengths[j] = data[offset];
714
+ codeLengthSum += codeLengths[j];
715
+ }
716
+ const huffmanValues = new Uint8Array(codeLengthSum);
717
+ for (let j = 0; j < codeLengthSum; j++, offset++) {
718
+ huffmanValues[j] = data[offset];
719
+ }
720
+ i += 17 + codeLengthSum;
721
+ if (huffmanTableSpec >> 4 === 0) {
722
+ this.huffmanTablesDC[huffmanTableSpec & 15] = buildHuffmanTable(
723
+ codeLengths,
724
+ huffmanValues
725
+ );
726
+ } else {
727
+ this.huffmanTablesAC[huffmanTableSpec & 15] = buildHuffmanTable(
728
+ codeLengths,
729
+ huffmanValues
730
+ );
731
+ }
732
+ }
733
+ break;
734
+ }
735
+ case 65501:
736
+ readUint16();
737
+ this.resetInterval = readUint16();
738
+ break;
739
+ case 65498: {
740
+ readUint16();
741
+ const selectorsCount = data[offset++];
742
+ const components = [];
743
+ const frame = this.frames[0];
744
+ for (let i = 0; i < selectorsCount; i++) {
745
+ const component = frame.components[data[offset++]];
746
+ const tableSpec = data[offset++];
747
+ component.huffmanTableDC = this.huffmanTablesDC[tableSpec >> 4];
748
+ component.huffmanTableAC = this.huffmanTablesAC[tableSpec & 15];
749
+ components.push(component);
750
+ }
751
+ const spectralStart = data[offset++];
752
+ const spectralEnd = data[offset++];
753
+ const successiveApproximation = data[offset++];
754
+ const processed = decodeScan(
755
+ data,
756
+ offset,
757
+ frame,
758
+ components,
759
+ this.resetInterval,
760
+ spectralStart,
761
+ spectralEnd,
762
+ successiveApproximation >> 4,
763
+ successiveApproximation & 15
764
+ );
765
+ offset += processed;
766
+ break;
767
+ }
768
+ case 65535:
769
+ if (data[offset] !== 255) {
770
+ offset--;
771
+ }
772
+ break;
773
+ default:
774
+ if (data[offset - 3] === 255 && data[offset - 2] >= 192 && data[offset - 2] <= 254) {
775
+ offset -= 3;
776
+ break;
777
+ }
778
+ throw new Error(`unknown JPEG marker ${fileMarker.toString(16)}`);
779
+ }
780
+ fileMarker = readUint16();
781
+ }
782
+ }
783
+ getResult() {
784
+ const { frames } = this;
785
+ if (this.frames.length === 0) {
786
+ throw new Error("no frames were decoded");
787
+ } else if (this.frames.length > 1) {
788
+ console.warn("more than one frame is not supported");
789
+ }
790
+ for (let i = 0; i < this.frames.length; i++) {
791
+ const cp = this.frames[i].components;
792
+ for (const j of Object.keys(cp)) {
793
+ cp[j].quantizationTable = this.quantizationTables[cp[j].quantizationIdx];
794
+ delete cp[j].quantizationIdx;
795
+ }
796
+ }
797
+ const frame = frames[0];
798
+ const { components, componentsOrder } = frame;
799
+ const outComponents = [];
800
+ const width = frame.samplesPerLine;
801
+ const height = frame.scanLines;
802
+ for (let i = 0; i < componentsOrder.length; i++) {
803
+ const component = components[componentsOrder[i]];
804
+ outComponents.push({
805
+ lines: buildComponentData(frame, component),
806
+ scaleX: component.h / frame.maxH,
807
+ scaleY: component.v / frame.maxV
808
+ });
809
+ }
810
+ const out = new Uint8Array(width * height * outComponents.length);
811
+ let oi = 0;
812
+ for (let y = 0; y < height; ++y) {
813
+ for (let x = 0; x < width; ++x) {
814
+ for (let i = 0; i < outComponents.length; ++i) {
815
+ const component = outComponents[i];
816
+ out[oi] = component.lines[0 | y * component.scaleY][0 | x * component.scaleX];
817
+ ++oi;
818
+ }
819
+ }
820
+ }
821
+ return out;
822
+ }
823
+ }
824
+ class JpegDecoder extends BaseDecoder {
825
+ constructor(fileDirectory) {
826
+ super();
827
+ this.reader = new JpegStreamReader();
828
+ if (fileDirectory.JPEGTables) {
829
+ this.reader.parse(fileDirectory.JPEGTables);
830
+ }
831
+ }
832
+ decodeBlock(buffer) {
833
+ this.reader.resetFrames();
834
+ this.reader.parse(new Uint8Array(buffer));
835
+ return this.reader.getResult().buffer;
836
+ }
837
+ }
838
+ export {
839
+ JpegDecoder as default
840
+ };