bare-exif 1.1.1 → 1.1.2

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 CHANGED
@@ -26,8 +26,42 @@ data.removeEntry(exif.constants.tags.ORIENTATION)
26
26
  // Serialize into raw EXIF
27
27
  const exifBytes = data.saveData()
28
28
  // <Uint8Array>
29
+
30
+ // Free the data when you're done (or use `using` to do it automatically)
31
+ data.destroy()
32
+ ```
33
+
34
+ ## API
35
+
36
+ ### `const data = new exif.Data(buffer)`
37
+
38
+ Parse EXIF data from a buffer. `data` owns the EXIF tree.
39
+
40
+ ### `data.destroy()`
41
+
42
+ Destroy every entry handed out by `data`, then free the EXIF tree. Safe to call more than once. If you never call it, a finalizer does it when `data` is garbage collected. Prefer `using` to call it automatically when `data` goes out of scope:
43
+
44
+ ```js
45
+ using data = new exif.Data(image)
46
+ // data.destroy() runs for you at the end of the scope
29
47
  ```
30
48
 
49
+ ### `const entry = data.entry(tag)`
50
+
51
+ Return the entry for `tag`, or `null` if absent. The entry borrows from `data` and may not outlive it: `entry.data` is a view into the tree, not a copy.
52
+
53
+ ### `entry.destroy()`
54
+
55
+ Release the entry's view of the tree and detach `entry.data`. Safe to call more than once. The entry itself is owned by `data`, so this frees nothing — to remove a tag from the tree, use `data.removeEntry(tag)`.
56
+
57
+ ### `data.removeEntry(tag)`
58
+
59
+ Destroy any live entry for `tag`, then remove it from the EXIF tree and free it.
60
+
61
+ ### `data.saveData()`
62
+
63
+ Serialize the EXIF tree back into a raw `Uint8Array`.
64
+
31
65
  ## License
32
66
 
33
67
  Apache-2.0
package/binding.c CHANGED
@@ -3,9 +3,9 @@
3
3
  #include <js.h>
4
4
  #include <libexif/exif-data.h>
5
5
  #include <libexif/exif-tag.h>
6
+ #include <stdint.h>
6
7
  #include <stdlib.h>
7
8
  #include <string.h>
8
- #include <stdint.h>
9
9
 
10
10
  typedef struct {
11
11
  ExifData *handle;
@@ -15,92 +15,177 @@ typedef struct {
15
15
  ExifEntry *handle;
16
16
  } bare_exif_entry_t;
17
17
 
18
+ static void
19
+ bare_exif_finalize_data(js_env_t *env, void *data, void *hint) {
20
+ bare_exif_data_t *self = data;
21
+
22
+ if (self->handle != NULL) exif_data_unref(self->handle);
23
+
24
+ free(self);
25
+ }
26
+
27
+ static void
28
+ bare_exif_finalize_entry(js_env_t *env, void *data, void *hint) {
29
+ // exif_data_get_entry() lends the pointer; the ExifContent holds the only
30
+ // reference. Unref'ing here would free an entry the tree still points at.
31
+ free(data);
32
+ }
33
+
34
+ static bare_exif_data_t *
35
+ bare_exif__unwrap_data(js_env_t *env, js_value_t *object) {
36
+ int err;
37
+
38
+ bare_exif_data_t *data;
39
+ err = js_unwrap(env, object, (void **) &data);
40
+ assert(err == 0);
41
+
42
+ if (data->handle == NULL) {
43
+ err = js_throw_error(env, NULL, "EXIF data has been destroyed");
44
+ assert(err == 0);
45
+
46
+ return NULL;
47
+ }
48
+
49
+ return data;
50
+ }
51
+
52
+ static bare_exif_entry_t *
53
+ bare_exif__unwrap_entry(js_env_t *env, js_value_t *object) {
54
+ int err;
55
+
56
+ bare_exif_entry_t *entry;
57
+ err = js_unwrap(env, object, (void **) &entry);
58
+ assert(err == 0);
59
+
60
+ if (entry->handle == NULL) {
61
+ err = js_throw_error(env, NULL, "EXIF entry has been destroyed");
62
+ assert(err == 0);
63
+
64
+ return NULL;
65
+ }
66
+
67
+ return entry;
68
+ }
69
+
18
70
  static js_value_t *
19
71
  bare_exif_init_data(js_env_t *env, js_callback_info_t *info) {
20
72
  int err;
21
73
 
22
- size_t argc = 3;
23
- js_value_t *argv[3];
74
+ size_t argc = 4;
75
+ js_value_t *argv[4];
24
76
 
25
77
  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
26
78
  assert(err == 0);
27
79
 
28
- assert(argc == 3);
80
+ assert(argc == 4);
29
81
 
30
82
  uint8_t *buffer;
31
- err = js_get_arraybuffer_info(env, argv[0], (void **) &buffer, NULL);
83
+ size_t buffer_cap;
84
+ err = js_get_arraybuffer_info(env, argv[1], (void **) &buffer, &buffer_cap);
32
85
  assert(err == 0);
33
86
 
34
87
  int64_t offset;
35
- err = js_get_value_int64(env, argv[1], &offset);
88
+ err = js_get_value_int64(env, argv[2], &offset);
36
89
  assert(err == 0);
37
90
 
38
91
  int64_t len;
39
- err = js_get_value_int64(env, argv[2], &len);
92
+ err = js_get_value_int64(env, argv[3], &len);
40
93
  assert(err == 0);
41
94
 
42
- js_value_t *handle;
95
+ if (offset < 0 || len < 0 || offset + len > (int64_t) buffer_cap) {
96
+ err = js_throw_range_error(env, NULL, "Buffer out of range");
97
+ assert(err == 0);
43
98
 
44
- bare_exif_data_t *loader;
45
- err = js_create_arraybuffer(env, sizeof(bare_exif_data_t), (void **) &loader, &handle);
46
- assert(err == 0);
99
+ return NULL;
100
+ }
47
101
 
48
- loader->handle = exif_data_new_from_data(&buffer[offset], len);
102
+ ExifData *handle = exif_data_new_from_data(&buffer[offset], len);
49
103
 
50
- return handle;
104
+ if (handle == NULL) {
105
+ err = js_throw_error(env, NULL, "Failed to load EXIF data");
106
+ assert(err == 0);
107
+
108
+ return NULL;
109
+ }
110
+
111
+ bare_exif_data_t *data = malloc(sizeof(bare_exif_data_t));
112
+
113
+ data->handle = handle;
114
+
115
+ err = js_wrap(env, argv[0], data, bare_exif_finalize_data, NULL, NULL);
116
+ assert(err == 0);
117
+
118
+ return NULL;
51
119
  }
52
120
 
53
121
  static js_value_t *
54
- bare_exif_get_entry(js_env_t *env, js_callback_info_t *info) {
122
+ bare_exif_destroy_data(js_env_t *env, js_callback_info_t *info) {
55
123
  int err;
56
124
 
57
- size_t argc = 2;
58
- js_value_t *argv[2];
125
+ size_t argc = 1;
126
+ js_value_t *argv[1];
59
127
 
60
128
  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
61
129
  assert(err == 0);
62
130
 
63
- assert(argc == 2);
131
+ assert(argc == 1);
64
132
 
65
133
  bare_exif_data_t *data;
66
- err = js_get_arraybuffer_info(env, argv[0], (void **) &data, NULL);
134
+ err = js_unwrap(env, argv[0], (void **) &data);
67
135
  assert(err == 0);
68
136
 
69
- int64_t exif_tag;
70
- err = js_get_value_int64(env, argv[1], &exif_tag);
71
- assert(err == 0);
137
+ if (data->handle != NULL) {
138
+ exif_data_unref(data->handle);
72
139
 
73
- ExifEntry *entry = exif_data_get_entry(data->handle, (ExifTag)exif_tag);
74
-
75
- if (entry == NULL) {
76
- return NULL;
140
+ data->handle = NULL;
77
141
  }
78
142
 
79
- js_value_t *result;
80
- err = js_create_object(env, &result);
143
+ return NULL;
144
+ }
145
+
146
+ static js_value_t *
147
+ bare_exif_init_entry(js_env_t *env, js_callback_info_t *info) {
148
+ int err;
149
+
150
+ size_t argc = 3;
151
+ js_value_t *argv[3];
152
+
153
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
81
154
  assert(err == 0);
82
155
 
83
- js_value_t *handle;
84
- bare_exif_entry_t *loader;
85
- err = js_create_arraybuffer(env, sizeof(bare_exif_entry_t), (void **) &loader, &handle);
156
+ assert(argc == 3);
157
+
158
+ bare_exif_data_t *data = bare_exif__unwrap_data(env, argv[1]);
159
+
160
+ if (data == NULL) return NULL;
161
+
162
+ int64_t exif_tag;
163
+ err = js_get_value_int64(env, argv[2], &exif_tag);
86
164
  assert(err == 0);
87
- loader->handle = entry;
88
165
 
89
- err = js_set_named_property(env, result, "handle", handle);
166
+ ExifEntry *handle = exif_data_get_entry(data->handle, (ExifTag) exif_tag);
167
+
168
+ if (handle == NULL) return NULL;
169
+
170
+ bare_exif_entry_t *entry = malloc(sizeof(bare_exif_entry_t));
171
+
172
+ entry->handle = handle;
173
+
174
+ err = js_wrap(env, argv[0], entry, bare_exif_finalize_entry, NULL, NULL);
90
175
  assert(err == 0);
91
176
 
92
- int tag = entry->tag;
93
- int format = entry->format;
94
- unsigned long components = entry->components;
95
- unsigned int size = entry->size;
96
- ExifByteOrder byte_order = exif_data_get_byte_order(entry->parent->parent);
177
+ int tag = handle->tag;
178
+ int format = handle->format;
179
+ unsigned long components = handle->components;
180
+ unsigned int size = handle->size;
181
+ ExifByteOrder byteOrder = exif_data_get_byte_order(handle->parent->parent);
97
182
 
98
183
  #define V(n) \
99
184
  { \
100
185
  js_value_t *val; \
101
186
  err = js_create_int64(env, n, &val); \
102
187
  assert(err == 0); \
103
- err = js_set_named_property(env, result, #n, val); \
188
+ err = js_set_named_property(env, argv[0], #n, val); \
104
189
  assert(err == 0); \
105
190
  }
106
191
 
@@ -108,17 +193,45 @@ bare_exif_get_entry(js_env_t *env, js_callback_info_t *info) {
108
193
  V(format);
109
194
  V(components);
110
195
  V(size);
111
- V(byte_order);
196
+ V(byteOrder);
112
197
  #undef V
113
198
 
199
+ // A borrowed view into the entry, detached again by destroyEntry() before
200
+ // the data tree it points into can be freed.
114
201
  js_value_t *buffer;
115
- err = js_create_external_arraybuffer(env, entry->data, entry->size, NULL, NULL, &buffer);
202
+ err = js_create_external_arraybuffer(env, handle->data, handle->size, NULL, NULL, &buffer);
116
203
  assert(err == 0);
117
204
 
118
- err = js_set_named_property(env, result, "data", buffer);
205
+ err = js_set_named_property(env, argv[0], "data", buffer);
119
206
  assert(err == 0);
120
207
 
121
- return result;
208
+ return argv[0];
209
+ }
210
+
211
+ static js_value_t *
212
+ bare_exif_destroy_entry(js_env_t *env, js_callback_info_t *info) {
213
+ int err;
214
+
215
+ size_t argc = 2;
216
+ js_value_t *argv[2];
217
+
218
+ err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
219
+ assert(err == 0);
220
+
221
+ assert(argc == 2);
222
+
223
+ bare_exif_entry_t *entry;
224
+ err = js_unwrap(env, argv[0], (void **) &entry);
225
+ assert(err == 0);
226
+
227
+ if (entry->handle != NULL) {
228
+ entry->handle = NULL;
229
+
230
+ err = js_detach_arraybuffer(env, argv[1]);
231
+ assert(err == 0);
232
+ }
233
+
234
+ return NULL;
122
235
  }
123
236
 
124
237
  static js_value_t *
@@ -133,15 +246,15 @@ bare_exif_get_entry_value(js_env_t *env, js_callback_info_t *info) {
133
246
 
134
247
  assert(argc == 1);
135
248
 
136
- bare_exif_entry_t *entry;
137
- err = js_get_arraybuffer_info(env, argv[0], (void **) &entry, NULL);
138
- assert(err == 0);
249
+ bare_exif_entry_t *entry = bare_exif__unwrap_entry(env, argv[0]);
250
+
251
+ if (entry == NULL) return NULL;
139
252
 
140
- char buffer[1024];
141
- exif_entry_get_value(entry->handle, buffer, sizeof(buffer));
253
+ char text[1024];
254
+ exif_entry_get_value(entry->handle, text, sizeof(text));
142
255
 
143
256
  js_value_t *result;
144
- err = js_create_string_utf8(env, (utf8_t*)buffer, strlen(buffer), &result);
257
+ err = js_create_string_utf8(env, (utf8_t *) text, strlen(text), &result);
145
258
  assert(err == 0);
146
259
 
147
260
  return result;
@@ -159,15 +272,15 @@ bare_exif_remove_entry(js_env_t *env, js_callback_info_t *info) {
159
272
 
160
273
  assert(argc == 2);
161
274
 
162
- bare_exif_data_t *data;
163
- err = js_get_arraybuffer_info(env, argv[0], (void **) &data, NULL);
164
- assert(err == 0);
275
+ bare_exif_data_t *data = bare_exif__unwrap_data(env, argv[0]);
276
+
277
+ if (data == NULL) return NULL;
165
278
 
166
279
  int64_t exif_tag;
167
280
  err = js_get_value_int64(env, argv[1], &exif_tag);
168
281
  assert(err == 0);
169
282
 
170
- ExifEntry *entry = exif_data_get_entry(data->handle, (ExifTag)exif_tag);
283
+ ExifEntry *entry = exif_data_get_entry(data->handle, (ExifTag) exif_tag);
171
284
 
172
285
  if (entry != NULL) {
173
286
  exif_content_remove_entry(entry->parent, entry);
@@ -188,9 +301,9 @@ bare_exif_save_data(js_env_t *env, js_callback_info_t *info) {
188
301
 
189
302
  assert(argc == 1);
190
303
 
191
- bare_exif_data_t *data;
192
- err = js_get_arraybuffer_info(env, argv[0], (void **) &data, NULL);
193
- assert(err == 0);
304
+ bare_exif_data_t *data = bare_exif__unwrap_data(env, argv[0]);
305
+
306
+ if (data == NULL) return NULL;
194
307
 
195
308
  unsigned char *bytes = NULL;
196
309
  unsigned int len = 0;
@@ -209,48 +322,6 @@ bare_exif_save_data(js_env_t *env, js_callback_info_t *info) {
209
322
  return result;
210
323
  }
211
324
 
212
- static js_value_t *
213
- bare_exif_destroy_data(js_env_t *env, js_callback_info_t *info) {
214
- int err;
215
-
216
- size_t argc = 1;
217
- js_value_t *argv[1];
218
-
219
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
220
- assert(err == 0);
221
-
222
- assert(argc == 1);
223
-
224
- bare_exif_data_t *data;
225
- err = js_get_arraybuffer_info(env, argv[0], (void **) &data, NULL);
226
- assert(err == 0);
227
-
228
- exif_data_unref(data->handle);
229
-
230
- return NULL;
231
- }
232
-
233
- static js_value_t *
234
- bare_exif_destroy_entry(js_env_t *env, js_callback_info_t *info) {
235
- int err;
236
-
237
- size_t argc = 1;
238
- js_value_t *argv[1];
239
-
240
- err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
241
- assert(err == 0);
242
-
243
- assert(argc == 1);
244
-
245
- bare_exif_entry_t *entry;
246
- err = js_get_arraybuffer_info(env, argv[0], (void **) &entry, NULL);
247
- assert(err == 0);
248
-
249
- exif_entry_unref(entry->handle);
250
-
251
- return NULL;
252
- }
253
-
254
325
  static js_value_t *
255
326
  bare_exif_exports(js_env_t *env, js_value_t *exports) {
256
327
  int err;
@@ -524,12 +595,12 @@ bare_exif_exports(js_env_t *env, js_value_t *exports) {
524
595
  }
525
596
 
526
597
  V("initData", bare_exif_init_data)
527
- V("entry", bare_exif_get_entry)
598
+ V("destroyData", bare_exif_destroy_data)
599
+ V("initEntry", bare_exif_init_entry)
600
+ V("destroyEntry", bare_exif_destroy_entry)
528
601
  V("entryValue", bare_exif_get_entry_value)
529
602
  V("removeEntry", bare_exif_remove_entry)
530
603
  V("saveData", bare_exif_save_data)
531
- V("destroyData", bare_exif_destroy_data)
532
- V("destroyEntry", bare_exif_destroy_entry)
533
604
  #undef V
534
605
 
535
606
  return exports;
package/index.js CHANGED
@@ -8,14 +8,19 @@ exports.constants = {
8
8
  }
9
9
 
10
10
  class EXIFEntry {
11
+ // An entry borrows from the data tree it was read from. Holding on to the
12
+ // parent keeps it reachable, so an entry can never be collected after the
13
+ // tree it points into.
11
14
  constructor(data) {
12
- this._handle = data.handle
13
- this.tag = data.tag
14
- this.format = data.format
15
- this.components = data.components
16
- this.data = data.data
17
- this.size = data.size
18
- this.byteOrder = data.byte_order
15
+ this._data = data
16
+ this._destroyed = false
17
+
18
+ this.tag = 0
19
+ this.format = 0
20
+ this.components = 0
21
+ this.size = 0
22
+ this.byteOrder = 0
23
+ this.data = null
19
24
  }
20
25
 
21
26
  #readComponent(index) {
@@ -81,6 +86,10 @@ class EXIFEntry {
81
86
  }
82
87
 
83
88
  read() {
89
+ if (this._destroyed) {
90
+ throw new Error('EXIF entry has been destroyed')
91
+ }
92
+
84
93
  if (!this.components || this.components < 0) return null
85
94
 
86
95
  if (
@@ -99,13 +108,18 @@ class EXIFEntry {
99
108
  }
100
109
 
101
110
  value() {
102
- return binding.entryValue(this._handle)
111
+ return binding.entryValue(this)
103
112
  }
104
113
 
105
114
  destroy() {
106
- if (this._handle === null) return
107
- binding.destroyEntry(this._handle)
108
- this._handle = null
115
+ if (this._destroyed) return
116
+
117
+ this._data._entries.delete(this)
118
+
119
+ binding.destroyEntry(this, this.data)
120
+
121
+ this.data = null
122
+ this._destroyed = true
109
123
  }
110
124
 
111
125
  [Symbol.dispose]() {
@@ -115,27 +129,45 @@ class EXIFEntry {
115
129
 
116
130
  exports.Data = class EXIFData {
117
131
  constructor(data) {
118
- this._handle = binding.initData(data.buffer, data.byteOffset, data.byteLength)
132
+ this._destroyed = false
133
+
134
+ // The entries handed out so far. They borrow from the tree below, so they
135
+ // are destroyed before it is.
136
+ this._entries = new Set()
137
+
138
+ binding.initData(this, data.buffer, data.byteOffset, data.byteLength)
119
139
  }
120
140
 
121
141
  entry(tag) {
122
- const data = binding.entry(this._handle, tag)
123
- if (!data) return null
124
- return new EXIFEntry(data)
142
+ const entry = new EXIFEntry(this)
143
+
144
+ if (binding.initEntry(entry, this, tag) === undefined) return null
145
+
146
+ this._entries.add(entry)
147
+
148
+ return entry
125
149
  }
126
150
 
127
151
  removeEntry(tag) {
128
- return binding.removeEntry(this._handle, tag)
152
+ for (const entry of this._entries) {
153
+ if (entry.tag === tag) entry.destroy()
154
+ }
155
+
156
+ binding.removeEntry(this, tag)
129
157
  }
130
158
 
131
159
  saveData() {
132
- return new Uint8Array(binding.saveData(this._handle))
160
+ return new Uint8Array(binding.saveData(this))
133
161
  }
134
162
 
135
163
  destroy() {
136
- if (this._handle === null) return
137
- binding.destroyData(this._handle)
138
- this._handle = null
164
+ if (this._destroyed) return
165
+
166
+ for (const entry of [...this._entries]) entry.destroy()
167
+
168
+ binding.destroyData(this)
169
+
170
+ this._destroyed = true
139
171
  }
140
172
 
141
173
  [Symbol.dispose]() {
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "bare-exif",
3
- "version": "1.1.1",
3
+ "version": "1.1.2",
4
4
  "description": "EXIF support for Bare",
5
5
  "exports": {
6
6
  "./package": "./package.json",
Binary file
Binary file
Binary file
Binary file