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/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<[[number, number], [number, number], [number, number]]>,
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<[[number, number], [number, number], [number, number]]>,
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.33.1",
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": "^24.0.3",
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.103.0",
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": 88,
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));
@@ -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(dataView, tiffHeaderOffset, includeUnknown);
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(dataView, tiffHeaderOffset, readTags['MakerNote'].__offset, byteOrder, includeUnknown);
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(dataView, tiffHeaderOffset, readTags['MakerNote'].__offset, includeUnknown);
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)));
@@ -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
- tiffHeaderOffset = appMarkerPosition + TIFF_HEADER_OFFSET;
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
+ }
@@ -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(dataView, IFD_TYPE_MPF, dataOffset, get0thIfdOffset(dataView, dataOffset, byteOrder), byteOrder, includeUnknown);
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
 
@@ -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(dataView, IFD_TYPE_PENTAX, originOffset, originOffset + PENTAX_IFD_OFFSET, byteOrder, includeUnknown, true);
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));
@@ -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(decodeRawData(value), EXIF_OFFSET, includeUnknown).tags
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,
@@ -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 + Types.getLongAt(dataView, tiffHeaderOffset + 4, byteOrder);
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 = 12;
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(dataView, IFD_TYPE_1ST, offsetOrigin, offsetOrigin + nextIfdOffset, byteOrder, includeUnknown);
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(tags, readIfd(dataView, IFD_TYPE_EXIF, tiffHeaderOffset, tiffHeaderOffset + tags[EXIF_IFD_POINTER_KEY].value, byteOrder, includeUnknown));
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(tags, readIfd(dataView, IFD_TYPE_GPS, tiffHeaderOffset, tiffHeaderOffset + tags[GPS_INFO_IFD_POINTER_KEY].value, byteOrder, includeUnknown));
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(tags, readIfd(dataView, IFD_TYPE_INTEROPERABILITY, tiffHeaderOffset, tiffHeaderOffset + tags[INTEROPERABILITY_IFD_POINTER_KEY].value, byteOrder, includeUnknown));
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
+ };