bare-gpac 0.0.0 → 0.1.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/CMakeLists.txt +28 -0
- package/LICENSE +201 -0
- package/NOTICE +13 -0
- package/README.md +52 -0
- package/binding.c +911 -0
- package/binding.js +1 -0
- package/cmake/ports/libgpac/patches/01-remove-item-references.patch +16 -0
- package/cmake/ports/libgpac/patches/02-library-only.patch +32 -0
- package/cmake/ports/libgpac/patches/03-windows-compat.patch +93 -0
- package/cmake/ports/libgpac/port.cmake +159 -0
- package/index.js +80 -0
- package/package.json +44 -1
- package/prebuilds/android-arm/bare-gpac.bare +0 -0
- package/prebuilds/android-arm64/bare-gpac.bare +0 -0
- package/prebuilds/android-ia32/bare-gpac.bare +0 -0
- package/prebuilds/android-x64/bare-gpac.bare +0 -0
- package/prebuilds/darwin-arm64/bare-gpac.bare +0 -0
- package/prebuilds/darwin-x64/bare-gpac.bare +0 -0
- package/prebuilds/ios-arm64/bare-gpac.bare +0 -0
- package/prebuilds/ios-arm64-simulator/bare-gpac.bare +0 -0
- package/prebuilds/ios-x64-simulator/bare-gpac.bare +0 -0
- package/prebuilds/linux-arm64/bare-gpac.bare +0 -0
- package/prebuilds/linux-x64/bare-gpac.bare +0 -0
- package/prebuilds/win32-arm64/bare-gpac.bare +0 -0
- package/prebuilds/win32-x64/bare-gpac.bare +0 -0
package/binding.c
ADDED
|
@@ -0,0 +1,911 @@
|
|
|
1
|
+
#include <assert.h>
|
|
2
|
+
#include <bare.h>
|
|
3
|
+
#include <gpac/internal/isomedia_dev.h>
|
|
4
|
+
#include <gpac/isomedia.h>
|
|
5
|
+
#include <js.h>
|
|
6
|
+
#include <stdint.h>
|
|
7
|
+
#include <stdio.h>
|
|
8
|
+
#include <stdlib.h>
|
|
9
|
+
#include <string.h>
|
|
10
|
+
|
|
11
|
+
typedef struct {
|
|
12
|
+
GF_ISOFile *handle;
|
|
13
|
+
GF_Blob input;
|
|
14
|
+
GF_Box **boxes;
|
|
15
|
+
uint32_t box_count;
|
|
16
|
+
} bare_gpac_file_t;
|
|
17
|
+
|
|
18
|
+
typedef struct {
|
|
19
|
+
uint8_t *data;
|
|
20
|
+
size_t len;
|
|
21
|
+
size_t capacity;
|
|
22
|
+
GF_Err error;
|
|
23
|
+
} bare_gpac_output_t;
|
|
24
|
+
|
|
25
|
+
static bool
|
|
26
|
+
bare_gpac__get_fourcc(js_env_t *env, js_value_t *value, uint32_t *type) {
|
|
27
|
+
size_t len;
|
|
28
|
+
if (js_get_value_string_utf8(env, value, NULL, 0, &len) < 0) {
|
|
29
|
+
return false;
|
|
30
|
+
}
|
|
31
|
+
|
|
32
|
+
if (len != 4) {
|
|
33
|
+
js_throw_range_error(env, NULL, "Expected a four-byte type");
|
|
34
|
+
|
|
35
|
+
return false;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
utf8_t bytes[5];
|
|
39
|
+
if (js_get_value_string_utf8(env, value, bytes, sizeof(bytes), NULL) < 0) {
|
|
40
|
+
return false;
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
*type = GF_4CC(bytes[0], bytes[1], bytes[2], bytes[3]);
|
|
44
|
+
|
|
45
|
+
return true;
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
static void
|
|
49
|
+
bare_gpac__set_string(js_env_t *env, js_value_t *object, const char *key, const char *text) {
|
|
50
|
+
int err;
|
|
51
|
+
|
|
52
|
+
js_value_t *value;
|
|
53
|
+
err = js_create_string_utf8(env, (const utf8_t *) (text ? text : ""), -1, &value);
|
|
54
|
+
assert(err == 0);
|
|
55
|
+
|
|
56
|
+
err = js_set_named_property(env, object, key, value);
|
|
57
|
+
assert(err == 0);
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
static void
|
|
61
|
+
bare_gpac__set_fourcc(js_env_t *env, js_value_t *object, const char *key, uint32_t type) {
|
|
62
|
+
char fourcc[5] = {type >> 24, type >> 16, type >> 8, type, 0};
|
|
63
|
+
bare_gpac__set_string(env, object, key, fourcc);
|
|
64
|
+
}
|
|
65
|
+
|
|
66
|
+
static void
|
|
67
|
+
bare_gpac__set_boolean(js_env_t *env, js_value_t *object, const char *key, bool boolean) {
|
|
68
|
+
int err;
|
|
69
|
+
|
|
70
|
+
js_value_t *value;
|
|
71
|
+
err = js_get_boolean(env, boolean, &value);
|
|
72
|
+
assert(err == 0);
|
|
73
|
+
|
|
74
|
+
err = js_set_named_property(env, object, key, value);
|
|
75
|
+
assert(err == 0);
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
static void
|
|
79
|
+
bare_gpac__set_uint32(js_env_t *env, js_value_t *object, const char *key, uint32_t number) {
|
|
80
|
+
int err;
|
|
81
|
+
|
|
82
|
+
js_value_t *value;
|
|
83
|
+
err = js_create_uint32(env, number, &value);
|
|
84
|
+
assert(err == 0);
|
|
85
|
+
|
|
86
|
+
err = js_set_named_property(env, object, key, value);
|
|
87
|
+
assert(err == 0);
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
static js_value_t *
|
|
91
|
+
bare_gpac__copy_arraybuffer(js_env_t *env, const void *data, size_t len) {
|
|
92
|
+
int err;
|
|
93
|
+
|
|
94
|
+
js_value_t *result;
|
|
95
|
+
void *output;
|
|
96
|
+
err = js_create_arraybuffer(env, len, &output, &result);
|
|
97
|
+
if (err < 0) {
|
|
98
|
+
return NULL;
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
if (len) {
|
|
102
|
+
memcpy(output, data, len);
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
return result;
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
static js_value_t *
|
|
109
|
+
bare_gpac__throw(js_env_t *env, GF_Err code) {
|
|
110
|
+
int err;
|
|
111
|
+
|
|
112
|
+
err = js_throw_error(env, "ERR_GPAC", gf_error_to_string(code));
|
|
113
|
+
assert(err == 0);
|
|
114
|
+
|
|
115
|
+
return NULL;
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
static void
|
|
119
|
+
bare_gpac__close(bare_gpac_file_t *self) {
|
|
120
|
+
if (self->handle != NULL) {
|
|
121
|
+
gf_isom_delete(self->handle);
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
self->handle = NULL;
|
|
125
|
+
|
|
126
|
+
free(self->input.data);
|
|
127
|
+
self->input.data = NULL;
|
|
128
|
+
|
|
129
|
+
free(self->boxes);
|
|
130
|
+
self->boxes = NULL;
|
|
131
|
+
self->box_count = 0;
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
static void
|
|
135
|
+
bare_gpac__on_finalize(js_env_t *env, void *data, void *hint) {
|
|
136
|
+
bare_gpac_file_t *self = data;
|
|
137
|
+
|
|
138
|
+
bare_gpac__close(self);
|
|
139
|
+
|
|
140
|
+
free(self);
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
static bare_gpac_file_t *
|
|
144
|
+
bare_gpac__unwrap(js_env_t *env, js_value_t *value) {
|
|
145
|
+
int err;
|
|
146
|
+
|
|
147
|
+
bare_gpac_file_t *self;
|
|
148
|
+
err = js_unwrap(env, value, (void **) &self);
|
|
149
|
+
assert(err == 0);
|
|
150
|
+
|
|
151
|
+
if (self->handle == NULL) {
|
|
152
|
+
js_throw_error(env, NULL, "ISO-BMFF file has been destroyed");
|
|
153
|
+
|
|
154
|
+
return NULL;
|
|
155
|
+
}
|
|
156
|
+
|
|
157
|
+
return self;
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
static js_value_t *
|
|
161
|
+
bare_gpac_init(js_env_t *env, js_callback_info_t *info) {
|
|
162
|
+
int err;
|
|
163
|
+
|
|
164
|
+
size_t argc = 4;
|
|
165
|
+
js_value_t *argv[4];
|
|
166
|
+
|
|
167
|
+
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
|
|
168
|
+
assert(err == 0);
|
|
169
|
+
|
|
170
|
+
assert(argc == 4);
|
|
171
|
+
|
|
172
|
+
uint8_t *data;
|
|
173
|
+
size_t buffer_cap;
|
|
174
|
+
err = js_get_arraybuffer_info(env, argv[1], (void **) &data, &buffer_cap);
|
|
175
|
+
assert(err == 0);
|
|
176
|
+
|
|
177
|
+
int64_t offset;
|
|
178
|
+
err = js_get_value_int64(env, argv[2], &offset);
|
|
179
|
+
assert(err == 0);
|
|
180
|
+
|
|
181
|
+
int64_t len;
|
|
182
|
+
err = js_get_value_int64(env, argv[3], &len);
|
|
183
|
+
assert(err == 0);
|
|
184
|
+
|
|
185
|
+
if (offset < 0 || len < 8 || len > UINT32_MAX || (uint64_t) offset > buffer_cap || (uint64_t) len > buffer_cap - (size_t) offset) {
|
|
186
|
+
return bare_gpac__throw(env, GF_BAD_PARAM);
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
bare_gpac_file_t *self = calloc(1, sizeof(*self));
|
|
190
|
+
|
|
191
|
+
if (self == NULL) {
|
|
192
|
+
return bare_gpac__throw(env, GF_OUT_OF_MEM);
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
self->input.data = malloc((size_t) len);
|
|
196
|
+
|
|
197
|
+
if (self->input.data == NULL) {
|
|
198
|
+
free(self);
|
|
199
|
+
|
|
200
|
+
return bare_gpac__throw(env, GF_OUT_OF_MEM);
|
|
201
|
+
}
|
|
202
|
+
|
|
203
|
+
memcpy(self->input.data, data + offset, (size_t) len);
|
|
204
|
+
self->input.size = (uint32_t) len;
|
|
205
|
+
|
|
206
|
+
char url[64];
|
|
207
|
+
snprintf(url, sizeof(url), "gmem://%p", (void *) &self->input);
|
|
208
|
+
|
|
209
|
+
self->handle = gf_isom_open(url, GF_ISOM_OPEN_READ_EDIT, NULL);
|
|
210
|
+
|
|
211
|
+
if (self->handle == NULL) {
|
|
212
|
+
GF_Err code = gf_isom_last_error(NULL);
|
|
213
|
+
|
|
214
|
+
bare_gpac__on_finalize(env, self, NULL);
|
|
215
|
+
|
|
216
|
+
return bare_gpac__throw(env, code);
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
gf_isom_keep_utc_times(self->handle, GF_TRUE);
|
|
220
|
+
gf_isom_disable_inplace_rewrite(self->handle);
|
|
221
|
+
|
|
222
|
+
err = js_wrap(env, argv[0], self, bare_gpac__on_finalize, NULL, NULL);
|
|
223
|
+
|
|
224
|
+
if (err < 0) {
|
|
225
|
+
bare_gpac__on_finalize(env, self, NULL);
|
|
226
|
+
|
|
227
|
+
return NULL;
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
return argv[0];
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
static js_value_t *
|
|
234
|
+
bare_gpac_items(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_gpac_file_t *self = bare_gpac__unwrap(env, argv[0]);
|
|
246
|
+
|
|
247
|
+
if (self == NULL) {
|
|
248
|
+
return NULL;
|
|
249
|
+
}
|
|
250
|
+
|
|
251
|
+
uint32_t count = gf_isom_get_meta_item_count(self->handle, GF_TRUE, 0);
|
|
252
|
+
uint32_t primary = gf_isom_get_meta_primary_item_id(self->handle, GF_TRUE, 0);
|
|
253
|
+
|
|
254
|
+
js_value_t *result;
|
|
255
|
+
err = js_create_array_with_length(env, count, &result);
|
|
256
|
+
assert(err == 0);
|
|
257
|
+
|
|
258
|
+
for (uint32_t i = 0; i < count; i++) {
|
|
259
|
+
uint32_t id;
|
|
260
|
+
uint32_t type;
|
|
261
|
+
uint32_t protection;
|
|
262
|
+
uint32_t version;
|
|
263
|
+
const char *name;
|
|
264
|
+
const char *mime;
|
|
265
|
+
const char *encoding;
|
|
266
|
+
const char *url;
|
|
267
|
+
const char *urn;
|
|
268
|
+
|
|
269
|
+
GF_Err code = gf_isom_get_meta_item_info(self->handle, GF_TRUE, 0, i + 1, &id, &type, &protection, &version, NULL, &name, &mime, &encoding, &url, &urn);
|
|
270
|
+
if (code) {
|
|
271
|
+
return bare_gpac__throw(env, code);
|
|
272
|
+
}
|
|
273
|
+
|
|
274
|
+
js_value_t *item;
|
|
275
|
+
err = js_create_object(env, &item);
|
|
276
|
+
assert(err == 0);
|
|
277
|
+
|
|
278
|
+
bare_gpac__set_uint32(env, item, "id", id);
|
|
279
|
+
bare_gpac__set_boolean(env, item, "primary", id == primary);
|
|
280
|
+
bare_gpac__set_fourcc(env, item, "type", type);
|
|
281
|
+
bare_gpac__set_string(env, item, "name", name);
|
|
282
|
+
bare_gpac__set_string(env, item, "contentType", mime);
|
|
283
|
+
bare_gpac__set_string(env, item, "contentEncoding", encoding);
|
|
284
|
+
|
|
285
|
+
err = js_set_element(env, result, i, item);
|
|
286
|
+
assert(err == 0);
|
|
287
|
+
}
|
|
288
|
+
|
|
289
|
+
return result;
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
static js_value_t *
|
|
293
|
+
bare_gpac_add_item(js_env_t *env, js_callback_info_t *info) {
|
|
294
|
+
int err;
|
|
295
|
+
|
|
296
|
+
size_t argc = 9;
|
|
297
|
+
js_value_t *argv[9];
|
|
298
|
+
|
|
299
|
+
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
|
|
300
|
+
assert(err == 0);
|
|
301
|
+
|
|
302
|
+
assert(argc == 9);
|
|
303
|
+
|
|
304
|
+
bare_gpac_file_t *self = bare_gpac__unwrap(env, argv[0]);
|
|
305
|
+
|
|
306
|
+
if (self == NULL) {
|
|
307
|
+
return NULL;
|
|
308
|
+
}
|
|
309
|
+
|
|
310
|
+
uint8_t *data;
|
|
311
|
+
size_t buffer_cap;
|
|
312
|
+
err = js_get_arraybuffer_info(env, argv[1], (void **) &data, &buffer_cap);
|
|
313
|
+
assert(err == 0);
|
|
314
|
+
|
|
315
|
+
int64_t offset;
|
|
316
|
+
err = js_get_value_int64(env, argv[2], &offset);
|
|
317
|
+
assert(err == 0);
|
|
318
|
+
|
|
319
|
+
int64_t len;
|
|
320
|
+
err = js_get_value_int64(env, argv[3], &len);
|
|
321
|
+
assert(err == 0);
|
|
322
|
+
|
|
323
|
+
if (offset < 0 || len <= 0 || len > UINT32_MAX || (uint64_t) offset > buffer_cap || (uint64_t) len > buffer_cap - (size_t) offset) {
|
|
324
|
+
return bare_gpac__throw(env, GF_BAD_PARAM);
|
|
325
|
+
}
|
|
326
|
+
|
|
327
|
+
uint32_t id;
|
|
328
|
+
err = js_get_value_uint32(env, argv[4], &id);
|
|
329
|
+
assert(err == 0);
|
|
330
|
+
|
|
331
|
+
uint32_t type;
|
|
332
|
+
if (!bare_gpac__get_fourcc(env, argv[5], &type)) {
|
|
333
|
+
return NULL;
|
|
334
|
+
}
|
|
335
|
+
|
|
336
|
+
char *strings[3] = {NULL, NULL, NULL};
|
|
337
|
+
GF_Err code = GF_OK;
|
|
338
|
+
|
|
339
|
+
for (size_t i = 0; i < 3; i++) {
|
|
340
|
+
size_t string_len;
|
|
341
|
+
err = js_get_value_string_utf8(env, argv[6 + i], NULL, 0, &string_len);
|
|
342
|
+
assert(err == 0);
|
|
343
|
+
|
|
344
|
+
strings[i] = malloc(string_len + 1);
|
|
345
|
+
|
|
346
|
+
if (strings[i] == NULL) {
|
|
347
|
+
code = GF_OUT_OF_MEM;
|
|
348
|
+
|
|
349
|
+
break;
|
|
350
|
+
}
|
|
351
|
+
|
|
352
|
+
err = js_get_value_string_utf8(env, argv[6 + i], (utf8_t *) strings[i], string_len + 1, NULL);
|
|
353
|
+
assert(err == 0);
|
|
354
|
+
}
|
|
355
|
+
|
|
356
|
+
if (!code) {
|
|
357
|
+
code = gf_isom_add_meta_item_memory(self->handle, GF_TRUE, 0, strings[0], &id, type, strings[1][0] ? strings[1] : NULL, strings[2][0] ? strings[2] : NULL, NULL, (char *) data + offset, (uint32_t) len, NULL);
|
|
358
|
+
}
|
|
359
|
+
|
|
360
|
+
for (size_t i = 0; i < 3; i++) free(strings[i]);
|
|
361
|
+
|
|
362
|
+
if (code) {
|
|
363
|
+
return bare_gpac__throw(env, code);
|
|
364
|
+
}
|
|
365
|
+
|
|
366
|
+
js_value_t *result;
|
|
367
|
+
err = js_create_uint32(env, id, &result);
|
|
368
|
+
assert(err == 0);
|
|
369
|
+
|
|
370
|
+
return result;
|
|
371
|
+
}
|
|
372
|
+
|
|
373
|
+
static js_value_t *
|
|
374
|
+
bare_gpac_read_item(js_env_t *env, js_callback_info_t *info) {
|
|
375
|
+
int err;
|
|
376
|
+
|
|
377
|
+
size_t argc = 2;
|
|
378
|
+
js_value_t *argv[2];
|
|
379
|
+
|
|
380
|
+
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
|
|
381
|
+
assert(err == 0);
|
|
382
|
+
|
|
383
|
+
assert(argc == 2);
|
|
384
|
+
|
|
385
|
+
bare_gpac_file_t *self = bare_gpac__unwrap(env, argv[0]);
|
|
386
|
+
|
|
387
|
+
if (self == NULL) {
|
|
388
|
+
return NULL;
|
|
389
|
+
}
|
|
390
|
+
|
|
391
|
+
uint32_t id;
|
|
392
|
+
err = js_get_value_uint32(env, argv[1], &id);
|
|
393
|
+
assert(err == 0);
|
|
394
|
+
|
|
395
|
+
uint32_t index = gf_isom_get_meta_item_by_id(self->handle, GF_TRUE, 0, id);
|
|
396
|
+
|
|
397
|
+
if (index) {
|
|
398
|
+
GF_ItemInfoEntryBox *infe = gf_list_get(self->handle->meta->item_infos->item_infos, index - 1);
|
|
399
|
+
|
|
400
|
+
if (infe->full_path != NULL && infe->data_len) {
|
|
401
|
+
return bare_gpac__copy_arraybuffer(env, infe->full_path, infe->data_len);
|
|
402
|
+
}
|
|
403
|
+
}
|
|
404
|
+
|
|
405
|
+
uint8_t *data = NULL;
|
|
406
|
+
uint32_t len = 0;
|
|
407
|
+
uint32_t capacity = 0;
|
|
408
|
+
|
|
409
|
+
GF_Err code = gf_isom_extract_meta_item_mem(self->handle, GF_TRUE, 0, id, &data, &len, &capacity, NULL, GF_FALSE);
|
|
410
|
+
|
|
411
|
+
if (code == GF_OK && data == NULL) {
|
|
412
|
+
code = GF_NOT_SUPPORTED;
|
|
413
|
+
}
|
|
414
|
+
|
|
415
|
+
if (code) {
|
|
416
|
+
gf_free(data);
|
|
417
|
+
|
|
418
|
+
return bare_gpac__throw(env, code);
|
|
419
|
+
}
|
|
420
|
+
|
|
421
|
+
js_value_t *result = bare_gpac__copy_arraybuffer(env, data, len);
|
|
422
|
+
|
|
423
|
+
gf_free(data);
|
|
424
|
+
|
|
425
|
+
return result;
|
|
426
|
+
}
|
|
427
|
+
|
|
428
|
+
typedef struct {
|
|
429
|
+
uint64_t start;
|
|
430
|
+
uint64_t len;
|
|
431
|
+
} bare_gpac_range_t;
|
|
432
|
+
|
|
433
|
+
static GF_Err
|
|
434
|
+
bare_gpac__item_range(bare_gpac_file_t *self, GF_MediaDataBox *idat, GF_ItemLocationEntry *item, GF_ItemExtentEntry *extent, bare_gpac_range_t *range) {
|
|
435
|
+
if (item->data_reference_index || item->construction_method > 1 || extent->extent_index) {
|
|
436
|
+
return GF_NOT_SUPPORTED;
|
|
437
|
+
}
|
|
438
|
+
|
|
439
|
+
uint64_t origin = item->construction_method == 1 ? idat->bsOffset : 0;
|
|
440
|
+
uint64_t limit = item->construction_method == 1 ? idat->dataSize : self->input.size;
|
|
441
|
+
|
|
442
|
+
if (item->base_offset > limit || extent->extent_offset > limit - item->base_offset) {
|
|
443
|
+
return GF_ISOM_INVALID_FILE;
|
|
444
|
+
}
|
|
445
|
+
|
|
446
|
+
uint64_t offset = item->base_offset + extent->extent_offset;
|
|
447
|
+
uint64_t len = extent->extent_length;
|
|
448
|
+
|
|
449
|
+
if (!len) {
|
|
450
|
+
if (gf_list_count(item->extent_entries) != 1) {
|
|
451
|
+
return GF_NOT_SUPPORTED;
|
|
452
|
+
}
|
|
453
|
+
len = limit - offset;
|
|
454
|
+
}
|
|
455
|
+
|
|
456
|
+
if (len > limit - offset) {
|
|
457
|
+
return GF_ISOM_INVALID_FILE;
|
|
458
|
+
}
|
|
459
|
+
|
|
460
|
+
range->start = origin + offset;
|
|
461
|
+
range->len = len;
|
|
462
|
+
|
|
463
|
+
return GF_OK;
|
|
464
|
+
}
|
|
465
|
+
|
|
466
|
+
static GF_Err
|
|
467
|
+
bare_gpac__erase_item_data(bare_gpac_file_t *self, uint32_t id) {
|
|
468
|
+
GF_MetaBox *meta = self->handle->meta;
|
|
469
|
+
|
|
470
|
+
if (meta == NULL || meta->item_infos == NULL || meta->item_locations == NULL) {
|
|
471
|
+
return GF_BAD_PARAM;
|
|
472
|
+
}
|
|
473
|
+
|
|
474
|
+
if (!gf_isom_get_meta_item_by_id(self->handle, GF_TRUE, 0, id)) {
|
|
475
|
+
return GF_NOT_FOUND;
|
|
476
|
+
}
|
|
477
|
+
|
|
478
|
+
GF_List *locations = meta->item_locations->location_entries;
|
|
479
|
+
GF_ItemLocationEntry *target = NULL;
|
|
480
|
+
|
|
481
|
+
for (uint32_t i = 0; i < gf_list_count(locations); i++) {
|
|
482
|
+
GF_ItemLocationEntry *item = gf_list_get(locations, i);
|
|
483
|
+
|
|
484
|
+
if (item->item_ID != id) {
|
|
485
|
+
continue;
|
|
486
|
+
}
|
|
487
|
+
if (target != NULL) {
|
|
488
|
+
return GF_ISOM_INVALID_FILE;
|
|
489
|
+
}
|
|
490
|
+
|
|
491
|
+
target = item;
|
|
492
|
+
}
|
|
493
|
+
|
|
494
|
+
if (target == NULL) {
|
|
495
|
+
return GF_ISOM_INVALID_FILE;
|
|
496
|
+
}
|
|
497
|
+
|
|
498
|
+
// Only idat storage needs explicit erasure; leave other removal behavior alone.
|
|
499
|
+
if (target->construction_method == 0) {
|
|
500
|
+
return GF_OK;
|
|
501
|
+
}
|
|
502
|
+
|
|
503
|
+
if (target->construction_method != 1 || target->data_reference_index) {
|
|
504
|
+
return GF_NOT_SUPPORTED;
|
|
505
|
+
}
|
|
506
|
+
|
|
507
|
+
GF_MediaDataBox *idat = NULL;
|
|
508
|
+
|
|
509
|
+
for (uint32_t i = 0; i < gf_list_count(meta->child_boxes); i++) {
|
|
510
|
+
GF_Box *box = gf_list_get(meta->child_boxes, i);
|
|
511
|
+
|
|
512
|
+
if (box->type != GF_ISOM_BOX_TYPE_IDAT) continue;
|
|
513
|
+
|
|
514
|
+
if (idat != NULL) {
|
|
515
|
+
return GF_ISOM_INVALID_FILE;
|
|
516
|
+
}
|
|
517
|
+
|
|
518
|
+
idat = (GF_MediaDataBox *) box;
|
|
519
|
+
}
|
|
520
|
+
|
|
521
|
+
if (idat == NULL || idat->data == NULL || idat->bsOffset > self->input.size || idat->dataSize > self->input.size - idat->bsOffset) {
|
|
522
|
+
return GF_ISOM_INVALID_FILE;
|
|
523
|
+
}
|
|
524
|
+
|
|
525
|
+
uint32_t count = gf_list_count(target->extent_entries);
|
|
526
|
+
|
|
527
|
+
if (!count) {
|
|
528
|
+
return GF_ISOM_INVALID_FILE;
|
|
529
|
+
}
|
|
530
|
+
|
|
531
|
+
if ((size_t) count > SIZE_MAX / sizeof(bare_gpac_range_t)) {
|
|
532
|
+
return GF_OUT_OF_MEM;
|
|
533
|
+
}
|
|
534
|
+
|
|
535
|
+
bare_gpac_range_t *ranges = malloc((size_t) count * sizeof(*ranges));
|
|
536
|
+
|
|
537
|
+
if (ranges == NULL) {
|
|
538
|
+
return GF_OUT_OF_MEM;
|
|
539
|
+
}
|
|
540
|
+
|
|
541
|
+
GF_Err code = GF_OK;
|
|
542
|
+
|
|
543
|
+
for (uint32_t i = 0; i < count; i++) {
|
|
544
|
+
code = bare_gpac__item_range(self, idat, target, gf_list_get(target->extent_entries, i), &ranges[i]);
|
|
545
|
+
if (code) {
|
|
546
|
+
goto done;
|
|
547
|
+
}
|
|
548
|
+
}
|
|
549
|
+
|
|
550
|
+
for (uint32_t i = 0; i < gf_list_count(locations); i++) {
|
|
551
|
+
GF_ItemLocationEntry *item = gf_list_get(locations, i);
|
|
552
|
+
|
|
553
|
+
if (item == target) continue;
|
|
554
|
+
|
|
555
|
+
if (item->construction_method > 1 || item->data_reference_index) {
|
|
556
|
+
code = GF_NOT_SUPPORTED;
|
|
557
|
+
goto done;
|
|
558
|
+
}
|
|
559
|
+
|
|
560
|
+
for (uint32_t j = 0; j < gf_list_count(item->extent_entries); j++) {
|
|
561
|
+
bare_gpac_range_t other;
|
|
562
|
+
code = bare_gpac__item_range(self, idat, item, gf_list_get(item->extent_entries, j), &other);
|
|
563
|
+
if (code) goto done;
|
|
564
|
+
|
|
565
|
+
for (uint32_t k = 0; k < count; k++) {
|
|
566
|
+
if (ranges[k].len && other.len && ranges[k].start < other.start + other.len && other.start < ranges[k].start + ranges[k].len) {
|
|
567
|
+
code = GF_BAD_PARAM;
|
|
568
|
+
goto done;
|
|
569
|
+
}
|
|
570
|
+
}
|
|
571
|
+
}
|
|
572
|
+
}
|
|
573
|
+
|
|
574
|
+
// GPAC serializes its idat copy but extracts items from the owned input.
|
|
575
|
+
// No bytes or item records are changed until all ranges have passed validation.
|
|
576
|
+
for (uint32_t i = 0; i < count; i++) {
|
|
577
|
+
memset(idat->data + (size_t) (ranges[i].start - idat->bsOffset), 0, (size_t) ranges[i].len);
|
|
578
|
+
memset(self->input.data + (size_t) ranges[i].start, 0, (size_t) ranges[i].len);
|
|
579
|
+
}
|
|
580
|
+
|
|
581
|
+
done:
|
|
582
|
+
free(ranges);
|
|
583
|
+
|
|
584
|
+
return code;
|
|
585
|
+
}
|
|
586
|
+
|
|
587
|
+
static js_value_t *
|
|
588
|
+
bare_gpac_erase_item_data(js_env_t *env, js_callback_info_t *info) {
|
|
589
|
+
int err;
|
|
590
|
+
|
|
591
|
+
size_t argc = 2;
|
|
592
|
+
js_value_t *argv[2];
|
|
593
|
+
|
|
594
|
+
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
|
|
595
|
+
assert(err == 0);
|
|
596
|
+
|
|
597
|
+
assert(argc == 2);
|
|
598
|
+
|
|
599
|
+
bare_gpac_file_t *self = bare_gpac__unwrap(env, argv[0]);
|
|
600
|
+
|
|
601
|
+
if (self == NULL) {
|
|
602
|
+
return NULL;
|
|
603
|
+
}
|
|
604
|
+
|
|
605
|
+
uint32_t id;
|
|
606
|
+
err = js_get_value_uint32(env, argv[1], &id);
|
|
607
|
+
assert(err == 0);
|
|
608
|
+
|
|
609
|
+
if (id == gf_isom_get_meta_primary_item_id(self->handle, GF_TRUE, 0)) {
|
|
610
|
+
return bare_gpac__throw(env, GF_BAD_PARAM);
|
|
611
|
+
}
|
|
612
|
+
|
|
613
|
+
GF_Err code = bare_gpac__erase_item_data(self, id);
|
|
614
|
+
if (code) {
|
|
615
|
+
return bare_gpac__throw(env, code);
|
|
616
|
+
}
|
|
617
|
+
|
|
618
|
+
return NULL;
|
|
619
|
+
}
|
|
620
|
+
|
|
621
|
+
static js_value_t *
|
|
622
|
+
bare_gpac_remove_item(js_env_t *env, js_callback_info_t *info) {
|
|
623
|
+
int err;
|
|
624
|
+
|
|
625
|
+
size_t argc = 3;
|
|
626
|
+
js_value_t *argv[3];
|
|
627
|
+
|
|
628
|
+
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
|
|
629
|
+
assert(err == 0);
|
|
630
|
+
|
|
631
|
+
assert(argc == 3);
|
|
632
|
+
|
|
633
|
+
bare_gpac_file_t *self = bare_gpac__unwrap(env, argv[0]);
|
|
634
|
+
|
|
635
|
+
if (self == NULL) {
|
|
636
|
+
return NULL;
|
|
637
|
+
}
|
|
638
|
+
|
|
639
|
+
uint32_t id;
|
|
640
|
+
err = js_get_value_uint32(env, argv[1], &id);
|
|
641
|
+
assert(err == 0);
|
|
642
|
+
|
|
643
|
+
if (id == gf_isom_get_meta_primary_item_id(self->handle, GF_TRUE, 0)) {
|
|
644
|
+
return bare_gpac__throw(env, GF_BAD_PARAM);
|
|
645
|
+
}
|
|
646
|
+
|
|
647
|
+
bool keep_refs;
|
|
648
|
+
err = js_get_value_bool(env, argv[2], &keep_refs);
|
|
649
|
+
assert(err == 0);
|
|
650
|
+
|
|
651
|
+
GF_Err code = gf_isom_remove_meta_item(self->handle, GF_TRUE, 0, id, keep_refs, NULL);
|
|
652
|
+
if (code) {
|
|
653
|
+
return bare_gpac__throw(env, code);
|
|
654
|
+
}
|
|
655
|
+
|
|
656
|
+
return NULL;
|
|
657
|
+
}
|
|
658
|
+
|
|
659
|
+
static js_value_t *
|
|
660
|
+
bare_gpac_find_box(js_env_t *env, js_callback_info_t *info) {
|
|
661
|
+
int err;
|
|
662
|
+
|
|
663
|
+
size_t argc = 2;
|
|
664
|
+
js_value_t *argv[2];
|
|
665
|
+
|
|
666
|
+
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
|
|
667
|
+
assert(err == 0);
|
|
668
|
+
|
|
669
|
+
assert(argc == 2);
|
|
670
|
+
|
|
671
|
+
bare_gpac_file_t *self = bare_gpac__unwrap(env, argv[0]);
|
|
672
|
+
|
|
673
|
+
if (self == NULL) {
|
|
674
|
+
return NULL;
|
|
675
|
+
}
|
|
676
|
+
|
|
677
|
+
uint32_t type;
|
|
678
|
+
if (!bare_gpac__get_fourcc(env, argv[1], &type)) {
|
|
679
|
+
return NULL;
|
|
680
|
+
}
|
|
681
|
+
|
|
682
|
+
GF_Box *box = gf_isom_box_find_child(self->handle->TopBoxes, type);
|
|
683
|
+
uint32_t id = 0;
|
|
684
|
+
|
|
685
|
+
if (box != NULL) {
|
|
686
|
+
for (uint32_t i = 0; i < self->box_count; i++) {
|
|
687
|
+
if (self->boxes[i] == box) {
|
|
688
|
+
id = i + 1;
|
|
689
|
+
break;
|
|
690
|
+
}
|
|
691
|
+
}
|
|
692
|
+
|
|
693
|
+
if (!id) {
|
|
694
|
+
if (self->box_count == UINT32_MAX || (size_t) self->box_count >= SIZE_MAX / sizeof(*self->boxes)) {
|
|
695
|
+
return bare_gpac__throw(env, GF_OUT_OF_MEM);
|
|
696
|
+
}
|
|
697
|
+
|
|
698
|
+
GF_Box **boxes = realloc(self->boxes, ((size_t) self->box_count + 1) * sizeof(*boxes));
|
|
699
|
+
|
|
700
|
+
if (boxes == NULL) {
|
|
701
|
+
return bare_gpac__throw(env, GF_OUT_OF_MEM);
|
|
702
|
+
}
|
|
703
|
+
|
|
704
|
+
self->boxes = boxes;
|
|
705
|
+
self->boxes[self->box_count++] = box;
|
|
706
|
+
id = self->box_count;
|
|
707
|
+
}
|
|
708
|
+
}
|
|
709
|
+
|
|
710
|
+
js_value_t *result;
|
|
711
|
+
|
|
712
|
+
if (box == NULL) {
|
|
713
|
+
err = js_get_null(env, &result);
|
|
714
|
+
assert(err == 0);
|
|
715
|
+
|
|
716
|
+
return result;
|
|
717
|
+
}
|
|
718
|
+
|
|
719
|
+
err = js_create_object(env, &result);
|
|
720
|
+
assert(err == 0);
|
|
721
|
+
|
|
722
|
+
bare_gpac__set_uint32(env, result, "id", id);
|
|
723
|
+
|
|
724
|
+
type = box->type == GF_ISOM_BOX_TYPE_UNKNOWN ? ((GF_UnknownBox *) box)->original_4cc : box->type;
|
|
725
|
+
bare_gpac__set_fourcc(env, result, "type", type);
|
|
726
|
+
|
|
727
|
+
return result;
|
|
728
|
+
}
|
|
729
|
+
|
|
730
|
+
static js_value_t *
|
|
731
|
+
bare_gpac_remove_box(js_env_t *env, js_callback_info_t *info) {
|
|
732
|
+
int err;
|
|
733
|
+
|
|
734
|
+
size_t argc = 2;
|
|
735
|
+
js_value_t *argv[2];
|
|
736
|
+
|
|
737
|
+
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
|
|
738
|
+
assert(err == 0);
|
|
739
|
+
|
|
740
|
+
assert(argc == 2);
|
|
741
|
+
|
|
742
|
+
bare_gpac_file_t *self = bare_gpac__unwrap(env, argv[0]);
|
|
743
|
+
|
|
744
|
+
if (self == NULL) {
|
|
745
|
+
return NULL;
|
|
746
|
+
}
|
|
747
|
+
|
|
748
|
+
uint32_t id;
|
|
749
|
+
err = js_get_value_uint32(env, argv[1], &id);
|
|
750
|
+
assert(err == 0);
|
|
751
|
+
|
|
752
|
+
if (!id || id > self->box_count || self->boxes[id - 1] == NULL) {
|
|
753
|
+
return bare_gpac__throw(env, GF_BAD_PARAM);
|
|
754
|
+
}
|
|
755
|
+
|
|
756
|
+
GF_Box *box = self->boxes[id - 1];
|
|
757
|
+
|
|
758
|
+
if (box->type != GF_ISOM_BOX_TYPE_UNKNOWN) {
|
|
759
|
+
return bare_gpac__throw(env, GF_NOT_SUPPORTED);
|
|
760
|
+
}
|
|
761
|
+
|
|
762
|
+
gf_isom_box_del_parent(&self->handle->TopBoxes, box);
|
|
763
|
+
|
|
764
|
+
self->boxes[id - 1] = NULL;
|
|
765
|
+
|
|
766
|
+
return NULL;
|
|
767
|
+
}
|
|
768
|
+
|
|
769
|
+
static GF_Err
|
|
770
|
+
bare_gpac__on_write(void *data, uint8_t *block, uint32_t len, void *sample, uint32_t magic) {
|
|
771
|
+
bare_gpac_output_t *output = data;
|
|
772
|
+
|
|
773
|
+
if (output->error) {
|
|
774
|
+
return output->error;
|
|
775
|
+
}
|
|
776
|
+
|
|
777
|
+
if (len > UINT32_MAX - output->len) {
|
|
778
|
+
return output->error = GF_OUT_OF_MEM;
|
|
779
|
+
}
|
|
780
|
+
|
|
781
|
+
size_t end = output->len + len;
|
|
782
|
+
|
|
783
|
+
if (end > output->capacity) {
|
|
784
|
+
size_t capacity = end > UINT32_MAX / 2 ? end : end * 2;
|
|
785
|
+
uint8_t *next = realloc(output->data, capacity);
|
|
786
|
+
|
|
787
|
+
if (next == NULL) {
|
|
788
|
+
return output->error = GF_OUT_OF_MEM;
|
|
789
|
+
}
|
|
790
|
+
|
|
791
|
+
output->data = next;
|
|
792
|
+
output->capacity = capacity;
|
|
793
|
+
}
|
|
794
|
+
|
|
795
|
+
if (len) {
|
|
796
|
+
memcpy(output->data + output->len, block, len);
|
|
797
|
+
}
|
|
798
|
+
|
|
799
|
+
output->len = end;
|
|
800
|
+
|
|
801
|
+
return GF_OK;
|
|
802
|
+
}
|
|
803
|
+
|
|
804
|
+
static js_value_t *
|
|
805
|
+
bare_gpac_write(js_env_t *env, js_callback_info_t *info) {
|
|
806
|
+
int err;
|
|
807
|
+
|
|
808
|
+
size_t argc = 1;
|
|
809
|
+
js_value_t *argv[1];
|
|
810
|
+
|
|
811
|
+
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
|
|
812
|
+
assert(err == 0);
|
|
813
|
+
|
|
814
|
+
assert(argc == 1);
|
|
815
|
+
|
|
816
|
+
bare_gpac_file_t *self = bare_gpac__unwrap(env, argv[0]);
|
|
817
|
+
|
|
818
|
+
if (self == NULL) {
|
|
819
|
+
return NULL;
|
|
820
|
+
}
|
|
821
|
+
|
|
822
|
+
bare_gpac_output_t output = {0};
|
|
823
|
+
|
|
824
|
+
self->handle->openMode = GF_ISOM_OPEN_EDIT;
|
|
825
|
+
|
|
826
|
+
GF_Err code = gf_isom_set_storage_mode(self->handle, GF_ISOM_STORE_STREAMABLE);
|
|
827
|
+
|
|
828
|
+
if (!code) {
|
|
829
|
+
code = gf_isom_set_final_name(self->handle, "_gpac_isobmff_redirect");
|
|
830
|
+
}
|
|
831
|
+
|
|
832
|
+
if (!code) {
|
|
833
|
+
code = gf_isom_set_write_callback(self->handle, bare_gpac__on_write, NULL, NULL, &output, 65536);
|
|
834
|
+
}
|
|
835
|
+
|
|
836
|
+
if (code) {
|
|
837
|
+
return bare_gpac__throw(env, code);
|
|
838
|
+
}
|
|
839
|
+
|
|
840
|
+
code = gf_isom_close(self->handle);
|
|
841
|
+
|
|
842
|
+
if (!code) {
|
|
843
|
+
code = output.error;
|
|
844
|
+
}
|
|
845
|
+
|
|
846
|
+
self->handle = NULL;
|
|
847
|
+
bare_gpac__close(self);
|
|
848
|
+
|
|
849
|
+
if (code) {
|
|
850
|
+
free(output.data);
|
|
851
|
+
|
|
852
|
+
return bare_gpac__throw(env, code);
|
|
853
|
+
}
|
|
854
|
+
|
|
855
|
+
js_value_t *result = bare_gpac__copy_arraybuffer(env, output.data, output.len);
|
|
856
|
+
|
|
857
|
+
free(output.data);
|
|
858
|
+
|
|
859
|
+
return result;
|
|
860
|
+
}
|
|
861
|
+
|
|
862
|
+
static js_value_t *
|
|
863
|
+
bare_gpac_destroy(js_env_t *env, js_callback_info_t *info) {
|
|
864
|
+
int err;
|
|
865
|
+
|
|
866
|
+
size_t argc = 1;
|
|
867
|
+
js_value_t *argv[1];
|
|
868
|
+
|
|
869
|
+
err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
|
|
870
|
+
assert(err == 0);
|
|
871
|
+
|
|
872
|
+
assert(argc == 1);
|
|
873
|
+
|
|
874
|
+
bare_gpac_file_t *self;
|
|
875
|
+
err = js_unwrap(env, argv[0], (void **) &self);
|
|
876
|
+
assert(err == 0);
|
|
877
|
+
|
|
878
|
+
bare_gpac__close(self);
|
|
879
|
+
|
|
880
|
+
return NULL;
|
|
881
|
+
}
|
|
882
|
+
|
|
883
|
+
static js_value_t *
|
|
884
|
+
bare_gpac_exports(js_env_t *env, js_value_t *exports) {
|
|
885
|
+
int err;
|
|
886
|
+
|
|
887
|
+
#define V(name, fn) \
|
|
888
|
+
{ \
|
|
889
|
+
js_value_t *value; \
|
|
890
|
+
err = js_create_function(env, name, -1, fn, NULL, &value); \
|
|
891
|
+
assert(err == 0); \
|
|
892
|
+
err = js_set_named_property(env, exports, name, value); \
|
|
893
|
+
assert(err == 0); \
|
|
894
|
+
}
|
|
895
|
+
|
|
896
|
+
V("init", bare_gpac_init)
|
|
897
|
+
V("items", bare_gpac_items)
|
|
898
|
+
V("readItem", bare_gpac_read_item)
|
|
899
|
+
V("addItem", bare_gpac_add_item)
|
|
900
|
+
V("removeItem", bare_gpac_remove_item)
|
|
901
|
+
V("eraseItemData", bare_gpac_erase_item_data)
|
|
902
|
+
V("findBox", bare_gpac_find_box)
|
|
903
|
+
V("removeBox", bare_gpac_remove_box)
|
|
904
|
+
V("write", bare_gpac_write)
|
|
905
|
+
V("destroy", bare_gpac_destroy)
|
|
906
|
+
#undef V
|
|
907
|
+
|
|
908
|
+
return exports;
|
|
909
|
+
}
|
|
910
|
+
|
|
911
|
+
BARE_MODULE(bare_gpac, bare_gpac_exports)
|