exifreader 4.47.0 → 4.48.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -39,6 +39,10 @@ export const ITEM_INFO_TYPE_EXIF = 0x45786966;
39
39
  export const ITEM_INFO_TYPE_MIME = 0x6d696d65;
40
40
  const ITEM_INFO_TYPE_URI = 0x75726920;
41
41
 
42
+ // The spec sets no maximum for the infe strings; the cap bounds the memory one
43
+ // malformed string can take, far above any real name, MIME type or URI.
44
+ const MAX_INFE_STRING_LENGTH = 65536;
45
+
42
46
  export const BOX_TYPE_OFFSET = 4;
43
47
  export const BOX_MIN_LENGTH = 8;
44
48
 
@@ -103,7 +107,7 @@ export function parseBox(dataView, offset, containerEnd = dataView.byteLength) {
103
107
  return parseItemInformationBox(dataView, offset, version, contentOffset + VERSION_SIZE, length, containerEnd);
104
108
  }
105
109
  if (type === TYPE_INFE) {
106
- return parseItemInformationEntryBox(dataView, offset, version, contentOffset + VERSION_SIZE, length);
110
+ return parseItemInformationEntryBox(dataView, offset, version, contentOffset + VERSION_SIZE, length, containerEnd);
107
111
  }
108
112
 
109
113
  return {
@@ -586,18 +590,19 @@ function parseItemInformationBox(dataView, startOffset, version, contentOffset,
586
590
  };
587
591
  }
588
592
 
589
- function parseItemInformationEntryBox(dataView, startOffset, version, contentOffset, length) {
593
+ function parseItemInformationEntryBox(dataView, startOffset, version, contentOffset, length, containerEnd) {
590
594
  const FLAGS_SIZE = 3;
591
595
 
592
596
  contentOffset += FLAGS_SIZE;
593
597
  const entry = {type: 'infe', length};
598
+ const entryEnd = Math.min(startOffset + length, containerEnd);
594
599
 
595
600
  if (version === 0 || version === 1) {
596
601
  entry.itemId = dataView.getUint16(contentOffset);
597
602
  contentOffset += 2;
598
603
  entry.itemProtectionIndex = dataView.getUint16(contentOffset);
599
604
  contentOffset += 2;
600
- entry.itemName = getNullTerminatedStringFromDataView(dataView, contentOffset);
605
+ entry.itemName = readEntryString(dataView, contentOffset, entryEnd).value;
601
606
  contentOffset += entry.itemName.length + 1;
602
607
  // entry.contentType = getNullTerminatedStringFromDataView(dataView, offset);
603
608
  // offset += entry.contentType.length + 1;
@@ -640,19 +645,35 @@ function parseItemInformationEntryBox(dataView, startOffset, version, contentOff
640
645
  contentOffset += 2;
641
646
  entry.itemType = dataView.getUint32(contentOffset);
642
647
  contentOffset += 4;
643
- entry.itemName = getNullTerminatedStringFromDataView(dataView, contentOffset);
648
+ const itemName = readEntryString(dataView, contentOffset, entryEnd);
649
+ entry.itemName = itemName.value;
650
+ if (!itemName.isTerminated) {
651
+ return entry;
652
+ }
644
653
  contentOffset += entry.itemName.length + 1;
645
654
  if (entry.itemType === ITEM_INFO_TYPE_MIME) {
646
- entry.contentType = getNullTerminatedStringFromDataView(dataView, contentOffset);
655
+ const contentType = readEntryString(dataView, contentOffset, entryEnd);
656
+ entry.contentType = contentType.value;
657
+ if (!contentType.isTerminated) {
658
+ return entry;
659
+ }
647
660
  contentOffset += entry.contentType.length + 1;
648
- if (startOffset + length > contentOffset) {
649
- entry.contentEncoding = getNullTerminatedStringFromDataView(dataView, contentOffset);
650
- contentOffset += entry.contentEncoding.length + 1;
661
+ if (entryEnd > contentOffset) {
662
+ entry.contentEncoding = readEntryString(dataView, contentOffset, entryEnd).value;
651
663
  }
652
664
  } else if (entry.itemType === ITEM_INFO_TYPE_URI) {
653
- entry.itemUri = getNullTerminatedStringFromDataView(dataView, contentOffset);
654
- contentOffset += entry.itemUri.length + 1;
665
+ entry.itemUri = readEntryString(dataView, contentOffset, entryEnd).value;
655
666
  }
656
667
  }
657
668
  return entry;
658
669
  }
670
+
671
+ /**
672
+ * Reads one string of an infe box, bounded by the box end and the length cap.
673
+ * isTerminated is false when the string ran into either bound instead of a NUL.
674
+ */
675
+ function readEntryString(dataView, offset, entryEnd) {
676
+ const limit = Math.min(entryEnd, offset + MAX_INFE_STRING_LENGTH);
677
+ const value = getNullTerminatedStringFromDataView(dataView, offset, limit);
678
+ return {value, isTerminated: offset + value.length < limit};
679
+ }
@@ -40,6 +40,9 @@ const ICC_TOTAL_CHUNKS_OFFSET = ICC_CHUNK_NUMBER_OFFSET + 1;
40
40
  // Guards against memory exhaustion from a crafted file. Both chunk fields are a
41
41
  // single byte, so a longer list could never be assembled into a profile anyway.
42
42
  const MAX_ICC_CHUNKS = 255;
43
+ // Guards against memory exhaustion from a crafted file. An extended XMP segment
44
+ // holds at most about 64 KiB, so this still allows about 64 MiB of XMP.
45
+ const MAX_XMP_CHUNKS = 1024;
43
46
 
44
47
  const APP2_MPF_IDENTIFIER = 'MPF\0';
45
48
 
@@ -168,14 +171,18 @@ function findJpegOffsets(dataView, metadataBlocks) {
168
171
  xmpChunks = [];
169
172
  }
170
173
  fieldLength = dataView.getUint16(appMarkerPosition + APP_MARKER_SIZE);
171
- xmpChunks.push(getXmpChunkDetails(appMarkerPosition, fieldLength));
174
+ if (xmpChunks.length < MAX_XMP_CHUNKS) {
175
+ xmpChunks.push(getXmpChunkDetails(appMarkerPosition, fieldLength));
176
+ }
172
177
  blockType = 'xmp';
173
178
  } else if (Constants.USE_XMP && isApp1ExtendedXmpMarker(dataView, appMarkerPosition)) {
174
179
  if (!xmpChunks) {
175
180
  xmpChunks = [];
176
181
  }
177
182
  fieldLength = dataView.getUint16(appMarkerPosition + APP_MARKER_SIZE);
178
- xmpChunks.push(getExtendedXmpChunkDetails(appMarkerPosition, fieldLength));
183
+ if (xmpChunks.length < MAX_XMP_CHUNKS) {
184
+ xmpChunks.push(getExtendedXmpChunkDetails(appMarkerPosition, fieldLength));
185
+ }
179
186
  blockType = 'xmp';
180
187
  } else if (Constants.USE_IPTC && isApp13PhotoshopMarker(dataView, appMarkerPosition)) {
181
188
  fieldLength = dataView.getUint16(appMarkerPosition + APP_MARKER_SIZE);
@@ -4,7 +4,7 @@
4
4
 
5
5
  // Specification: http://www.libpng.org/pub/png/spec/1.2/
6
6
 
7
- import {getStringFromDataView, getNullTerminatedStringFromDataView, pushMetadataBlock} from './utils.js';
7
+ import {getStringFromDataView, pushMetadataBlock} from './utils.js';
8
8
  import Constants from './constants.js';
9
9
 
10
10
  export default {
@@ -26,6 +26,8 @@ export const TYPE_PHYS = 'pHYs';
26
26
  export const TYPE_TIME = 'tIME';
27
27
  export const TYPE_EXIF = 'eXIf';
28
28
  export const TYPE_ICCP = 'iCCP';
29
+ // PNG spec: an iCCP profile name is at most 79 bytes, like a text keyword.
30
+ const MAX_ICC_PROFILE_NAME_LENGTH = 79;
29
31
 
30
32
  /**
31
33
  * Checks if the provided data view represents a PNG file.
@@ -84,15 +86,10 @@ function findPngOffsets(dataView, async, metadataBlocks) {
84
86
  }
85
87
  } else if (isPngTextChunk(dataView, offset, async)) {
86
88
  offsets.hasAppMarkers = true;
87
- const chunkType = getStringFromDataView(dataView, offset + PNG_CHUNK_TYPE_OFFSET, PNG_CHUNK_TYPE_SIZE);
88
89
  if (!offsets.pngTextChunks) {
89
90
  offsets.pngTextChunks = [];
90
91
  }
91
- offsets.pngTextChunks.push({
92
- length: chunkDataLength,
93
- type: chunkType,
94
- offset: offset + PNG_CHUNK_DATA_OFFSET
95
- });
92
+ offsets.pngTextChunks.push(offset + PNG_CHUNK_LENGTH_OFFSET);
96
93
  blockType = 'png';
97
94
  } else if (isPngExifChunk(dataView, offset)) {
98
95
  offsets.hasAppMarkers = true;
@@ -100,20 +97,20 @@ function findPngOffsets(dataView, async, metadataBlocks) {
100
97
  blockType = 'exif';
101
98
  } else if (Constants.USE_ICC && async && isPngIccpChunk(dataView, offset)) {
102
99
  const iccHeaderOffset = offset + PNG_CHUNK_DATA_OFFSET;
103
- const iccHeader = parseIccHeader(dataView, iccHeaderOffset);
100
+ const iccHeader = parseIccHeader(dataView, iccHeaderOffset, chunkDataLength);
104
101
  if (iccHeader !== undefined) {
105
102
  offsets.hasAppMarkers = true;
103
+ // PNG spec: a file has at most one iCCP chunk, so only the first valid one is kept.
106
104
  if (!offsets.iccChunks) {
107
- offsets.iccChunks = [];
105
+ offsets.iccChunks = [{
106
+ offset: iccHeader.compressedProfileOffset,
107
+ length: chunkDataLength - (iccHeader.compressedProfileOffset - iccHeaderOffset),
108
+ chunkNumber: 1,
109
+ chunksTotal: 1,
110
+ profileName: iccHeader.profileName,
111
+ compressionMethod: iccHeader.compressionMethod
112
+ }];
108
113
  }
109
- offsets.iccChunks.push({
110
- offset: iccHeader.compressedProfileOffset,
111
- length: chunkDataLength - (iccHeader.compressedProfileOffset - iccHeaderOffset),
112
- chunkNumber: 1,
113
- chunksTotal: 1,
114
- profileName: iccHeader.profileName,
115
- compressionMethod: iccHeader.compressionMethod
116
- });
117
114
  blockType = 'icc';
118
115
  }
119
116
  } else if (isPngChunk(dataView, offset)) {
@@ -190,22 +187,32 @@ function getPngXmpDataOffset(dataView, offset) {
190
187
  return offset;
191
188
  }
192
189
 
193
- function parseIccHeader(dataView, offset) {
190
+ function parseIccHeader(dataView, offset, chunkDataLength) {
194
191
  const NULL_SEPARATOR_SIZE = 1;
195
192
  const COMPRESSION_METHOD_SIZE = 1;
193
+ const chunkEnd = Math.min(offset + chunkDataLength, dataView.byteLength);
196
194
 
197
- const profileName = getNullTerminatedStringFromDataView(dataView, offset);
198
- offset += profileName.length + NULL_SEPARATOR_SIZE;
199
-
200
- if (offset + COMPRESSION_METHOD_SIZE > dataView.byteLength) {
195
+ const profileNameLength = getIccProfileNameLength(dataView, offset, chunkEnd);
196
+ if (profileNameLength === undefined) {
197
+ return undefined;
198
+ }
199
+ const compressionMethodOffset = offset + profileNameLength + NULL_SEPARATOR_SIZE;
200
+ if (compressionMethodOffset + COMPRESSION_METHOD_SIZE > chunkEnd) {
201
201
  return undefined;
202
202
  }
203
- const compressionMethod = dataView.getUint8(offset);
204
- offset += COMPRESSION_METHOD_SIZE;
205
203
 
206
204
  return {
207
- profileName,
208
- compressionMethod,
209
- compressedProfileOffset: offset
205
+ profileName: getStringFromDataView(dataView, offset, profileNameLength),
206
+ compressionMethod: dataView.getUint8(compressionMethodOffset),
207
+ compressedProfileOffset: compressionMethodOffset + COMPRESSION_METHOD_SIZE
210
208
  };
211
209
  }
210
+
211
+ function getIccProfileNameLength(dataView, offset, chunkEnd) {
212
+ for (let i = 0; i <= MAX_ICC_PROFILE_NAME_LENGTH && offset + i < chunkEnd; i++) {
213
+ if (dataView.getUint8(offset + i) === 0) {
214
+ return i;
215
+ }
216
+ }
217
+ return undefined;
218
+ }
package/src/iptc-tags.js CHANGED
@@ -5,6 +5,7 @@
5
5
  import IptcTagNames from './iptc-tag-names.js';
6
6
  import TagDecoder from './tag-decoder.js';
7
7
  import {NOOP_TAG_FILTER} from './tag-filter.js';
8
+ import {getValueBudget, BYTES_PER_IPTC_DATASET, IPTC_DATASET_HEADER_SIZE} from './tags-helpers.js';
8
9
 
9
10
  const BYTES_8BIM = 0x3842494d;
10
11
  const BYTES_8BIM_SIZE = 4;
@@ -14,25 +15,36 @@ const RESOURCE_NAME_MIN_SIZE = 2;
14
15
  const RESOURCE_SIZE_SIZE = 4;
15
16
  const RESOURCE_BLOCK_MIN_HEADER_SIZE = BYTES_8BIM_SIZE + RESOURCE_ID_SIZE + RESOURCE_NAME_MIN_SIZE + RESOURCE_SIZE_SIZE;
16
17
  const NAA_RESOURCE_BLOCK_TYPE = 0x0404; // Sometimes called resource ID.
17
- const TAG_HEADER_SIZE = 5;
18
18
 
19
19
  export default {
20
20
  read
21
21
  };
22
22
 
23
- function read(dataView, dataOffset, includeUnknown, tagFilter = NOOP_TAG_FILTER) {
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
- new DataView(Uint8Array.from(dataView).buffer),
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 += TAG_HEADER_SIZE + tagSize;
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 + TAG_HEADER_SIZE, tagSize);
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 loadAdaptiveFromMemory(dataUriToBuffer(filename), options);
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, {
@@ -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 parsedThumbnailIfdTags = deps.filterTagsForParse(
291
- 'thumbnail',
294
+ const mainThumbnail = getMainThumbnail({
292
295
  thumbnailIfdTags,
293
- tagFilter
294
- );
295
-
296
- const thumbnail = Constants.USE_EXIF
297
- && Constants.USE_THUMBNAIL
298
- && deps.Thumbnail.get(exifDataView || dataView, parsedThumbnailIfdTags, tiffHeaderOffset);
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
- // The thumbnail image is never read from a text chunk, so the
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
- for (let i = 0; i < Math.ceil(tags['MPEntry'].value.length / ENTRY_SIZE); i++) {
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);
@@ -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(dataView, originOffset + tags['LevelInfo'].__offset, byteOrder));
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
- function parseLevelInfoK3III(dataView, levelInfoOffset, byteOrder) {
78
- const tags = {};
79
-
80
- if (levelInfoOffset + 7 > dataView.byteLength) {
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
- const cameraOrientation = dataView.getInt8(levelInfoOffset + LIK3III.CAMERA_ORIENTATION);
85
- tags['CameraOrientation'] = {
86
- value: cameraOrientation,
87
- description: getOrientationDescription(cameraOrientation)
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
- const rollAngle = dataView.getInt16(levelInfoOffset + LIK3III.ROLL_ANGLE, byteOrder === ByteOrder.LITTLE_ENDIAN);
91
- tags['RollAngle'] = {
92
- value: rollAngle,
93
- description: getRollAngleDescription(rollAngle)
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
- const pitchAngle = dataView.getInt16(levelInfoOffset + LIK3III.PITCH_ANGLE, byteOrder === ByteOrder.LITTLE_ENDIAN);
97
- tags['PitchAngle'] = {
98
- value: pitchAngle,
99
- description: getPitchAngleDescription(pitchAngle)
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)';