exifreader 4.33.1 → 4.35.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 +37 -0
- package/dist/exif-reader.js +1 -1
- package/dist/exif-reader.js.map +1 -1
- package/exif-reader.d.ts +13 -5
- package/package.json +4 -4
- package/src/canon-tags.js +2 -2
- package/src/exif-reader.js +25 -5
- package/src/image-header-jpeg.js +135 -1
- package/src/image-header-tiff.js +1 -3
- package/src/mpf-tags.js +10 -2
- package/src/pentax-tags.js +10 -2
- package/src/png-text-tags.js +8 -2
- package/src/tags-helpers.js +72 -4
- package/src/tags.js +46 -13
- package/src/tiff-constants.js +25 -0
package/exif-reader.d.ts
CHANGED
|
@@ -138,19 +138,20 @@ interface NumberArrayFileTag {
|
|
|
138
138
|
value: Array<number>
|
|
139
139
|
}
|
|
140
140
|
|
|
141
|
-
type TypedTag<V> = {
|
|
141
|
+
type TypedTag<V, C = V> = {
|
|
142
142
|
id: number,
|
|
143
143
|
description: string,
|
|
144
|
+
computed?: C,
|
|
144
145
|
value: V
|
|
145
146
|
}
|
|
146
147
|
|
|
147
|
-
type RationalTag = TypedTag<[number, number]>
|
|
148
|
+
type RationalTag = TypedTag<[number, number], number | null>
|
|
148
149
|
|
|
149
150
|
type NumberTag = TypedTag<number>;
|
|
150
151
|
|
|
151
152
|
type NumberArrayTag = TypedTag<number[]>
|
|
152
153
|
|
|
153
|
-
type StringArrayTag = TypedTag<string[]>
|
|
154
|
+
type StringArrayTag = TypedTag<string[], string | string[]>
|
|
154
155
|
|
|
155
156
|
type StringTag = TypedTag<string>;
|
|
156
157
|
|
|
@@ -310,6 +311,7 @@ interface XmlDomParser {
|
|
|
310
311
|
|
|
311
312
|
type CommonOptions = {
|
|
312
313
|
includeUnknown?: boolean,
|
|
314
|
+
computed?: boolean,
|
|
313
315
|
domParser?: XmlDomParser
|
|
314
316
|
};
|
|
315
317
|
|
|
@@ -445,9 +447,15 @@ interface ExifTags {
|
|
|
445
447
|
// GPS tags
|
|
446
448
|
'GPSVersionID'?: NumberTag,
|
|
447
449
|
'GPSLatitudeRef'?: StringArrayTag,
|
|
448
|
-
'GPSLatitude'?: TypedTag<
|
|
450
|
+
'GPSLatitude'?: TypedTag<
|
|
451
|
+
[[number, number], [number, number], [number, number]],
|
|
452
|
+
[number | null, number | null, number | null]
|
|
453
|
+
>,
|
|
449
454
|
'GPSLongitudeRef'?: StringArrayTag,
|
|
450
|
-
'GPSLongitude'?: TypedTag<
|
|
455
|
+
'GPSLongitude'?: TypedTag<
|
|
456
|
+
[[number, number], [number, number], [number, number]],
|
|
457
|
+
[number | null, number | null, number | null]
|
|
458
|
+
>,
|
|
451
459
|
'GPSAltitudeRef'?: NumberTag,
|
|
452
460
|
'GPSAltitude'?: RationalTag,
|
|
453
461
|
'GPSTimeStamp'?: NumberArrayTag,
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "exifreader",
|
|
3
|
-
"version": "4.
|
|
3
|
+
"version": "4.35.0",
|
|
4
4
|
"description": "Library that parses Exif metadata in images.",
|
|
5
5
|
"author": "Mattias Wallander <mattias@wallander.eu>",
|
|
6
6
|
"repository": {
|
|
@@ -28,7 +28,7 @@
|
|
|
28
28
|
"@babel/core": "^7.25.2",
|
|
29
29
|
"@babel/preset-env": "^7.25.4",
|
|
30
30
|
"@babel/register": "^7.24.6",
|
|
31
|
-
"@types/node": "^
|
|
31
|
+
"@types/node": "^25.0.1",
|
|
32
32
|
"babel-loader": "^10.0.0",
|
|
33
33
|
"babel-plugin-rewire": "^1.2.0",
|
|
34
34
|
"chai": "^4.3.10",
|
|
@@ -45,7 +45,7 @@
|
|
|
45
45
|
"string-replace-loader": "^3.1.0",
|
|
46
46
|
"terser-webpack-plugin": "^5.3.10",
|
|
47
47
|
"typescript": "^5.6.2",
|
|
48
|
-
"webpack": "5.
|
|
48
|
+
"webpack": "5.104.1",
|
|
49
49
|
"webpack-cli": "^5.1.4",
|
|
50
50
|
"webpack-dev-server": "^5.0.4"
|
|
51
51
|
},
|
|
@@ -70,7 +70,7 @@
|
|
|
70
70
|
"nyc": {
|
|
71
71
|
"check-coverage": true,
|
|
72
72
|
"statements": 93,
|
|
73
|
-
"branches":
|
|
73
|
+
"branches": 87,
|
|
74
74
|
"functions": 97,
|
|
75
75
|
"lines": 93,
|
|
76
76
|
"reporter": [
|
package/src/canon-tags.js
CHANGED
|
@@ -20,8 +20,8 @@ export default {
|
|
|
20
20
|
SHOT_INFO_AUTO_ROTATE
|
|
21
21
|
};
|
|
22
22
|
|
|
23
|
-
function read(dataView, tiffHeaderOffset, offset, byteOrder, includeUnknown) {
|
|
24
|
-
let tags = readIfd(dataView, IFD_TYPE_CANON, tiffHeaderOffset, tiffHeaderOffset + offset, byteOrder, includeUnknown);
|
|
23
|
+
function read(dataView, tiffHeaderOffset, offset, byteOrder, includeUnknown, computed = false) {
|
|
24
|
+
let tags = readIfd(dataView, IFD_TYPE_CANON, tiffHeaderOffset, tiffHeaderOffset + offset, byteOrder, includeUnknown, computed);
|
|
25
25
|
|
|
26
26
|
if (tags['ShotInfo']) {
|
|
27
27
|
tags = objectAssign({}, tags, parseShotInfo(tags['ShotInfo'].value));
|
package/src/exif-reader.js
CHANGED
|
@@ -209,11 +209,13 @@ export function loadView(
|
|
|
209
209
|
{
|
|
210
210
|
expanded = false,
|
|
211
211
|
async = false,
|
|
212
|
+
computed = false,
|
|
212
213
|
includeUnknown = false,
|
|
213
214
|
domParser = undefined,
|
|
214
215
|
} = {
|
|
215
216
|
expanded: false,
|
|
216
217
|
async: false,
|
|
218
|
+
computed: false,
|
|
217
219
|
includeUnknown: false,
|
|
218
220
|
domParser: undefined,
|
|
219
221
|
}
|
|
@@ -260,7 +262,12 @@ export function loadView(
|
|
|
260
262
|
|
|
261
263
|
if (Constants.USE_EXIF && hasExifData(tiffHeaderOffset)) {
|
|
262
264
|
foundMetaData = true;
|
|
263
|
-
const {tags: readTags, byteOrder} = Tags.read(
|
|
265
|
+
const {tags: readTags, byteOrder} = Tags.read(
|
|
266
|
+
dataView,
|
|
267
|
+
tiffHeaderOffset,
|
|
268
|
+
includeUnknown,
|
|
269
|
+
computed
|
|
270
|
+
);
|
|
264
271
|
if (readTags.Thumbnail) {
|
|
265
272
|
tags.Thumbnail = readTags.Thumbnail;
|
|
266
273
|
delete readTags.Thumbnail;
|
|
@@ -320,14 +327,27 @@ export function loadView(
|
|
|
320
327
|
|
|
321
328
|
if (Constants.USE_MAKER_NOTES && readTags['MakerNote']) {
|
|
322
329
|
if (hasCanonData(readTags)) {
|
|
323
|
-
const readCanonTags = CanonTags.read(
|
|
330
|
+
const readCanonTags = CanonTags.read(
|
|
331
|
+
dataView,
|
|
332
|
+
tiffHeaderOffset,
|
|
333
|
+
readTags['MakerNote'].__offset,
|
|
334
|
+
byteOrder,
|
|
335
|
+
includeUnknown,
|
|
336
|
+
computed
|
|
337
|
+
);
|
|
324
338
|
if (expanded) {
|
|
325
339
|
tags.makerNotes = readCanonTags;
|
|
326
340
|
} else {
|
|
327
341
|
tags = objectAssign({}, tags, readCanonTags);
|
|
328
342
|
}
|
|
329
343
|
} else if (hasPentaxType1Data(readTags)) {
|
|
330
|
-
const readPentaxTags = PentaxTags.read(
|
|
344
|
+
const readPentaxTags = PentaxTags.read(
|
|
345
|
+
dataView,
|
|
346
|
+
tiffHeaderOffset,
|
|
347
|
+
readTags['MakerNote'].__offset,
|
|
348
|
+
includeUnknown,
|
|
349
|
+
computed
|
|
350
|
+
);
|
|
331
351
|
if (expanded) {
|
|
332
352
|
tags.makerNotes = readPentaxTags;
|
|
333
353
|
} else {
|
|
@@ -374,7 +394,7 @@ export function loadView(
|
|
|
374
394
|
|
|
375
395
|
if (Constants.USE_MPF && hasMpfData(mpfDataOffset)) {
|
|
376
396
|
foundMetaData = true;
|
|
377
|
-
const readMpfTags = MpfTags.read(dataView, mpfDataOffset, includeUnknown);
|
|
397
|
+
const readMpfTags = MpfTags.read(dataView, mpfDataOffset, includeUnknown, computed);
|
|
378
398
|
if (expanded) {
|
|
379
399
|
tags.mpf = readMpfTags;
|
|
380
400
|
} else {
|
|
@@ -395,7 +415,7 @@ export function loadView(
|
|
|
395
415
|
|
|
396
416
|
if (Constants.USE_PNG && hasPngTextData(pngTextChunks)) {
|
|
397
417
|
foundMetaData = true;
|
|
398
|
-
const {readTags, readTagsPromise} = PngTextTags.read(dataView, pngTextChunks, async, includeUnknown);
|
|
418
|
+
const {readTags, readTagsPromise} = PngTextTags.read(dataView, pngTextChunks, async, includeUnknown, computed);
|
|
399
419
|
addPngTextTags(readTags);
|
|
400
420
|
if (readTagsPromise) {
|
|
401
421
|
tagsPromises.push(readTagsPromise.then((tagList) => tagList.forEach(addPngTextTags)));
|
package/src/image-header-jpeg.js
CHANGED
|
@@ -4,6 +4,17 @@
|
|
|
4
4
|
|
|
5
5
|
import {getStringFromDataView} from './utils.js';
|
|
6
6
|
import Constants from './constants.js';
|
|
7
|
+
import ByteOrder from './byte-order.js';
|
|
8
|
+
import {
|
|
9
|
+
IFD_ENTRY_COUNT_LENGTH,
|
|
10
|
+
IFD_ENTRY_LENGTH,
|
|
11
|
+
NEXT_IFD_POINTER_LENGTH,
|
|
12
|
+
TIFF_BYTE_ORDER_OFFSET,
|
|
13
|
+
TIFF_HEADER_LENGTH,
|
|
14
|
+
TIFF_ID,
|
|
15
|
+
TIFF_ID_OFFSET,
|
|
16
|
+
TIFF_IFD_OFFSET_OFFSET,
|
|
17
|
+
} from './tiff-constants.js';
|
|
7
18
|
|
|
8
19
|
export default {
|
|
9
20
|
isJpegFile,
|
|
@@ -68,6 +79,11 @@ function findJpegOffsets(dataView) {
|
|
|
68
79
|
let xmpChunks;
|
|
69
80
|
let iccChunks;
|
|
70
81
|
let mpfDataOffset;
|
|
82
|
+
let exifSegmentCount = 0;
|
|
83
|
+
let bestExifSegmentScore;
|
|
84
|
+
let bestExifSegmentTiffHeaderOffset;
|
|
85
|
+
let bestExifSegmentAppMarkerPosition;
|
|
86
|
+
let bestExifSegmentFieldLength;
|
|
71
87
|
|
|
72
88
|
while (appMarkerPosition + APP_ID_OFFSET + 5 <= dataView.byteLength) {
|
|
73
89
|
if (Constants.USE_FILE && isSOF0Marker(dataView, appMarkerPosition)) {
|
|
@@ -81,7 +97,50 @@ function findJpegOffsets(dataView) {
|
|
|
81
97
|
jfifDataOffset = appMarkerPosition + JFIF_DATA_OFFSET;
|
|
82
98
|
} else if (Constants.USE_EXIF && isApp1ExifMarker(dataView, appMarkerPosition)) {
|
|
83
99
|
fieldLength = dataView.getUint16(appMarkerPosition + APP_MARKER_SIZE);
|
|
84
|
-
|
|
100
|
+
exifSegmentCount++;
|
|
101
|
+
|
|
102
|
+
const currentTiffHeaderOffset = appMarkerPosition + TIFF_HEADER_OFFSET;
|
|
103
|
+
|
|
104
|
+
if (exifSegmentCount === 1) {
|
|
105
|
+
bestExifSegmentTiffHeaderOffset = currentTiffHeaderOffset;
|
|
106
|
+
bestExifSegmentAppMarkerPosition = appMarkerPosition;
|
|
107
|
+
bestExifSegmentFieldLength = fieldLength;
|
|
108
|
+
} else if (exifSegmentCount === 2) {
|
|
109
|
+
bestExifSegmentScore = getExifMarkerScore(
|
|
110
|
+
dataView,
|
|
111
|
+
bestExifSegmentAppMarkerPosition,
|
|
112
|
+
bestExifSegmentFieldLength,
|
|
113
|
+
bestExifSegmentTiffHeaderOffset
|
|
114
|
+
);
|
|
115
|
+
const currentExifSegmentScore = getExifMarkerScore(
|
|
116
|
+
dataView,
|
|
117
|
+
appMarkerPosition,
|
|
118
|
+
fieldLength,
|
|
119
|
+
currentTiffHeaderOffset
|
|
120
|
+
);
|
|
121
|
+
|
|
122
|
+
if (currentExifSegmentScore > bestExifSegmentScore) {
|
|
123
|
+
bestExifSegmentScore = currentExifSegmentScore;
|
|
124
|
+
bestExifSegmentTiffHeaderOffset = currentTiffHeaderOffset;
|
|
125
|
+
bestExifSegmentAppMarkerPosition = appMarkerPosition;
|
|
126
|
+
bestExifSegmentFieldLength = fieldLength;
|
|
127
|
+
}
|
|
128
|
+
} else {
|
|
129
|
+
const currentExifSegmentScore = getExifMarkerScore(
|
|
130
|
+
dataView,
|
|
131
|
+
appMarkerPosition,
|
|
132
|
+
fieldLength,
|
|
133
|
+
currentTiffHeaderOffset
|
|
134
|
+
);
|
|
135
|
+
if (currentExifSegmentScore > bestExifSegmentScore) {
|
|
136
|
+
bestExifSegmentScore = currentExifSegmentScore;
|
|
137
|
+
bestExifSegmentTiffHeaderOffset = currentTiffHeaderOffset;
|
|
138
|
+
bestExifSegmentAppMarkerPosition = appMarkerPosition;
|
|
139
|
+
bestExifSegmentFieldLength = fieldLength;
|
|
140
|
+
}
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
tiffHeaderOffset = bestExifSegmentTiffHeaderOffset;
|
|
85
144
|
} else if (Constants.USE_XMP && isApp1XmpMarker(dataView, appMarkerPosition)) {
|
|
86
145
|
if (!xmpChunks) {
|
|
87
146
|
xmpChunks = [];
|
|
@@ -122,6 +181,10 @@ function findJpegOffsets(dataView) {
|
|
|
122
181
|
appMarkerPosition += APP_MARKER_SIZE + fieldLength;
|
|
123
182
|
}
|
|
124
183
|
|
|
184
|
+
if (exifSegmentCount > 1) {
|
|
185
|
+
warnAboutMultipleExifSegments(exifSegmentCount);
|
|
186
|
+
}
|
|
187
|
+
|
|
125
188
|
return {
|
|
126
189
|
hasAppMarkers: appMarkerPosition > JPEG_ID_SIZE,
|
|
127
190
|
fileDataOffset: sof0DataOffset || sof2DataOffset,
|
|
@@ -229,3 +292,74 @@ function isAppMarker(dataView, appMarkerPosition) {
|
|
|
229
292
|
function isFillByte(dataView, appMarkerPosition) {
|
|
230
293
|
return dataView.getUint16(appMarkerPosition) === FILL_BYTE;
|
|
231
294
|
}
|
|
295
|
+
|
|
296
|
+
function getExifMarkerScore(dataView, appMarkerPosition, fieldLength, tiffHeaderOffset) {
|
|
297
|
+
const segmentEnd = appMarkerPosition + APP_MARKER_SIZE + fieldLength;
|
|
298
|
+
const details = getExifTiffHeaderDetails(dataView, tiffHeaderOffset, segmentEnd);
|
|
299
|
+
if (!details) {
|
|
300
|
+
return 0;
|
|
301
|
+
}
|
|
302
|
+
|
|
303
|
+
const ifdEntriesScore = Number.isInteger(details.ifdEntries) ? details.ifdEntries : 0;
|
|
304
|
+
|
|
305
|
+
return (details.isValid ? 1000000000 : 0)
|
|
306
|
+
+ (ifdEntriesScore * 1000000)
|
|
307
|
+
+ fieldLength;
|
|
308
|
+
}
|
|
309
|
+
|
|
310
|
+
function getExifTiffHeaderDetails(dataView, tiffHeaderOffset, segmentEnd) {
|
|
311
|
+
try {
|
|
312
|
+
if (tiffHeaderOffset + TIFF_HEADER_LENGTH > segmentEnd) {
|
|
313
|
+
return undefined;
|
|
314
|
+
}
|
|
315
|
+
|
|
316
|
+
const byteOrderRaw = dataView.getUint16(
|
|
317
|
+
tiffHeaderOffset + TIFF_BYTE_ORDER_OFFSET
|
|
318
|
+
);
|
|
319
|
+
const isLittleEndian = byteOrderRaw === ByteOrder.LITTLE_ENDIAN;
|
|
320
|
+
if (!isLittleEndian && (byteOrderRaw !== ByteOrder.BIG_ENDIAN)) {
|
|
321
|
+
return undefined;
|
|
322
|
+
}
|
|
323
|
+
|
|
324
|
+
const tiffId = dataView.getUint16(
|
|
325
|
+
tiffHeaderOffset + TIFF_ID_OFFSET,
|
|
326
|
+
isLittleEndian
|
|
327
|
+
);
|
|
328
|
+
if (tiffId !== TIFF_ID) {
|
|
329
|
+
return undefined;
|
|
330
|
+
}
|
|
331
|
+
|
|
332
|
+
const ifdOffset = dataView.getUint32(
|
|
333
|
+
tiffHeaderOffset + TIFF_IFD_OFFSET_OFFSET,
|
|
334
|
+
isLittleEndian
|
|
335
|
+
);
|
|
336
|
+
const ifdEntryCountOffset = tiffHeaderOffset + ifdOffset;
|
|
337
|
+
if (ifdEntryCountOffset + IFD_ENTRY_COUNT_LENGTH > segmentEnd) {
|
|
338
|
+
return undefined;
|
|
339
|
+
}
|
|
340
|
+
|
|
341
|
+
const ifdEntries = dataView.getUint16(ifdEntryCountOffset, isLittleEndian);
|
|
342
|
+
const ifdTotalLength = IFD_ENTRY_COUNT_LENGTH
|
|
343
|
+
+ (ifdEntries * IFD_ENTRY_LENGTH)
|
|
344
|
+
+ NEXT_IFD_POINTER_LENGTH;
|
|
345
|
+
const hasFullIfd = (ifdEntryCountOffset + ifdTotalLength) <= segmentEnd;
|
|
346
|
+
const isValid = hasFullIfd && (ifdEntries > 0);
|
|
347
|
+
|
|
348
|
+
return {ifdEntries, isValid};
|
|
349
|
+
} catch (error) {
|
|
350
|
+
return undefined;
|
|
351
|
+
}
|
|
352
|
+
}
|
|
353
|
+
|
|
354
|
+
function warnAboutMultipleExifSegments(exifSegmentCount) {
|
|
355
|
+
/* eslint-disable no-console */
|
|
356
|
+
if (typeof console === 'undefined' || typeof console.warn !== 'function') {
|
|
357
|
+
return;
|
|
358
|
+
}
|
|
359
|
+
|
|
360
|
+
console.warn(
|
|
361
|
+
`ExifReader: Found ${exifSegmentCount} Exif segments (APP1). `
|
|
362
|
+
+ 'Will pick the best candidate segment.'
|
|
363
|
+
);
|
|
364
|
+
/* eslint-enable no-console */
|
|
365
|
+
}
|
package/src/image-header-tiff.js
CHANGED
|
@@ -4,6 +4,7 @@
|
|
|
4
4
|
|
|
5
5
|
import ByteOrder from './byte-order.js';
|
|
6
6
|
import Constants from './constants.js';
|
|
7
|
+
import {TIFF_ID, TIFF_ID_OFFSET} from './tiff-constants.js';
|
|
7
8
|
|
|
8
9
|
export default {
|
|
9
10
|
isTiffFile,
|
|
@@ -17,9 +18,6 @@ function isTiffFile(dataView) {
|
|
|
17
18
|
}
|
|
18
19
|
|
|
19
20
|
function hasTiffMarker(dataView) {
|
|
20
|
-
const TIFF_ID = 0x2a;
|
|
21
|
-
const TIFF_ID_OFFSET = 2;
|
|
22
|
-
|
|
23
21
|
const littleEndian = dataView.getUint16(0) === ByteOrder.LITTLE_ENDIAN;
|
|
24
22
|
return dataView.getUint16(TIFF_ID_OFFSET, littleEndian) === TIFF_ID;
|
|
25
23
|
}
|
package/src/mpf-tags.js
CHANGED
|
@@ -14,9 +14,17 @@ export default {
|
|
|
14
14
|
|
|
15
15
|
const ENTRY_SIZE = 16;
|
|
16
16
|
|
|
17
|
-
function read(dataView, dataOffset, includeUnknown) {
|
|
17
|
+
function read(dataView, dataOffset, includeUnknown, computed = false) {
|
|
18
18
|
const byteOrder = ByteOrder.getByteOrder(dataView, dataOffset);
|
|
19
|
-
const tags = readIfd(
|
|
19
|
+
const tags = readIfd(
|
|
20
|
+
dataView,
|
|
21
|
+
IFD_TYPE_MPF,
|
|
22
|
+
dataOffset,
|
|
23
|
+
get0thIfdOffset(dataView, dataOffset, byteOrder),
|
|
24
|
+
byteOrder,
|
|
25
|
+
includeUnknown,
|
|
26
|
+
computed
|
|
27
|
+
);
|
|
20
28
|
return addMpfImages(dataView, dataOffset, tags, byteOrder);
|
|
21
29
|
}
|
|
22
30
|
|
package/src/pentax-tags.js
CHANGED
|
@@ -31,13 +31,21 @@ export default {
|
|
|
31
31
|
LIK3III
|
|
32
32
|
};
|
|
33
33
|
|
|
34
|
-
function read(dataView, tiffHeaderOffset, offset, includeUnknown) {
|
|
34
|
+
function read(dataView, tiffHeaderOffset, offset, includeUnknown, computed = false) {
|
|
35
35
|
// Pentax does not use the standard TIFF header offset as base for tag
|
|
36
36
|
// offsets but instead uses the start of the IFD, i.e. directly after the
|
|
37
37
|
// two byte order bytes. originOffset below is this offset.
|
|
38
38
|
const byteOrder = ByteOrder.getByteOrder(dataView, tiffHeaderOffset + offset + BYTE_ORDER_OFFSET);
|
|
39
39
|
const originOffset = tiffHeaderOffset + offset;
|
|
40
|
-
let tags = readIfd(
|
|
40
|
+
let tags = readIfd(
|
|
41
|
+
dataView,
|
|
42
|
+
IFD_TYPE_PENTAX,
|
|
43
|
+
originOffset,
|
|
44
|
+
originOffset + PENTAX_IFD_OFFSET,
|
|
45
|
+
byteOrder,
|
|
46
|
+
includeUnknown,
|
|
47
|
+
computed
|
|
48
|
+
);
|
|
41
49
|
|
|
42
50
|
if (hasLevelInfoK3III(tags)) {
|
|
43
51
|
tags = objectAssign({}, tags, parseLevelInfoK3III(dataView, originOffset + tags['LevelInfo'].__offset, byteOrder));
|
package/src/png-text-tags.js
CHANGED
|
@@ -24,7 +24,7 @@ const COMPRESSION_SECTION_ITXT_EXTRA_BYTE = 1;
|
|
|
24
24
|
const COMPRESSION_FLAG_COMPRESSED = 1;
|
|
25
25
|
const EXIF_OFFSET = 6;
|
|
26
26
|
|
|
27
|
-
function read(dataView, pngTextChunks, async, includeUnknown) {
|
|
27
|
+
function read(dataView, pngTextChunks, async, includeUnknown, computed = false) {
|
|
28
28
|
const tags = {};
|
|
29
29
|
const tagsPromises = [];
|
|
30
30
|
for (let i = 0; i < pngTextChunks.length; i++) {
|
|
@@ -35,7 +35,12 @@ function read(dataView, pngTextChunks, async, includeUnknown) {
|
|
|
35
35
|
try {
|
|
36
36
|
if (Constants.USE_EXIF && isExifGroupTag(name, value)) {
|
|
37
37
|
return {
|
|
38
|
-
__exif: Tags.read(
|
|
38
|
+
__exif: Tags.read(
|
|
39
|
+
decodeRawData(value),
|
|
40
|
+
EXIF_OFFSET,
|
|
41
|
+
includeUnknown,
|
|
42
|
+
computed
|
|
43
|
+
).tags
|
|
39
44
|
};
|
|
40
45
|
} else if (Constants.USE_IPTC && isIptcGroupTag(name, value)) {
|
|
41
46
|
return {
|
|
@@ -151,6 +156,7 @@ function getEncodingFromType(type) {
|
|
|
151
156
|
|
|
152
157
|
function constructTag(valueChars, type, langChars, keywordChars) {
|
|
153
158
|
const value = getValue(valueChars);
|
|
159
|
+
|
|
154
160
|
return {
|
|
155
161
|
name: getName(type, langChars, keywordChars),
|
|
156
162
|
value,
|
package/src/tags-helpers.js
CHANGED
|
@@ -5,6 +5,7 @@
|
|
|
5
5
|
import Constants from './constants.js';
|
|
6
6
|
import Types from './types.js';
|
|
7
7
|
import TagNames, {IFD_TYPE_0TH, IFD_TYPE_1ST, IFD_TYPE_PENTAX} from './tag-names.js';
|
|
8
|
+
import {IFD_ENTRY_LENGTH, TIFF_IFD_OFFSET_OFFSET} from './tiff-constants.js';
|
|
8
9
|
|
|
9
10
|
const getTagValueAt = {
|
|
10
11
|
1: Types.getByteAt,
|
|
@@ -19,12 +20,17 @@ const getTagValueAt = {
|
|
|
19
20
|
};
|
|
20
21
|
|
|
21
22
|
export function get0thIfdOffset(dataView, tiffHeaderOffset, byteOrder) {
|
|
22
|
-
return tiffHeaderOffset
|
|
23
|
+
return tiffHeaderOffset
|
|
24
|
+
+ Types.getLongAt(
|
|
25
|
+
dataView,
|
|
26
|
+
tiffHeaderOffset + TIFF_IFD_OFFSET_OFFSET,
|
|
27
|
+
byteOrder
|
|
28
|
+
);
|
|
23
29
|
}
|
|
24
30
|
|
|
25
|
-
export function readIfd(dataView, ifdType, offsetOrigin, offset, byteOrder, includeUnknown) {
|
|
31
|
+
export function readIfd(dataView, ifdType, offsetOrigin, offset, byteOrder, includeUnknown, computed = false) {
|
|
26
32
|
const FIELD_COUNT_SIZE = Types.getTypeSize('SHORT');
|
|
27
|
-
const FIELD_SIZE =
|
|
33
|
+
const FIELD_SIZE = IFD_ENTRY_LENGTH;
|
|
28
34
|
|
|
29
35
|
const tags = {};
|
|
30
36
|
const numberOfFields = getNumberOfFields(dataView, offset, byteOrder);
|
|
@@ -42,6 +48,9 @@ export function readIfd(dataView, ifdType, offsetOrigin, offset, byteOrder, incl
|
|
|
42
48
|
'value': tag.value,
|
|
43
49
|
'description': tag.description
|
|
44
50
|
};
|
|
51
|
+
if (computed) {
|
|
52
|
+
tags[tag.name].computed = getComputedTagValue(tag.tagType, tag.value);
|
|
53
|
+
}
|
|
45
54
|
if (tag.name === 'MakerNote' || (ifdType === IFD_TYPE_PENTAX && tag.name === 'LevelInfo')) {
|
|
46
55
|
tags[tag.name].__offset = tag.__offset;
|
|
47
56
|
}
|
|
@@ -53,7 +62,15 @@ export function readIfd(dataView, ifdType, offsetOrigin, offset, byteOrder, incl
|
|
|
53
62
|
if (Constants.USE_THUMBNAIL && (offset < dataView.byteLength - Types.getTypeSize('LONG'))) {
|
|
54
63
|
const nextIfdOffset = Types.getLongAt(dataView, offset, byteOrder);
|
|
55
64
|
if (nextIfdOffset !== 0 && ifdType === IFD_TYPE_0TH) {
|
|
56
|
-
tags['Thumbnail'] = readIfd(
|
|
65
|
+
tags['Thumbnail'] = readIfd(
|
|
66
|
+
dataView,
|
|
67
|
+
IFD_TYPE_1ST,
|
|
68
|
+
offsetOrigin,
|
|
69
|
+
offsetOrigin + nextIfdOffset,
|
|
70
|
+
byteOrder,
|
|
71
|
+
includeUnknown,
|
|
72
|
+
computed
|
|
73
|
+
);
|
|
57
74
|
}
|
|
58
75
|
}
|
|
59
76
|
|
|
@@ -126,6 +143,7 @@ function readTag(dataView, ifdType, offsetOrigin, offset, byteOrder, includeUnkn
|
|
|
126
143
|
name: tagName,
|
|
127
144
|
value: tagValue,
|
|
128
145
|
description: tagDescription,
|
|
146
|
+
tagType,
|
|
129
147
|
__offset: tagValueOffset
|
|
130
148
|
};
|
|
131
149
|
}
|
|
@@ -191,3 +209,53 @@ function getDescriptionFromTagValue(tagValue) {
|
|
|
191
209
|
}
|
|
192
210
|
return tagValue;
|
|
193
211
|
}
|
|
212
|
+
|
|
213
|
+
function getComputedTagValue(tagType, value) {
|
|
214
|
+
if (tagType === Types.tagTypes['ASCII']) {
|
|
215
|
+
if (Array.isArray(value) && value.length === 1) {
|
|
216
|
+
return value[0];
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
return value;
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
if (tagType === Types.tagTypes['RATIONAL'] || tagType === Types.tagTypes['SRATIONAL']) {
|
|
223
|
+
if (isSingleRationalValue(value)) {
|
|
224
|
+
return getComputedRationalValue(value);
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
if (Array.isArray(value)) {
|
|
228
|
+
return value.map((rational) => getComputedRationalValue(rational));
|
|
229
|
+
}
|
|
230
|
+
|
|
231
|
+
return value;
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
return value;
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
function isSingleRationalValue(value) {
|
|
238
|
+
if (!Array.isArray(value) || value.length !== 2) {
|
|
239
|
+
return false;
|
|
240
|
+
}
|
|
241
|
+
|
|
242
|
+
return typeof value[0] === 'number' && typeof value[1] === 'number';
|
|
243
|
+
}
|
|
244
|
+
|
|
245
|
+
function getComputedRationalValue(rational) {
|
|
246
|
+
if (!Array.isArray(rational) || rational.length !== 2) {
|
|
247
|
+
return rational;
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
const numerator = rational[0];
|
|
251
|
+
const denominator = rational[1];
|
|
252
|
+
if (!Number.isFinite(numerator) || !Number.isFinite(denominator)) {
|
|
253
|
+
return rational;
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
if (denominator === 0) {
|
|
257
|
+
return null;
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
return numerator / denominator;
|
|
261
|
+
}
|
package/src/tags.js
CHANGED
|
@@ -15,39 +15,72 @@ export default {
|
|
|
15
15
|
read,
|
|
16
16
|
};
|
|
17
17
|
|
|
18
|
-
function read(dataView, tiffHeaderOffset, includeUnknown) {
|
|
18
|
+
function read(dataView, tiffHeaderOffset, includeUnknown, computed = false) {
|
|
19
19
|
const byteOrder = ByteOrder.getByteOrder(dataView, tiffHeaderOffset);
|
|
20
|
-
let tags = read0thIfd(dataView, tiffHeaderOffset, byteOrder, includeUnknown);
|
|
21
|
-
tags = readExifIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown);
|
|
22
|
-
tags = readGpsIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown);
|
|
23
|
-
tags = readInteroperabilityIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown);
|
|
20
|
+
let tags = read0thIfd(dataView, tiffHeaderOffset, byteOrder, includeUnknown, computed);
|
|
21
|
+
tags = readExifIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown, computed);
|
|
22
|
+
tags = readGpsIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown, computed);
|
|
23
|
+
tags = readInteroperabilityIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown, computed);
|
|
24
24
|
|
|
25
25
|
return {tags, byteOrder};
|
|
26
26
|
}
|
|
27
27
|
|
|
28
|
-
function read0thIfd(dataView, tiffHeaderOffset, byteOrder, includeUnknown) {
|
|
29
|
-
return readIfd(dataView, IFD_TYPE_0TH, tiffHeaderOffset, get0thIfdOffset(dataView, tiffHeaderOffset, byteOrder), byteOrder, includeUnknown);
|
|
28
|
+
function read0thIfd(dataView, tiffHeaderOffset, byteOrder, includeUnknown, computed) {
|
|
29
|
+
return readIfd(dataView, IFD_TYPE_0TH, tiffHeaderOffset, get0thIfdOffset(dataView, tiffHeaderOffset, byteOrder), byteOrder, includeUnknown, computed);
|
|
30
30
|
}
|
|
31
31
|
|
|
32
|
-
function readExifIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown) {
|
|
32
|
+
function readExifIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown, computed) {
|
|
33
33
|
if (tags[EXIF_IFD_POINTER_KEY] !== undefined) {
|
|
34
|
-
return objectAssign(
|
|
34
|
+
return objectAssign(
|
|
35
|
+
tags,
|
|
36
|
+
readIfd(
|
|
37
|
+
dataView,
|
|
38
|
+
IFD_TYPE_EXIF,
|
|
39
|
+
tiffHeaderOffset,
|
|
40
|
+
tiffHeaderOffset + tags[EXIF_IFD_POINTER_KEY].value,
|
|
41
|
+
byteOrder,
|
|
42
|
+
includeUnknown,
|
|
43
|
+
computed
|
|
44
|
+
)
|
|
45
|
+
);
|
|
35
46
|
}
|
|
36
47
|
|
|
37
48
|
return tags;
|
|
38
49
|
}
|
|
39
50
|
|
|
40
|
-
function readGpsIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown) {
|
|
51
|
+
function readGpsIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown, computed) {
|
|
41
52
|
if (tags[GPS_INFO_IFD_POINTER_KEY] !== undefined) {
|
|
42
|
-
return objectAssign(
|
|
53
|
+
return objectAssign(
|
|
54
|
+
tags,
|
|
55
|
+
readIfd(
|
|
56
|
+
dataView,
|
|
57
|
+
IFD_TYPE_GPS,
|
|
58
|
+
tiffHeaderOffset,
|
|
59
|
+
tiffHeaderOffset + tags[GPS_INFO_IFD_POINTER_KEY].value,
|
|
60
|
+
byteOrder,
|
|
61
|
+
includeUnknown,
|
|
62
|
+
computed
|
|
63
|
+
)
|
|
64
|
+
);
|
|
43
65
|
}
|
|
44
66
|
|
|
45
67
|
return tags;
|
|
46
68
|
}
|
|
47
69
|
|
|
48
|
-
function readInteroperabilityIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown) {
|
|
70
|
+
function readInteroperabilityIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown, computed) {
|
|
49
71
|
if (tags[INTEROPERABILITY_IFD_POINTER_KEY] !== undefined) {
|
|
50
|
-
return objectAssign(
|
|
72
|
+
return objectAssign(
|
|
73
|
+
tags,
|
|
74
|
+
readIfd(
|
|
75
|
+
dataView,
|
|
76
|
+
IFD_TYPE_INTEROPERABILITY,
|
|
77
|
+
tiffHeaderOffset,
|
|
78
|
+
tiffHeaderOffset + tags[INTEROPERABILITY_IFD_POINTER_KEY].value,
|
|
79
|
+
byteOrder,
|
|
80
|
+
includeUnknown,
|
|
81
|
+
computed
|
|
82
|
+
)
|
|
83
|
+
);
|
|
51
84
|
}
|
|
52
85
|
|
|
53
86
|
return tags;
|
|
@@ -0,0 +1,25 @@
|
|
|
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 const TIFF_BYTE_ORDER_OFFSET = 0;
|
|
6
|
+
export const TIFF_ID_OFFSET = 2;
|
|
7
|
+
export const TIFF_IFD_OFFSET_OFFSET = 4;
|
|
8
|
+
export const TIFF_HEADER_LENGTH = 8;
|
|
9
|
+
|
|
10
|
+
export const TIFF_ID = 0x2a;
|
|
11
|
+
|
|
12
|
+
export const IFD_ENTRY_COUNT_LENGTH = 2;
|
|
13
|
+
export const IFD_ENTRY_LENGTH = 12;
|
|
14
|
+
export const NEXT_IFD_POINTER_LENGTH = 4;
|
|
15
|
+
|
|
16
|
+
export default {
|
|
17
|
+
TIFF_BYTE_ORDER_OFFSET,
|
|
18
|
+
TIFF_ID_OFFSET,
|
|
19
|
+
TIFF_IFD_OFFSET_OFFSET,
|
|
20
|
+
TIFF_HEADER_LENGTH,
|
|
21
|
+
TIFF_ID,
|
|
22
|
+
IFD_ENTRY_COUNT_LENGTH,
|
|
23
|
+
IFD_ENTRY_LENGTH,
|
|
24
|
+
NEXT_IFD_POINTER_LENGTH,
|
|
25
|
+
};
|