exifreader 4.35.0 → 4.36.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 +88 -0
- package/dist/exif-reader.js +1 -1
- package/dist/exif-reader.js.map +1 -1
- package/exif-reader.d.ts +56 -3
- package/package.json +7 -5
- package/src/canon-tags.js +20 -2
- package/src/exif-reader.js +617 -220
- package/src/iptc-tags.js +56 -6
- package/src/loadview-pipeline.js +417 -0
- package/src/mpf-tags.js +10 -2
- package/src/pentax-tags.js +11 -2
- package/src/photoshop-tags.js +24 -1
- package/src/png-text-tags.js +28 -4
- package/src/tag-filter-config.js +124 -0
- package/src/tag-filter.js +409 -0
- package/src/tags-helpers.js +63 -16
- package/src/tags.js +29 -13
- package/webpack.config.js +3 -0
package/src/iptc-tags.js
CHANGED
|
@@ -4,6 +4,7 @@
|
|
|
4
4
|
|
|
5
5
|
import IptcTagNames from './iptc-tag-names.js';
|
|
6
6
|
import TagDecoder from './tag-decoder.js';
|
|
7
|
+
import {NOOP_TAG_FILTER} from './tag-filter.js';
|
|
7
8
|
|
|
8
9
|
const BYTES_8BIM = 0x3842494d;
|
|
9
10
|
const BYTES_8BIM_SIZE = 4;
|
|
@@ -19,13 +20,19 @@ export default {
|
|
|
19
20
|
read
|
|
20
21
|
};
|
|
21
22
|
|
|
22
|
-
function read(dataView, dataOffset, includeUnknown) {
|
|
23
|
+
function read(dataView, dataOffset, includeUnknown, tagFilter = NOOP_TAG_FILTER) {
|
|
23
24
|
try {
|
|
24
25
|
if (Array.isArray(dataView)) {
|
|
25
|
-
return parseTags(
|
|
26
|
+
return parseTags(
|
|
27
|
+
new DataView(Uint8Array.from(dataView).buffer),
|
|
28
|
+
{size: dataView.length},
|
|
29
|
+
0,
|
|
30
|
+
includeUnknown,
|
|
31
|
+
tagFilter
|
|
32
|
+
);
|
|
26
33
|
}
|
|
27
34
|
const {naaBlock, dataOffset: newDataOffset} = getNaaResourceBlock(dataView, dataOffset);
|
|
28
|
-
return parseTags(dataView, naaBlock, newDataOffset, includeUnknown);
|
|
35
|
+
return parseTags(dataView, naaBlock, newDataOffset, includeUnknown, tagFilter);
|
|
29
36
|
} catch (error) {
|
|
30
37
|
return {};
|
|
31
38
|
}
|
|
@@ -69,14 +76,21 @@ function getBlockPadding(resourceBlock) {
|
|
|
69
76
|
return 0;
|
|
70
77
|
}
|
|
71
78
|
|
|
72
|
-
function parseTags(dataView, naaBlock, dataOffset, includeUnknown) {
|
|
79
|
+
function parseTags(dataView, naaBlock, dataOffset, includeUnknown, tagFilter) {
|
|
73
80
|
const tags = {};
|
|
74
81
|
let encoding = undefined;
|
|
75
82
|
|
|
76
83
|
const endOfBlockOffset = dataOffset + naaBlock['size'];
|
|
77
84
|
|
|
78
85
|
while ((dataOffset < endOfBlockOffset) && (dataOffset < dataView.byteLength)) {
|
|
79
|
-
const {tag, tagSize} = readTag(
|
|
86
|
+
const {tag, tagSize} = readTag(
|
|
87
|
+
dataView,
|
|
88
|
+
dataOffset,
|
|
89
|
+
tags,
|
|
90
|
+
encoding,
|
|
91
|
+
includeUnknown,
|
|
92
|
+
tagFilter
|
|
93
|
+
);
|
|
80
94
|
|
|
81
95
|
if (tag === null) {
|
|
82
96
|
break;
|
|
@@ -115,7 +129,14 @@ function parseTags(dataView, naaBlock, dataOffset, includeUnknown) {
|
|
|
115
129
|
return tags;
|
|
116
130
|
}
|
|
117
131
|
|
|
118
|
-
function readTag(
|
|
132
|
+
function readTag(
|
|
133
|
+
dataView,
|
|
134
|
+
dataOffset,
|
|
135
|
+
tags = {},
|
|
136
|
+
encoding = undefined,
|
|
137
|
+
includeUnknown = false,
|
|
138
|
+
tagFilter = NOOP_TAG_FILTER
|
|
139
|
+
) {
|
|
119
140
|
const TAG_CODE_OFFSET = 1;
|
|
120
141
|
const TAG_SIZE_OFFSET = 3;
|
|
121
142
|
|
|
@@ -130,6 +151,14 @@ function readTag(dataView, dataOffset, tags, encoding, includeUnknown) {
|
|
|
130
151
|
return {tag: undefined, tagSize};
|
|
131
152
|
}
|
|
132
153
|
|
|
154
|
+
if (!tagFilter.shouldParseTag(
|
|
155
|
+
'iptc',
|
|
156
|
+
getIptcTagNameForFiltering(tagCode, includeUnknown),
|
|
157
|
+
tagCode
|
|
158
|
+
)) {
|
|
159
|
+
return {tag: undefined, tagSize};
|
|
160
|
+
}
|
|
161
|
+
|
|
133
162
|
const tagValue = getTagValue(dataView, dataOffset + TAG_HEADER_SIZE, tagSize);
|
|
134
163
|
|
|
135
164
|
const tag = {
|
|
@@ -148,6 +177,27 @@ function readTag(dataView, dataOffset, tags, encoding, includeUnknown) {
|
|
|
148
177
|
return {tag, tagSize};
|
|
149
178
|
}
|
|
150
179
|
|
|
180
|
+
function getIptcTagNameForFiltering(tagCode, includeUnknown) {
|
|
181
|
+
const tag = IptcTagNames['iptc'][tagCode];
|
|
182
|
+
if (!tag) {
|
|
183
|
+
if (includeUnknown) {
|
|
184
|
+
return `undefined-${tagCode}`;
|
|
185
|
+
}
|
|
186
|
+
|
|
187
|
+
return undefined;
|
|
188
|
+
}
|
|
189
|
+
|
|
190
|
+
if (typeof tag === 'string') {
|
|
191
|
+
return tag;
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
if (tag && typeof tag.name === 'string') {
|
|
195
|
+
return tag.name;
|
|
196
|
+
}
|
|
197
|
+
|
|
198
|
+
return undefined;
|
|
199
|
+
}
|
|
200
|
+
|
|
151
201
|
function leadByteIsMissing(dataView, dataOffset) {
|
|
152
202
|
const TAG_LEAD_BYTE = 0x1c;
|
|
153
203
|
return dataView.getUint8(dataOffset) !== TAG_LEAD_BYTE;
|
|
@@ -0,0 +1,417 @@
|
|
|
1
|
+
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
2
|
+
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
3
|
+
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
|
4
|
+
|
|
5
|
+
export function buildTagsFromMergeSteps({
|
|
6
|
+
mergeSteps,
|
|
7
|
+
deferredResults,
|
|
8
|
+
parsedGroups,
|
|
9
|
+
expanded,
|
|
10
|
+
tagFilter,
|
|
11
|
+
dataView,
|
|
12
|
+
tiffHeaderOffset,
|
|
13
|
+
fileType,
|
|
14
|
+
pngTextChunks,
|
|
15
|
+
pngTextIsAsync,
|
|
16
|
+
thumbnailIfdTags,
|
|
17
|
+
deps,
|
|
18
|
+
}) {
|
|
19
|
+
let tags = {};
|
|
20
|
+
|
|
21
|
+
for (let i = 0; i < mergeSteps.length; i++) {
|
|
22
|
+
tags = applyMergeStep({
|
|
23
|
+
step: mergeSteps[i],
|
|
24
|
+
deferredResults,
|
|
25
|
+
parsedGroups,
|
|
26
|
+
expanded,
|
|
27
|
+
tagFilter,
|
|
28
|
+
dataView,
|
|
29
|
+
tiffHeaderOffset,
|
|
30
|
+
fileType,
|
|
31
|
+
thumbnailIfdTags,
|
|
32
|
+
tags,
|
|
33
|
+
deps,
|
|
34
|
+
});
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
if (
|
|
38
|
+
expanded
|
|
39
|
+
&& pngTextIsAsync
|
|
40
|
+
&& tagFilter.shouldReturnGroup('png')
|
|
41
|
+
&& tags.png
|
|
42
|
+
) {
|
|
43
|
+
tags.pngText = deps.objectAssign({}, tags.png);
|
|
44
|
+
}
|
|
45
|
+
|
|
46
|
+
if (
|
|
47
|
+
expanded
|
|
48
|
+
&& tagFilter.shouldReturnGroup('png')
|
|
49
|
+
&& deps.hasPngTextData(pngTextChunks)
|
|
50
|
+
&& tags.png
|
|
51
|
+
&& !tags.pngText
|
|
52
|
+
) {
|
|
53
|
+
tags.pngText = deps.objectAssign({}, tags.png);
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
return tags;
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
export function applyMergeStep({
|
|
60
|
+
step,
|
|
61
|
+
deferredResults,
|
|
62
|
+
parsedGroups,
|
|
63
|
+
expanded,
|
|
64
|
+
tagFilter,
|
|
65
|
+
dataView,
|
|
66
|
+
tiffHeaderOffset,
|
|
67
|
+
fileType,
|
|
68
|
+
thumbnailIfdTags,
|
|
69
|
+
tags,
|
|
70
|
+
deps,
|
|
71
|
+
}) {
|
|
72
|
+
if (step.type === 'mergeGroupAssign') {
|
|
73
|
+
const returnedTags =
|
|
74
|
+
deps.filterTagsForReturn(step.groupKey, step.parsedTags, tagFilter);
|
|
75
|
+
|
|
76
|
+
return mergeAssignGroup(tags, step.groupKey, returnedTags, expanded, deps);
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
if (step.type === 'mergeGroupMerge') {
|
|
80
|
+
const returnedTags =
|
|
81
|
+
deps.filterTagsForReturn(step.groupKey, step.parsedTags, tagFilter);
|
|
82
|
+
|
|
83
|
+
return mergeMergeGroup(tags, step.groupKey, returnedTags, expanded, deps);
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
if (step.type === 'mergeXmpGroupAssign') {
|
|
87
|
+
const returnedTags =
|
|
88
|
+
deps.filterTagsForReturn('xmp', step.parsedTags, tagFilter);
|
|
89
|
+
|
|
90
|
+
if (expanded) {
|
|
91
|
+
tags.xmp = returnedTags;
|
|
92
|
+
|
|
93
|
+
return tags;
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
const returnedTagsForFlat = deps.objectAssign({}, returnedTags);
|
|
97
|
+
delete returnedTagsForFlat._raw;
|
|
98
|
+
|
|
99
|
+
return deps.objectAssign({}, tags, returnedTagsForFlat);
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
if (step.type === 'mergeIccDeferred') {
|
|
103
|
+
const resolvedReadTags = deferredResults[step.deferredKey];
|
|
104
|
+
const parsedIccTags =
|
|
105
|
+
deps.filterTagsForParse('icc', resolvedReadTags, tagFilter);
|
|
106
|
+
parsedGroups.icc = parsedIccTags;
|
|
107
|
+
|
|
108
|
+
if (!tagFilter.shouldReturnGroup('icc')) {
|
|
109
|
+
return tags;
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
const returnedIccTags =
|
|
113
|
+
deps.filterTagsForReturn('icc', parsedIccTags, tagFilter);
|
|
114
|
+
|
|
115
|
+
return mergeAssignGroup(tags, 'icc', returnedIccTags, expanded, deps);
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
if (step.type === 'mergePngFile') {
|
|
119
|
+
const returnedPngFileTags =
|
|
120
|
+
deps.filterTagsForReturn('png', step.parsedTags, tagFilter);
|
|
121
|
+
|
|
122
|
+
if (!tagFilter.shouldReturnGroup('png')) {
|
|
123
|
+
return tags;
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
if (expanded) {
|
|
127
|
+
tags.png = !tags.png ? returnedPngFileTags : deps.objectAssign(
|
|
128
|
+
{},
|
|
129
|
+
tags.png,
|
|
130
|
+
returnedPngFileTags
|
|
131
|
+
);
|
|
132
|
+
tags.pngFile = returnedPngFileTags;
|
|
133
|
+
|
|
134
|
+
return tags;
|
|
135
|
+
}
|
|
136
|
+
|
|
137
|
+
return deps.objectAssign({}, tags, returnedPngFileTags);
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
if (step.type === 'mergePngChunk') {
|
|
141
|
+
const returnedPngChunkTags =
|
|
142
|
+
deps.filterTagsForReturn('png', step.parsedTags, tagFilter);
|
|
143
|
+
|
|
144
|
+
if (!tagFilter.shouldReturnGroup('png')) {
|
|
145
|
+
return tags;
|
|
146
|
+
}
|
|
147
|
+
|
|
148
|
+
if (expanded) {
|
|
149
|
+
tags.png = !tags.png ? returnedPngChunkTags : deps.objectAssign(
|
|
150
|
+
{},
|
|
151
|
+
tags.png,
|
|
152
|
+
returnedPngChunkTags
|
|
153
|
+
);
|
|
154
|
+
|
|
155
|
+
return tags;
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
return deps.objectAssign({}, tags, returnedPngChunkTags);
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
if (step.type === 'processPngTextReadTags') {
|
|
162
|
+
return addPngTextReadTagsToTagsAndGroups({
|
|
163
|
+
readTags: step.readTags,
|
|
164
|
+
parsedGroups,
|
|
165
|
+
expanded,
|
|
166
|
+
tagFilter,
|
|
167
|
+
tags,
|
|
168
|
+
deps,
|
|
169
|
+
});
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
if (step.type === 'processPngTextReadTagsDeferredList') {
|
|
173
|
+
const tagList = deferredResults[step.deferredKey] || [];
|
|
174
|
+
|
|
175
|
+
for (let i = 0; i < tagList.length; i++) {
|
|
176
|
+
tags = addPngTextReadTagsToTagsAndGroups({
|
|
177
|
+
readTags: tagList[i],
|
|
178
|
+
parsedGroups,
|
|
179
|
+
expanded,
|
|
180
|
+
tagFilter,
|
|
181
|
+
tags,
|
|
182
|
+
deps,
|
|
183
|
+
});
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
return tags;
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
if (step.type === 'gps') {
|
|
190
|
+
if (
|
|
191
|
+
expanded
|
|
192
|
+
&& tagFilter.shouldReturnGroup('gps')
|
|
193
|
+
&& parsedGroups.exif
|
|
194
|
+
) {
|
|
195
|
+
const gpsGroup = deps.getGpsGroupFromExifTags(parsedGroups.exif);
|
|
196
|
+
if (gpsGroup) {
|
|
197
|
+
const returnedGpsGroup =
|
|
198
|
+
deps.filterTagsForReturn('gps', gpsGroup, tagFilter);
|
|
199
|
+
tags.gps = returnedGpsGroup;
|
|
200
|
+
}
|
|
201
|
+
}
|
|
202
|
+
|
|
203
|
+
return tags;
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
if (step.type === 'composite') {
|
|
207
|
+
if (!tagFilter.shouldReturnGroup('composite')) {
|
|
208
|
+
return tags;
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
let compositeInput = tags;
|
|
212
|
+
let compositeInputExpanded = expanded;
|
|
213
|
+
if (tagFilter.isActive) {
|
|
214
|
+
compositeInput = {exif: parsedGroups.exif, file: parsedGroups.file};
|
|
215
|
+
compositeInputExpanded = true;
|
|
216
|
+
}
|
|
217
|
+
|
|
218
|
+
const composite = deps.Composite.get(compositeInput, compositeInputExpanded);
|
|
219
|
+
if (!composite) {
|
|
220
|
+
return tags;
|
|
221
|
+
}
|
|
222
|
+
|
|
223
|
+
const returnedCompositeTags =
|
|
224
|
+
deps.filterTagsForReturn('composite', composite, tagFilter);
|
|
225
|
+
|
|
226
|
+
return mergeAssignGroup(
|
|
227
|
+
tags,
|
|
228
|
+
'composite',
|
|
229
|
+
returnedCompositeTags,
|
|
230
|
+
expanded,
|
|
231
|
+
deps
|
|
232
|
+
);
|
|
233
|
+
}
|
|
234
|
+
|
|
235
|
+
if (step.type === 'thumbnail') {
|
|
236
|
+
if (
|
|
237
|
+
!tagFilter.shouldReturnGroup('thumbnail')
|
|
238
|
+
|| !tagFilter.shouldReturnTag('thumbnail', 'Thumbnail')
|
|
239
|
+
) {
|
|
240
|
+
delete tags.Thumbnail;
|
|
241
|
+
|
|
242
|
+
return tags;
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
if (!thumbnailIfdTags) {
|
|
246
|
+
return tags;
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
const parsedThumbnailIfdTags = thumbnailIfdTags ? deps.filterTagsForParse(
|
|
250
|
+
'thumbnail',
|
|
251
|
+
thumbnailIfdTags,
|
|
252
|
+
tagFilter
|
|
253
|
+
) : undefined;
|
|
254
|
+
if (parsedThumbnailIfdTags) {
|
|
255
|
+
parsedGroups.thumbnail = parsedThumbnailIfdTags;
|
|
256
|
+
}
|
|
257
|
+
|
|
258
|
+
const thumbnail = (deps.Constants.USE_JPEG || deps.Constants.USE_WEBP)
|
|
259
|
+
&& deps.Constants.USE_EXIF
|
|
260
|
+
&& deps.Constants.USE_THUMBNAIL
|
|
261
|
+
&& deps.Thumbnail.get(dataView, parsedThumbnailIfdTags, tiffHeaderOffset);
|
|
262
|
+
if (thumbnail) {
|
|
263
|
+
tags.Thumbnail = thumbnail;
|
|
264
|
+
} else {
|
|
265
|
+
delete tags.Thumbnail;
|
|
266
|
+
}
|
|
267
|
+
|
|
268
|
+
return tags;
|
|
269
|
+
}
|
|
270
|
+
|
|
271
|
+
if (step.type === 'fileType') {
|
|
272
|
+
if (
|
|
273
|
+
fileType
|
|
274
|
+
&& tagFilter.shouldReturnGroup('file')
|
|
275
|
+
&& tagFilter.shouldReturnTag('file', 'FileType')
|
|
276
|
+
) {
|
|
277
|
+
if (expanded) {
|
|
278
|
+
if (!tags.file) {
|
|
279
|
+
tags.file = {};
|
|
280
|
+
}
|
|
281
|
+
tags.file.FileType = fileType;
|
|
282
|
+
} else {
|
|
283
|
+
tags.FileType = fileType;
|
|
284
|
+
}
|
|
285
|
+
}
|
|
286
|
+
|
|
287
|
+
return tags;
|
|
288
|
+
}
|
|
289
|
+
|
|
290
|
+
return tags;
|
|
291
|
+
}
|
|
292
|
+
|
|
293
|
+
export function mergeAssignGroup(tags, groupKey, returnedTags, expanded, deps) {
|
|
294
|
+
if (expanded) {
|
|
295
|
+
tags[groupKey] = returnedTags;
|
|
296
|
+
|
|
297
|
+
return tags;
|
|
298
|
+
}
|
|
299
|
+
|
|
300
|
+
return deps.objectAssign({}, tags, returnedTags);
|
|
301
|
+
}
|
|
302
|
+
|
|
303
|
+
export function mergeMergeGroup(tags, groupKey, returnedTags, expanded, deps) {
|
|
304
|
+
if (expanded) {
|
|
305
|
+
if (!tags[groupKey]) {
|
|
306
|
+
tags[groupKey] = returnedTags;
|
|
307
|
+
} else {
|
|
308
|
+
tags[groupKey] = deps.objectAssign({}, tags[groupKey], returnedTags);
|
|
309
|
+
}
|
|
310
|
+
|
|
311
|
+
return tags;
|
|
312
|
+
}
|
|
313
|
+
|
|
314
|
+
return deps.objectAssign({}, tags, returnedTags);
|
|
315
|
+
}
|
|
316
|
+
|
|
317
|
+
export function addPngTextReadTagsToTagsAndGroups({
|
|
318
|
+
readTags,
|
|
319
|
+
parsedGroups,
|
|
320
|
+
expanded,
|
|
321
|
+
tagFilter,
|
|
322
|
+
tags,
|
|
323
|
+
deps,
|
|
324
|
+
}) {
|
|
325
|
+
const embeddedExifTags = readTags.__exif;
|
|
326
|
+
const embeddedIptcTags = readTags.__iptc;
|
|
327
|
+
delete readTags.__exif;
|
|
328
|
+
delete readTags.__iptc;
|
|
329
|
+
|
|
330
|
+
if (embeddedExifTags) {
|
|
331
|
+
const parsedEmbeddedExifTags =
|
|
332
|
+
deps.filterTagsForParse('exif', embeddedExifTags, tagFilter);
|
|
333
|
+
parsedGroups.exif = !parsedGroups.exif ? parsedEmbeddedExifTags : deps.objectAssign(
|
|
334
|
+
{},
|
|
335
|
+
parsedGroups.exif,
|
|
336
|
+
parsedEmbeddedExifTags
|
|
337
|
+
);
|
|
338
|
+
|
|
339
|
+
if (tagFilter.shouldReturnGroup('exif')) {
|
|
340
|
+
const returnedEmbeddedExifTags = deps.filterTagsForReturn(
|
|
341
|
+
'exif',
|
|
342
|
+
parsedEmbeddedExifTags,
|
|
343
|
+
tagFilter
|
|
344
|
+
);
|
|
345
|
+
if (expanded) {
|
|
346
|
+
tags.exif = !tags.exif ? returnedEmbeddedExifTags : deps.objectAssign(
|
|
347
|
+
{},
|
|
348
|
+
tags.exif,
|
|
349
|
+
returnedEmbeddedExifTags
|
|
350
|
+
);
|
|
351
|
+
} else {
|
|
352
|
+
tags = deps.objectAssign({}, tags, returnedEmbeddedExifTags);
|
|
353
|
+
}
|
|
354
|
+
}
|
|
355
|
+
}
|
|
356
|
+
|
|
357
|
+
if (embeddedIptcTags) {
|
|
358
|
+
const parsedEmbeddedIptcTags =
|
|
359
|
+
deps.filterTagsForParse('iptc', embeddedIptcTags, tagFilter);
|
|
360
|
+
parsedGroups.iptc = !parsedGroups.iptc ? parsedEmbeddedIptcTags : deps.objectAssign(
|
|
361
|
+
{},
|
|
362
|
+
parsedGroups.iptc,
|
|
363
|
+
parsedEmbeddedIptcTags
|
|
364
|
+
);
|
|
365
|
+
|
|
366
|
+
if (tagFilter.shouldReturnGroup('iptc')) {
|
|
367
|
+
const returnedEmbeddedIptcTags = deps.filterTagsForReturn(
|
|
368
|
+
'iptc',
|
|
369
|
+
parsedEmbeddedIptcTags,
|
|
370
|
+
tagFilter
|
|
371
|
+
);
|
|
372
|
+
if (expanded) {
|
|
373
|
+
tags.iptc = !tags.iptc ? returnedEmbeddedIptcTags : deps.objectAssign(
|
|
374
|
+
{},
|
|
375
|
+
tags.iptc,
|
|
376
|
+
returnedEmbeddedIptcTags
|
|
377
|
+
);
|
|
378
|
+
} else {
|
|
379
|
+
tags = deps.objectAssign({}, tags, returnedEmbeddedIptcTags);
|
|
380
|
+
}
|
|
381
|
+
}
|
|
382
|
+
}
|
|
383
|
+
|
|
384
|
+
if (tagFilter.shouldReturnGroup('png')) {
|
|
385
|
+
const parsedPngTextTags = deps.filterTagsForParse('png', readTags, tagFilter);
|
|
386
|
+
const returnedPngTextTags =
|
|
387
|
+
deps.filterTagsForReturn('png', parsedPngTextTags, tagFilter);
|
|
388
|
+
parsedGroups.pngText = parsedPngTextTags;
|
|
389
|
+
|
|
390
|
+
if (expanded) {
|
|
391
|
+
tags.png = !tags.png ? returnedPngTextTags : deps.objectAssign(
|
|
392
|
+
{},
|
|
393
|
+
tags.png,
|
|
394
|
+
returnedPngTextTags
|
|
395
|
+
);
|
|
396
|
+
// Historical behavior in build fixtures:
|
|
397
|
+
// - if PNG text chunks yield actual "png" tags, `pngText` should contain only those
|
|
398
|
+
// - otherwise (e.g. only embedded Exif/IPTC), `pngText` should represent the full `png` group
|
|
399
|
+
// and will be filled in later as a fallback from `tags.png`
|
|
400
|
+
if (returnedPngTextTags && Object.keys(returnedPngTextTags).length > 0) {
|
|
401
|
+
tags.pngText = !tags.pngText ? returnedPngTextTags : deps.objectAssign(
|
|
402
|
+
{},
|
|
403
|
+
tags.pngText,
|
|
404
|
+
returnedPngTextTags
|
|
405
|
+
);
|
|
406
|
+
}
|
|
407
|
+
} else {
|
|
408
|
+
tags = deps.objectAssign({}, tags, returnedPngTextTags);
|
|
409
|
+
}
|
|
410
|
+
}
|
|
411
|
+
|
|
412
|
+
return tags;
|
|
413
|
+
}
|
|
414
|
+
|
|
415
|
+
export function isThenable(value) {
|
|
416
|
+
return !!value && typeof value.then === 'function';
|
|
417
|
+
}
|
package/src/mpf-tags.js
CHANGED
|
@@ -14,7 +14,13 @@ export default {
|
|
|
14
14
|
|
|
15
15
|
const ENTRY_SIZE = 16;
|
|
16
16
|
|
|
17
|
-
function read(
|
|
17
|
+
function read(
|
|
18
|
+
dataView,
|
|
19
|
+
dataOffset,
|
|
20
|
+
includeUnknown,
|
|
21
|
+
computed = false,
|
|
22
|
+
tagFilter = undefined
|
|
23
|
+
) {
|
|
18
24
|
const byteOrder = ByteOrder.getByteOrder(dataView, dataOffset);
|
|
19
25
|
const tags = readIfd(
|
|
20
26
|
dataView,
|
|
@@ -23,7 +29,9 @@ function read(dataView, dataOffset, includeUnknown, computed = false) {
|
|
|
23
29
|
get0thIfdOffset(dataView, dataOffset, byteOrder),
|
|
24
30
|
byteOrder,
|
|
25
31
|
includeUnknown,
|
|
26
|
-
computed
|
|
32
|
+
computed,
|
|
33
|
+
tagFilter,
|
|
34
|
+
'mpf'
|
|
27
35
|
);
|
|
28
36
|
return addMpfImages(dataView, dataOffset, tags, byteOrder);
|
|
29
37
|
}
|
package/src/pentax-tags.js
CHANGED
|
@@ -31,7 +31,14 @@ export default {
|
|
|
31
31
|
LIK3III
|
|
32
32
|
};
|
|
33
33
|
|
|
34
|
-
function read(
|
|
34
|
+
function read(
|
|
35
|
+
dataView,
|
|
36
|
+
tiffHeaderOffset,
|
|
37
|
+
offset,
|
|
38
|
+
includeUnknown,
|
|
39
|
+
computed = false,
|
|
40
|
+
tagFilter = undefined
|
|
41
|
+
) {
|
|
35
42
|
// Pentax does not use the standard TIFF header offset as base for tag
|
|
36
43
|
// offsets but instead uses the start of the IFD, i.e. directly after the
|
|
37
44
|
// two byte order bytes. originOffset below is this offset.
|
|
@@ -44,7 +51,9 @@ function read(dataView, tiffHeaderOffset, offset, includeUnknown, computed = fal
|
|
|
44
51
|
originOffset + PENTAX_IFD_OFFSET,
|
|
45
52
|
byteOrder,
|
|
46
53
|
includeUnknown,
|
|
47
|
-
computed
|
|
54
|
+
computed,
|
|
55
|
+
tagFilter,
|
|
56
|
+
'makerNotes'
|
|
48
57
|
);
|
|
49
58
|
|
|
50
59
|
if (hasLevelInfoK3III(tags)) {
|
package/src/photoshop-tags.js
CHANGED
|
@@ -7,6 +7,7 @@
|
|
|
7
7
|
import {getDataView, getStringFromDataView, getPascalStringFromDataView} from './utils.js';
|
|
8
8
|
import Types from './types.js';
|
|
9
9
|
import TagNames from './photoshop-tag-names.js';
|
|
10
|
+
import {NOOP_TAG_FILTER} from './tag-filter.js';
|
|
10
11
|
|
|
11
12
|
export default {
|
|
12
13
|
read
|
|
@@ -18,7 +19,7 @@ const RESOURCE_LENGTH_SIZE = 4;
|
|
|
18
19
|
|
|
19
20
|
const SIGNATURE_SIZE = SIGNATURE.length;
|
|
20
21
|
|
|
21
|
-
function read(bytes, includeUnknown) {
|
|
22
|
+
function read(bytes, includeUnknown, tagFilter = NOOP_TAG_FILTER) {
|
|
22
23
|
const dataView = getDataView(new Uint8Array(bytes).buffer);
|
|
23
24
|
const tags = {};
|
|
24
25
|
let offset = 0;
|
|
@@ -33,6 +34,12 @@ function read(bytes, includeUnknown) {
|
|
|
33
34
|
const resourceSize = Types.getLongAt(dataView, offset);
|
|
34
35
|
offset += RESOURCE_LENGTH_SIZE;
|
|
35
36
|
if (signature === SIGNATURE) {
|
|
37
|
+
const resolvedTagName = getTagNameForFiltering(tagId, tagName, includeUnknown);
|
|
38
|
+
if (!tagFilter.shouldParseTag('photoshop', resolvedTagName, tagId)) {
|
|
39
|
+
offset += resourceSize + (resourceSize % 2);
|
|
40
|
+
continue;
|
|
41
|
+
}
|
|
42
|
+
|
|
36
43
|
const valueDataView = getDataView(dataView.buffer, offset, resourceSize);
|
|
37
44
|
const tag = {
|
|
38
45
|
id: tagId,
|
|
@@ -55,6 +62,22 @@ function read(bytes, includeUnknown) {
|
|
|
55
62
|
return tags;
|
|
56
63
|
}
|
|
57
64
|
|
|
65
|
+
function getTagNameForFiltering(tagId, tagName, includeUnknown) {
|
|
66
|
+
if (tagName) {
|
|
67
|
+
return tagName;
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
if (TagNames[tagId] && TagNames[tagId].name) {
|
|
71
|
+
return TagNames[tagId].name;
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
if (includeUnknown) {
|
|
75
|
+
return `undefined-${tagId}`;
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
return undefined;
|
|
79
|
+
}
|
|
80
|
+
|
|
58
81
|
function getTagName(dataView, offset) {
|
|
59
82
|
// The name is encoded as a Pascal string (the string is prefixed with one
|
|
60
83
|
// byte containing the length of the string) and everything is padded with a
|
package/src/png-text-tags.js
CHANGED
|
@@ -10,6 +10,7 @@ import {TYPE_TEXT, TYPE_ITXT, TYPE_ZTXT} from './image-header-png.js';
|
|
|
10
10
|
import Tags from './tags.js';
|
|
11
11
|
import IptcTags from './iptc-tags.js';
|
|
12
12
|
import Constants from './constants.js';
|
|
13
|
+
import {NOOP_TAG_FILTER} from './tag-filter.js';
|
|
13
14
|
|
|
14
15
|
export default {
|
|
15
16
|
read
|
|
@@ -24,9 +25,17 @@ const COMPRESSION_SECTION_ITXT_EXTRA_BYTE = 1;
|
|
|
24
25
|
const COMPRESSION_FLAG_COMPRESSED = 1;
|
|
25
26
|
const EXIF_OFFSET = 6;
|
|
26
27
|
|
|
27
|
-
function read(
|
|
28
|
+
function read(
|
|
29
|
+
dataView,
|
|
30
|
+
pngTextChunks,
|
|
31
|
+
async,
|
|
32
|
+
includeUnknown,
|
|
33
|
+
computed = false,
|
|
34
|
+
tagFilter = NOOP_TAG_FILTER
|
|
35
|
+
) {
|
|
28
36
|
const tags = {};
|
|
29
37
|
const tagsPromises = [];
|
|
38
|
+
|
|
30
39
|
for (let i = 0; i < pngTextChunks.length; i++) {
|
|
31
40
|
const {offset, length, type} = pngTextChunks[i];
|
|
32
41
|
const nameAndValue = getNameAndValue(dataView, offset, length, type, async);
|
|
@@ -34,19 +43,34 @@ function read(dataView, pngTextChunks, async, includeUnknown, computed = false)
|
|
|
34
43
|
tagsPromises.push(nameAndValue.then(({name, value, description}) => {
|
|
35
44
|
try {
|
|
36
45
|
if (Constants.USE_EXIF && isExifGroupTag(name, value)) {
|
|
46
|
+
if (!tagFilter.shouldParseGroup('exif')) {
|
|
47
|
+
return {};
|
|
48
|
+
}
|
|
37
49
|
return {
|
|
38
50
|
__exif: Tags.read(
|
|
39
51
|
decodeRawData(value),
|
|
40
52
|
EXIF_OFFSET,
|
|
41
53
|
includeUnknown,
|
|
42
|
-
computed
|
|
54
|
+
computed,
|
|
55
|
+
tagFilter
|
|
43
56
|
).tags
|
|
44
57
|
};
|
|
45
58
|
} else if (Constants.USE_IPTC && isIptcGroupTag(name, value)) {
|
|
59
|
+
if (!tagFilter.shouldParseGroup('iptc')) {
|
|
60
|
+
return {};
|
|
61
|
+
}
|
|
46
62
|
return {
|
|
47
|
-
__iptc: IptcTags.read(
|
|
63
|
+
__iptc: IptcTags.read(
|
|
64
|
+
decodeRawData(value),
|
|
65
|
+
0,
|
|
66
|
+
includeUnknown,
|
|
67
|
+
tagFilter
|
|
68
|
+
)
|
|
48
69
|
};
|
|
49
70
|
} else if (name && !isExifGroupTag(name, value) && !isIptcGroupTag(name, value)) {
|
|
71
|
+
if (!tagFilter.shouldParseGroup('png')) {
|
|
72
|
+
return {};
|
|
73
|
+
}
|
|
50
74
|
return {
|
|
51
75
|
[name]: {
|
|
52
76
|
value,
|
|
@@ -61,7 +85,7 @@ function read(dataView, pngTextChunks, async, includeUnknown, computed = false)
|
|
|
61
85
|
}));
|
|
62
86
|
} else {
|
|
63
87
|
const {name, value, description} = nameAndValue;
|
|
64
|
-
if (name) {
|
|
88
|
+
if (name && tagFilter.shouldParseGroup('png')) {
|
|
65
89
|
tags[name] = {
|
|
66
90
|
value,
|
|
67
91
|
description
|