exifreader 4.14.1 → 4.15.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/src/tags.js CHANGED
@@ -2,32 +2,17 @@
2
2
  * License, v. 2.0. If a copy of the MPL was not distributed with this
3
3
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
4
 
5
- import Constants from './constants.js';
6
5
  import {objectAssign} from './utils.js';
7
6
  import ByteOrder from './byte-order.js';
8
- import Types from './types.js';
9
- import TagNames, {IFD_TYPE_0TH, IFD_TYPE_1ST, IFD_TYPE_EXIF, IFD_TYPE_GPS, IFD_TYPE_INTEROPERABILITY, IFD_TYPE_MPF} from './tag-names.js';
10
- import {deferInit, getBase64Image} from './utils.js';
7
+ import {IFD_TYPE_0TH, IFD_TYPE_EXIF, IFD_TYPE_GPS, IFD_TYPE_INTEROPERABILITY} from './tag-names.js';
8
+ import {readIfd, get0thIfdOffset} from './tags-helpers.js';
11
9
 
12
10
  const EXIF_IFD_POINTER_KEY = 'Exif IFD Pointer';
13
11
  const GPS_INFO_IFD_POINTER_KEY = 'GPS Info IFD Pointer';
14
12
  const INTEROPERABILITY_IFD_POINTER_KEY = 'Interoperability IFD Pointer';
15
13
 
16
- const getTagValueAt = {
17
- 1: Types.getByteAt,
18
- 2: Types.getAsciiAt,
19
- 3: Types.getShortAt,
20
- 4: Types.getLongAt,
21
- 5: Types.getRationalAt,
22
- 7: Types.getUndefinedAt,
23
- 9: Types.getSlongAt,
24
- 10: Types.getSrationalAt,
25
- 13: Types.getIfdPointerAt
26
- };
27
-
28
14
  export default {
29
15
  read,
30
- readMpf
31
16
  };
32
17
 
33
18
  function read(dataView, tiffHeaderOffset, includeUnknown) {
@@ -44,10 +29,6 @@ function read0thIfd(dataView, tiffHeaderOffset, byteOrder, includeUnknown) {
44
29
  return readIfd(dataView, IFD_TYPE_0TH, tiffHeaderOffset, get0thIfdOffset(dataView, tiffHeaderOffset, byteOrder), byteOrder, includeUnknown);
45
30
  }
46
31
 
47
- function get0thIfdOffset(dataView, tiffHeaderOffset, byteOrder) {
48
- return tiffHeaderOffset + Types.getLongAt(dataView, tiffHeaderOffset + 4, byteOrder);
49
- }
50
-
51
32
  function readExifIfd(tags, dataView, tiffHeaderOffset, byteOrder, includeUnknown) {
52
33
  if (tags[EXIF_IFD_POINTER_KEY] !== undefined) {
53
34
  return objectAssign(tags, readIfd(dataView, IFD_TYPE_EXIF, tiffHeaderOffset, tiffHeaderOffset + tags[EXIF_IFD_POINTER_KEY].value, byteOrder, includeUnknown));
@@ -71,297 +52,3 @@ function readInteroperabilityIfd(tags, dataView, tiffHeaderOffset, byteOrder, in
71
52
 
72
53
  return tags;
73
54
  }
74
-
75
- function readMpf(dataView, dataOffset, includeUnknown) {
76
- const byteOrder = ByteOrder.getByteOrder(dataView, dataOffset);
77
- const tags = readIfd(dataView, IFD_TYPE_MPF, dataOffset, get0thIfdOffset(dataView, dataOffset, byteOrder), byteOrder, includeUnknown);
78
- return addMpfImages(dataView, dataOffset, tags, byteOrder);
79
- }
80
-
81
- function addMpfImages(dataView, dataOffset, tags, byteOrder) {
82
- const ENTRY_SIZE = 16;
83
-
84
- if (!tags['MPEntry']) {
85
- return tags;
86
- }
87
-
88
- const images = [];
89
- for (let i = 0; i < Math.ceil(tags['MPEntry'].value.length / ENTRY_SIZE); i++) {
90
- images[i] = {};
91
-
92
- const attributes = getImageNumberValue(tags['MPEntry'].value, i * ENTRY_SIZE, Types.getTypeSize('LONG'), byteOrder);
93
- images[i]['ImageFlags'] = getImageFlags(attributes);
94
- images[i]['ImageFormat'] = getImageFormat(attributes);
95
- images[i]['ImageType'] = getImageType(attributes);
96
-
97
- const imageSize = getImageNumberValue(tags['MPEntry'].value, i * ENTRY_SIZE + 4, Types.getTypeSize('LONG'), byteOrder);
98
- images[i]['ImageSize'] = {
99
- value: imageSize,
100
- description: '' + imageSize
101
- };
102
-
103
- const imageOffset = isFirstIndividualImage(i) ? 0 : getImageNumberValue(tags['MPEntry'].value, i * ENTRY_SIZE + 8, Types.getTypeSize('LONG'), byteOrder) + dataOffset;
104
- images[i]['ImageOffset'] = {
105
- value: imageOffset,
106
- description: '' + imageOffset
107
- };
108
-
109
- const dependentImage1EntryNumber =
110
- getImageNumberValue(tags['MPEntry'].value, i * ENTRY_SIZE + 12, Types.getTypeSize('SHORT'), byteOrder);
111
- images[i]['DependentImage1EntryNumber'] = {
112
- value: dependentImage1EntryNumber,
113
- description: '' + dependentImage1EntryNumber
114
- };
115
-
116
- const dependentImage2EntryNumber =
117
- getImageNumberValue(tags['MPEntry'].value, i * ENTRY_SIZE + 14, Types.getTypeSize('SHORT'), byteOrder);
118
- images[i]['DependentImage2EntryNumber'] = {
119
- value: dependentImage2EntryNumber,
120
- description: '' + dependentImage2EntryNumber
121
- };
122
-
123
- images[i].image = dataView.buffer.slice(imageOffset, imageOffset + imageSize);
124
- deferInit(images[i], 'base64', function () {
125
- return getBase64Image(this.image);
126
- });
127
- }
128
-
129
- tags['Images'] = images;
130
-
131
- return tags;
132
- }
133
-
134
- function getImageNumberValue(entries, offset, size, byteOrder) {
135
- if (byteOrder === ByteOrder.LITTLE_ENDIAN) {
136
- let value = 0;
137
- for (let i = 0; i < size; i++) {
138
- value += entries[offset + i] << (8 * i);
139
- }
140
- return value;
141
- }
142
-
143
- let value = 0;
144
- for (let i = 0; i < size; i++) {
145
- value += entries[offset + i] << (8 * (size - 1 - i));
146
- }
147
- return value;
148
- }
149
-
150
- function getImageFlags(attributes) {
151
- const flags = [
152
- (attributes >> 31) & 0x1,
153
- (attributes >> 30) & 0x1,
154
- (attributes >> 29) & 0x1
155
- ];
156
-
157
- const flagsDescription = [];
158
-
159
- if (flags[0]) {
160
- flagsDescription.push('Dependent Parent Image');
161
- }
162
- if (flags[1]) {
163
- flagsDescription.push('Dependent Child Image');
164
- }
165
- if (flags[2]) {
166
- flagsDescription.push('Representative Image');
167
- }
168
-
169
- return {
170
- value: flags,
171
- description: flagsDescription.join(', ') || 'None'
172
- };
173
- }
174
-
175
- function getImageFormat(attributes) {
176
- const imageFormat = attributes >> 24 & 0x7;
177
- return {
178
- value: imageFormat,
179
- description: imageFormat === 0 ? 'JPEG' : 'Unknown'
180
- };
181
- }
182
-
183
- function getImageType(attributes) {
184
- const type = attributes & 0xffffff;
185
- const descriptions = {
186
- 0x30000: 'Baseline MP Primary Image',
187
- 0x10001: 'Large Thumbnail (VGA equivalent)',
188
- 0x10002: 'Large Thumbnail (Full HD equivalent)',
189
- 0x20001: 'Multi-Frame Image (Panorama)',
190
- 0x20002: 'Multi-Frame Image (Disparity)',
191
- 0x20003: 'Multi-Frame Image (Multi-Angle)',
192
- 0x0: 'Undefined',
193
- };
194
-
195
- return {
196
- value: type,
197
- description: descriptions[type] || 'Unknown'
198
- };
199
- }
200
-
201
- function isFirstIndividualImage(i) {
202
- return i === 0;
203
- }
204
-
205
- function readIfd(dataView, ifdType, tiffHeaderOffset, offset, byteOrder, includeUnknown) {
206
- const FIELD_COUNT_SIZE = Types.getTypeSize('SHORT');
207
- const FIELD_SIZE = 12;
208
-
209
- const tags = {};
210
- const numberOfFields = getNumberOfFields(dataView, offset, byteOrder);
211
-
212
- offset += FIELD_COUNT_SIZE;
213
- for (let fieldIndex = 0; fieldIndex < numberOfFields; fieldIndex++) {
214
- if (offset + FIELD_SIZE > dataView.byteLength) {
215
- break;
216
- }
217
-
218
- const tag = readTag(dataView, ifdType, tiffHeaderOffset, offset, byteOrder, includeUnknown);
219
- if (tag !== undefined) {
220
- tags[tag.name] = {
221
- 'id': tag.id,
222
- 'value': tag.value,
223
- 'description': tag.description
224
- };
225
- }
226
-
227
- offset += FIELD_SIZE;
228
- }
229
-
230
- if (Constants.USE_THUMBNAIL && (offset < dataView.byteLength - Types.getTypeSize('LONG'))) {
231
- const nextIfdOffset = Types.getLongAt(dataView, offset, byteOrder);
232
- if (nextIfdOffset !== 0 && ifdType === IFD_TYPE_0TH) {
233
- tags['Thumbnail'] = readIfd(dataView, IFD_TYPE_1ST, tiffHeaderOffset, tiffHeaderOffset + nextIfdOffset, byteOrder, true);
234
- }
235
- }
236
-
237
- return tags;
238
- }
239
-
240
- function getNumberOfFields(dataView, offset, byteOrder) {
241
- if (offset + Types.getTypeSize('SHORT') <= dataView.byteLength) {
242
- return Types.getShortAt(dataView, offset, byteOrder);
243
- }
244
- return 0;
245
- }
246
-
247
- function readTag(dataView, ifdType, tiffHeaderOffset, offset, byteOrder, includeUnknown) {
248
- const TAG_CODE_IPTC_NAA = 0x83bb;
249
- const TAG_TYPE_OFFSET = Types.getTypeSize('SHORT');
250
- const TAG_COUNT_OFFSET = TAG_TYPE_OFFSET + Types.getTypeSize('SHORT');
251
- const TAG_VALUE_OFFSET = TAG_COUNT_OFFSET + Types.getTypeSize('LONG');
252
-
253
- const tagCode = Types.getShortAt(dataView, offset, byteOrder);
254
- const tagType = Types.getShortAt(dataView, offset + TAG_TYPE_OFFSET, byteOrder);
255
- const tagCount = Types.getLongAt(dataView, offset + TAG_COUNT_OFFSET, byteOrder);
256
- let tagValue;
257
-
258
- if (Types.typeSizes[tagType] === undefined || (!includeUnknown && TagNames[ifdType][tagCode] === undefined)) {
259
- return undefined;
260
- }
261
-
262
- if (tagValueFitsInOffsetSlot(tagType, tagCount)) {
263
- tagValue = getTagValue(dataView, offset + TAG_VALUE_OFFSET, tagType, tagCount, byteOrder);
264
- } else {
265
- const tagValueOffset = Types.getLongAt(dataView, offset + TAG_VALUE_OFFSET, byteOrder);
266
- if (tagValueFitsInDataView(dataView, tiffHeaderOffset, tagValueOffset, tagType, tagCount)) {
267
- const forceByteType = tagCode === TAG_CODE_IPTC_NAA;
268
- tagValue = getTagValue(dataView, tiffHeaderOffset + tagValueOffset, tagType, tagCount, byteOrder, forceByteType);
269
- } else {
270
- tagValue = '<faulty value>';
271
- }
272
- }
273
-
274
- if (tagType === Types.tagTypes['ASCII']) {
275
- tagValue = splitNullSeparatedAsciiString(tagValue);
276
- tagValue = decodeAsciiValue(tagValue);
277
- }
278
-
279
- let tagName = `undefined-${tagCode}`;
280
- let tagDescription = tagValue;
281
-
282
- if (TagNames[ifdType][tagCode] !== undefined) {
283
- if ((TagNames[ifdType][tagCode]['name'] !== undefined) && (TagNames[ifdType][tagCode]['description'] !== undefined)) {
284
- tagName = TagNames[ifdType][tagCode]['name'];
285
- try {
286
- tagDescription = TagNames[ifdType][tagCode]['description'](tagValue);
287
- } catch (error) {
288
- tagDescription = getDescriptionFromTagValue(tagValue);
289
- }
290
- } else if ((tagType === Types.tagTypes['RATIONAL']) || (tagType === Types.tagTypes['SRATIONAL'])) {
291
- tagName = TagNames[ifdType][tagCode];
292
- tagDescription = '' + (tagValue[0] / tagValue[1]);
293
- } else {
294
- tagName = TagNames[ifdType][tagCode];
295
- tagDescription = getDescriptionFromTagValue(tagValue);
296
- }
297
- }
298
-
299
- return {
300
- id: tagCode,
301
- name: tagName,
302
- value: tagValue,
303
- description: tagDescription
304
- };
305
- }
306
-
307
- function tagValueFitsInOffsetSlot(tagType, tagCount) {
308
- return Types.typeSizes[tagType] * tagCount <= Types.getTypeSize('LONG');
309
- }
310
-
311
- function getTagValue(dataView, offset, type, count, byteOrder, forceByteType = false) {
312
- let value = [];
313
-
314
- if (forceByteType) {
315
- count = count * Types.typeSizes[type];
316
- type = Types.tagTypes['BYTE'];
317
- }
318
- for (let valueIndex = 0; valueIndex < count; valueIndex++) {
319
- value.push(getTagValueAt[type](dataView, offset, byteOrder));
320
- offset += Types.typeSizes[type];
321
- }
322
-
323
- if (type === Types.tagTypes['ASCII']) {
324
- value = Types.getAsciiValue(value);
325
- } else if (value.length === 1) {
326
- value = value[0];
327
- }
328
-
329
- return value;
330
- }
331
-
332
- function tagValueFitsInDataView(dataView, tiffHeaderOffset, tagValueOffset, tagType, tagCount) {
333
- return tiffHeaderOffset + tagValueOffset + Types.typeSizes[tagType] * tagCount <= dataView.byteLength;
334
- }
335
-
336
- function splitNullSeparatedAsciiString(string) {
337
- const tagValue = [];
338
- let i = 0;
339
-
340
- for (let j = 0; j < string.length; j++) {
341
- if (string[j] === '\x00') {
342
- i++;
343
- continue;
344
- }
345
- if (tagValue[i] === undefined) {
346
- tagValue[i] = '';
347
- }
348
- tagValue[i] += string[j];
349
- }
350
-
351
- return tagValue;
352
- }
353
-
354
- function decodeAsciiValue(asciiValue) {
355
- try {
356
- return asciiValue.map((value) => decodeURIComponent(escape(value)));
357
- } catch (error) {
358
- return asciiValue;
359
- }
360
- }
361
-
362
- function getDescriptionFromTagValue(tagValue) {
363
- if (tagValue instanceof Array) {
364
- return tagValue.join(', ');
365
- }
366
- return tagValue;
367
- }
package/src/utils.js CHANGED
@@ -68,7 +68,7 @@ export function getBase64Image(image) {
68
68
  if (typeof Buffer === 'undefined') {
69
69
  return undefined;
70
70
  }
71
- if (typeof Buffer.from !== undefined) { // eslint-disable-line no-undef
71
+ if (typeof Buffer.from !== 'undefined') { // eslint-disable-line no-undef
72
72
  return Buffer.from(image).toString('base64'); // eslint-disable-line no-undef
73
73
  }
74
74
  return (new Buffer(image)).toString('base64'); // eslint-disable-line no-undef
@@ -84,7 +84,7 @@ export function dataUriToBuffer(dataUri) {
84
84
  if (typeof Buffer === 'undefined') {
85
85
  return undefined;
86
86
  }
87
- if (typeof Buffer.from !== undefined) { // eslint-disable-line no-undef
87
+ if (typeof Buffer.from !== 'undefined') { // eslint-disable-line no-undef
88
88
  return Buffer.from(data, 'base64'); // eslint-disable-line no-undef
89
89
  }
90
90
  return new Buffer(data, 'base64'); // eslint-disable-line no-undef
@@ -92,7 +92,7 @@ export function dataUriToBuffer(dataUri) {
92
92
 
93
93
  const decodedData = decodeURIComponent(data);
94
94
  if (typeof Buffer !== 'undefined') {
95
- if (typeof Buffer.from !== undefined) { // eslint-disable-line no-undef
95
+ if (typeof Buffer.from !== 'undefined') { // eslint-disable-line no-undef
96
96
  return Buffer.from(decodedData); // eslint-disable-line no-undef
97
97
  }
98
98
  return new Buffer(decodedData); // eslint-disable-line no-undef
package/src/xmp-tags.js CHANGED
@@ -221,12 +221,16 @@ function parseNodeAttributesAsTags(attributes) {
221
221
  const tags = {};
222
222
 
223
223
  for (const name in attributes) {
224
- if (isTagAttribute(name)) {
225
- tags[getLocalName(name)] = {
226
- value: attributes[name],
227
- attributes: {},
228
- description: getDescription(attributes[name], name)
229
- };
224
+ try {
225
+ if (isTagAttribute(name)) {
226
+ tags[getLocalName(name)] = {
227
+ value: attributes[name],
228
+ attributes: {},
229
+ description: getDescription(attributes[name], name)
230
+ };
231
+ }
232
+ } catch (error) {
233
+ // Keep going and try to parse the rest of the tags.
230
234
  }
231
235
  }
232
236
 
@@ -321,8 +325,12 @@ function parseNodeChildrenAsTags(children) {
321
325
  const tags = {};
322
326
 
323
327
  for (const name in children) {
324
- if (!isNamespaceDefinition(name)) {
325
- tags[getLocalName(name)] = parseNodeAsTag(children[name], name);
328
+ try {
329
+ if (!isNamespaceDefinition(name)) {
330
+ tags[getLocalName(name)] = parseNodeAsTag(children[name], name);
331
+ }
332
+ } catch (error) {
333
+ // Keep going and try to parse the rest of the tags.
326
334
  }
327
335
  }
328
336
 
@@ -330,6 +338,12 @@ function parseNodeChildrenAsTags(children) {
330
338
  }
331
339
 
332
340
  function parseNodeAsTag(node, name) {
341
+ if (isDuplicateTag(node)) {
342
+ return parseNodeAsDuplicateTag(node, name);
343
+ }
344
+ if (isEmptyResourceTag(node)) {
345
+ return {value: '', attributes: {}, description: ''};
346
+ }
333
347
  if (hasNestedSimpleRdfDescription(node)) {
334
348
  return parseNodeAsSimpleRdfDescription(node, name);
335
349
  }
@@ -345,6 +359,20 @@ function parseNodeAsTag(node, name) {
345
359
  return parseNodeAsSimpleValue(node, name);
346
360
  }
347
361
 
362
+ function isEmptyResourceTag(node) {
363
+ return (node.attributes['rdf:parseType'] === 'Resource')
364
+ && (typeof node.value === 'string')
365
+ && (node.value.trim() === '');
366
+ }
367
+
368
+ function isDuplicateTag(node) {
369
+ return Array.isArray(node);
370
+ }
371
+
372
+ function parseNodeAsDuplicateTag(node, name) {
373
+ return parseNodeAsSimpleValue(node[node.length - 1], name);
374
+ }
375
+
348
376
  function hasNestedSimpleRdfDescription(node) {
349
377
  return ((node.attributes['rdf:parseType'] === 'Resource') && (node.value['rdf:value'] !== undefined))
350
378
  || ((node.value['rdf:Description'] !== undefined) && (node.value['rdf:Description'].value['rdf:value'] !== undefined));
package/webpack.config.js CHANGED
@@ -62,7 +62,7 @@ module.exports = {
62
62
  watch: !process.env.CI
63
63
  }
64
64
  ],
65
- https: true,
65
+ server: 'https',
66
66
  open: !process.env.CI,
67
67
  liveReload: !process.env.CI
68
68
  },