exifreader 4.47.0 → 4.48.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.
- package/README.md +42 -28
- package/bin/build.js +3 -0
- package/bin/unshare-file.js +29 -0
- package/dist/exif-reader.js +1 -1
- package/dist/exif-reader.js.map +1 -1
- package/exif-reader.d.ts +6 -6
- package/package.json +6 -6
- package/src/canon-tags.js +4 -3
- package/src/composite.js +94 -47
- package/src/exif-reader.js +61 -9
- package/src/file-loaders.js +64 -22
- package/src/icc-tag-names.js +2 -11
- package/src/image-header-iso-bmff.js +31 -10
- package/src/image-header-jpeg.js +9 -2
- package/src/image-header-png.js +34 -27
- package/src/iptc-tags.js +46 -11
- package/src/load-auto.js +6 -3
- package/src/loadview-pipeline.js +58 -23
- package/src/mpf-tags.js +6 -1
- package/src/pentax-tags.js +45 -21
- package/src/photoshop-tag-names.js +6 -2
- package/src/photoshop-tags.js +24 -23
- package/src/png-text-tags.js +175 -45
- package/src/tag-filter-config.js +25 -0
- package/src/tag-names-exif-ifd.js +32 -11
- package/src/tag-names-interoperability-ifd.js +2 -2
- package/src/tag-names-mpf-ifd.js +2 -2
- package/src/tag-names-utils.js +17 -3
- package/src/tags-helpers.js +177 -50
- package/src/tags.js +10 -0
- package/src/utils.js +185 -27
- package/src/xml.js +19 -2
- package/src/xmp-element-depth.js +226 -0
- package/src/xmp-namespaces.js +2 -2
- package/src/xmp-tags.js +38 -12
|
@@ -39,6 +39,10 @@ export const ITEM_INFO_TYPE_EXIF = 0x45786966;
|
|
|
39
39
|
export const ITEM_INFO_TYPE_MIME = 0x6d696d65;
|
|
40
40
|
const ITEM_INFO_TYPE_URI = 0x75726920;
|
|
41
41
|
|
|
42
|
+
// The spec sets no maximum for the infe strings; the cap bounds the memory one
|
|
43
|
+
// malformed string can take, far above any real name, MIME type or URI.
|
|
44
|
+
const MAX_INFE_STRING_LENGTH = 65536;
|
|
45
|
+
|
|
42
46
|
export const BOX_TYPE_OFFSET = 4;
|
|
43
47
|
export const BOX_MIN_LENGTH = 8;
|
|
44
48
|
|
|
@@ -103,7 +107,7 @@ export function parseBox(dataView, offset, containerEnd = dataView.byteLength) {
|
|
|
103
107
|
return parseItemInformationBox(dataView, offset, version, contentOffset + VERSION_SIZE, length, containerEnd);
|
|
104
108
|
}
|
|
105
109
|
if (type === TYPE_INFE) {
|
|
106
|
-
return parseItemInformationEntryBox(dataView, offset, version, contentOffset + VERSION_SIZE, length);
|
|
110
|
+
return parseItemInformationEntryBox(dataView, offset, version, contentOffset + VERSION_SIZE, length, containerEnd);
|
|
107
111
|
}
|
|
108
112
|
|
|
109
113
|
return {
|
|
@@ -586,18 +590,19 @@ function parseItemInformationBox(dataView, startOffset, version, contentOffset,
|
|
|
586
590
|
};
|
|
587
591
|
}
|
|
588
592
|
|
|
589
|
-
function parseItemInformationEntryBox(dataView, startOffset, version, contentOffset, length) {
|
|
593
|
+
function parseItemInformationEntryBox(dataView, startOffset, version, contentOffset, length, containerEnd) {
|
|
590
594
|
const FLAGS_SIZE = 3;
|
|
591
595
|
|
|
592
596
|
contentOffset += FLAGS_SIZE;
|
|
593
597
|
const entry = {type: 'infe', length};
|
|
598
|
+
const entryEnd = Math.min(startOffset + length, containerEnd);
|
|
594
599
|
|
|
595
600
|
if (version === 0 || version === 1) {
|
|
596
601
|
entry.itemId = dataView.getUint16(contentOffset);
|
|
597
602
|
contentOffset += 2;
|
|
598
603
|
entry.itemProtectionIndex = dataView.getUint16(contentOffset);
|
|
599
604
|
contentOffset += 2;
|
|
600
|
-
entry.itemName =
|
|
605
|
+
entry.itemName = readEntryString(dataView, contentOffset, entryEnd).value;
|
|
601
606
|
contentOffset += entry.itemName.length + 1;
|
|
602
607
|
// entry.contentType = getNullTerminatedStringFromDataView(dataView, offset);
|
|
603
608
|
// offset += entry.contentType.length + 1;
|
|
@@ -640,19 +645,35 @@ function parseItemInformationEntryBox(dataView, startOffset, version, contentOff
|
|
|
640
645
|
contentOffset += 2;
|
|
641
646
|
entry.itemType = dataView.getUint32(contentOffset);
|
|
642
647
|
contentOffset += 4;
|
|
643
|
-
|
|
648
|
+
const itemName = readEntryString(dataView, contentOffset, entryEnd);
|
|
649
|
+
entry.itemName = itemName.value;
|
|
650
|
+
if (!itemName.isTerminated) {
|
|
651
|
+
return entry;
|
|
652
|
+
}
|
|
644
653
|
contentOffset += entry.itemName.length + 1;
|
|
645
654
|
if (entry.itemType === ITEM_INFO_TYPE_MIME) {
|
|
646
|
-
|
|
655
|
+
const contentType = readEntryString(dataView, contentOffset, entryEnd);
|
|
656
|
+
entry.contentType = contentType.value;
|
|
657
|
+
if (!contentType.isTerminated) {
|
|
658
|
+
return entry;
|
|
659
|
+
}
|
|
647
660
|
contentOffset += entry.contentType.length + 1;
|
|
648
|
-
if (
|
|
649
|
-
entry.contentEncoding =
|
|
650
|
-
contentOffset += entry.contentEncoding.length + 1;
|
|
661
|
+
if (entryEnd > contentOffset) {
|
|
662
|
+
entry.contentEncoding = readEntryString(dataView, contentOffset, entryEnd).value;
|
|
651
663
|
}
|
|
652
664
|
} else if (entry.itemType === ITEM_INFO_TYPE_URI) {
|
|
653
|
-
entry.itemUri =
|
|
654
|
-
contentOffset += entry.itemUri.length + 1;
|
|
665
|
+
entry.itemUri = readEntryString(dataView, contentOffset, entryEnd).value;
|
|
655
666
|
}
|
|
656
667
|
}
|
|
657
668
|
return entry;
|
|
658
669
|
}
|
|
670
|
+
|
|
671
|
+
/**
|
|
672
|
+
* Reads one string of an infe box, bounded by the box end and the length cap.
|
|
673
|
+
* isTerminated is false when the string ran into either bound instead of a NUL.
|
|
674
|
+
*/
|
|
675
|
+
function readEntryString(dataView, offset, entryEnd) {
|
|
676
|
+
const limit = Math.min(entryEnd, offset + MAX_INFE_STRING_LENGTH);
|
|
677
|
+
const value = getNullTerminatedStringFromDataView(dataView, offset, limit);
|
|
678
|
+
return {value, isTerminated: offset + value.length < limit};
|
|
679
|
+
}
|
package/src/image-header-jpeg.js
CHANGED
|
@@ -40,6 +40,9 @@ const ICC_TOTAL_CHUNKS_OFFSET = ICC_CHUNK_NUMBER_OFFSET + 1;
|
|
|
40
40
|
// Guards against memory exhaustion from a crafted file. Both chunk fields are a
|
|
41
41
|
// single byte, so a longer list could never be assembled into a profile anyway.
|
|
42
42
|
const MAX_ICC_CHUNKS = 255;
|
|
43
|
+
// Guards against memory exhaustion from a crafted file. An extended XMP segment
|
|
44
|
+
// holds at most about 64 KiB, so this still allows about 64 MiB of XMP.
|
|
45
|
+
const MAX_XMP_CHUNKS = 1024;
|
|
43
46
|
|
|
44
47
|
const APP2_MPF_IDENTIFIER = 'MPF\0';
|
|
45
48
|
|
|
@@ -168,14 +171,18 @@ function findJpegOffsets(dataView, metadataBlocks) {
|
|
|
168
171
|
xmpChunks = [];
|
|
169
172
|
}
|
|
170
173
|
fieldLength = dataView.getUint16(appMarkerPosition + APP_MARKER_SIZE);
|
|
171
|
-
xmpChunks.
|
|
174
|
+
if (xmpChunks.length < MAX_XMP_CHUNKS) {
|
|
175
|
+
xmpChunks.push(getXmpChunkDetails(appMarkerPosition, fieldLength));
|
|
176
|
+
}
|
|
172
177
|
blockType = 'xmp';
|
|
173
178
|
} else if (Constants.USE_XMP && isApp1ExtendedXmpMarker(dataView, appMarkerPosition)) {
|
|
174
179
|
if (!xmpChunks) {
|
|
175
180
|
xmpChunks = [];
|
|
176
181
|
}
|
|
177
182
|
fieldLength = dataView.getUint16(appMarkerPosition + APP_MARKER_SIZE);
|
|
178
|
-
xmpChunks.
|
|
183
|
+
if (xmpChunks.length < MAX_XMP_CHUNKS) {
|
|
184
|
+
xmpChunks.push(getExtendedXmpChunkDetails(appMarkerPosition, fieldLength));
|
|
185
|
+
}
|
|
179
186
|
blockType = 'xmp';
|
|
180
187
|
} else if (Constants.USE_IPTC && isApp13PhotoshopMarker(dataView, appMarkerPosition)) {
|
|
181
188
|
fieldLength = dataView.getUint16(appMarkerPosition + APP_MARKER_SIZE);
|
package/src/image-header-png.js
CHANGED
|
@@ -4,7 +4,7 @@
|
|
|
4
4
|
|
|
5
5
|
// Specification: http://www.libpng.org/pub/png/spec/1.2/
|
|
6
6
|
|
|
7
|
-
import {getStringFromDataView,
|
|
7
|
+
import {getStringFromDataView, pushMetadataBlock} from './utils.js';
|
|
8
8
|
import Constants from './constants.js';
|
|
9
9
|
|
|
10
10
|
export default {
|
|
@@ -26,6 +26,8 @@ export const TYPE_PHYS = 'pHYs';
|
|
|
26
26
|
export const TYPE_TIME = 'tIME';
|
|
27
27
|
export const TYPE_EXIF = 'eXIf';
|
|
28
28
|
export const TYPE_ICCP = 'iCCP';
|
|
29
|
+
// PNG spec: an iCCP profile name is at most 79 bytes, like a text keyword.
|
|
30
|
+
const MAX_ICC_PROFILE_NAME_LENGTH = 79;
|
|
29
31
|
|
|
30
32
|
/**
|
|
31
33
|
* Checks if the provided data view represents a PNG file.
|
|
@@ -84,15 +86,10 @@ function findPngOffsets(dataView, async, metadataBlocks) {
|
|
|
84
86
|
}
|
|
85
87
|
} else if (isPngTextChunk(dataView, offset, async)) {
|
|
86
88
|
offsets.hasAppMarkers = true;
|
|
87
|
-
const chunkType = getStringFromDataView(dataView, offset + PNG_CHUNK_TYPE_OFFSET, PNG_CHUNK_TYPE_SIZE);
|
|
88
89
|
if (!offsets.pngTextChunks) {
|
|
89
90
|
offsets.pngTextChunks = [];
|
|
90
91
|
}
|
|
91
|
-
offsets.pngTextChunks.push(
|
|
92
|
-
length: chunkDataLength,
|
|
93
|
-
type: chunkType,
|
|
94
|
-
offset: offset + PNG_CHUNK_DATA_OFFSET
|
|
95
|
-
});
|
|
92
|
+
offsets.pngTextChunks.push(offset + PNG_CHUNK_LENGTH_OFFSET);
|
|
96
93
|
blockType = 'png';
|
|
97
94
|
} else if (isPngExifChunk(dataView, offset)) {
|
|
98
95
|
offsets.hasAppMarkers = true;
|
|
@@ -100,20 +97,20 @@ function findPngOffsets(dataView, async, metadataBlocks) {
|
|
|
100
97
|
blockType = 'exif';
|
|
101
98
|
} else if (Constants.USE_ICC && async && isPngIccpChunk(dataView, offset)) {
|
|
102
99
|
const iccHeaderOffset = offset + PNG_CHUNK_DATA_OFFSET;
|
|
103
|
-
const iccHeader = parseIccHeader(dataView, iccHeaderOffset);
|
|
100
|
+
const iccHeader = parseIccHeader(dataView, iccHeaderOffset, chunkDataLength);
|
|
104
101
|
if (iccHeader !== undefined) {
|
|
105
102
|
offsets.hasAppMarkers = true;
|
|
103
|
+
// PNG spec: a file has at most one iCCP chunk, so only the first valid one is kept.
|
|
106
104
|
if (!offsets.iccChunks) {
|
|
107
|
-
offsets.iccChunks = [
|
|
105
|
+
offsets.iccChunks = [{
|
|
106
|
+
offset: iccHeader.compressedProfileOffset,
|
|
107
|
+
length: chunkDataLength - (iccHeader.compressedProfileOffset - iccHeaderOffset),
|
|
108
|
+
chunkNumber: 1,
|
|
109
|
+
chunksTotal: 1,
|
|
110
|
+
profileName: iccHeader.profileName,
|
|
111
|
+
compressionMethod: iccHeader.compressionMethod
|
|
112
|
+
}];
|
|
108
113
|
}
|
|
109
|
-
offsets.iccChunks.push({
|
|
110
|
-
offset: iccHeader.compressedProfileOffset,
|
|
111
|
-
length: chunkDataLength - (iccHeader.compressedProfileOffset - iccHeaderOffset),
|
|
112
|
-
chunkNumber: 1,
|
|
113
|
-
chunksTotal: 1,
|
|
114
|
-
profileName: iccHeader.profileName,
|
|
115
|
-
compressionMethod: iccHeader.compressionMethod
|
|
116
|
-
});
|
|
117
114
|
blockType = 'icc';
|
|
118
115
|
}
|
|
119
116
|
} else if (isPngChunk(dataView, offset)) {
|
|
@@ -190,22 +187,32 @@ function getPngXmpDataOffset(dataView, offset) {
|
|
|
190
187
|
return offset;
|
|
191
188
|
}
|
|
192
189
|
|
|
193
|
-
function parseIccHeader(dataView, offset) {
|
|
190
|
+
function parseIccHeader(dataView, offset, chunkDataLength) {
|
|
194
191
|
const NULL_SEPARATOR_SIZE = 1;
|
|
195
192
|
const COMPRESSION_METHOD_SIZE = 1;
|
|
193
|
+
const chunkEnd = Math.min(offset + chunkDataLength, dataView.byteLength);
|
|
196
194
|
|
|
197
|
-
const
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
195
|
+
const profileNameLength = getIccProfileNameLength(dataView, offset, chunkEnd);
|
|
196
|
+
if (profileNameLength === undefined) {
|
|
197
|
+
return undefined;
|
|
198
|
+
}
|
|
199
|
+
const compressionMethodOffset = offset + profileNameLength + NULL_SEPARATOR_SIZE;
|
|
200
|
+
if (compressionMethodOffset + COMPRESSION_METHOD_SIZE > chunkEnd) {
|
|
201
201
|
return undefined;
|
|
202
202
|
}
|
|
203
|
-
const compressionMethod = dataView.getUint8(offset);
|
|
204
|
-
offset += COMPRESSION_METHOD_SIZE;
|
|
205
203
|
|
|
206
204
|
return {
|
|
207
|
-
profileName,
|
|
208
|
-
compressionMethod,
|
|
209
|
-
compressedProfileOffset:
|
|
205
|
+
profileName: getStringFromDataView(dataView, offset, profileNameLength),
|
|
206
|
+
compressionMethod: dataView.getUint8(compressionMethodOffset),
|
|
207
|
+
compressedProfileOffset: compressionMethodOffset + COMPRESSION_METHOD_SIZE
|
|
210
208
|
};
|
|
211
209
|
}
|
|
210
|
+
|
|
211
|
+
function getIccProfileNameLength(dataView, offset, chunkEnd) {
|
|
212
|
+
for (let i = 0; i <= MAX_ICC_PROFILE_NAME_LENGTH && offset + i < chunkEnd; i++) {
|
|
213
|
+
if (dataView.getUint8(offset + i) === 0) {
|
|
214
|
+
return i;
|
|
215
|
+
}
|
|
216
|
+
}
|
|
217
|
+
return undefined;
|
|
218
|
+
}
|
package/src/iptc-tags.js
CHANGED
|
@@ -5,6 +5,7 @@
|
|
|
5
5
|
import IptcTagNames from './iptc-tag-names.js';
|
|
6
6
|
import TagDecoder from './tag-decoder.js';
|
|
7
7
|
import {NOOP_TAG_FILTER} from './tag-filter.js';
|
|
8
|
+
import {getValueBudget, BYTES_PER_IPTC_DATASET, IPTC_DATASET_HEADER_SIZE} from './tags-helpers.js';
|
|
8
9
|
|
|
9
10
|
const BYTES_8BIM = 0x3842494d;
|
|
10
11
|
const BYTES_8BIM_SIZE = 4;
|
|
@@ -14,25 +15,36 @@ const RESOURCE_NAME_MIN_SIZE = 2;
|
|
|
14
15
|
const RESOURCE_SIZE_SIZE = 4;
|
|
15
16
|
const RESOURCE_BLOCK_MIN_HEADER_SIZE = BYTES_8BIM_SIZE + RESOURCE_ID_SIZE + RESOURCE_NAME_MIN_SIZE + RESOURCE_SIZE_SIZE;
|
|
16
17
|
const NAA_RESOURCE_BLOCK_TYPE = 0x0404; // Sometimes called resource ID.
|
|
17
|
-
const TAG_HEADER_SIZE = 5;
|
|
18
18
|
|
|
19
19
|
export default {
|
|
20
20
|
read
|
|
21
21
|
};
|
|
22
22
|
|
|
23
|
-
|
|
23
|
+
/**
|
|
24
|
+
* Reads the IPTC datasets of an NAA resource block, or of a naked IPTC block
|
|
25
|
+
* given as an array of bytes.
|
|
26
|
+
*
|
|
27
|
+
* @param {{iptcDatasetsRemaining: number}} [valueBudget] - The per-load budget
|
|
28
|
+
* from getValueBudget. Each dataset header read draws from its
|
|
29
|
+
* iptcDatasetsRemaining, and reading stops when it runs out, returning the
|
|
30
|
+
* tags read so far. Omitted, a budget is sized from the data read.
|
|
31
|
+
* @returns {Object} The read tags, keyed by tag name.
|
|
32
|
+
*/
|
|
33
|
+
function read(dataView, dataOffset, includeUnknown, tagFilter = NOOP_TAG_FILTER, valueBudget) {
|
|
24
34
|
try {
|
|
25
35
|
if (Array.isArray(dataView)) {
|
|
36
|
+
const arrayDataView = new DataView(Uint8Array.from(dataView).buffer);
|
|
26
37
|
return parseTags(
|
|
27
|
-
|
|
38
|
+
arrayDataView,
|
|
28
39
|
{size: dataView.length},
|
|
29
40
|
0,
|
|
30
41
|
includeUnknown,
|
|
31
|
-
tagFilter
|
|
42
|
+
tagFilter,
|
|
43
|
+
valueBudget || getValueBudget(arrayDataView)
|
|
32
44
|
);
|
|
33
45
|
}
|
|
34
46
|
const {naaBlock, dataOffset: newDataOffset} = getNaaResourceBlock(dataView, dataOffset);
|
|
35
|
-
return parseTags(dataView, naaBlock, newDataOffset, includeUnknown, tagFilter);
|
|
47
|
+
return parseTags(dataView, naaBlock, newDataOffset, includeUnknown, tagFilter, valueBudget || getValueBudget(dataView));
|
|
36
48
|
} catch (error) {
|
|
37
49
|
return {};
|
|
38
50
|
}
|
|
@@ -76,7 +88,7 @@ function getBlockPadding(resourceBlock) {
|
|
|
76
88
|
return 0;
|
|
77
89
|
}
|
|
78
90
|
|
|
79
|
-
function parseTags(dataView, naaBlock, dataOffset, includeUnknown, tagFilter) {
|
|
91
|
+
function parseTags(dataView, naaBlock, dataOffset, includeUnknown, tagFilter, valueBudget) {
|
|
80
92
|
const tags = {};
|
|
81
93
|
let encoding = undefined;
|
|
82
94
|
|
|
@@ -89,7 +101,8 @@ function parseTags(dataView, naaBlock, dataOffset, includeUnknown, tagFilter) {
|
|
|
89
101
|
tags,
|
|
90
102
|
encoding,
|
|
91
103
|
includeUnknown,
|
|
92
|
-
tagFilter
|
|
104
|
+
tagFilter,
|
|
105
|
+
valueBudget
|
|
93
106
|
);
|
|
94
107
|
|
|
95
108
|
if (tag === null) {
|
|
@@ -123,7 +136,7 @@ function parseTags(dataView, naaBlock, dataOffset, includeUnknown, tagFilter) {
|
|
|
123
136
|
}
|
|
124
137
|
}
|
|
125
138
|
|
|
126
|
-
dataOffset +=
|
|
139
|
+
dataOffset += IPTC_DATASET_HEADER_SIZE + tagSize;
|
|
127
140
|
}
|
|
128
141
|
|
|
129
142
|
return tags;
|
|
@@ -135,18 +148,23 @@ function readTag(
|
|
|
135
148
|
tags = {},
|
|
136
149
|
encoding = undefined,
|
|
137
150
|
includeUnknown = false,
|
|
138
|
-
tagFilter = NOOP_TAG_FILTER
|
|
151
|
+
tagFilter = NOOP_TAG_FILTER,
|
|
152
|
+
valueBudget
|
|
139
153
|
) {
|
|
140
154
|
const TAG_CODE_OFFSET = 1;
|
|
141
155
|
const TAG_SIZE_OFFSET = 3;
|
|
142
156
|
|
|
143
|
-
if (leadByteIsMissing(dataView, dataOffset)) {
|
|
157
|
+
if (leadByteIsMissing(dataView, dataOffset) || headerIsTruncated(dataView, dataOffset)) {
|
|
144
158
|
return {tag: null, tagSize: 0};
|
|
145
159
|
}
|
|
146
160
|
|
|
147
161
|
const tagCode = dataView.getUint16(dataOffset + TAG_CODE_OFFSET);
|
|
148
162
|
const tagSize = dataView.getUint16(dataOffset + TAG_SIZE_OFFSET);
|
|
149
163
|
|
|
164
|
+
if (valueIsTruncated(dataView, dataOffset, tagSize) || !takeDatasetUnits(valueBudget, tagSize)) {
|
|
165
|
+
return {tag: null, tagSize: 0};
|
|
166
|
+
}
|
|
167
|
+
|
|
150
168
|
if (!includeUnknown && !IptcTagNames['iptc'][tagCode]) {
|
|
151
169
|
return {tag: undefined, tagSize};
|
|
152
170
|
}
|
|
@@ -159,7 +177,7 @@ function readTag(
|
|
|
159
177
|
return {tag: undefined, tagSize};
|
|
160
178
|
}
|
|
161
179
|
|
|
162
|
-
const tagValue = getTagValue(dataView, dataOffset +
|
|
180
|
+
const tagValue = getTagValue(dataView, dataOffset + IPTC_DATASET_HEADER_SIZE, tagSize);
|
|
163
181
|
|
|
164
182
|
const tag = {
|
|
165
183
|
id: tagCode,
|
|
@@ -177,6 +195,15 @@ function readTag(
|
|
|
177
195
|
return {tag, tagSize};
|
|
178
196
|
}
|
|
179
197
|
|
|
198
|
+
function takeDatasetUnits(valueBudget, tagSize) {
|
|
199
|
+
const units = Math.ceil((IPTC_DATASET_HEADER_SIZE + tagSize) / BYTES_PER_IPTC_DATASET);
|
|
200
|
+
if (valueBudget.iptcDatasetsRemaining >= units) {
|
|
201
|
+
valueBudget.iptcDatasetsRemaining -= units;
|
|
202
|
+
return true;
|
|
203
|
+
}
|
|
204
|
+
return false;
|
|
205
|
+
}
|
|
206
|
+
|
|
180
207
|
function getIptcTagNameForFiltering(tagCode, includeUnknown) {
|
|
181
208
|
const tag = IptcTagNames['iptc'][tagCode];
|
|
182
209
|
if (!tag) {
|
|
@@ -203,6 +230,14 @@ function leadByteIsMissing(dataView, dataOffset) {
|
|
|
203
230
|
return dataView.getUint8(dataOffset) !== TAG_LEAD_BYTE;
|
|
204
231
|
}
|
|
205
232
|
|
|
233
|
+
function headerIsTruncated(dataView, dataOffset) {
|
|
234
|
+
return dataOffset + IPTC_DATASET_HEADER_SIZE > dataView.byteLength;
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
function valueIsTruncated(dataView, dataOffset, tagSize) {
|
|
238
|
+
return dataOffset + IPTC_DATASET_HEADER_SIZE + tagSize > dataView.byteLength;
|
|
239
|
+
}
|
|
240
|
+
|
|
206
241
|
function getTagValue(dataView, offset, size) {
|
|
207
242
|
const value = [];
|
|
208
243
|
|
package/src/load-auto.js
CHANGED
|
@@ -55,19 +55,22 @@ export function makeLoadAuto(loadFromData) {
|
|
|
55
55
|
|
|
56
56
|
function loadAdaptiveFromFilenameOrUrl(filename, options) {
|
|
57
57
|
if (/^\w+:\/\//.test(filename)) {
|
|
58
|
+
// Cap at `end`, not `end - start`: a 200 replaces the buffer from byte 0.
|
|
58
59
|
if (typeof fetch !== 'undefined') {
|
|
59
60
|
return adaptiveLoop({
|
|
60
|
-
readRange: (start, end) => fetchRange(filename, {start, end}),
|
|
61
|
+
readRange: (start, end) => fetchRange(filename, {start, end, maxBytes: end}),
|
|
61
62
|
options,
|
|
62
63
|
});
|
|
63
64
|
}
|
|
64
65
|
return adaptiveLoop({
|
|
65
|
-
readRange: (start, end) => nodeGetRange(filename, {start, end}),
|
|
66
|
+
readRange: (start, end) => nodeGetRange(filename, {start, end, maxBytes: end}),
|
|
66
67
|
options,
|
|
67
68
|
});
|
|
68
69
|
}
|
|
69
70
|
if (isDataUri(filename)) {
|
|
70
|
-
return
|
|
71
|
+
return Promise.resolve()
|
|
72
|
+
.then(() => dataUriToBuffer(filename))
|
|
73
|
+
.then((buffer) => loadAdaptiveFromMemory(buffer, options));
|
|
71
74
|
}
|
|
72
75
|
return adaptiveLoop({
|
|
73
76
|
readRange: (start, end, ctx) => readLocalFileRange(filename, {
|
package/src/loadview-pipeline.js
CHANGED
|
@@ -20,6 +20,7 @@ export function buildTagsFromMergeSteps({
|
|
|
20
20
|
deps,
|
|
21
21
|
}) {
|
|
22
22
|
let tags = {};
|
|
23
|
+
const embeddedExifThumbnails = [];
|
|
23
24
|
|
|
24
25
|
for (let i = 0; i < mergeSteps.length; i++) {
|
|
25
26
|
tags = applyMergeStep({
|
|
@@ -33,6 +34,7 @@ export function buildTagsFromMergeSteps({
|
|
|
33
34
|
exifDataView,
|
|
34
35
|
fileType,
|
|
35
36
|
thumbnailIfdTags,
|
|
37
|
+
embeddedExifThumbnails,
|
|
36
38
|
tags,
|
|
37
39
|
deps,
|
|
38
40
|
});
|
|
@@ -73,6 +75,7 @@ export function applyMergeStep({
|
|
|
73
75
|
exifDataView,
|
|
74
76
|
fileType,
|
|
75
77
|
thumbnailIfdTags,
|
|
78
|
+
embeddedExifThumbnails = [],
|
|
76
79
|
tags,
|
|
77
80
|
deps,
|
|
78
81
|
}) {
|
|
@@ -195,8 +198,11 @@ export function applyMergeStep({
|
|
|
195
198
|
}
|
|
196
199
|
|
|
197
200
|
if (Constants.USE_PNG && step.type === 'processPngTextReadTags') {
|
|
201
|
+
addEmbeddedExifThumbnail(embeddedExifThumbnails, step.embeddedExifThumbnail);
|
|
198
202
|
return addPngTextReadTagsToTagsAndGroups({
|
|
199
203
|
readTags: step.readTags,
|
|
204
|
+
embeddedExifTags: step.embeddedExifTags,
|
|
205
|
+
embeddedIptcTags: step.embeddedIptcTags,
|
|
200
206
|
parsedGroups,
|
|
201
207
|
expanded,
|
|
202
208
|
tagFilter,
|
|
@@ -211,6 +217,7 @@ export function applyMergeStep({
|
|
|
211
217
|
|
|
212
218
|
for (let i = 0; i < tagList.length; i++) {
|
|
213
219
|
const entry = tagList[i];
|
|
220
|
+
addEmbeddedExifThumbnail(embeddedExifThumbnails, entry.embeddedExifThumbnail);
|
|
214
221
|
tags = addPngTextReadTagsToTagsAndGroups({
|
|
215
222
|
readTags: entry.readTags || {},
|
|
216
223
|
embeddedExifTags: entry.embeddedExifTags,
|
|
@@ -274,32 +281,30 @@ export function applyMergeStep({
|
|
|
274
281
|
}
|
|
275
282
|
|
|
276
283
|
if (step.type === 'thumbnail') {
|
|
284
|
+
// Flat output can already hold an XMP or PNG text tag named Thumbnail.
|
|
285
|
+
delete tags.Thumbnail;
|
|
286
|
+
|
|
277
287
|
if (
|
|
278
288
|
!tagFilter.shouldReturnGroup('thumbnail')
|
|
279
289
|
|| !tagFilter.shouldReturnTag('thumbnail', 'Thumbnail')
|
|
280
290
|
) {
|
|
281
|
-
delete tags.Thumbnail;
|
|
282
|
-
|
|
283
|
-
return tags;
|
|
284
|
-
}
|
|
285
|
-
|
|
286
|
-
if (!thumbnailIfdTags) {
|
|
287
291
|
return tags;
|
|
288
292
|
}
|
|
289
293
|
|
|
290
|
-
const
|
|
291
|
-
'thumbnail',
|
|
294
|
+
const mainThumbnail = getMainThumbnail({
|
|
292
295
|
thumbnailIfdTags,
|
|
293
|
-
tagFilter
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
296
|
+
tagFilter,
|
|
297
|
+
dataView,
|
|
298
|
+
exifDataView,
|
|
299
|
+
tiffHeaderOffset,
|
|
300
|
+
deps,
|
|
301
|
+
});
|
|
302
|
+
let thumbnail = mainThumbnail;
|
|
303
|
+
if (!hasImage(mainThumbnail)) {
|
|
304
|
+
thumbnail = getFirstEmbeddedExifThumbnailWithImage(embeddedExifThumbnails) || mainThumbnail;
|
|
305
|
+
}
|
|
299
306
|
if (thumbnail) {
|
|
300
307
|
tags.Thumbnail = thumbnail;
|
|
301
|
-
} else {
|
|
302
|
-
delete tags.Thumbnail;
|
|
303
308
|
}
|
|
304
309
|
|
|
305
310
|
return tags;
|
|
@@ -322,6 +327,9 @@ export function applyMergeStep({
|
|
|
322
327
|
}
|
|
323
328
|
|
|
324
329
|
if (step.type === 'fileType') {
|
|
330
|
+
// Flat output can already hold an XMP or PNG text tag named FileType.
|
|
331
|
+
delete tags.FileType;
|
|
332
|
+
|
|
325
333
|
if (
|
|
326
334
|
fileType
|
|
327
335
|
&& tagFilter.shouldReturnGroup('file')
|
|
@@ -343,6 +351,39 @@ export function applyMergeStep({
|
|
|
343
351
|
return tags;
|
|
344
352
|
}
|
|
345
353
|
|
|
354
|
+
function addEmbeddedExifThumbnail(embeddedExifThumbnails, embeddedExifThumbnail) {
|
|
355
|
+
if (embeddedExifThumbnail) {
|
|
356
|
+
embeddedExifThumbnails.push(embeddedExifThumbnail);
|
|
357
|
+
}
|
|
358
|
+
}
|
|
359
|
+
|
|
360
|
+
function getMainThumbnail({thumbnailIfdTags, tagFilter, dataView, exifDataView, tiffHeaderOffset, deps}) {
|
|
361
|
+
if (!thumbnailIfdTags) {
|
|
362
|
+
return undefined;
|
|
363
|
+
}
|
|
364
|
+
|
|
365
|
+
const parsedThumbnailIfdTags = deps.filterTagsForParse(
|
|
366
|
+
'thumbnail',
|
|
367
|
+
thumbnailIfdTags,
|
|
368
|
+
tagFilter
|
|
369
|
+
);
|
|
370
|
+
|
|
371
|
+
return Constants.USE_EXIF
|
|
372
|
+
&& Constants.USE_THUMBNAIL
|
|
373
|
+
&& deps.Thumbnail.get(exifDataView || dataView, parsedThumbnailIfdTags, tiffHeaderOffset);
|
|
374
|
+
}
|
|
375
|
+
|
|
376
|
+
function hasImage(thumbnail) {
|
|
377
|
+
return !!thumbnail && !!thumbnail.image;
|
|
378
|
+
}
|
|
379
|
+
|
|
380
|
+
function getFirstEmbeddedExifThumbnailWithImage(embeddedExifThumbnails) {
|
|
381
|
+
if (!(Constants.USE_PNG && Constants.USE_EXIF && Constants.USE_THUMBNAIL)) {
|
|
382
|
+
return undefined;
|
|
383
|
+
}
|
|
384
|
+
return embeddedExifThumbnails.filter(hasImage)[0];
|
|
385
|
+
}
|
|
386
|
+
|
|
346
387
|
export function mergeAssignGroup(tags, groupKey, returnedTags, expanded, deps) {
|
|
347
388
|
if (expanded) {
|
|
348
389
|
tags[groupKey] = returnedTags;
|
|
@@ -405,13 +446,7 @@ export function addPngTextReadTagsToTagsAndGroups({
|
|
|
405
446
|
if (expanded) {
|
|
406
447
|
merge.group(tags, 'exif', returnedEmbeddedExifTags);
|
|
407
448
|
} else {
|
|
408
|
-
|
|
409
|
-
// thumbnail IFD would land at the top level with no image.
|
|
410
|
-
const returnedEmbeddedExifTagsForFlat =
|
|
411
|
-
deps.objectAssign({}, returnedEmbeddedExifTags);
|
|
412
|
-
delete returnedEmbeddedExifTagsForFlat.Thumbnail;
|
|
413
|
-
|
|
414
|
-
tags = merge.topLevel(tags, returnedEmbeddedExifTagsForFlat);
|
|
449
|
+
tags = merge.topLevel(tags, returnedEmbeddedExifTags);
|
|
415
450
|
}
|
|
416
451
|
}
|
|
417
452
|
}
|
package/src/mpf-tags.js
CHANGED
|
@@ -20,6 +20,10 @@ const ENTRY_SIZE = 16;
|
|
|
20
20
|
// proportional to its size instead of n^2.
|
|
21
21
|
const MAX_IMAGE_SIZE_PER_BUFFER_SIZE = 8;
|
|
22
22
|
|
|
23
|
+
// Real MPF files carry a handful of images (the corpus maximum is 2). The cap
|
|
24
|
+
// keeps a crafted entry table from building an object per 16 bytes of the file.
|
|
25
|
+
const MAX_IMAGES = 256;
|
|
26
|
+
|
|
23
27
|
function read(
|
|
24
28
|
dataView,
|
|
25
29
|
dataOffset,
|
|
@@ -63,7 +67,8 @@ function addMpfImages(dataView, dataOffset, tags, byteOrder) {
|
|
|
63
67
|
const byteOffset = dataView.byteOffset || 0;
|
|
64
68
|
let remainingImageBytes = bufferLength * MAX_IMAGE_SIZE_PER_BUFFER_SIZE;
|
|
65
69
|
const images = [];
|
|
66
|
-
|
|
70
|
+
const imageCount = Math.min(Math.ceil(tags['MPEntry'].value.length / ENTRY_SIZE), MAX_IMAGES);
|
|
71
|
+
for (let i = 0; i < imageCount; i++) {
|
|
67
72
|
images[i] = {};
|
|
68
73
|
|
|
69
74
|
const attributes = getImageNumberValue(tags['MPEntry'].value, i * ENTRY_SIZE, Types.getTypeSize('LONG'), byteOrder);
|
package/src/pentax-tags.js
CHANGED
|
@@ -23,6 +23,8 @@ const LIK3III = {
|
|
|
23
23
|
ROLL_ANGLE: 3,
|
|
24
24
|
PITCH_ANGLE: 5
|
|
25
25
|
};
|
|
26
|
+
const INT8_SIZE = 1;
|
|
27
|
+
const INT16_SIZE = 2;
|
|
26
28
|
|
|
27
29
|
export default {
|
|
28
30
|
read,
|
|
@@ -60,8 +62,15 @@ function read(
|
|
|
60
62
|
);
|
|
61
63
|
|
|
62
64
|
if (hasLevelInfoK3III(tags)) {
|
|
63
|
-
tags = objectAssign({}, tags, parseLevelInfoK3III(
|
|
65
|
+
tags = objectAssign({}, tags, parseLevelInfoK3III(
|
|
66
|
+
dataView,
|
|
67
|
+
originOffset + tags['LevelInfo'].__offset,
|
|
68
|
+
getLevelInfoLength(tags['LevelInfo'].value),
|
|
69
|
+
byteOrder
|
|
70
|
+
));
|
|
64
71
|
delete tags['LevelInfo'];
|
|
72
|
+
} else if (tags['LevelInfo']) {
|
|
73
|
+
delete tags['LevelInfo'].__offset;
|
|
65
74
|
}
|
|
66
75
|
|
|
67
76
|
return tags;
|
|
@@ -74,34 +83,49 @@ function hasLevelInfoK3III(tags) {
|
|
|
74
83
|
return tags['PentaxModelID'] && tags['PentaxModelID'].value === MODEL_ID.K3_III && tags['LevelInfo'];
|
|
75
84
|
}
|
|
76
85
|
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
return tags;
|
|
86
|
+
// A value of numbers holds at least as many bytes as elements, whatever its TIFF type.
|
|
87
|
+
function getLevelInfoLength(levelInfoValue) {
|
|
88
|
+
if (Array.isArray(levelInfoValue) && typeof levelInfoValue[0] === 'number') {
|
|
89
|
+
return levelInfoValue.length;
|
|
82
90
|
}
|
|
91
|
+
return 0;
|
|
92
|
+
}
|
|
83
93
|
|
|
84
|
-
|
|
85
|
-
tags
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
94
|
+
function parseLevelInfoK3III(dataView, levelInfoOffset, levelInfoLength, byteOrder) {
|
|
95
|
+
const tags = {};
|
|
96
|
+
const littleEndian = byteOrder === ByteOrder.LITTLE_ENDIAN;
|
|
97
|
+
|
|
98
|
+
if (fieldFitsInLevelInfo(LIK3III.CAMERA_ORIENTATION, INT8_SIZE, levelInfoLength)) {
|
|
99
|
+
const cameraOrientation = dataView.getInt8(levelInfoOffset + LIK3III.CAMERA_ORIENTATION);
|
|
100
|
+
tags['CameraOrientation'] = {
|
|
101
|
+
value: cameraOrientation,
|
|
102
|
+
description: getOrientationDescription(cameraOrientation)
|
|
103
|
+
};
|
|
104
|
+
}
|
|
89
105
|
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
106
|
+
if (fieldFitsInLevelInfo(LIK3III.ROLL_ANGLE, INT16_SIZE, levelInfoLength)) {
|
|
107
|
+
const rollAngle = dataView.getInt16(levelInfoOffset + LIK3III.ROLL_ANGLE, littleEndian);
|
|
108
|
+
tags['RollAngle'] = {
|
|
109
|
+
value: rollAngle,
|
|
110
|
+
description: getRollAngleDescription(rollAngle)
|
|
111
|
+
};
|
|
112
|
+
}
|
|
95
113
|
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
114
|
+
if (fieldFitsInLevelInfo(LIK3III.PITCH_ANGLE, INT16_SIZE, levelInfoLength)) {
|
|
115
|
+
const pitchAngle = dataView.getInt16(levelInfoOffset + LIK3III.PITCH_ANGLE, littleEndian);
|
|
116
|
+
tags['PitchAngle'] = {
|
|
117
|
+
value: pitchAngle,
|
|
118
|
+
description: getPitchAngleDescription(pitchAngle)
|
|
119
|
+
};
|
|
120
|
+
}
|
|
101
121
|
|
|
102
122
|
return tags;
|
|
103
123
|
}
|
|
104
124
|
|
|
125
|
+
function fieldFitsInLevelInfo(fieldOffset, fieldSize, levelInfoLength) {
|
|
126
|
+
return fieldOffset + fieldSize <= levelInfoLength;
|
|
127
|
+
}
|
|
128
|
+
|
|
105
129
|
function getOrientationDescription(orientation) {
|
|
106
130
|
if (orientation === 0) {
|
|
107
131
|
return 'Horizontal (normal)';
|