exifreader 4.47.0 → 4.48.0
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 +22 -22
- 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/package.json +2 -2
- package/src/composite.js +94 -47
- package/src/exif-reader.js +54 -8
- package/src/file-loaders.js +64 -22
- package/src/image-header-iso-bmff.js +31 -10
- package/src/image-header-jpeg.js +9 -2
- package/src/image-header-png.js +33 -21
- 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 +15 -22
- package/src/png-text-tags.js +169 -42
- package/src/tag-filter-config.js +2 -0
- package/src/tags-helpers.js +177 -50
- package/src/tags.js +10 -0
- package/src/utils.js +149 -15
- 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 +30 -7
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.
|
|
@@ -100,20 +102,20 @@ function findPngOffsets(dataView, async, metadataBlocks) {
|
|
|
100
102
|
blockType = 'exif';
|
|
101
103
|
} else if (Constants.USE_ICC && async && isPngIccpChunk(dataView, offset)) {
|
|
102
104
|
const iccHeaderOffset = offset + PNG_CHUNK_DATA_OFFSET;
|
|
103
|
-
const iccHeader = parseIccHeader(dataView, iccHeaderOffset);
|
|
105
|
+
const iccHeader = parseIccHeader(dataView, iccHeaderOffset, chunkDataLength);
|
|
104
106
|
if (iccHeader !== undefined) {
|
|
105
107
|
offsets.hasAppMarkers = true;
|
|
108
|
+
// PNG spec: a file has at most one iCCP chunk, so only the first valid one is kept.
|
|
106
109
|
if (!offsets.iccChunks) {
|
|
107
|
-
offsets.iccChunks = [
|
|
110
|
+
offsets.iccChunks = [{
|
|
111
|
+
offset: iccHeader.compressedProfileOffset,
|
|
112
|
+
length: chunkDataLength - (iccHeader.compressedProfileOffset - iccHeaderOffset),
|
|
113
|
+
chunkNumber: 1,
|
|
114
|
+
chunksTotal: 1,
|
|
115
|
+
profileName: iccHeader.profileName,
|
|
116
|
+
compressionMethod: iccHeader.compressionMethod
|
|
117
|
+
}];
|
|
108
118
|
}
|
|
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
119
|
blockType = 'icc';
|
|
118
120
|
}
|
|
119
121
|
} else if (isPngChunk(dataView, offset)) {
|
|
@@ -190,22 +192,32 @@ function getPngXmpDataOffset(dataView, offset) {
|
|
|
190
192
|
return offset;
|
|
191
193
|
}
|
|
192
194
|
|
|
193
|
-
function parseIccHeader(dataView, offset) {
|
|
195
|
+
function parseIccHeader(dataView, offset, chunkDataLength) {
|
|
194
196
|
const NULL_SEPARATOR_SIZE = 1;
|
|
195
197
|
const COMPRESSION_METHOD_SIZE = 1;
|
|
198
|
+
const chunkEnd = Math.min(offset + chunkDataLength, dataView.byteLength);
|
|
196
199
|
|
|
197
|
-
const
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
200
|
+
const profileNameLength = getIccProfileNameLength(dataView, offset, chunkEnd);
|
|
201
|
+
if (profileNameLength === undefined) {
|
|
202
|
+
return undefined;
|
|
203
|
+
}
|
|
204
|
+
const compressionMethodOffset = offset + profileNameLength + NULL_SEPARATOR_SIZE;
|
|
205
|
+
if (compressionMethodOffset + COMPRESSION_METHOD_SIZE > chunkEnd) {
|
|
201
206
|
return undefined;
|
|
202
207
|
}
|
|
203
|
-
const compressionMethod = dataView.getUint8(offset);
|
|
204
|
-
offset += COMPRESSION_METHOD_SIZE;
|
|
205
208
|
|
|
206
209
|
return {
|
|
207
|
-
profileName,
|
|
208
|
-
compressionMethod,
|
|
209
|
-
compressedProfileOffset:
|
|
210
|
+
profileName: getStringFromDataView(dataView, offset, profileNameLength),
|
|
211
|
+
compressionMethod: dataView.getUint8(compressionMethodOffset),
|
|
212
|
+
compressedProfileOffset: compressionMethodOffset + COMPRESSION_METHOD_SIZE
|
|
210
213
|
};
|
|
211
214
|
}
|
|
215
|
+
|
|
216
|
+
function getIccProfileNameLength(dataView, offset, chunkEnd) {
|
|
217
|
+
for (let i = 0; i <= MAX_ICC_PROFILE_NAME_LENGTH && offset + i < chunkEnd; i++) {
|
|
218
|
+
if (dataView.getUint8(offset + i) === 0) {
|
|
219
|
+
return i;
|
|
220
|
+
}
|
|
221
|
+
}
|
|
222
|
+
return undefined;
|
|
223
|
+
}
|
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)';
|
|
@@ -23,6 +23,9 @@ export const PathRecordTypes = {
|
|
|
23
23
|
};
|
|
24
24
|
|
|
25
25
|
const PATH_RECORD_SIZE = 24;
|
|
26
|
+
// Real clipping paths hold at most a few thousand records. The cap is shared by
|
|
27
|
+
// all PathInformation resources of one read so that splitting a path does not multiply it.
|
|
28
|
+
export const MAX_PATH_RECORDS = 32768;
|
|
26
29
|
|
|
27
30
|
export default {
|
|
28
31
|
0x07d0: {
|
|
@@ -38,12 +41,12 @@ export default {
|
|
|
38
41
|
},
|
|
39
42
|
};
|
|
40
43
|
|
|
41
|
-
function pathResource(dataView) {
|
|
44
|
+
function pathResource(dataView, recordBudget = {remaining: MAX_PATH_RECORDS}) {
|
|
42
45
|
const TYPE_SIZE = 2;
|
|
43
46
|
const types = {};
|
|
44
47
|
const paths = [];
|
|
45
48
|
|
|
46
|
-
for (let offset = 0; offset < dataView.byteLength; offset += TYPE_SIZE + PATH_RECORD_SIZE) {
|
|
49
|
+
for (let offset = 0; offset < dataView.byteLength && recordBudget.remaining > 0; offset += TYPE_SIZE + PATH_RECORD_SIZE) {
|
|
47
50
|
const type = Types.getShortAt(dataView, offset);
|
|
48
51
|
if (PATH_RECORD_TYPES[type]) {
|
|
49
52
|
if (!types[type]) {
|
|
@@ -53,6 +56,7 @@ function pathResource(dataView) {
|
|
|
53
56
|
type,
|
|
54
57
|
path: PATH_RECORD_TYPES[type].path(dataView, offset + TYPE_SIZE)
|
|
55
58
|
});
|
|
59
|
+
recordBudget.remaining--;
|
|
56
60
|
}
|
|
57
61
|
}
|
|
58
62
|
return JSON.stringify({types, paths});
|
package/src/photoshop-tags.js
CHANGED
|
@@ -4,9 +4,9 @@
|
|
|
4
4
|
|
|
5
5
|
// Specification: https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/
|
|
6
6
|
|
|
7
|
-
import {getDataView, getStringFromDataView, getPascalStringFromDataView, setProperty} from './utils.js';
|
|
7
|
+
import {getByteString, getDataView, getStringFromDataView, getPascalStringFromDataView, getTagKey, setProperty} from './utils.js';
|
|
8
8
|
import Types from './types.js';
|
|
9
|
-
import TagNames from './photoshop-tag-names.js';
|
|
9
|
+
import TagNames, {MAX_PATH_RECORDS} from './photoshop-tag-names.js';
|
|
10
10
|
import {NOOP_TAG_FILTER} from './tag-filter.js';
|
|
11
11
|
|
|
12
12
|
export default {
|
|
@@ -25,7 +25,9 @@ function read(bytes, includeUnknown, tagFilter = NOOP_TAG_FILTER) {
|
|
|
25
25
|
if (!Array.isArray(bytes)) {
|
|
26
26
|
return {};
|
|
27
27
|
}
|
|
28
|
-
const
|
|
28
|
+
const byteArray = new Uint8Array(bytes);
|
|
29
|
+
const dataView = getDataView(byteArray.buffer);
|
|
30
|
+
const pathRecordBudget = {remaining: MAX_PATH_RECORDS};
|
|
29
31
|
const tags = {};
|
|
30
32
|
let offset = 0;
|
|
31
33
|
|
|
@@ -45,8 +47,8 @@ function read(bytes, includeUnknown, tagFilter = NOOP_TAG_FILTER) {
|
|
|
45
47
|
// it by the bytes that are actually present.
|
|
46
48
|
const resourceSize = Math.min(declaredResourceSize, dataView.byteLength - offset);
|
|
47
49
|
if (signature === SIGNATURE) {
|
|
48
|
-
const
|
|
49
|
-
if (!tagFilter.shouldParseTag('photoshop',
|
|
50
|
+
const tagKey = getResourceTagKey(tagId, tagName);
|
|
51
|
+
if (!tagFilter.shouldParseTag('photoshop', tagKey, tagId)) {
|
|
50
52
|
offset += resourceSize + (resourceSize % 2);
|
|
51
53
|
continue;
|
|
52
54
|
}
|
|
@@ -54,17 +56,17 @@ function read(bytes, includeUnknown, tagFilter = NOOP_TAG_FILTER) {
|
|
|
54
56
|
const valueDataView = getDataView(dataView.buffer, offset, resourceSize);
|
|
55
57
|
const tag = {
|
|
56
58
|
id: tagId,
|
|
57
|
-
value:
|
|
59
|
+
value: getByteString(byteArray, offset, offset + resourceSize),
|
|
58
60
|
};
|
|
59
61
|
if (TagNames[tagId]) {
|
|
60
62
|
try {
|
|
61
|
-
tag.description = TagNames[tagId].description(valueDataView);
|
|
63
|
+
tag.description = TagNames[tagId].description(valueDataView, pathRecordBudget);
|
|
62
64
|
} catch (error) {
|
|
63
65
|
tag.description = '<no description formatter>';
|
|
64
66
|
}
|
|
65
|
-
setProperty(tags,
|
|
67
|
+
setProperty(tags, tagKey, tag);
|
|
66
68
|
} else if (includeUnknown) {
|
|
67
|
-
tags[
|
|
69
|
+
tags[tagKey] = tag;
|
|
68
70
|
}
|
|
69
71
|
}
|
|
70
72
|
offset += resourceSize + (resourceSize % 2);
|
|
@@ -73,20 +75,11 @@ function read(bytes, includeUnknown, tagFilter = NOOP_TAG_FILTER) {
|
|
|
73
75
|
return tags;
|
|
74
76
|
}
|
|
75
77
|
|
|
76
|
-
function
|
|
77
|
-
if (
|
|
78
|
-
return tagName;
|
|
78
|
+
function getResourceTagKey(tagId, tagName) {
|
|
79
|
+
if (TagNames[tagId]) {
|
|
80
|
+
return getTagKey(tagName || TagNames[tagId].name);
|
|
79
81
|
}
|
|
80
|
-
|
|
81
|
-
if (TagNames[tagId] && TagNames[tagId].name) {
|
|
82
|
-
return TagNames[tagId].name;
|
|
83
|
-
}
|
|
84
|
-
|
|
85
|
-
if (includeUnknown) {
|
|
86
|
-
return `undefined-${tagId}`;
|
|
87
|
-
}
|
|
88
|
-
|
|
89
|
-
return undefined;
|
|
82
|
+
return `undefined-${tagId}`;
|
|
90
83
|
}
|
|
91
84
|
|
|
92
85
|
function getTagName(dataView, offset) {
|