Line data Source code
1 : /*
2 : * GPAC - Multimedia Framework C SDK
3 : *
4 : * Authors: Jean Le Feuvre
5 : * Copyright (c) Telecom ParisTech 2000-2021
6 : * All rights reserved
7 : *
8 : * This file is part of GPAC / ISO Media File Format sub-project
9 : *
10 : * GPAC is free software; you can redistribute it and/or modify
11 : * it under the terms of the GNU Lesser General Public License as published by
12 : * the Free Software Foundation; either version 2, or (at your option)
13 : * any later version.
14 : *
15 : * GPAC is distributed in the hope that it will be useful,
16 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 : * GNU Lesser General Public License for more details.
19 : *
20 : * You should have received a copy of the GNU Lesser General Public
21 : * License along with this library; see the file COPYING. If not, write to
22 : * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
23 : *
24 : */
25 :
26 : #include <gpac/internal/isomedia_dev.h>
27 :
28 : #ifndef GPAC_DISABLE_ISOM
29 :
30 : //Add this funct to handle incomplete files...
31 : //bytesExpected is 0 most of the time. If the file is incomplete, bytesExpected
32 : //is the number of bytes missing to parse the box...
33 24139 : GF_Err gf_isom_parse_root_box(GF_Box **outBox, GF_BitStream *bs, u32 *box_type, u64 *bytesExpected, Bool progressive_mode)
34 : {
35 : GF_Err ret;
36 : u64 start;
37 24139 : start = gf_bs_get_position(bs);
38 24139 : ret = gf_isom_box_parse_ex(outBox, bs, 0, GF_TRUE);
39 24139 : if (ret == GF_ISOM_INCOMPLETE_FILE) {
40 4492 : if (!*outBox) {
41 : // We could not even read the box size, we at least need 8 bytes
42 7 : *bytesExpected = 8;
43 7 : if (box_type) *box_type = 0;
44 7 : GF_LOG(progressive_mode ? GF_LOG_DEBUG : GF_LOG_ERROR, GF_LOG_CONTAINER, ("[iso file] Incomplete box - start "LLU"\n", start));
45 : }
46 : else {
47 4485 : u32 type = (*outBox)->type;
48 4485 : if (type==GF_ISOM_BOX_TYPE_UNKNOWN)
49 0 : type = ((GF_UnknownBox *) (*outBox))->original_4cc;
50 :
51 4485 : *bytesExpected = (*outBox)->size;
52 4485 : if (box_type) *box_type = (*outBox)->type;
53 :
54 4485 : GF_LOG(progressive_mode ? GF_LOG_DEBUG : GF_LOG_ERROR, GF_LOG_CONTAINER, ("[iso file] Incomplete box %s - start "LLU" size "LLU"\n", gf_4cc_to_str(type), start, (*outBox)->size));
55 4485 : gf_isom_box_del(*outBox);
56 4485 : *outBox = NULL;
57 : }
58 4492 : gf_bs_seek(bs, start);
59 : }
60 24139 : return ret;
61 : }
62 :
63 53 : u32 gf_isom_solve_uuid_box(u8 *UUID)
64 : {
65 : u32 i;
66 : char strUUID[33], strChar[3];
67 53 : strUUID[0] = 0;
68 53 : strUUID[32] = 0;
69 901 : for (i=0; i<16; i++) {
70 848 : snprintf(strChar, 3, "%02X", (unsigned char) UUID[i]);
71 : strcat(strUUID, strChar);
72 : }
73 53 : if (!strnicmp(strUUID, "8974dbce7be74c5184f97148f9882554", 32))
74 : return GF_ISOM_BOX_UUID_TENC;
75 49 : if (!strnicmp(strUUID, "A5D40B30E81411DDBA2F0800200C9A66", 32))
76 : return GF_ISOM_BOX_UUID_MSSM;
77 49 : if (!strnicmp(strUUID, "D4807EF2CA3946958E5426CB9E46A79F", 32))
78 : return GF_ISOM_BOX_UUID_TFRF;
79 49 : if (!strnicmp(strUUID, "6D1D9B0542D544E680E2141DAFF757B2", 32))
80 : return GF_ISOM_BOX_UUID_TFXD;
81 39 : if (!strnicmp(strUUID, "A2394F525A9B4F14A2446C427C648DF4", 32))
82 : return GF_ISOM_BOX_UUID_PSEC;
83 18 : if (!strnicmp(strUUID, "D08A4F1810F34A82B6C832D8ABA183D3", 32))
84 : return GF_ISOM_BOX_UUID_PSSH;
85 :
86 17 : return 0;
87 : }
88 :
89 : static GF_Err gf_isom_full_box_read(GF_Box *ptr, GF_BitStream *bs);
90 :
91 120022 : GF_Err gf_isom_box_parse_ex(GF_Box **outBox, GF_BitStream *bs, u32 parent_type, Bool is_root_box)
92 : {
93 : u32 type, uuid_type, hdr_size, restore_type;
94 : u64 size, start, comp_start, payload_start, end;
95 : char uuid[16];
96 : GF_Err e;
97 : GF_BitStream *uncomp_bs = NULL;
98 120022 : u8 *uncomp_data = NULL;
99 : u32 compressed_size=0;
100 : GF_Box *newBox;
101 120022 : Bool skip_logs = (gf_bs_get_cookie(bs) & GF_ISOM_BS_COOKIE_NO_LOGS ) ? GF_TRUE : GF_FALSE;
102 : Bool is_special = GF_TRUE;
103 :
104 120022 : if ((bs == NULL) || (outBox == NULL) ) return GF_BAD_PARAM;
105 120022 : *outBox = NULL;
106 120022 : if (gf_bs_available(bs) < 8) {
107 : return GF_ISOM_INCOMPLETE_FILE;
108 : }
109 :
110 120003 : comp_start = start = gf_bs_get_position(bs);
111 :
112 : uuid_type = 0;
113 120003 : size = (u64) gf_bs_read_u32(bs);
114 : hdr_size = 4;
115 : /*fix for some boxes found in some old hinted files*/
116 120003 : if ((size >= 2) && (size <= 4)) {
117 : size = 4;
118 : type = GF_ISOM_BOX_TYPE_VOID;
119 : } else {
120 120003 : type = gf_bs_read_u32(bs);
121 : hdr_size += 4;
122 : /*no size means till end of file - EXCEPT FOR some old QuickTime boxes...*/
123 120003 : if (type == GF_ISOM_BOX_TYPE_TOTL)
124 : size = 12;
125 120002 : if (!size) {
126 4 : if (is_root_box) {
127 1 : if (!skip_logs) {
128 1 : GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[iso file] Warning Read Box type %s (0x%08X) size 0 reading till the end of file\n", gf_4cc_to_str(type), type));
129 : }
130 1 : size = gf_bs_available(bs) + 8;
131 : } else {
132 3 : if (!skip_logs) {
133 0 : GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[iso file] Read Box type %s (0x%08X) at position "LLU" has size 0 but is not at root/file level, skipping\n", gf_4cc_to_str(type), type, start));
134 : }
135 : return GF_OK;
136 : }
137 : }
138 120000 : if (is_root_box && (size>=8)) {
139 : Bool do_uncompress = GF_FALSE;
140 : u8 *compb = NULL;
141 24132 : u32 osize = 0;
142 : u32 otype = type;
143 24132 : if (type==GF_4CC('!', 'm', 'o', 'f')) {
144 : do_uncompress = GF_TRUE;
145 : type = GF_ISOM_BOX_TYPE_MOOF;
146 : }
147 24122 : else if (type==GF_4CC('!', 'm', 'o', 'v')) {
148 : do_uncompress = GF_TRUE;
149 : type = GF_ISOM_BOX_TYPE_MOOV;
150 : }
151 24120 : else if (type==GF_4CC('!', 's', 'i', 'x')) {
152 : do_uncompress = GF_TRUE;
153 : type = GF_ISOM_BOX_TYPE_SIDX;
154 : }
155 24119 : else if (type==GF_4CC('!', 's', 's', 'x')) {
156 : do_uncompress = GF_TRUE;
157 : type = GF_ISOM_BOX_TYPE_SSIX;
158 : }
159 :
160 : if (do_uncompress) {
161 13 : compb = gf_malloc((u32) (size-8));
162 :
163 : compressed_size = (u32) (size - 8);
164 13 : gf_bs_read_data(bs, compb, compressed_size);
165 13 : e = gf_gz_decompress_payload(compb, compressed_size, &uncomp_data, &osize);
166 13 : if (e) {
167 0 : GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[iso file] Failed to uncompress payload for box type %s (0x%08X)\n", gf_4cc_to_str(otype), otype));
168 0 : return e;
169 : }
170 :
171 : //keep size as complete box size for tests below
172 13 : size = osize + 8;
173 13 : uncomp_bs = gf_bs_new(uncomp_data, osize, GF_BITSTREAM_READ);
174 : bs = uncomp_bs;
175 : start = 0;
176 13 : gf_free(compb);
177 : }
178 : }
179 : }
180 : /*handle uuid*/
181 : memset(uuid, 0, 16);
182 120000 : if (type == GF_ISOM_BOX_TYPE_UUID ) {
183 49 : if (gf_bs_available(bs) < 16) {
184 : return GF_ISOM_INCOMPLETE_FILE;
185 : }
186 49 : gf_bs_read_data(bs, uuid, 16);
187 49 : hdr_size += 16;
188 49 : uuid_type = gf_isom_solve_uuid_box(uuid);
189 : }
190 :
191 : //handle large box
192 120000 : if (size == 1) {
193 0 : if (gf_bs_available(bs) < 8) {
194 : return GF_ISOM_INCOMPLETE_FILE;
195 : }
196 0 : size = gf_bs_read_u64(bs);
197 0 : hdr_size += 8;
198 : }
199 120000 : if (!skip_logs)
200 112383 : GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[iso file] Read Box type %s size "LLD" start "LLD"\n", gf_4cc_to_str(type), size, start));
201 :
202 120000 : if ( size < hdr_size ) {
203 0 : GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[iso file] Box size "LLD" less than box header size %d\n", size, hdr_size));
204 : return GF_ISOM_INVALID_FILE;
205 : }
206 : restore_type = 0;
207 120000 : if ((parent_type==GF_ISOM_BOX_TYPE_STSD) && (type==GF_QT_SUBTYPE_RAW) ) {
208 0 : u64 cookie = gf_bs_get_cookie(bs);
209 : restore_type = type;
210 0 : if (cookie & GF_ISOM_BS_COOKIE_VISUAL_TRACK)
211 : type = GF_QT_SUBTYPE_RAW_VID;
212 : else
213 : type = GF_QT_SUBTYPE_RAW_AUD;
214 :
215 : }
216 :
217 : //some special boxes (references and track groups) are handled by a single generic box with an associated ref/group type
218 120000 : if (parent_type && (parent_type == GF_ISOM_BOX_TYPE_TREF)) {
219 354 : newBox = gf_isom_box_new(GF_ISOM_BOX_TYPE_REFT);
220 354 : if (!newBox) return GF_OUT_OF_MEM;
221 354 : ((GF_TrackReferenceTypeBox*)newBox)->reference_type = type;
222 119646 : } else if (parent_type && (parent_type == GF_ISOM_BOX_TYPE_IREF)) {
223 34 : newBox = gf_isom_box_new(GF_ISOM_BOX_TYPE_REFI);
224 34 : if (!newBox) return GF_OUT_OF_MEM;
225 34 : ((GF_ItemReferenceTypeBox*)newBox)->reference_type = type;
226 119612 : } else if (parent_type && (parent_type == GF_ISOM_BOX_TYPE_TRGR)) {
227 19 : newBox = gf_isom_box_new(GF_ISOM_BOX_TYPE_TRGT);
228 19 : if (!newBox) return GF_OUT_OF_MEM;
229 19 : ((GF_TrackGroupTypeBox*)newBox)->group_type = type;
230 119593 : } else if (parent_type && (parent_type == GF_ISOM_BOX_TYPE_GRPL)) {
231 0 : newBox = gf_isom_box_new(GF_ISOM_BOX_TYPE_GRPT);
232 0 : if (!newBox) return GF_OUT_OF_MEM;
233 0 : ((GF_EntityToGroupTypeBox*)newBox)->grouping_type = type;
234 : } else {
235 : //OK, create the box based on the type
236 : is_special = GF_FALSE;
237 119593 : newBox = gf_isom_box_new_ex(uuid_type ? uuid_type : type, parent_type, skip_logs, is_root_box);
238 119593 : if (!newBox) return GF_OUT_OF_MEM;
239 : }
240 :
241 : //OK, init and read this box
242 120000 : if (type==GF_ISOM_BOX_TYPE_UUID && !is_special) {
243 49 : memcpy(((GF_UUIDBox *)newBox)->uuid, uuid, 16);
244 49 : ((GF_UUIDBox *)newBox)->internal_4cc = uuid_type;
245 : }
246 :
247 120000 : if (!newBox->type) newBox->type = type;
248 120000 : if (restore_type)
249 0 : newBox->type = restore_type;
250 :
251 120000 : payload_start = gf_bs_get_position(bs);
252 :
253 120000 : retry_unknown_box:
254 :
255 120000 : end = gf_bs_available(bs);
256 120000 : if (size - hdr_size > end ) {
257 4488 : newBox->size = size - hdr_size - end;
258 4488 : *outBox = newBox;
259 4488 : return GF_ISOM_INCOMPLETE_FILE;
260 : }
261 :
262 115512 : newBox->size = size - hdr_size;
263 :
264 115512 : e = gf_isom_full_box_read(newBox, bs);
265 115512 : if (!e) e = gf_isom_box_read(newBox, bs);
266 115512 : if (e) {
267 7 : if (gf_opts_get_bool("core", "no-check"))
268 : e = GF_OK;
269 : }
270 115512 : newBox->size = size;
271 115512 : end = gf_bs_get_position(bs);
272 :
273 115512 : if (uncomp_bs) {
274 13 : gf_free(uncomp_data);
275 13 : gf_bs_del(uncomp_bs);
276 13 : if (e) {
277 0 : gf_isom_box_del(newBox);
278 0 : *outBox = NULL;
279 0 : return e;
280 : }
281 : //move size to real bitstream offsets for tests below
282 13 : size -= 8;
283 : //remember compressed vs real size info for moof in order to properly recompute data_offset/base_data_offset
284 13 : if (type==GF_ISOM_BOX_TYPE_MOOF) {
285 10 : ((GF_MovieFragmentBox *)newBox)->compressed_diff = (s32)size - (s32)compressed_size;
286 : }
287 : //remember compressed vs real size info for moov in order to properly recompute chunk offset
288 3 : else if (type==GF_ISOM_BOX_TYPE_MOOV) {
289 2 : ((GF_MovieBox *)newBox)->compressed_diff = (s32)size - (s32)compressed_size;
290 2 : ((GF_MovieBox *)newBox)->file_offset = comp_start;
291 : }
292 : //remember compressed vs real size info for dump
293 1 : else if (type==GF_ISOM_BOX_TYPE_SIDX) {
294 1 : ((GF_SegmentIndexBox *)newBox)->compressed_diff = (s32)size - (s32)compressed_size;
295 : }
296 : //remember compressed vs real size info for dump
297 0 : else if (type==GF_ISOM_BOX_TYPE_SSIX) {
298 0 : ((GF_SubsegmentIndexBox *)newBox)->compressed_diff = (s32)size - (s32)compressed_size;
299 : }
300 13 : newBox->internal_flags = GF_ISOM_BOX_COMPRESSED;
301 : }
302 :
303 :
304 115512 : if (e && (e != GF_ISOM_INCOMPLETE_FILE)) {
305 6 : gf_isom_box_del(newBox);
306 6 : *outBox = NULL;
307 :
308 6 : if (parent_type==GF_ISOM_BOX_TYPE_STSD) {
309 0 : newBox = gf_isom_box_new(GF_ISOM_BOX_TYPE_UNKNOWN);
310 0 : if (!newBox) return GF_OUT_OF_MEM;
311 0 : ((GF_UnknownBox *)newBox)->original_4cc = type;
312 0 : newBox->size = size;
313 0 : gf_bs_seek(bs, payload_start);
314 0 : goto retry_unknown_box;
315 : }
316 6 : if (!skip_logs) {
317 6 : GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[iso file] Read Box \"%s\" (start "LLU") failed (%s) - skipping\n", gf_4cc_to_str(type), start, gf_error_to_string(e)));
318 : }
319 : //we don't try to reparse known boxes that have been failing (too dangerous)
320 : return e;
321 : }
322 :
323 115506 : if (end-start > size) {
324 0 : if (!skip_logs) {
325 0 : GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[iso file] Box \"%s\" size "LLU" (start "LLU") invalid (read "LLU")\n", gf_4cc_to_str(type), size, start, (end-start) ));
326 : }
327 : /*let's still try to load the file since no error was notified*/
328 0 : gf_bs_seek(bs, start+size);
329 115506 : } else if (end-start < size) {
330 0 : u32 to_skip = (u32) (size-(end-start));
331 0 : if (!skip_logs) {
332 0 : if ((to_skip!=4) || gf_bs_peek_bits(bs, 32, 0)) {
333 0 : GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[iso file] Box \"%s\" (start "LLU") has %u extra bytes\n", gf_4cc_to_str(type), start, to_skip));
334 : }
335 : }
336 0 : gf_bs_skip_bytes(bs, to_skip);
337 : }
338 115506 : *outBox = newBox;
339 :
340 115506 : return e;
341 : }
342 :
343 : GF_EXPORT
344 1182 : GF_Err gf_isom_box_parse(GF_Box **outBox, GF_BitStream *bs)
345 : {
346 1182 : return gf_isom_box_parse_ex(outBox, bs, 0, GF_FALSE);
347 : }
348 :
349 153021 : void gf_isom_box_array_reset(GF_List *boxlist)
350 : {
351 : u32 count, i;
352 153021 : if (!boxlist) return;
353 150285 : count = gf_list_count(boxlist);
354 344787 : for (i = 0; i < count; i++) {
355 194502 : GF_Box *a = (GF_Box *)gf_list_get(boxlist, i);
356 194502 : if (a) gf_isom_box_del(a);
357 : }
358 : }
359 :
360 153021 : void gf_isom_box_array_del(GF_List *boxlist)
361 : {
362 153021 : gf_isom_box_array_reset(boxlist);
363 153021 : gf_list_del(boxlist);
364 153021 : }
365 :
366 688 : void gf_isom_box_array_reset_parent(GF_List **child_boxes, GF_List *boxlist)
367 : {
368 : u32 count, i;
369 688 : if (!boxlist) return;
370 255 : count = gf_list_count(boxlist);
371 510 : for (i = 0; i < count; i++) {
372 255 : GF_Box *a = (GF_Box *)gf_list_get(boxlist, i);
373 255 : if (a) gf_isom_box_del_parent(child_boxes, a);
374 : }
375 255 : gf_list_reset(boxlist);
376 : }
377 55324 : void gf_isom_box_array_del_parent(GF_List **child_boxes, GF_List *boxlist)
378 : {
379 55324 : if (!boxlist) return;
380 166 : gf_isom_box_array_reset_parent(child_boxes, boxlist);
381 166 : gf_list_del(boxlist);
382 : }
383 :
384 :
385 36647 : GF_Err gf_isom_box_array_read(GF_Box *parent, GF_BitStream *bs)
386 : {
387 36647 : return gf_isom_box_array_read_ex(parent, bs, parent->type);
388 : }
389 :
390 : #ifndef GPAC_DISABLE_ISOM_WRITE
391 :
392 : GF_EXPORT
393 154719 : GF_Err gf_isom_box_write_header(GF_Box *ptr, GF_BitStream *bs)
394 : {
395 : u64 start;
396 154719 : if (! bs || !ptr) return GF_BAD_PARAM;
397 154719 : if (!ptr->size) return GF_ISOM_INVALID_FILE;
398 :
399 154719 : start = gf_bs_get_position(bs);
400 154719 : if (ptr->size > 0xFFFFFFFF) {
401 2 : gf_bs_write_u32(bs, 1);
402 : } else {
403 154717 : gf_bs_write_u32(bs, (u32) ptr->size);
404 : }
405 154719 : gf_bs_write_u32(bs, ptr->type);
406 154719 : if (ptr->type == GF_ISOM_BOX_TYPE_UUID) {
407 : u32 i;
408 : Bool conv_uuid = GF_TRUE;
409 : GF_UUIDBox *uuidb = (GF_UUIDBox *)ptr;
410 : char strUUID[32];
411 :
412 35 : switch (uuidb->internal_4cc) {
413 : case GF_ISOM_BOX_UUID_TENC:
414 : memcpy(strUUID, "8974dbce7be74c5184f97148f9882554", 32);
415 : break;
416 : case GF_ISOM_BOX_UUID_PSEC:
417 : memcpy(strUUID, "A2394F525A9B4F14A2446C427C648DF4", 32);
418 : break;
419 : case GF_ISOM_BOX_UUID_MSSM:
420 : memcpy(strUUID, "A5D40B30E81411DDBA2F0800200C9A66", 32);
421 : break;
422 : case GF_ISOM_BOX_UUID_PSSH:
423 : memcpy(strUUID, "D08A4F1810F34A82B6C832D8ABA183D3", 32);
424 : break;
425 : case GF_ISOM_BOX_UUID_TFXD:
426 : memcpy(strUUID, "6D1D9B0542D544E680E2141DAFF757B2", 32);
427 : break;
428 : default:
429 : conv_uuid = GF_FALSE;
430 : break;
431 : }
432 :
433 : if (conv_uuid) {
434 : char uuid[16];
435 368 : for (i = 0; i < 16; i++) {
436 : char t[3];
437 368 : t[2] = 0;
438 368 : t[0] = strUUID[2*i];
439 368 : t[1] = strUUID[2*i+1];
440 368 : uuid[i] = (u8) strtol(t, NULL, 16);
441 : }
442 23 : gf_bs_write_data(bs, uuid, 16);
443 : } else {
444 12 : gf_bs_write_data(bs, uuidb->uuid, 16);
445 : }
446 : }
447 154719 : if (ptr->size > 0xFFFFFFFF)
448 2 : gf_bs_write_u64(bs, ptr->size);
449 :
450 154719 : GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[iso file] Written Box type %s size "LLD" start "LLD"\n", gf_4cc_to_str(ptr->type), ptr->size, start));
451 :
452 : return GF_OK;
453 : }
454 :
455 58767 : GF_Err gf_isom_full_box_write(GF_Box *s, GF_BitStream *bs)
456 : {
457 : GF_Err e;
458 : GF_FullBox *ptr = (GF_FullBox *)s;
459 58767 : e = gf_isom_box_write_header(s, bs);
460 58767 : if (e) return e;
461 58767 : gf_bs_write_u8(bs, ptr->version);
462 58767 : gf_bs_write_u24(bs, ptr->flags);
463 58767 : return GF_OK;
464 : }
465 :
466 :
467 62286 : GF_Err gf_isom_box_array_write(GF_Box *parent, GF_List *list, GF_BitStream *bs)
468 : {
469 : u32 count, i;
470 : GF_Err e;
471 62286 : if (!list) return GF_OK;
472 62265 : count = gf_list_count(list);
473 182589 : for (i = 0; i < count; i++) {
474 120324 : GF_Box *a = (GF_Box *)gf_list_get(list, i);
475 120324 : if (a) {
476 120324 : e = gf_isom_box_write(a, bs);
477 120324 : if (e) {
478 0 : GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("ISOBMF: Error %s writing box %s\n", gf_error_to_string(e), gf_4cc_to_str(a->type) ));
479 : return e;
480 : }
481 : }
482 : }
483 : return GF_OK;
484 : }
485 :
486 :
487 117202 : GF_Err gf_isom_box_array_size(GF_Box *parent, GF_List *list)
488 : {
489 : GF_Err e;
490 : u32 count, i;
491 117202 : if (! list) return GF_OK;
492 :
493 117181 : count = gf_list_count(list);
494 358329 : for (i = 0; i < count; i++) {
495 241148 : GF_Box *a = (GF_Box *)gf_list_get(list, i);
496 241148 : if (a) {
497 241148 : e = gf_isom_box_size(a);
498 241148 : if (e) {
499 0 : GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("ISOBMF: Error %s computing box %s size\n", gf_error_to_string(e), gf_4cc_to_str(a->type) ));
500 : return e;
501 : }
502 241148 : parent->size += a->size;
503 : }
504 : }
505 : return GF_OK;
506 : }
507 :
508 : #endif /*GPAC_DISABLE_ISOM_WRITE*/
509 :
510 :
511 :
512 : GF_Box * unkn_box_new();
513 : void unkn_box_del(GF_Box *);
514 : GF_Err unkn_box_read(GF_Box *s, GF_BitStream *bs);
515 : GF_Err unkn_box_write(GF_Box *s, GF_BitStream *bs);
516 : GF_Err unkn_box_size(GF_Box *s);
517 : GF_Err unkn_box_dump(GF_Box *a, FILE * trace);
518 :
519 : //definition of boxes new/del/read/write/size. For now still exported since some files other than box_funcs.c call them
520 : //this should be fixed by only using gf_isom_box_new
521 :
522 : #define ISOM_BOX_IMPL_DECL(a_name) \
523 : GF_Box * a_name##_box_new(); \
524 : void a_name##_box_del(GF_Box *); \
525 : GF_Err a_name##_box_read(GF_Box *s, GF_BitStream *bs); \
526 : GF_Err a_name##_box_write(GF_Box *s, GF_BitStream *bs); \
527 : GF_Err a_name##_box_size(GF_Box *s);\
528 : GF_Err a_name##_box_dump(GF_Box *a, FILE * trace);
529 :
530 : #define ISOM_BOX_IMPL_DECL_CHILD(a_name) \
531 : GF_Box * a_name##_box_new(); \
532 : void a_name##_box_del(GF_Box *); \
533 : GF_Err a_name##_box_read(GF_Box *s, GF_BitStream *bs); \
534 : GF_Err a_name##_box_write(GF_Box *s, GF_BitStream *bs); \
535 : GF_Err a_name##_box_size(GF_Box *s);\
536 : GF_Err a_name##_box_dump(GF_Box *a, FILE * trace);\
537 : GF_Err a_name##_on_child_box(GF_Box *s, GF_Box *a, Bool is_rem);\
538 :
539 :
540 : ISOM_BOX_IMPL_DECL(reftype)
541 : ISOM_BOX_IMPL_DECL(ireftype)
542 : ISOM_BOX_IMPL_DECL(free)
543 : ISOM_BOX_IMPL_DECL(wide)
544 : ISOM_BOX_IMPL_DECL(mdat)
545 : ISOM_BOX_IMPL_DECL_CHILD(moov)
546 : ISOM_BOX_IMPL_DECL(mvhd)
547 : ISOM_BOX_IMPL_DECL(mdhd)
548 : ISOM_BOX_IMPL_DECL(vmhd)
549 : ISOM_BOX_IMPL_DECL(smhd)
550 : ISOM_BOX_IMPL_DECL(hmhd)
551 : ISOM_BOX_IMPL_DECL(nmhd)
552 : ISOM_BOX_IMPL_DECL_CHILD(stbl)
553 : ISOM_BOX_IMPL_DECL_CHILD(dinf)
554 : ISOM_BOX_IMPL_DECL(url)
555 : ISOM_BOX_IMPL_DECL(urn)
556 : ISOM_BOX_IMPL_DECL(cprt)
557 : ISOM_BOX_IMPL_DECL(kind)
558 : ISOM_BOX_IMPL_DECL(chpl)
559 : ISOM_BOX_IMPL_DECL(hdlr)
560 : ISOM_BOX_IMPL_DECL(iods)
561 : ISOM_BOX_IMPL_DECL_CHILD(trak)
562 : ISOM_BOX_IMPL_DECL_CHILD(mp4s)
563 : ISOM_BOX_IMPL_DECL_CHILD(audio_sample_entry)
564 : ISOM_BOX_IMPL_DECL(gen_sample_entry)
565 : ISOM_BOX_IMPL_DECL_CHILD(edts)
566 : ISOM_BOX_IMPL_DECL_CHILD(udta)
567 : ISOM_BOX_IMPL_DECL(dref)
568 : ISOM_BOX_IMPL_DECL_CHILD(stsd)
569 : ISOM_BOX_IMPL_DECL(stts)
570 : ISOM_BOX_IMPL_DECL(ctts)
571 : ISOM_BOX_IMPL_DECL(stsh)
572 : ISOM_BOX_IMPL_DECL(elst)
573 : ISOM_BOX_IMPL_DECL(stsc)
574 : ISOM_BOX_IMPL_DECL(stsz)
575 : ISOM_BOX_IMPL_DECL(stco)
576 : ISOM_BOX_IMPL_DECL(stss)
577 : ISOM_BOX_IMPL_DECL(stdp)
578 : ISOM_BOX_IMPL_DECL(sdtp)
579 : ISOM_BOX_IMPL_DECL(co64)
580 : ISOM_BOX_IMPL_DECL(esds)
581 : ISOM_BOX_IMPL_DECL_CHILD(minf)
582 : ISOM_BOX_IMPL_DECL(tkhd)
583 : ISOM_BOX_IMPL_DECL(tref)
584 : ISOM_BOX_IMPL_DECL_CHILD(mdia)
585 : ISOM_BOX_IMPL_DECL_CHILD(mfra)
586 : ISOM_BOX_IMPL_DECL(tfra)
587 : ISOM_BOX_IMPL_DECL(mfro)
588 : ISOM_BOX_IMPL_DECL(uuid)
589 : ISOM_BOX_IMPL_DECL(void)
590 : ISOM_BOX_IMPL_DECL(gnrm)
591 : ISOM_BOX_IMPL_DECL(gnrv)
592 : ISOM_BOX_IMPL_DECL(gnra)
593 : ISOM_BOX_IMPL_DECL(pdin)
594 : ISOM_BOX_IMPL_DECL(def_parent)
595 : ISOM_BOX_IMPL_DECL(def_parent_full)
596 : ISOM_BOX_IMPL_DECL(csgp)
597 :
598 :
599 : #ifndef GPAC_DISABLE_ISOM_HINTING
600 :
601 : ISOM_BOX_IMPL_DECL_CHILD(hinf)
602 : ISOM_BOX_IMPL_DECL(trpy)
603 : ISOM_BOX_IMPL_DECL(totl)
604 : ISOM_BOX_IMPL_DECL(nump)
605 : ISOM_BOX_IMPL_DECL(npck)
606 : ISOM_BOX_IMPL_DECL(tpyl)
607 : ISOM_BOX_IMPL_DECL(tpay)
608 : ISOM_BOX_IMPL_DECL(maxr)
609 : ISOM_BOX_IMPL_DECL(dmed)
610 : ISOM_BOX_IMPL_DECL(dimm)
611 : ISOM_BOX_IMPL_DECL(drep)
612 : ISOM_BOX_IMPL_DECL(tmin)
613 : ISOM_BOX_IMPL_DECL(tmax)
614 : ISOM_BOX_IMPL_DECL(pmax)
615 : ISOM_BOX_IMPL_DECL(dmax)
616 : ISOM_BOX_IMPL_DECL(payt)
617 : ISOM_BOX_IMPL_DECL(name)
618 : ISOM_BOX_IMPL_DECL(rely)
619 : ISOM_BOX_IMPL_DECL(snro)
620 : ISOM_BOX_IMPL_DECL(tims)
621 : ISOM_BOX_IMPL_DECL(tsro)
622 : ISOM_BOX_IMPL_DECL(ghnt)
623 : ISOM_BOX_IMPL_DECL_CHILD(hnti)
624 : ISOM_BOX_IMPL_DECL(sdp)
625 : ISOM_BOX_IMPL_DECL(rtpo)
626 : ISOM_BOX_IMPL_DECL(tssy)
627 : ISOM_BOX_IMPL_DECL(rssr)
628 : ISOM_BOX_IMPL_DECL_CHILD(srpp)
629 : ISOM_BOX_IMPL_DECL(rtp_hnti)
630 :
631 : #endif
632 :
633 : ISOM_BOX_IMPL_DECL(ftyp)
634 : ISOM_BOX_IMPL_DECL(padb)
635 : ISOM_BOX_IMPL_DECL(gppc)
636 :
637 :
638 : #ifndef GPAC_DISABLE_ISOM_FRAGMENTS
639 : ISOM_BOX_IMPL_DECL_CHILD(mvex)
640 : ISOM_BOX_IMPL_DECL(trex)
641 : ISOM_BOX_IMPL_DECL_CHILD(moof)
642 : ISOM_BOX_IMPL_DECL(mfhd)
643 : ISOM_BOX_IMPL_DECL_CHILD(traf)
644 : ISOM_BOX_IMPL_DECL(tfhd)
645 : ISOM_BOX_IMPL_DECL(trun)
646 : ISOM_BOX_IMPL_DECL(styp)
647 : ISOM_BOX_IMPL_DECL(mehd)
648 : /*smooth streaming timing*/
649 : ISOM_BOX_IMPL_DECL(tfxd)
650 : ISOM_BOX_IMPL_DECL(tfrf)
651 :
652 : #endif
653 :
654 : /*avc ext*/
655 : ISOM_BOX_IMPL_DECL(avcc)
656 : ISOM_BOX_IMPL_DECL_CHILD(video_sample_entry)
657 : ISOM_BOX_IMPL_DECL(m4ds)
658 : ISOM_BOX_IMPL_DECL(btrt)
659 : ISOM_BOX_IMPL_DECL(mehd)
660 :
661 : /*3GPP streaming text*/
662 : ISOM_BOX_IMPL_DECL(ftab)
663 : ISOM_BOX_IMPL_DECL_CHILD(tx3g)
664 : ISOM_BOX_IMPL_DECL(text)
665 : ISOM_BOX_IMPL_DECL(styl)
666 : ISOM_BOX_IMPL_DECL(hlit)
667 : ISOM_BOX_IMPL_DECL(hclr)
668 : ISOM_BOX_IMPL_DECL(krok)
669 : ISOM_BOX_IMPL_DECL(dlay)
670 : ISOM_BOX_IMPL_DECL(href)
671 : ISOM_BOX_IMPL_DECL(tbox)
672 : ISOM_BOX_IMPL_DECL(blnk)
673 : ISOM_BOX_IMPL_DECL(twrp)
674 :
675 :
676 : #ifndef GPAC_DISABLE_VTT
677 :
678 : /*WebVTT boxes*/
679 : ISOM_BOX_IMPL_DECL(boxstring);
680 : ISOM_BOX_IMPL_DECL_CHILD(vtcu)
681 : ISOM_BOX_IMPL_DECL(vtte)
682 : ISOM_BOX_IMPL_DECL_CHILD(wvtt)
683 :
684 : #endif //GPAC_DISABLE_VTT
685 :
686 : /* Items functions */
687 : ISOM_BOX_IMPL_DECL_CHILD(meta)
688 : ISOM_BOX_IMPL_DECL(xml)
689 : ISOM_BOX_IMPL_DECL(bxml)
690 : ISOM_BOX_IMPL_DECL(iloc)
691 : ISOM_BOX_IMPL_DECL(pitm)
692 : ISOM_BOX_IMPL_DECL_CHILD(ipro)
693 : ISOM_BOX_IMPL_DECL(infe)
694 : ISOM_BOX_IMPL_DECL_CHILD(iinf)
695 : ISOM_BOX_IMPL_DECL_CHILD(iref)
696 : ISOM_BOX_IMPL_DECL_CHILD(sinf)
697 : ISOM_BOX_IMPL_DECL(frma)
698 : ISOM_BOX_IMPL_DECL(schm)
699 : ISOM_BOX_IMPL_DECL_CHILD(schi)
700 : ISOM_BOX_IMPL_DECL(enca)
701 : ISOM_BOX_IMPL_DECL(encs)
702 : ISOM_BOX_IMPL_DECL(encv)
703 : ISOM_BOX_IMPL_DECL(resv)
704 :
705 :
706 : /** ISMACryp functions **/
707 : ISOM_BOX_IMPL_DECL(iKMS)
708 : ISOM_BOX_IMPL_DECL(iSFM)
709 : ISOM_BOX_IMPL_DECL(iSLT)
710 :
711 : #ifndef GPAC_DISABLE_ISOM_ADOBE
712 : /* Adobe extensions */
713 : ISOM_BOX_IMPL_DECL(abst)
714 : ISOM_BOX_IMPL_DECL(afra)
715 : ISOM_BOX_IMPL_DECL(asrt)
716 : ISOM_BOX_IMPL_DECL(afrt)
717 : #endif /*GPAC_DISABLE_ISOM_ADOBE*/
718 :
719 : /* Apple extensions */
720 : ISOM_BOX_IMPL_DECL(ilst)
721 : ISOM_BOX_IMPL_DECL(ilst_item)
722 : ISOM_BOX_IMPL_DECL(databox)
723 : ISOM_BOX_IMPL_DECL(gmin)
724 : ISOM_BOX_IMPL_DECL(alis)
725 : ISOM_BOX_IMPL_DECL(clef)
726 :
727 : /*OMA extensions*/
728 : ISOM_BOX_IMPL_DECL(ohdr)
729 : ISOM_BOX_IMPL_DECL(grpi)
730 : ISOM_BOX_IMPL_DECL(mdri)
731 : ISOM_BOX_IMPL_DECL(odtt)
732 : ISOM_BOX_IMPL_DECL(odrb)
733 : ISOM_BOX_IMPL_DECL(odkm)
734 :
735 :
736 : ISOM_BOX_IMPL_DECL(pasp)
737 : ISOM_BOX_IMPL_DECL(clap)
738 : ISOM_BOX_IMPL_DECL_CHILD(metx)
739 : ISOM_BOX_IMPL_DECL(txtc)
740 : ISOM_BOX_IMPL_DECL(tsel)
741 : ISOM_BOX_IMPL_DECL(dimC)
742 : ISOM_BOX_IMPL_DECL_CHILD(dims)
743 : ISOM_BOX_IMPL_DECL(diST)
744 : ISOM_BOX_IMPL_DECL(ac3)
745 : ISOM_BOX_IMPL_DECL(ec3)
746 : ISOM_BOX_IMPL_DECL(dac3)
747 : ISOM_BOX_IMPL_DECL(dec3)
748 : ISOM_BOX_IMPL_DECL(dmlp)
749 : ISOM_BOX_IMPL_DECL(lsrc)
750 : ISOM_BOX_IMPL_DECL_CHILD(lsr1)
751 : ISOM_BOX_IMPL_DECL(mvcg)
752 : ISOM_BOX_IMPL_DECL(vwid)
753 :
754 : ISOM_BOX_IMPL_DECL(subs)
755 :
756 : ISOM_BOX_IMPL_DECL(tmcd)
757 : ISOM_BOX_IMPL_DECL(tcmi)
758 : ISOM_BOX_IMPL_DECL(fiel)
759 : ISOM_BOX_IMPL_DECL(gama)
760 : ISOM_BOX_IMPL_DECL(chrm)
761 : ISOM_BOX_IMPL_DECL(chan)
762 :
763 :
764 : #ifndef GPAC_DISABLE_ISOM_FRAGMENTS
765 : ISOM_BOX_IMPL_DECL(sidx)
766 : ISOM_BOX_IMPL_DECL(ssix)
767 : ISOM_BOX_IMPL_DECL(leva)
768 : ISOM_BOX_IMPL_DECL(pcrb)
769 : ISOM_BOX_IMPL_DECL(tfdt)
770 : ISOM_BOX_IMPL_DECL(emsg)
771 :
772 : #endif
773 :
774 : ISOM_BOX_IMPL_DECL(rvcc)
775 : ISOM_BOX_IMPL_DECL(sbgp)
776 : ISOM_BOX_IMPL_DECL(sgpd)
777 : ISOM_BOX_IMPL_DECL(saiz)
778 : ISOM_BOX_IMPL_DECL(saio)
779 :
780 : ISOM_BOX_IMPL_DECL(pssh)
781 :
782 : ISOM_BOX_IMPL_DECL(tenc)
783 : ISOM_BOX_IMPL_DECL(piff_tenc)
784 : ISOM_BOX_IMPL_DECL(piff_psec)
785 : ISOM_BOX_IMPL_DECL(piff_pssh)
786 : ISOM_BOX_IMPL_DECL(senc)
787 : ISOM_BOX_IMPL_DECL(cslg)
788 : ISOM_BOX_IMPL_DECL(ccst)
789 : ISOM_BOX_IMPL_DECL(auxi)
790 : ISOM_BOX_IMPL_DECL(hvcc)
791 : ISOM_BOX_IMPL_DECL(av1c)
792 : ISOM_BOX_IMPL_DECL(dOps)
793 : ISOM_BOX_IMPL_DECL(prft)
794 : ISOM_BOX_IMPL_DECL(vvcc)
795 :
796 : //VPx
797 : ISOM_BOX_IMPL_DECL(vpcc)
798 : ISOM_BOX_IMPL_DECL(SmDm)
799 : ISOM_BOX_IMPL_DECL(CoLL)
800 :
801 : ISOM_BOX_IMPL_DECL(trep)
802 :
803 : //FEC
804 : ISOM_BOX_IMPL_DECL_CHILD(fiin)
805 : ISOM_BOX_IMPL_DECL_CHILD(paen)
806 : ISOM_BOX_IMPL_DECL(fpar)
807 : ISOM_BOX_IMPL_DECL(fecr)
808 : ISOM_BOX_IMPL_DECL(segr)
809 : ISOM_BOX_IMPL_DECL(gitn)
810 : ISOM_BOX_IMPL_DECL_CHILD(fdsa)
811 : ISOM_BOX_IMPL_DECL(fdpa)
812 : ISOM_BOX_IMPL_DECL(extr)
813 :
814 :
815 : /*
816 : Adobe's protection boxes
817 : */
818 : ISOM_BOX_IMPL_DECL_CHILD(adkm)
819 : ISOM_BOX_IMPL_DECL_CHILD(ahdr)
820 : ISOM_BOX_IMPL_DECL_CHILD(aprm)
821 : ISOM_BOX_IMPL_DECL(aeib)
822 : ISOM_BOX_IMPL_DECL_CHILD(akey)
823 : ISOM_BOX_IMPL_DECL(flxs)
824 : ISOM_BOX_IMPL_DECL(adaf)
825 :
826 : /* Image File Format declarations */
827 : ISOM_BOX_IMPL_DECL(ispe)
828 : ISOM_BOX_IMPL_DECL(colr)
829 : ISOM_BOX_IMPL_DECL(pixi)
830 : ISOM_BOX_IMPL_DECL(rloc)
831 : ISOM_BOX_IMPL_DECL(irot)
832 : ISOM_BOX_IMPL_DECL(imir)
833 : ISOM_BOX_IMPL_DECL(ipco)
834 : ISOM_BOX_IMPL_DECL_CHILD(iprp)
835 : ISOM_BOX_IMPL_DECL(ipma)
836 : ISOM_BOX_IMPL_DECL_CHILD(trgr)
837 : ISOM_BOX_IMPL_DECL(trgt)
838 : ISOM_BOX_IMPL_DECL(ienc)
839 : ISOM_BOX_IMPL_DECL(iaux)
840 :
841 : /* MIAF declarations */
842 : ISOM_BOX_IMPL_DECL(clli)
843 : ISOM_BOX_IMPL_DECL(mdcv)
844 :
845 : ISOM_BOX_IMPL_DECL(grpl)
846 :
847 : ISOM_BOX_IMPL_DECL_CHILD(strk)
848 : ISOM_BOX_IMPL_DECL(stri)
849 : ISOM_BOX_IMPL_DECL(stsg)
850 : ISOM_BOX_IMPL_DECL(elng)
851 : ISOM_BOX_IMPL_DECL(stvi)
852 : ISOM_BOX_IMPL_DECL(auxc)
853 : ISOM_BOX_IMPL_DECL(oinf)
854 : ISOM_BOX_IMPL_DECL(tols)
855 :
856 : ISOM_BOX_IMPL_DECL(trik)
857 : ISOM_BOX_IMPL_DECL(bloc)
858 : ISOM_BOX_IMPL_DECL(ainf)
859 : ISOM_BOX_IMPL_DECL(mhac)
860 : ISOM_BOX_IMPL_DECL(mhap)
861 :
862 : ISOM_BOX_IMPL_DECL(grptype)
863 :
864 : ISOM_BOX_IMPL_DECL_CHILD(jp2h)
865 : ISOM_BOX_IMPL_DECL(ihdr)
866 : ISOM_BOX_IMPL_DECL(load)
867 :
868 : /* Dolby Vision */
869 : ISOM_BOX_IMPL_DECL(dvcC)
870 : ISOM_BOX_IMPL_DECL(dvhe)
871 : ISOM_BOX_IMPL_DECL(dfla)
872 :
873 : ISOM_BOX_IMPL_DECL(pcmC)
874 : ISOM_BOX_IMPL_DECL(chnl)
875 :
876 : ISOM_BOX_IMPL_DECL(xtra)
877 :
878 : ISOM_BOX_IMPL_DECL(st3d)
879 : ISOM_BOX_IMPL_DECL(svhd)
880 : ISOM_BOX_IMPL_DECL(prhd)
881 : ISOM_BOX_IMPL_DECL(proj_type)
882 : //ISOM_BOX_IMPL_DECL(mesh)
883 :
884 :
885 : #define BOX_DEFINE(__type, b_rad, __par) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, 0, 0, 0, __par, "p12", GF_FALSE}
886 :
887 : #define BOX_DEFINE_CHILD(__type, b_rad, __par) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, 0, 0, 0, __par, "p12", GF_FALSE, b_rad##_on_child_box}
888 :
889 : #define BOX_DEFINE_S(__type, b_rad, __par, __spec) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, 0, 0, 0, __par, __spec, GF_FALSE }
890 :
891 : #define BOX_DEFINE_S_CHILD(__type, b_rad, __par, __spec) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, 0, 0, 0, __par, __spec, GF_FALSE, b_rad##_on_child_box}
892 :
893 : #define FBOX_DEFINE(__type, b_rad, __par, __max_v) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, 0, 1+__max_v, 0, __par, "p12", GF_FALSE }
894 :
895 : #define FBOX_DEFINE_CHILD(__type, b_rad, __par, __max_v) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, 0, 1+__max_v, 0, __par, "p12", GF_FALSE, b_rad##_on_child_box}
896 :
897 : #define FBOX_DEFINE_FLAGS(__type, b_rad, __par, __max_v, flags) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, 0, 1+__max_v, flags, __par, "p12", GF_FALSE }
898 :
899 : #define FBOX_DEFINE_FLAGS_S(__type, b_rad, __par, __max_v, flags, __spec) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, 0, 1+__max_v, flags, __par, __spec, GF_FALSE }
900 :
901 : #define FBOX_DEFINE_S(__type, b_rad, __par, __max_v, __spec) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, 0, 1+__max_v, 0, __par, __spec, GF_FALSE }
902 :
903 : #define FBOX_DEFINE_S_CHILD(__type, b_rad, __par, __max_v, __spec) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, 0, 1+__max_v, 0, __par, __spec, GF_FALSE, b_rad##_on_child_box}
904 :
905 : #define TREF_DEFINE(__type, b_rad, __par, __4cc, __spec) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, __4cc, 0, 0, __par, __spec, GF_FALSE }
906 :
907 : #define TRGT_DEFINE(__type, b_rad, __par, __4cc, max_version, __spec) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, __4cc, 1+max_version, 0, __par, __spec, GF_FALSE }
908 :
909 : #define SGPD_DEFINE(__type, b_rad, __par, __4cc, __spec) { __type, b_rad##_box_new, b_rad##_box_del, b_rad##_box_read, b_rad##_box_write, b_rad##_box_size, b_rad##_box_dump, __4cc, 1, 0, __par, __spec, GF_FALSE }
910 :
911 : #define ITUNES_TAG(_val) \
912 : BOX_DEFINE_S( _val, ilst_item, "ilst data", "apple")
913 :
914 : static struct box_registry_entry {
915 : u32 box_4cc;
916 : GF_Box * (*new_fn)();
917 : void (*del_fn)(GF_Box *a);
918 : GF_Err (*read_fn)(GF_Box *s, GF_BitStream *bs);
919 : GF_Err (*write_fn)(GF_Box *s, GF_BitStream *bs);
920 : GF_Err (*size_fn)(GF_Box *a);
921 : GF_Err (*dump_fn)(GF_Box *a, FILE *trace);
922 : u32 alt_4cc;//used for sample grouping type and track / item reference types
923 : u8 max_version_plus_one;
924 : u32 flags;
925 : const char *parents_4cc;
926 : const char *spec;
927 : Bool disabled;
928 : GF_Err (*add_rem_fn)(GF_Box *par, GF_Box *b, Bool is_remove);
929 : } box_registry [] =
930 : {
931 : //DO NOT MOVE THE FIRST ENTRY
932 : BOX_DEFINE_S(GF_ISOM_BOX_TYPE_UNKNOWN, unkn, "unknown", "unknown"),
933 : BOX_DEFINE_S(GF_ISOM_BOX_TYPE_UUID, uuid, "unknown", "unknown"),
934 :
935 : //all track reference types
936 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_META, "p12"),
937 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_HINT, "p12"),
938 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_FONT, "p12"),
939 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_HIND, "p12"),
940 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_VDEP, "p12"),
941 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_VPLX, "p12"),
942 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_SUBT, "p12"),
943 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_THUMB, "p12"),
944 :
945 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_OD, "p14"),
946 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_DECODE, "p14"),
947 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_OCR, "p14"),
948 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_IPI, "p14"),
949 :
950 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_BASE, "p15"),
951 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_SCAL, "p15"),
952 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_TBAS, "p15"),
953 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_SABT, "p15"),
954 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_OREF, "p15"),
955 :
956 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_ADDA, "p12"),
957 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_ADRC, "p12"),
958 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_ILOC, "p12"),
959 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_AVCP, "p15"),
960 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_SWTO, "p15"),
961 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_SWFR, "p15"),
962 :
963 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_CHAP, "apple"),
964 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_TMCD, "apple"),
965 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_CDEP, "apple"),
966 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_SCPT, "apple"),
967 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_SSRC, "apple"),
968 : TREF_DEFINE(GF_ISOM_BOX_TYPE_REFT, reftype, "tref", GF_ISOM_REF_LYRA, "apple"),
969 :
970 : //all item reference types
971 : TREF_DEFINE( GF_ISOM_BOX_TYPE_REFI, ireftype, "iref", GF_ISOM_REF_TBAS, "p12"),
972 : TREF_DEFINE( GF_ISOM_BOX_TYPE_REFI, ireftype, "iref", GF_ISOM_REF_ILOC, "p12"),
973 : TREF_DEFINE( GF_ISOM_BOX_TYPE_REFI, ireftype, "iref", GF_ISOM_REF_FDEL, "p12"),
974 :
975 : //all sample group descriptions
976 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_ROLL, "p12"),
977 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_PROL, "p12"),
978 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_RAP, "p12"),
979 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_SEIG, "p15"),
980 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_OINF, "p15"),
981 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_LINF, "p15"),
982 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_TRIF, "p15"),
983 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_NALM, "p15"),
984 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_TELE, "p12"),
985 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_RASH, "p12"),
986 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_ALST, "p12"),
987 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_SAP, "p12"),
988 :
989 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_AVLL, "p15"),
990 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_AVSS, "p15"),
991 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_DTRT, "p15"),
992 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_MVIF, "p15"),
993 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_SCIF, "p15"),
994 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_SCNM, "p15"),
995 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_STSA, "p15"),
996 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_TSAS, "p15"),
997 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_SYNC, "p15"),
998 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_TSCL, "p15"),
999 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_VIPR, "p15"),
1000 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_LBLI, "p15"),
1001 :
1002 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_3GAG, "3gpp"),
1003 : SGPD_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", GF_ISOM_SAMPLE_GROUP_AVCB, "3gpp"),
1004 :
1005 : //internal boxes
1006 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_GNRM, gnrm, "stsd", "unknown"),
1007 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_GNRV, gnrv, "stsd", "unknown"),
1008 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_GNRA, gnra, "stsd", "unknown"),
1009 :
1010 : //all track group types
1011 : TRGT_DEFINE( GF_ISOM_BOX_TYPE_TRGT, trgt, "trgr", GF_ISOM_BOX_TYPE_MSRC, 0, "p12" ),
1012 : TRGT_DEFINE( GF_ISOM_BOX_TYPE_TRGT, trgt, "trgr", GF_ISOM_BOX_TYPE_STER, 0, "p12" ),
1013 : TRGT_DEFINE( GF_ISOM_BOX_TYPE_TRGT, trgt, "trgr", GF_ISOM_BOX_TYPE_CSTG, 0, "p15" ),
1014 :
1015 : //part12 boxes
1016 : BOX_DEFINE( GF_ISOM_BOX_TYPE_FREE, free, "*"),
1017 : BOX_DEFINE( GF_ISOM_BOX_TYPE_SKIP, free, "*"),
1018 : BOX_DEFINE( GF_ISOM_BOX_TYPE_MDAT, mdat, "file"),
1019 : BOX_DEFINE( GF_ISOM_BOX_TYPE_IDAT, mdat, "meta"),
1020 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_MOOV, moov, "file"),
1021 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_MVHD, mvhd, "moov", 1),
1022 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_MDHD, mdhd, "mdia", 1),
1023 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_VMHD, vmhd, "minf", 0),
1024 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_SMHD, smhd, "minf", 0),
1025 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_HMHD, hmhd, "minf", 0),
1026 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_NMHD, nmhd, "minf", 0),
1027 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_STHD, nmhd, "minf", 0),
1028 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_STBL, stbl, "minf"),
1029 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_DINF, dinf, "minf meta"),
1030 : FBOX_DEFINE_FLAGS( GF_ISOM_BOX_TYPE_URL, url, "dref", 0, 1),
1031 : FBOX_DEFINE_FLAGS( GF_ISOM_BOX_TYPE_URN, urn, "dref", 0, 1),
1032 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_CPRT, cprt, "udta", 0),
1033 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_KIND, kind, "udta", 0),
1034 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_HDLR, hdlr, "mdia meta minf", 0), //minf container is OK in QT ...
1035 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_TRAK, trak, "moov"),
1036 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_EDTS, edts, "trak"),
1037 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_UDTA, udta, "moov trak moof traf"),
1038 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_DREF, dref, "dinf", 0),
1039 : FBOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_STSD, stsd, "stbl", 0),
1040 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_STTS, stts, "stbl", 0),
1041 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_CTTS, ctts, "stbl", 1),
1042 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_CSLG, cslg, "stbl trep", 1),
1043 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_STSH, stsh, "stbl", 0),
1044 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_ELST, elst, "edts", 1),
1045 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_STSC, stsc, "stbl", 0),
1046 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_STSZ, stsz, "stbl", 0),
1047 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_STZ2, stsz, "stbl", 0),
1048 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_STCO, stco, "stbl", 0),
1049 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_STSS, stss, "stbl", 0),
1050 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_STDP, stdp, "stbl", 0),
1051 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_SDTP, sdtp, "stbl traf", 0),
1052 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_CO64, co64, "stbl", 0),
1053 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_MINF, minf, "mdia"),
1054 : FBOX_DEFINE_FLAGS(GF_ISOM_BOX_TYPE_TKHD, tkhd, "trak", 1, 0x000001 | 0x000002 | 0x000004 | 0x000008),
1055 : BOX_DEFINE( GF_ISOM_BOX_TYPE_TREF, tref, "trak"),
1056 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_MDIA, mdia, "trak"),
1057 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_MFRA, mfra, "file"),
1058 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_MFRO, mfro, "mfra", 0),
1059 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_TFRA, tfra, "mfra", 1),
1060 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_ELNG, elng, "mdia", 0),
1061 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_PDIN, pdin, "file", 0),
1062 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_SBGP, sbgp, "stbl traf", 1),
1063 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_SGPD, sgpd, "stbl traf", 2),
1064 : BOX_DEFINE( GF_ISOM_BOX_TYPE_CSGP, csgp, "stbl traf"),
1065 : FBOX_DEFINE_FLAGS(GF_ISOM_BOX_TYPE_SAIZ, saiz, "stbl traf", 0, 0),
1066 : FBOX_DEFINE_FLAGS(GF_ISOM_BOX_TYPE_SAIZ, saiz, "stbl traf", 0, 1),
1067 : FBOX_DEFINE_FLAGS(GF_ISOM_BOX_TYPE_SAIO, saio, "stbl traf", 1, 0),
1068 : FBOX_DEFINE_FLAGS(GF_ISOM_BOX_TYPE_SAIO, saio, "stbl traf", 1, 1),
1069 : FBOX_DEFINE_FLAGS( GF_ISOM_BOX_TYPE_SUBS, subs, "stbl traf", 0, 7), //warning flags are not used as a bit mask but as an enum!!
1070 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_TRGR, trgr, "trak"),
1071 : BOX_DEFINE( GF_ISOM_BOX_TYPE_FTYP, ftyp, "file otyp"),
1072 : BOX_DEFINE( GF_ISOM_BOX_TYPE_OTYP, def_parent, "file"),
1073 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_PADB, padb, "stbl", 0),
1074 : BOX_DEFINE( GF_ISOM_BOX_TYPE_BTRT, btrt, "sample_entry"),
1075 : BOX_DEFINE( GF_ISOM_BOX_TYPE_PASP, pasp, "video_sample_entry ipco"),
1076 : BOX_DEFINE( GF_ISOM_BOX_TYPE_CLAP, clap, "video_sample_entry ipco"),
1077 : FBOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_META, meta, "file moov trak moof traf udta", 0), //apple uses meta in moov->udta
1078 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_XML, xml, "meta", 0),
1079 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_BXML, bxml, "meta", 0),
1080 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_ILOC, iloc, "meta", 2),
1081 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_PITM, pitm, "meta", 1),
1082 : FBOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_IPRO, ipro, "meta", 0),
1083 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_INFE, infe, "iinf", 3),
1084 : FBOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_IINF, iinf, "meta", 1),
1085 : FBOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_IREF, iref, "meta", 1),
1086 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_SINF, sinf, "ipro sample_entry"),
1087 : BOX_DEFINE( GF_ISOM_BOX_TYPE_RINF, sinf, "sample_entry"),
1088 : BOX_DEFINE( GF_ISOM_BOX_TYPE_FRMA, frma, "sinf rinf"),
1089 : FBOX_DEFINE_FLAGS(GF_ISOM_BOX_TYPE_SCHM, schm, "sinf rinf", 0, 1),
1090 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_SCHI, schi, "sinf rinf"),
1091 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_ENCA, audio_sample_entry, "stsd"),
1092 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_ENCV, video_sample_entry, "stsd"),
1093 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_RESV, video_sample_entry, "stsd"),
1094 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_TSEL, tsel, "udta", 0),
1095 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_STRK, strk, "udta"),
1096 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_STRI, stri, "strk", 0),
1097 : BOX_DEFINE( GF_ISOM_BOX_TYPE_STRD, def_parent, "strk"),
1098 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_STSG, stsg, "strd", 0),
1099 :
1100 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_ENCS, mp4s, "stsd"),
1101 : //THIS HAS TO BE FIXED, not extensible
1102 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_ENCT, mp4s, "stsd"),
1103 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_ENCM, mp4s, "stsd"),
1104 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_ENCF, mp4s, "stsd"),
1105 :
1106 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_METX, metx, "stsd"),
1107 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_METT, metx, "stsd"),
1108 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_STVI, stvi, "schi", 0),
1109 :
1110 :
1111 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_CHNL, chnl, "audio_sample_entry", 0),
1112 :
1113 : //FEC
1114 : FBOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_FIIN, fiin, "meta", 0),
1115 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_PAEN, paen, "fiin"),
1116 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_FPAR, fpar, "paen", 1),
1117 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_FECR, fecr, "paen", 1),
1118 : //fire uses the same box syntax as fecr
1119 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_FIRE, fecr, "paen", 1),
1120 : BOX_DEFINE( GF_ISOM_BOX_TYPE_SEGR, segr, "fiin"),
1121 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_GITN, gitn, "fiin", 0),
1122 :
1123 : #ifndef GPAC_DISABLE_ISOM_HINTING
1124 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_FDSA, fdsa, "fdp_sample"),
1125 : BOX_DEFINE( GF_ISOM_BOX_TYPE_FDPA, fdpa, "fdsa"),
1126 : BOX_DEFINE( GF_ISOM_BOX_TYPE_EXTR, extr, "fdsa"),
1127 : #endif
1128 :
1129 : //full boxes todo
1130 : //FBOX_DEFINE( GF_ISOM_BOX_TYPE_ASSP, assp, 1),
1131 : //FBOX_DEFINE( GF_ISOM_BOX_TYPE_MERE, assp, 0),
1132 : //FBOX_DEFINE( GF_ISOM_BOX_TYPE_SRAT, srat, 0),
1133 : //FBOX_DEFINE( GF_ISOM_BOX_TYPE_CHNL, chnl, 0),
1134 : //FBOX_DEFINE( GF_ISOM_BOX_TYPE_DMIX, dmix, 0),
1135 : //FBOX_DEFINE( GF_ISOM_BOX_TYPE_TLOU, alou, 0),
1136 : //FBOX_DEFINE( GF_ISOM_BOX_TYPE_ALOU, alou, 0),
1137 : //FBOX_DEFINE( GF_ISOM_BOX_TYPE_URI, uri, 0),
1138 : //FBOX_DEFINE( GF_ISOM_BOX_TYPE_URII, urii, 0),
1139 :
1140 : #ifndef GPAC_DISABLE_ISOM_HINTING
1141 : BOX_DEFINE( GF_ISOM_BOX_TYPE_RTP_STSD, ghnt, "stsd"),
1142 : BOX_DEFINE( GF_ISOM_BOX_TYPE_SRTP_STSD, ghnt, "stsd"),
1143 : BOX_DEFINE( GF_ISOM_BOX_TYPE_FDP_STSD, ghnt, "stsd"),
1144 : BOX_DEFINE( GF_ISOM_BOX_TYPE_RRTP_STSD, ghnt, "stsd"),
1145 : BOX_DEFINE( GF_ISOM_BOX_TYPE_RTCP_STSD, ghnt, "stsd"),
1146 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_HNTI, hnti, "udta"),
1147 : BOX_DEFINE( GF_ISOM_BOX_TYPE_SDP, sdp, "hnti"),
1148 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_HINF, hinf, "udta"),
1149 : BOX_DEFINE( GF_ISOM_BOX_TYPE_TRPY, trpy, "hinf"),
1150 : BOX_DEFINE( GF_ISOM_BOX_TYPE_NUMP, nump, "hinf"),
1151 : BOX_DEFINE( GF_ISOM_BOX_TYPE_TPYL, tpyl, "hinf"),
1152 : BOX_DEFINE( GF_ISOM_BOX_TYPE_TOTL, totl, "hinf"),
1153 : BOX_DEFINE( GF_ISOM_BOX_TYPE_NPCK, npck, "hinf"),
1154 : BOX_DEFINE( GF_ISOM_BOX_TYPE_TPAY, tpay, "hinf"),
1155 : BOX_DEFINE( GF_ISOM_BOX_TYPE_MAXR, maxr, "hinf"),
1156 : BOX_DEFINE( GF_ISOM_BOX_TYPE_DMED, dmed, "hinf"),
1157 : BOX_DEFINE( GF_ISOM_BOX_TYPE_DIMM, dimm, "hinf"),
1158 : BOX_DEFINE( GF_ISOM_BOX_TYPE_DREP, drep, "hinf"),
1159 : BOX_DEFINE( GF_ISOM_BOX_TYPE_TMIN, tmin, "hinf"),
1160 : BOX_DEFINE( GF_ISOM_BOX_TYPE_TMAX, tmax, "hinf"),
1161 : BOX_DEFINE( GF_ISOM_BOX_TYPE_PMAX, pmax, "hinf"),
1162 : BOX_DEFINE( GF_ISOM_BOX_TYPE_DMAX, dmax, "hinf"),
1163 : BOX_DEFINE( GF_ISOM_BOX_TYPE_PAYT, payt, "hinf"),
1164 : BOX_DEFINE( GF_ISOM_BOX_TYPE_RTP, rtp_hnti, "hnti"),
1165 :
1166 : BOX_DEFINE( GF_ISOM_BOX_TYPE_RTPO, rtpo, "rtp_packet"),
1167 :
1168 : BOX_DEFINE( GF_ISOM_BOX_TYPE_RELY, rely, "rtp srtp"),
1169 : BOX_DEFINE( GF_ISOM_BOX_TYPE_TIMS, tims, "rtp srtp rrtp"),
1170 : BOX_DEFINE( GF_ISOM_BOX_TYPE_TSRO, tsro, "rtp srtp rrtp"),
1171 : BOX_DEFINE( GF_ISOM_BOX_TYPE_SNRO, snro, "rtp srtp"),
1172 : BOX_DEFINE( GF_ISOM_BOX_TYPE_NAME, name, "udta"),
1173 : BOX_DEFINE( GF_ISOM_BOX_TYPE_TSSY, tssy, "rrtp"),
1174 : BOX_DEFINE( GF_ISOM_BOX_TYPE_RSSR, rssr, "rrtp"),
1175 : FBOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_SRPP, srpp, "srtp", 0),
1176 :
1177 : #endif
1178 :
1179 : #ifndef GPAC_DISABLE_ISOM_FRAGMENTS
1180 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_MVEX, mvex, "moov"),
1181 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_MEHD, mehd, "mvex", 1),
1182 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_TREX, trex, "mvex", 0),
1183 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_LEVA, leva, "mvex", 0),
1184 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_TREP, trep, "mvex", 0),
1185 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_MOOF, moof, "file"),
1186 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_MFHD, mfhd, "moof", 0),
1187 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_TRAF, traf, "moof"),
1188 : FBOX_DEFINE_FLAGS(GF_ISOM_BOX_TYPE_TFHD, tfhd, "traf", 0, 0x000001|0x000002|0x000008|0x000010|0x000020|0x010000|0x020000),
1189 : FBOX_DEFINE_FLAGS(GF_ISOM_BOX_TYPE_TRUN, trun, "traf", 0, 0x000001|0x000004|0x000100|0x000200|0x000400|0x000800),
1190 : #ifdef GF_ENABLE_CTRN
1191 : FBOX_DEFINE_FLAGS(GF_ISOM_BOX_TYPE_CTRN, trun, "traf", 0, 0),
1192 : #endif
1193 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_TFDT, tfdt, "traf", 1),
1194 : BOX_DEFINE( GF_ISOM_BOX_TYPE_STYP, ftyp, "file"),
1195 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_PRFT, prft, "file", 1),
1196 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_SIDX, sidx, "file", 1),
1197 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_SSIX, ssix, "file", 0),
1198 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_PCRB, pcrb, "file", "dash"),
1199 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_EMSG, emsg, "file", 1, "dash"),
1200 : #endif
1201 :
1202 :
1203 : //part14 boxes
1204 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_IODS, iods, "moov", 0, "p14"),
1205 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_MP4S, mp4s, "stsd", "p14"),
1206 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_MP4V, video_sample_entry, "stsd", "p14"),
1207 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_MP4A, audio_sample_entry, "stsd", "p14"),
1208 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_M4DS, m4ds, "sample_entry", "p14"),
1209 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_ESDS, esds, "mp4a mp4s mp4v encv enca encs resv wave", 0, "p14"),
1210 :
1211 : //part 15 boxes
1212 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_AVCC, avcc, "avc1 avc2 avc3 avc4 encv resv ipco", "p15"),
1213 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_SVCC, avcc, "avc1 avc2 avc3 avc4 svc1 svc2 encv resv", "p15"),
1214 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_MVCC, avcc, "avc1 avc2 avc3 avc4 mvc1 mvc2 encv resv", "p15"),
1215 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_HVCC, hvcc, "hvc1 hev1 hvc2 hev2 encv resv ipco dvhe", "p15"),
1216 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_LHVC, hvcc, "hvc1 hev1 hvc2 hev2 lhv1 lhe1 encv resv ipco", "p15"),
1217 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_VVCC, vvcc, "vvc1 vvi1 encv resv ipco dvhe", "p15"),
1218 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_AVC1, video_sample_entry, "stsd", "p15"),
1219 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_AVC2, video_sample_entry, "stsd", "p15"),
1220 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_AVC3, video_sample_entry, "stsd", "p15"),
1221 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_AVC4, video_sample_entry, "stsd", "p15"),
1222 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_SVC1, video_sample_entry, "stsd", "p15"),
1223 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_MVC1, video_sample_entry, "stsd", "p15"),
1224 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_HVC1, video_sample_entry, "stsd", "p15"),
1225 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_HEV1, video_sample_entry, "stsd", "p15"),
1226 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_HVC2, video_sample_entry, "stsd", "p15"),
1227 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_HEV2, video_sample_entry, "stsd", "p15"),
1228 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_LHV1, video_sample_entry, "stsd", "p15"),
1229 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_LHE1, video_sample_entry, "stsd", "p15"),
1230 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_HVT1, video_sample_entry, "stsd", "p15"),
1231 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_VVC1, video_sample_entry, "stsd", "p15"),
1232 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_VVI1, video_sample_entry, "stsd", "p15"),
1233 : FBOX_DEFINE_S(GF_ISOM_BOX_TYPE_MVCI, def_parent_full, "minf", 0, "p15"),
1234 : FBOX_DEFINE_S(GF_ISOM_BOX_TYPE_MVCG, mvcg, "mvci", 0, "p15"),
1235 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_VWID, vwid, "video_sample_entry", 0, "p15"),
1236 :
1237 : //mpegh 3D audio boxes
1238 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_MHA1, audio_sample_entry, "stsd", "mpegh3Daudio"),
1239 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_MHA2, audio_sample_entry, "stsd", "mpegh3Daudio"),
1240 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_MHM1, audio_sample_entry, "stsd", "mpegh3Daudio"),
1241 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_MHM2, audio_sample_entry, "stsd", "mpegh3Daudio"),
1242 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_MHAC, mhac, "mha1 mha2 mhm1 mhm2 wave", "mpegh3Daudio"),
1243 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_MHAP, mhap, "mha1 mha2 mhm1 mhm2 wave", "mpegh3Daudio"),
1244 :
1245 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_IPCM, audio_sample_entry, "stsd", "23003_5"),
1246 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_FPCM, audio_sample_entry, "stsd", "23003_5"),
1247 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_PCMC, pcmC, "ipcm fpcm", 0, "23003_5"),
1248 :
1249 : //AV1 in ISOBMFF boxes
1250 : BOX_DEFINE_S_CHILD(GF_ISOM_BOX_TYPE_AV01, video_sample_entry, "stsd", "av1"),
1251 : BOX_DEFINE_S(GF_ISOM_BOX_TYPE_AV1C, av1c, "av01 encv resv ipco", "av1"),
1252 :
1253 : // VP8-9 boxes
1254 : FBOX_DEFINE_FLAGS_S( GF_ISOM_BOX_TYPE_VPCC, vpcc, "vp08 vp09 encv resv", 1, 0, "vp"),
1255 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_VP08, video_sample_entry, "stsd", "vp"),
1256 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_VP09, video_sample_entry, "stsd", "vp"),
1257 : FBOX_DEFINE_FLAGS_S(GF_ISOM_BOX_TYPE_SMDM, SmDm, "vp08 vp09 encv resv", 1, 0, "vp"),
1258 : FBOX_DEFINE_FLAGS_S(GF_ISOM_BOX_TYPE_COLL, CoLL, "vp08 vp09 encv resv", 1, 0, "vp"),
1259 :
1260 : //Opus in ISOBMFF boxes
1261 : #ifndef GPAC_DISABLE_OGG
1262 : BOX_DEFINE_S_CHILD(GF_ISOM_BOX_TYPE_OPUS, audio_sample_entry, "stsd", "Opus"),
1263 : BOX_DEFINE_S(GF_ISOM_BOX_TYPE_DOPS, dOps, "Opus wave enca", "Opus"),
1264 : #endif
1265 :
1266 : //part20 boxes
1267 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_LSR1, lsr1, "stsd", "p20"),
1268 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_LSRC, lsrc, "lsr1", "p20"),
1269 :
1270 : //part30 boxes
1271 : #ifndef GPAC_DISABLE_TTXT
1272 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_STXT, metx, "stsd"),
1273 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_TXTC, txtc, "stxt mett sbtt", 0),
1274 : //we allow mime in any sample entry, not restricted in the spec ...
1275 : FBOX_DEFINE( GF_ISOM_BOX_TYPE_MIME, txtc, "sample_entry", 0),
1276 : #ifndef GPAC_DISABLE_VTT
1277 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_WVTT, wvtt, "stsd", "p30"),
1278 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_VTCC_CUE, vtcu, "vtt_sample", "p30"),
1279 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_VTTE, vtte, "vtt_sample", "p30"),
1280 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_VTTC_CONFIG, boxstring, "wvtt", "p30"),
1281 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_CTIM, boxstring, "vttc", "p30"),
1282 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_IDEN, boxstring, "vttc", "p30"),
1283 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_STTG, boxstring, "vttc", "p30"),
1284 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_PAYL, boxstring, "vttc", "p30"),
1285 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_VTTA, boxstring, "vttc", "p30"),
1286 : #endif
1287 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_STPP, metx, "stsd"),
1288 : BOX_DEFINE_CHILD( GF_ISOM_BOX_TYPE_SBTT, metx, "stsd"),
1289 : #endif
1290 :
1291 : //Image File Format
1292 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_IPRP, iprp, "meta", "iff"),
1293 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_IPCO, ipco, "iprp", "iff"),
1294 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_ISPE, ispe, "ipco", 0, "iff"),
1295 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_COLR, colr, "video_sample_entry ipco encv resv", "iff"),
1296 : //defined as a secondary box for now to avoid conflicts with master hashes
1297 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_COLR, colr, "jp2h", "iff"),
1298 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_PIXI, pixi, "ipco", 0, "iff"),
1299 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_RLOC, rloc, "ipco", 0, "iff"),
1300 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_IROT, irot, "ipco", "iff"),
1301 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_IMIR, imir, "ipco", "iff"),
1302 : FBOX_DEFINE_FLAGS_S( GF_ISOM_BOX_TYPE_IPMA, ipma, "iprp", 1, 1, "iff"),
1303 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_GRPL, grpl, "meta", "iff"),
1304 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_CCST, ccst, "sample_entry", 0, "iff"),
1305 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_AUXI, auxi, "sample_entry", 0, "iff"),
1306 : TRGT_DEFINE(GF_ISOM_BOX_TYPE_GRPT, grptype, "grpl", GF_ISOM_BOX_TYPE_ALTR, 0, "iff"),
1307 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_AUXC, auxc, "ipco", 0, "iff"),
1308 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_OINF, oinf, "ipco", 0, "iff"),
1309 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_TOLS, tols, "ipco", 0, "iff"),
1310 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_IENC, ienc, "ipco", 0, "cenc"),
1311 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_IAUX, iaux, "ipco", 0, "cenc"),
1312 :
1313 : //MIAF
1314 : BOX_DEFINE_S(GF_ISOM_BOX_TYPE_CLLI, clli, "mp4v jpeg avc1 avc2 avc3 avc4 svc1 svc2 hvc1 hev1 hvc2 hev2 lhv1 lhe1 vvc1 vvi1 encv resv", "miaf"),
1315 : BOX_DEFINE_S(GF_ISOM_BOX_TYPE_MDCV, mdcv, "mp4v jpeg avc1 avc2 avc3 avc4 svc1 svc2 hvc1 hev1 hvc2 hev2 lhv1 lhe1 vvc1 vvi1 encv resv", "miaf"),
1316 :
1317 : //other MPEG boxes
1318 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_RVCC, rvcc, "avc1 avc2 avc3 avc4 svc1 svc2 hvc1 hev1 hvc2 hev2 lhv1 lhe1 encv resv", "rvc"),
1319 :
1320 : //3GPP boxes
1321 : BOX_DEFINE_S_CHILD( GF_ISOM_SUBTYPE_3GP_AMR, audio_sample_entry, "stsd", "3gpp"),
1322 : BOX_DEFINE_S_CHILD( GF_ISOM_SUBTYPE_3GP_AMR_WB, audio_sample_entry, "stsd", "3gpp"),
1323 : BOX_DEFINE_S_CHILD( GF_ISOM_SUBTYPE_3GP_QCELP, audio_sample_entry, "stsd", "3gpp"),
1324 : BOX_DEFINE_S_CHILD( GF_ISOM_SUBTYPE_3GP_EVRC, audio_sample_entry, "stsd", "3gpp"),
1325 : BOX_DEFINE_S_CHILD( GF_ISOM_SUBTYPE_3GP_SMV, audio_sample_entry, "stsd", "3gpp"),
1326 : BOX_DEFINE_S_CHILD( GF_ISOM_SUBTYPE_3GP_H263, video_sample_entry, "stsd", "3gpp"),
1327 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_DAMR, gppc, "samr sawb enca", "3gpp"),
1328 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_DEVC, gppc, "sevc enca", "3gpp"),
1329 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_DQCP, gppc, "sqcp enca", "3gpp"),
1330 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_DSMV, gppc, "ssmv enca", "3gpp"),
1331 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_D263, gppc, "s263 encv", "3gpp"),
1332 : //3gpp timed text
1333 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_TX3G, tx3g, "stsd", "3gpp"),
1334 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_TEXT, text, "stsd", "apple"),
1335 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_FTAB, ftab, "tx3g text enct", "3gpp"),
1336 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_STYL, styl, "text_sample", "3gpp"),
1337 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_HLIT, hlit, "text_sample", "3gpp"),
1338 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_HCLR, hclr, "text_sample", "3gpp"),
1339 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_KROK, krok, "text_sample", "3gpp"),
1340 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_DLAY, dlay, "text_sample", "3gpp"),
1341 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_HREF, href, "text_sample", "3gpp"),
1342 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_TBOX, tbox, "text_sample", "3gpp"),
1343 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_BLNK, blnk, "text_sample", "3gpp"),
1344 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_TWRP, twrp, "text_sample", "3gpp"),
1345 : //3GPP dims
1346 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_DIMS, dims, "stsd", "3gpp"),
1347 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_DIMC, dimC, "dims encs", "3gpp"),
1348 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_DIST, diST, "dims", "3gpp"),
1349 :
1350 :
1351 : //CENC boxes
1352 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_PSSH, pssh, "moov moof meta", 0, "cenc"),
1353 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_TENC, tenc, "schi", 1, "cenc"),
1354 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_SENC, senc, "trak traf", "cenc"),
1355 :
1356 : // ISMA 1.1 boxes
1357 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_IKMS, iKMS, "schi", 0, "isma"),
1358 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_ISFM, iSFM, "schi", 0, "isma"),
1359 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_ISLT, iSLT, "schi", 0, "isma"),
1360 :
1361 : //OMA boxes
1362 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_ODKM, odkm, "schi", 0, "oma"),
1363 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_OHDR, ohdr, "odkm", 0, "oma"),
1364 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_GRPI, grpi, "ohdr", 0, "oma"),
1365 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_MDRI, mdri, "file", "oma"),
1366 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_ODTT, odtt, "mdri", 0, "oma"),
1367 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_ODRB, odrb, "mdri", 0, "oma"),
1368 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_ODAF, iSFM, "schi", 0, "oma"),
1369 :
1370 : //apple boxes
1371 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_MP3, audio_sample_entry, "stsd", "apple"),
1372 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_CHPL, chpl, "udta", 0, "apple"),
1373 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_VOID, void, "", "apple"),
1374 : BOX_DEFINE_S(GF_QT_BOX_TYPE_WIDE, wide, "*", "apple"),
1375 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_ILST, ilst, "meta", "apple"),
1376 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_DATA, databox, "ilst *", 0, "apple"),
1377 :
1378 : ITUNES_TAG(GF_ISOM_ITUNE_NAME),
1379 : ITUNES_TAG(GF_ISOM_ITUNE_ARTIST),
1380 : ITUNES_TAG(GF_ISOM_ITUNE_ALBUM_ARTIST),
1381 : ITUNES_TAG(GF_ISOM_ITUNE_ALBUM),
1382 : ITUNES_TAG(GF_ISOM_ITUNE_GROUP),
1383 : ITUNES_TAG(GF_ISOM_ITUNE_WRITER),
1384 : ITUNES_TAG(GF_ISOM_ITUNE_COMMENT),
1385 : ITUNES_TAG(GF_ISOM_ITUNE_GENRE_USER),
1386 : ITUNES_TAG(GF_ISOM_ITUNE_GENRE),
1387 : ITUNES_TAG(GF_ISOM_ITUNE_CREATED),
1388 : ITUNES_TAG(GF_ISOM_ITUNE_TRACKNUMBER),
1389 : ITUNES_TAG(GF_ISOM_ITUNE_DISK),
1390 : ITUNES_TAG(GF_ISOM_ITUNE_TEMPO),
1391 : ITUNES_TAG(GF_ISOM_ITUNE_COMPILATION),
1392 : ITUNES_TAG(GF_ISOM_ITUNE_TV_SHOW),
1393 : ITUNES_TAG(GF_ISOM_ITUNE_TV_EPISODE),
1394 : ITUNES_TAG(GF_ISOM_ITUNE_TV_SEASON),
1395 : ITUNES_TAG(GF_ISOM_ITUNE_TV_EPISODE_NUM),
1396 : ITUNES_TAG(GF_ISOM_ITUNE_TV_NETWORK),
1397 : ITUNES_TAG(GF_ISOM_ITUNE_DESCRIPTION),
1398 : ITUNES_TAG(GF_ISOM_ITUNE_LONG_DESCRIPTION),
1399 : ITUNES_TAG(GF_ISOM_ITUNE_LYRICS),
1400 : ITUNES_TAG(GF_ISOM_ITUNE_SORT_NAME),
1401 : ITUNES_TAG(GF_ISOM_ITUNE_SORT_ARTIST),
1402 : ITUNES_TAG(GF_ISOM_ITUNE_SORT_ALB_ARTIST),
1403 : ITUNES_TAG(GF_ISOM_ITUNE_SORT_ALBUM),
1404 : ITUNES_TAG(GF_ISOM_ITUNE_SORT_COMPOSER),
1405 : ITUNES_TAG(GF_ISOM_ITUNE_SORT_SHOW),
1406 : ITUNES_TAG(GF_ISOM_ITUNE_COVER_ART),
1407 : ITUNES_TAG(GF_ISOM_ITUNE_COPYRIGHT),
1408 : ITUNES_TAG(GF_ISOM_ITUNE_TOOL),
1409 : ITUNES_TAG(GF_ISOM_ITUNE_ENCODER),
1410 : ITUNES_TAG(GF_ISOM_ITUNE_PURCHASE_DATE),
1411 : ITUNES_TAG(GF_ISOM_ITUNE_PODCAST),
1412 : ITUNES_TAG(GF_ISOM_ITUNE_PODCAST_URL),
1413 : ITUNES_TAG(GF_ISOM_ITUNE_KEYWORDS),
1414 : ITUNES_TAG(GF_ISOM_ITUNE_CATEGORY),
1415 : ITUNES_TAG(GF_ISOM_ITUNE_HD_VIDEO),
1416 : ITUNES_TAG(GF_ISOM_ITUNE_MEDIA_TYPE),
1417 : ITUNES_TAG(GF_ISOM_ITUNE_RATING),
1418 : ITUNES_TAG(GF_ISOM_ITUNE_GAPLESS),
1419 : ITUNES_TAG(GF_ISOM_ITUNE_COMPOSER),
1420 : ITUNES_TAG(GF_ISOM_ITUNE_TRACK),
1421 : ITUNES_TAG(GF_ISOM_ITUNE_CONDUCTOR),
1422 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_iTunesSpecificInfo, ilst_item, "ilst data", "apple"),
1423 : BOX_DEFINE_S(GF_ISOM_BOX_TYPE_GMHD, def_parent, "minf", "apple"),
1424 : BOX_DEFINE_S(GF_QT_BOX_TYPE_LOAD, load, "trak", "apple"),
1425 : BOX_DEFINE_S(GF_QT_BOX_TYPE_TAPT, def_parent, "trak", "apple"),
1426 : FBOX_DEFINE_S( GF_QT_BOX_TYPE_GMIN, gmin, "gmhd", 0, "apple"),
1427 : FBOX_DEFINE_FLAGS_S( GF_QT_BOX_TYPE_ALIS, alis, "dref", 0, 1, "apple"),
1428 : FBOX_DEFINE_S( GF_QT_BOX_TYPE_CLEF, clef, "tapt", 0, "apple"),
1429 : FBOX_DEFINE_S( GF_QT_BOX_TYPE_PROF, clef, "tapt", 0, "apple"),
1430 : FBOX_DEFINE_S( GF_QT_BOX_TYPE_ENOF, clef, "tapt", 0, "apple"),
1431 : BOX_DEFINE_S( GF_QT_BOX_TYPE_WAVE, def_parent, "audio_sample_entry", "apple"),
1432 : FBOX_DEFINE_S( GF_QT_BOX_TYPE_CHAN, chan, "audio_sample_entry", 0, "apple"),
1433 : BOX_DEFINE_S( GF_QT_BOX_TYPE_FRMA, frma, "wave", "apple"),
1434 : BOX_DEFINE_S( GF_QT_BOX_TYPE_TERMINATOR, unkn, "wave", "apple"),
1435 : BOX_DEFINE_S( GF_QT_BOX_TYPE_ENDA, chrm, "wave", "apple"),
1436 : BOX_DEFINE_S( GF_QT_BOX_TYPE_TMCD, def_parent, "gmhd", "apple"),
1437 : BOX_DEFINE_S( GF_QT_BOX_TYPE_NAME, unkn, "tmcd", "apple"),
1438 : FBOX_DEFINE_S( GF_QT_BOX_TYPE_TCMI, tcmi, "tmcd", 0, "apple"),
1439 : BOX_DEFINE_S( GF_QT_BOX_TYPE_FIEL, fiel, "video_sample_entry", "apple"),
1440 : BOX_DEFINE_S( GF_QT_BOX_TYPE_GAMA, gama, "video_sample_entry", "apple"),
1441 : BOX_DEFINE_S( GF_QT_BOX_TYPE_CHRM, chrm, "video_sample_entry", "apple"),
1442 : BOX_DEFINE_S( GF_ISOM_SUBTYPE_TEXT, unkn, "gmhd", "apple"),
1443 :
1444 : //QT and prores sample entry types
1445 : BOX_DEFINE_S( GF_QT_BOX_TYPE_TMCD, tmcd, "stsd", "apple"),
1446 : BOX_DEFINE_S( GF_QT_SUBTYPE_C608, gen_sample_entry, "stsd", "apple"),
1447 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_APCH, video_sample_entry, "stsd", "apple"),
1448 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_APCO, video_sample_entry, "stsd", "apple"),
1449 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_APCS, video_sample_entry, "stsd", "apple"),
1450 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_APCN, video_sample_entry, "stsd", "apple"),
1451 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_AP4X, video_sample_entry, "stsd", "apple"),
1452 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_AP4H, video_sample_entry, "stsd", "apple"),
1453 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_RAW_AUD, audio_sample_entry, "stsd", "apple"),
1454 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_TWOS, audio_sample_entry, "stsd", "apple"),
1455 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_SOWT, audio_sample_entry, "stsd", "apple"),
1456 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_FL32, audio_sample_entry, "stsd", "apple"),
1457 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_FL64, audio_sample_entry, "stsd", "apple"),
1458 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_IN24, audio_sample_entry, "stsd", "apple"),
1459 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_IN32, audio_sample_entry, "stsd", "apple"),
1460 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_ULAW, audio_sample_entry, "stsd", "apple"),
1461 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_ALAW, audio_sample_entry, "stsd", "apple"),
1462 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_ADPCM, audio_sample_entry, "stsd", "apple"),
1463 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_IMA_ADPCM, audio_sample_entry, "stsd", "apple"),
1464 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_DVCA, audio_sample_entry, "stsd", "apple"),
1465 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_QDMC, audio_sample_entry, "stsd", "apple"),
1466 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_QDMC2, audio_sample_entry, "stsd", "apple"),
1467 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_QCELP, audio_sample_entry, "stsd", "apple"),
1468 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_kMP3, audio_sample_entry, "stsd", "apple"),
1469 :
1470 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_RAW_VID, video_sample_entry, "stsd", "apple"),
1471 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_YUYV, video_sample_entry, "stsd", "apple"),
1472 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_UYVY, video_sample_entry, "stsd", "apple"),
1473 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_YUV444, video_sample_entry, "stsd", "apple"),
1474 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_YUVA444, video_sample_entry, "stsd", "apple"),
1475 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_YUV422_10, video_sample_entry, "stsd", "apple"),
1476 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_YUV444_10, video_sample_entry, "stsd", "apple"),
1477 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_YUV422_16, video_sample_entry, "stsd", "apple"),
1478 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_YUV420, video_sample_entry, "stsd", "apple"),
1479 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_I420, video_sample_entry, "stsd", "apple"),
1480 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_IYUV, video_sample_entry, "stsd", "apple"),
1481 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_YV12, video_sample_entry, "stsd", "apple"),
1482 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_YVYU, video_sample_entry, "stsd", "apple"),
1483 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_RGBA, video_sample_entry, "stsd", "apple"),
1484 : BOX_DEFINE_S_CHILD( GF_QT_SUBTYPE_ABGR, video_sample_entry, "stsd", "apple"),
1485 :
1486 :
1487 : //dolby boxes
1488 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_AC3, audio_sample_entry, "stsd", "dolby"),
1489 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_EC3, audio_sample_entry, "stsd", "dolby"),
1490 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_DAC3, dac3, "ac-3 wave", "dolby"),
1491 : {GF_ISOM_BOX_TYPE_DEC3, dec3_box_new, dac3_box_del, dac3_box_read, dac3_box_write, dac3_box_size, dac3_box_dump, 0, 0, 0, "ec-3 enca", "dolby" },
1492 : BOX_DEFINE_S(GF_ISOM_BOX_TYPE_DVCC, dvcC, "dvhe dvav dva1 dvh1 avc1 avc2 avc3 avc4 hev1 encv resv", "DolbyVision"),
1493 : BOX_DEFINE_S_CHILD(GF_ISOM_BOX_TYPE_DVHE, video_sample_entry, "stsd", "DolbyVision"),
1494 : BOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_MLPA, audio_sample_entry, "stsd", "dolby"),
1495 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_DMLP, dmlp, "mlpa", "dolby"),
1496 :
1497 : //Adobe boxes
1498 : #ifndef GPAC_DISABLE_ISOM_ADOBE
1499 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_ABST, abst, "file", 0, "adobe"),
1500 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_AFRA, afra, "file", 0, "adobe"),
1501 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_ASRT, asrt, "abst", 0, "adobe"),
1502 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_AFRT, afrt, "abst", 0, "adobe"),
1503 : #endif
1504 : /*Adobe's protection boxes*/
1505 : FBOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_ADKM, adkm, "schi", 0, "adobe"),
1506 : FBOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_AHDR, ahdr, "adkm", 0, "adobe"),
1507 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_ADAF, adaf, "adkm", 0, "adobe"),
1508 : FBOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_APRM, aprm, "ahdr", 0, "adobe"),
1509 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_AEIB, aeib, "aprm", 0, "adobe"),
1510 : FBOX_DEFINE_S_CHILD( GF_ISOM_BOX_TYPE_AKEY, akey, "aprm", 0, "adobe"),
1511 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_FLXS, flxs, "akey", "adobe"),
1512 :
1513 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_TRIK, trik, "traf", 0, "dece"),
1514 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_BLOC, bloc, "file", 0, "dece"),
1515 : FBOX_DEFINE_FLAGS_S(GF_ISOM_BOX_TYPE_AINF, ainf, "moov", 0, 0x000001, "dece"),
1516 :
1517 :
1518 : //internally handled UUID for smooth - the code points are only used during creation and assigned to UUIDBox->internal4CC
1519 : //the box type is still "uuid", and the factory is used to read/write/size/dump the code
1520 : BOX_DEFINE_S(GF_ISOM_BOX_UUID_TENC, piff_tenc, "schi", "smooth"),
1521 : BOX_DEFINE_S(GF_ISOM_BOX_UUID_PSEC, piff_psec, "trak traf", "smooth"),
1522 : BOX_DEFINE_S(GF_ISOM_BOX_UUID_PSSH, piff_pssh, "moov moof", "smooth"),
1523 : BOX_DEFINE_S(GF_ISOM_BOX_UUID_TFXD, tfxd, "traf", "smooth"),
1524 : BOX_DEFINE_S(GF_ISOM_BOX_UUID_TFRF, tfrf, "traf", "smooth"),
1525 : BOX_DEFINE_S(GF_ISOM_BOX_UUID_MSSM, uuid, "file", "smooth"),
1526 : BOX_DEFINE_S(GF_ISOM_BOX_UUID_TFRF, uuid, "traf", "smooth"),
1527 :
1528 :
1529 : //J2K boxes
1530 : BOX_DEFINE_S_CHILD(GF_ISOM_BOX_TYPE_MJP2, video_sample_entry, "stsd", "j2k"),
1531 : BOX_DEFINE_S_CHILD(GF_ISOM_BOX_TYPE_JP2H, jp2h, "mjp2 encv", "j2k"),
1532 : BOX_DEFINE_S(GF_ISOM_BOX_TYPE_IHDR, ihdr, "jp2h", "j2k"),
1533 :
1534 : /* Image tracks */
1535 : BOX_DEFINE_S_CHILD(GF_ISOM_BOX_TYPE_JPEG, video_sample_entry, "stsd", "apple"),
1536 : BOX_DEFINE_S_CHILD(GF_ISOM_BOX_TYPE_JP2K, video_sample_entry, "stsd", "apple"),
1537 : BOX_DEFINE_S_CHILD(GF_ISOM_BOX_TYPE_PNG, video_sample_entry, "stsd", "apple"),
1538 :
1539 :
1540 : //Opus in ISOBMFF boxes
1541 : BOX_DEFINE_S_CHILD(GF_ISOM_BOX_TYPE_FLAC, audio_sample_entry, "stsd", "Flac"),
1542 : FBOX_DEFINE_S(GF_ISOM_BOX_TYPE_DFLA, dfla, "fLaC enca", 0, "Flac"),
1543 :
1544 : BOX_DEFINE_S(GF_ISOM_BOX_TYPE_XTRA, xtra, "udta", "WMA"),
1545 :
1546 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_ST3D, st3d, "video_sample_entry", 0, "youtube"),
1547 :
1548 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_SV3D, def_parent, "video_sample_entry", "youtube"),
1549 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_SVHD, svhd, "sv3d", 0, "youtube"),
1550 : BOX_DEFINE_S( GF_ISOM_BOX_TYPE_PROJ, def_parent, "sv3d", "youtube"),
1551 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_PRHD, prhd, "proj", 0, "youtube"),
1552 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_CBMP, proj_type, "proj", 0, "youtube"),
1553 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_EQUI, proj_type, "proj", 0, "youtube"),
1554 : FBOX_DEFINE_S( GF_ISOM_BOX_TYPE_MESH, proj_type, "proj", 0, "youtube"),
1555 :
1556 : /*
1557 : GF_ISOM_BOX_TYPE_CBMP = GF_4CC( 'c', 'b', 'm', 'p' ),
1558 : GF_ISOM_BOX_TYPE_EQUI = GF_4CC( 'e', 'q', 'u', 'i' ),
1559 : GF_ISOM_BOX_TYPE_MSHP = GF_4CC( 'm', 's', 'h', 'p' ),
1560 : GF_ISOM_BOX_TYPE_MESH = GF_4CC( 'm', 'e', 's', 'h' ),
1561 : */
1562 :
1563 : };
1564 :
1565 3028 : Bool gf_box_valid_in_parent(GF_Box *a, const char *parent_4cc)
1566 : {
1567 3028 : if (!a || !a->registry || !a->registry->parents_4cc) return GF_FALSE;
1568 3028 : if (strstr(a->registry->parents_4cc, parent_4cc) != NULL) return GF_TRUE;
1569 6 : return GF_FALSE;
1570 : }
1571 :
1572 : GF_EXPORT
1573 373610 : u32 gf_isom_get_num_supported_boxes()
1574 : {
1575 373610 : return sizeof(box_registry) / sizeof(struct box_registry_entry);
1576 : }
1577 :
1578 4 : void gf_isom_registry_disable(u32 boxCode, Bool disable)
1579 : {
1580 4 : u32 i=0, count = gf_isom_get_num_supported_boxes();
1581 496 : for (i=1; i<count; i++) {
1582 496 : if (box_registry[i].box_4cc==boxCode) {
1583 4 : box_registry[i].disabled = disable;
1584 4 : return;
1585 : }
1586 : }
1587 : }
1588 :
1589 373605 : static u32 get_box_reg_idx(u32 boxCode, u32 parent_type, u32 start_from)
1590 : {
1591 373605 : u32 i=0, count = gf_isom_get_num_supported_boxes();
1592 373605 : const char *parent_name = parent_type ? gf_4cc_to_str(parent_type) : NULL;
1593 :
1594 373605 : if (!start_from) start_from = 1;
1595 :
1596 53637243 : for (i=start_from; i<count; i++) {
1597 : u32 start_par_from;
1598 54009572 : if (box_registry[i].box_4cc != boxCode)
1599 53636994 : continue;
1600 :
1601 372578 : if (!parent_type)
1602 : return i;
1603 93377 : if (strstr(box_registry[i].parents_4cc, parent_name) != NULL)
1604 : return i;
1605 4647 : if (strstr(box_registry[i].parents_4cc, "*") != NULL)
1606 : return i;
1607 :
1608 3679 : if (strstr(box_registry[i].parents_4cc, "sample_entry") == NULL)
1609 222 : continue;
1610 :
1611 : /*parent is a sample entry, check if the parent_type matches a sample entry box (eg its parent must be stsd)*/
1612 :
1613 3457 : if (parent_type==GF_QT_SUBTYPE_RAW)
1614 : return i;
1615 :
1616 : start_par_from = 0;
1617 : while (parent_type) {
1618 : //locate parent registry
1619 3484 : u32 j = get_box_reg_idx(parent_type, 0, start_par_from);
1620 3484 : if (!j) break;
1621 : //if parent registry has "stsd" as parent, this is a sample entry
1622 3457 : if (box_registry[j].parents_4cc && (strstr(box_registry[j].parents_4cc, "stsd") != NULL))
1623 : return i;
1624 27 : start_par_from = j+1;
1625 : }
1626 : }
1627 : return 0;
1628 : }
1629 :
1630 370121 : GF_Box *gf_isom_box_new_ex(u32 boxType, u32 parentType, Bool skip_logs, Bool is_root_box)
1631 : {
1632 : GF_Box *a;
1633 370121 : s32 idx = get_box_reg_idx(boxType, parentType, 0);
1634 370121 : if (idx==0) {
1635 : #ifndef GPAC_DISABLE_LOG
1636 2479 : if (!skip_logs && (boxType != GF_ISOM_BOX_TYPE_UNKNOWN) && (boxType != GF_ISOM_BOX_TYPE_UUID)) {
1637 1224 : switch (parentType) {
1638 : case GF_ISOM_BOX_TYPE_ILST:
1639 : case GF_ISOM_BOX_TYPE_META:
1640 : case GF_ISOM_BOX_TYPE_UDTA:
1641 : case GF_ISOM_BOX_TYPE_UNKNOWN:
1642 : case GF_ISOM_BOX_TYPE_iTunesSpecificInfo:
1643 : case GF_QT_BOX_TYPE_WAVE:
1644 : break;
1645 52 : default:
1646 52 : if (is_root_box) {
1647 7 : GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("[iso file] Unknown top-level box type %s\n", gf_4cc_to_str(boxType)));
1648 45 : } else if (parentType) {
1649 : char szName[GF_4CC_MSIZE];
1650 43 : strcpy(szName, gf_4cc_to_str(parentType));
1651 43 : GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("[iso file] Unknown box type %s in parent %s\n", gf_4cc_to_str(boxType), szName));
1652 : } else {
1653 2 : GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("[iso file] Unknown box type %s\n", gf_4cc_to_str(boxType)));
1654 : }
1655 : break;
1656 : }
1657 25 : }
1658 : #endif
1659 1249 : if (boxType==GF_ISOM_BOX_TYPE_UUID) {
1660 6 : a = uuid_box_new();
1661 6 : if (a) a->registry = &box_registry[1];
1662 : } else {
1663 1243 : a = unkn_box_new();
1664 1243 : if (a) {
1665 1243 : ((GF_UnknownBox *)a)->original_4cc = boxType;
1666 1243 : a->registry = &box_registry[0];
1667 : }
1668 : }
1669 : return a;
1670 : }
1671 368872 : a = box_registry[idx].new_fn();
1672 :
1673 368872 : if (a) {
1674 368872 : if (a->type!=GF_ISOM_BOX_TYPE_UUID) {
1675 368792 : if (a->type==GF_ISOM_BOX_TYPE_UNKNOWN) {
1676 142 : ((GF_UnknownBox *)a)->original_4cc = boxType;
1677 : } else {
1678 368650 : a->type = boxType;
1679 : }
1680 : }
1681 368872 : a->registry = &box_registry[idx];
1682 :
1683 368872 : if ((a->type==GF_ISOM_BOX_TYPE_COLR) && (parentType==GF_ISOM_BOX_TYPE_JP2H)) {
1684 27 : ((GF_ColourInformationBox *)a)->is_jp2 = GF_TRUE;
1685 : }
1686 :
1687 : }
1688 : return a;
1689 : }
1690 :
1691 : GF_EXPORT
1692 250470 : GF_Box *gf_isom_box_new(u32 boxType)
1693 : {
1694 250470 : return gf_isom_box_new_ex(boxType, 0, 0, GF_FALSE);
1695 : }
1696 :
1697 40243 : GF_Err gf_isom_box_array_read_ex(GF_Box *parent, GF_BitStream *bs, u32 parent_type)
1698 : {
1699 : GF_Err e;
1700 40243 : GF_Box *a = NULL;
1701 40243 : Bool skip_logs = (gf_bs_get_cookie(bs) & GF_ISOM_BS_COOKIE_NO_LOGS ) ? GF_TRUE : GF_FALSE;
1702 :
1703 : //we may have terminators in some QT files (4 bytes set to 0 ...)
1704 172232 : while (parent->size>=8) {
1705 91749 : e = gf_isom_box_parse_ex(&a, bs, parent_type, GF_FALSE);
1706 91749 : if (e) {
1707 0 : if (a) gf_isom_box_del(a);
1708 : return e;
1709 : }
1710 : //sub box parsing aborted with no error
1711 91749 : if (!a) return GF_OK;
1712 :
1713 91746 : if (parent->size < a->size) {
1714 0 : if (!skip_logs) {
1715 0 : GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[iso file] Box \"%s\" is larger than container box\n", gf_4cc_to_str(a->type)));
1716 : }
1717 0 : parent->size = 0;
1718 : } else {
1719 91746 : parent->size -= a->size;
1720 : }
1721 :
1722 : //check container validity
1723 91746 : if (strlen(a->registry->parents_4cc)) {
1724 : Bool parent_OK = GF_FALSE;
1725 91746 : const char *parent_code = gf_4cc_to_str(parent->type);
1726 91746 : if (parent->type == GF_ISOM_BOX_TYPE_UNKNOWN)
1727 968 : parent_code = gf_4cc_to_str( ((GF_UnknownBox*)parent)->original_4cc );
1728 91746 : if (strstr(a->registry->parents_4cc, parent_code) != NULL) {
1729 : parent_OK = GF_TRUE;
1730 4651 : } else if (!strcmp(a->registry->parents_4cc, "*") || strstr(a->registry->parents_4cc, "* ") || strstr(a->registry->parents_4cc, " *")) {
1731 : parent_OK = GF_TRUE;
1732 : } else {
1733 : //parent must be a sample entry
1734 3683 : if (strstr(a->registry->parents_4cc, "sample_entry") != NULL) {
1735 : //parent is in an stsd
1736 3430 : if (strstr(parent->registry->parents_4cc, "stsd") != NULL) {
1737 3430 : if (strstr(a->registry->parents_4cc, "video_sample_entry") != NULL) {
1738 241 : if (((GF_SampleEntryBox*)parent)->internal_type==GF_ISOM_SAMPLE_ENTRY_VIDEO) {
1739 : parent_OK = GF_TRUE;
1740 : }
1741 : } else {
1742 : parent_OK = GF_TRUE;
1743 : }
1744 : }
1745 : }
1746 : //other types are sample formats, eg a 3GPP text sample, RTP hint sample or VTT cue. Not handled at this level
1747 253 : else if (a->type==GF_ISOM_BOX_TYPE_UNKNOWN) parent_OK = GF_TRUE;
1748 6 : else if (a->type==GF_ISOM_BOX_TYPE_UUID) parent_OK = GF_TRUE;
1749 : }
1750 91746 : if (! parent_OK && !skip_logs) {
1751 0 : GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[iso file] Box \"%s\" is invalid in container %s\n", gf_4cc_to_str(a->type), parent_code));
1752 : }
1753 : }
1754 :
1755 : //always register boxes
1756 91746 : if (!parent->child_boxes) {
1757 35996 : parent->child_boxes = gf_list_new();
1758 35996 : if (!parent->child_boxes) return GF_OUT_OF_MEM;
1759 : }
1760 91746 : e = gf_list_add(parent->child_boxes, a);
1761 91746 : if (e) return e;
1762 :
1763 91746 : if (parent->registry->add_rem_fn) {
1764 87275 : e = parent->registry->add_rem_fn(parent, a, GF_FALSE);
1765 87275 : if (e) {
1766 0 : if (e == GF_ISOM_INVALID_MEDIA) return GF_OK;
1767 : //if the box is no longer present, consider it destroyed
1768 0 : if (gf_list_find(parent->child_boxes, a) >=0) {
1769 0 : gf_isom_box_del_parent(&parent->child_boxes, a);
1770 : }
1771 : return e;
1772 : }
1773 : }
1774 : }
1775 : return GF_OK;
1776 : }
1777 :
1778 : GF_EXPORT
1779 370731 : void gf_isom_box_del(GF_Box *a)
1780 : {
1781 : GF_List *child_boxes;
1782 : const struct box_registry_entry *a_box_registry;
1783 370731 : if (!a) return;
1784 :
1785 370651 : child_boxes = a->child_boxes;
1786 370651 : a->child_boxes = NULL;
1787 :
1788 370651 : a_box_registry = a->registry;
1789 370651 : if (!a_box_registry) {
1790 0 : GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[iso file] Delete invalid box type %s without registry\n", gf_4cc_to_str(a->type) ));
1791 : } else {
1792 370651 : a_box_registry->del_fn(a);
1793 : }
1794 : //delete the other boxes after deleting the box for dumper case where all child boxes are stored in otherbox
1795 370651 : if (child_boxes) {
1796 77798 : gf_isom_box_array_del(child_boxes);
1797 : }
1798 : }
1799 :
1800 :
1801 115518 : GF_Err gf_isom_box_read(GF_Box *a, GF_BitStream *bs)
1802 : {
1803 115518 : if (!a) return GF_BAD_PARAM;
1804 115518 : if (!a->registry) {
1805 0 : GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[iso file] Read invalid box type %s without registry\n", gf_4cc_to_str(a->type) ));
1806 : return GF_ISOM_INVALID_FILE;
1807 : }
1808 115518 : return a->registry->read_fn(a, bs);
1809 : }
1810 :
1811 : #ifndef GPAC_DISABLE_ISOM_WRITE
1812 :
1813 154720 : GF_Err gf_isom_box_write_listing(GF_Box *a, GF_BitStream *bs)
1814 : {
1815 154720 : if (!a) return GF_BAD_PARAM;
1816 154720 : if (!a->registry) {
1817 0 : GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[iso file] Write invalid box type %s without registry\n", gf_4cc_to_str(a->type) ));
1818 : return GF_ISOM_INVALID_FILE;
1819 : }
1820 154720 : return a->registry->write_fn(a, bs);
1821 : }
1822 :
1823 :
1824 384458 : void gf_isom_check_position(GF_Box *s, GF_Box *child, u32 *pos)
1825 : {
1826 384458 : if (!s || !s->child_boxes || !child || !pos) return;
1827 191018 : if (s->internal_flags & GF_ISOM_ORDER_FREEZE)
1828 : return;
1829 :
1830 190147 : s32 cur_pos = gf_list_find(s->child_boxes, child);
1831 :
1832 : assert (cur_pos >= 0);
1833 :
1834 190147 : if (cur_pos != (s32) *pos) {
1835 11402 : gf_list_del_item(s->child_boxes, child);
1836 11402 : gf_list_insert(s->child_boxes, child, *pos);
1837 : }
1838 190147 : (*pos)++;
1839 : }
1840 :
1841 99844 : void gf_isom_check_position_list(GF_Box *s, GF_List *childlist, u32 *pos)
1842 : {
1843 : u32 i, count;
1844 99844 : if (!s || (s->internal_flags & GF_ISOM_ORDER_FREEZE))
1845 : return;
1846 99072 : count = gf_list_count(childlist);
1847 132501 : for (i=0; i<count; i++) {
1848 33429 : GF_Box *child = gf_list_get(childlist, i);
1849 33429 : gf_isom_check_position(s, child, pos);
1850 : }
1851 : }
1852 :
1853 :
1854 : GF_EXPORT
1855 154951 : GF_Err gf_isom_box_write(GF_Box *a, GF_BitStream *bs)
1856 : {
1857 : GF_Err e;
1858 154951 : u64 pos = gf_bs_get_position(bs);
1859 154951 : if (!a) return GF_BAD_PARAM;
1860 : //box has been disabled, do not write
1861 154951 : if (!a->size) return GF_OK;
1862 :
1863 154720 : if (a->registry->disabled) {
1864 0 : GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[iso file] Box %s disabled registry, skip write\n", gf_4cc_to_str(a->type)));
1865 : return GF_OK;
1866 : }
1867 :
1868 154720 : GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[iso file] Box %s size %d write\n", gf_4cc_to_str(a->type), a->size));
1869 154720 : e = gf_isom_box_write_listing(a, bs);
1870 154720 : if (e) return e;
1871 154718 : if (a->child_boxes) {
1872 52156 : e = gf_isom_box_array_write(a, a->child_boxes, bs);
1873 : }
1874 154718 : pos = gf_bs_get_position(bs) - pos;
1875 154718 : if (pos != a->size) {
1876 1053 : if ((a->type==GF_ISOM_BOX_TYPE_MDAT) || (a->type==GF_ISOM_BOX_TYPE_IDAT)) {
1877 :
1878 : } else {
1879 6 : GF_LOG(GF_LOG_WARNING, GF_LOG_CONTAINER, ("[iso file] Box %s wrote "LLU" bytes but size is "LLU"\n", gf_4cc_to_str(a->type), pos, a->size ));
1880 : }
1881 : }
1882 : return e;
1883 : }
1884 :
1885 288848 : static GF_Err gf_isom_box_size_listing(GF_Box *a)
1886 : {
1887 288848 : if (!a) return GF_BAD_PARAM;
1888 288848 : if (!a->registry) {
1889 0 : GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[iso file] Size invalid box type %s without registry\n", gf_4cc_to_str(a->type) ));
1890 : return GF_ISOM_INVALID_FILE;
1891 : }
1892 288848 : a->size = 8;
1893 :
1894 288848 : if (a->type == GF_ISOM_BOX_TYPE_UUID) {
1895 92 : a->size += 16;
1896 : }
1897 : //the large size is handled during write, cause at this stage we don't know the size
1898 288848 : if (a->registry->max_version_plus_one) {
1899 138250 : a->size += 4;
1900 : }
1901 288848 : return a->registry->size_fn(a);
1902 : }
1903 :
1904 : GF_EXPORT
1905 288848 : GF_Err gf_isom_box_size(GF_Box *a)
1906 : {
1907 : GF_Err e;
1908 288848 : if (!a) return GF_BAD_PARAM;
1909 288848 : if (a->registry->disabled) {
1910 0 : a->size = 0;
1911 0 : return GF_OK;
1912 : }
1913 288848 : e = gf_isom_box_size_listing(a);
1914 288848 : if (e) return e;
1915 : //box size set to 0 (not even a header), abort traversal
1916 288846 : if (!a->size) return GF_OK;
1917 :
1918 288525 : if (a->child_boxes) {
1919 96777 : e = gf_isom_box_array_size(a, a->child_boxes);
1920 96777 : if (e) return e;
1921 : }
1922 : return GF_OK;
1923 : }
1924 :
1925 : #endif /*GPAC_DISABLE_ISOM_WRITE*/
1926 :
1927 115512 : static GF_Err gf_isom_full_box_read(GF_Box *ptr, GF_BitStream *bs)
1928 : {
1929 115512 : if (ptr->registry->max_version_plus_one) {
1930 : GF_FullBox *self = (GF_FullBox *) ptr;
1931 62116 : ISOM_DECREASE_SIZE(ptr, 4)
1932 62116 : self->version = gf_bs_read_u8(bs);
1933 62116 : self->flags = gf_bs_read_u24(bs);
1934 : }
1935 : return GF_OK;
1936 : }
1937 :
1938 :
1939 : GF_EXPORT
1940 497 : GF_Err gf_isom_dump_supported_box(u32 idx, FILE * trace)
1941 : {
1942 : u32 i;
1943 : u32 nb_versions=0;
1944 : GF_Err e;
1945 :
1946 497 : if (box_registry[idx].max_version_plus_one) {
1947 165 : nb_versions = box_registry[idx].max_version_plus_one - 1;
1948 : }
1949 1027 : for (i = 0; i <= nb_versions; i++) {
1950 530 : GF_Box *a = box_registry[idx].new_fn();
1951 530 : if (!a) return GF_OUT_OF_MEM;
1952 :
1953 530 : a->registry = &box_registry[idx];
1954 :
1955 530 : if (box_registry[idx].alt_4cc) {
1956 62 : if (a->type==GF_ISOM_BOX_TYPE_REFT)
1957 29 : ((GF_TrackReferenceTypeBox*)a)->reference_type = box_registry[idx].alt_4cc;
1958 33 : else if (a->type==GF_ISOM_BOX_TYPE_REFI)
1959 3 : ((GF_ItemReferenceTypeBox*)a)->reference_type = box_registry[idx].alt_4cc;
1960 30 : else if (a->type==GF_ISOM_BOX_TYPE_TRGT)
1961 3 : ((GF_TrackGroupTypeBox*)a)->group_type = box_registry[idx].alt_4cc;
1962 27 : else if (a->type==GF_ISOM_BOX_TYPE_SGPD)
1963 26 : ((GF_SampleGroupDescriptionBox*)a)->grouping_type = box_registry[idx].alt_4cc;
1964 1 : else if (a->type==GF_ISOM_BOX_TYPE_GRPT)
1965 1 : ((GF_EntityToGroupTypeBox*)a)->grouping_type = box_registry[idx].alt_4cc;
1966 : }
1967 530 : if (box_registry[idx].max_version_plus_one) {
1968 198 : ((GF_FullBox *)a)->version = i;
1969 : }
1970 530 : if (box_registry[idx].flags) {
1971 : u32 flag_mask=1;
1972 : u32 flags = box_registry[idx].flags;
1973 15 : ((GF_FullBox *)a)->flags = 0;
1974 15 : e = gf_isom_box_dump(a, trace);
1975 :
1976 : //we dump all flags individually and this for all version, in order to simplify the XSLT processing
1977 66 : while (!e) {
1978 51 : u32 flag = flags & flag_mask;
1979 51 : flag_mask <<= 1;
1980 51 : if (flag) {
1981 34 : ((GF_FullBox *)a)->flags = flag;
1982 34 : e = gf_isom_box_dump(a, trace);
1983 : }
1984 51 : if (flag_mask > flags) break;
1985 36 : if (flag_mask == 0x80000000) break;
1986 : }
1987 :
1988 : } else {
1989 515 : e = gf_isom_box_dump(a, trace);
1990 : }
1991 :
1992 530 : gf_isom_box_del(a);
1993 : }
1994 : return e;
1995 : }
1996 :
1997 : GF_EXPORT
1998 497 : u32 gf_isom_get_supported_box_type(u32 idx)
1999 : {
2000 497 : return box_registry[idx].box_4cc;
2001 : }
2002 :
2003 : #ifndef GPAC_DISABLE_ISOM_DUMP
2004 :
2005 3960 : GF_Err gf_isom_box_dump_start(GF_Box *a, const char *name, FILE * trace)
2006 : {
2007 3960 : gf_fprintf(trace, "<%s ", name);
2008 3960 : if (a->size > 0xFFFFFFFF) {
2009 0 : gf_fprintf(trace, "LargeSize=\""LLU"\" ", a->size);
2010 : } else {
2011 3960 : gf_fprintf(trace, "Size=\"%u\" ", (u32) a->size);
2012 : }
2013 3960 : if (a->type==GF_ISOM_BOX_TYPE_UNKNOWN) {
2014 9 : gf_fprintf(trace, "Type=\"%s\" ", gf_4cc_to_str(((GF_UnknownBox*)a)->original_4cc));
2015 : } else {
2016 3951 : gf_fprintf(trace, "Type=\"%s\" ", gf_4cc_to_str(a->type));
2017 : }
2018 :
2019 3960 : if (a->type == GF_ISOM_BOX_TYPE_UUID) {
2020 : u32 i;
2021 12 : gf_fprintf(trace, "UUID=\"{");
2022 204 : for (i=0; i<16; i++) {
2023 192 : gf_fprintf(trace, "%02X", (unsigned char) ((GF_UUIDBox*)a)->uuid[i]);
2024 192 : if ((i<15) && (i%4)==3) gf_fprintf(trace, "-");
2025 : }
2026 12 : gf_fprintf(trace, "}\" ");
2027 : }
2028 :
2029 3960 : if (a->registry->max_version_plus_one) {
2030 2109 : gf_fprintf(trace, "Version=\"%d\" Flags=\"%d\" ", ((GF_FullBox*)a)->version,((GF_FullBox*)a)->flags);
2031 : }
2032 3960 : gf_fprintf(trace, "Specification=\"%s\" ", a->registry->spec);
2033 : //we don't want to rewrite our hashes
2034 3960 : if (gf_sys_is_test_mode() && (a->type==GF_ISOM_BOX_TYPE_FTYP)) {
2035 115 : gf_fprintf(trace, "Container=\"file\" ");
2036 : } else {
2037 3845 : gf_fprintf(trace, "Container=\"%s\" ", a->registry->parents_4cc);
2038 : }
2039 3960 : return GF_OK;
2040 : }
2041 :
2042 3981 : GF_Err gf_isom_box_dump(void *ptr, FILE * trace)
2043 : {
2044 : GF_Box *a = (GF_Box *) ptr;
2045 :
2046 3981 : if (!a) {
2047 0 : gf_fprintf(trace, "<!--ERROR: NULL Box Found-->\n");
2048 0 : return GF_OK;
2049 : }
2050 3981 : if (!a->registry) {
2051 0 : GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("[isom] trying to dump box %s not registered\n", gf_4cc_to_str(a->type) ));
2052 : return GF_ISOM_INVALID_FILE;
2053 : }
2054 3981 : a->registry->dump_fn(a, trace);
2055 3981 : return GF_OK;
2056 : }
2057 :
2058 3958 : void gf_isom_box_dump_done(const char *name, GF_Box *ptr, FILE *trace)
2059 : {
2060 3958 : if (ptr && ptr->child_boxes) {
2061 1222 : gf_isom_box_array_dump(ptr->child_boxes, trace);
2062 : }
2063 3958 : if (name)
2064 3958 : gf_fprintf(trace, "</%s>\n", name);
2065 3958 : }
2066 :
2067 489 : Bool gf_isom_box_is_file_level(GF_Box *s)
2068 : {
2069 489 : if (!s || !s->registry) return GF_FALSE;
2070 489 : if (strstr(s->registry->parents_4cc, "file")!= NULL) return GF_TRUE;
2071 114 : if (strstr(s->registry->parents_4cc, "*")!= NULL) return GF_TRUE;
2072 0 : return GF_FALSE;
2073 : }
2074 : #endif
2075 :
2076 :
2077 70716 : GF_Box *gf_isom_box_find_child(GF_List *children, u32 code)
2078 : {
2079 : u32 i, count;
2080 70716 : if (!children) return NULL;
2081 69403 : count = gf_list_count(children);
2082 190912 : for (i=0; i<count; i++) {
2083 149545 : GF_Box *c = gf_list_get(children, i);
2084 149545 : if (c->type==code) return c;
2085 :
2086 121511 : if (c->type==GF_ISOM_BOX_TYPE_UNKNOWN) {
2087 368 : if (((GF_UnknownBox*)c)->original_4cc==code)
2088 : return c;
2089 : }
2090 121509 : if (c->type==GF_ISOM_BOX_TYPE_UUID) {
2091 72 : if (((GF_UUIDBox*)c)->internal_4cc==code)
2092 : return c;
2093 : }
2094 : }
2095 : return NULL;
2096 : }
2097 :
2098 416 : Bool gf_isom_box_check_unique(GF_List *children, GF_Box *a)
2099 : {
2100 : u32 i, count;
2101 416 : if (!children) return GF_TRUE;
2102 416 : count = gf_list_count(children);
2103 1259 : for (i=0; i<count; i++) {
2104 843 : GF_Box *c = gf_list_get(children, i);
2105 843 : if (c==a) continue;
2106 427 : if (c->type==a->type) return GF_FALSE;
2107 : }
2108 : return GF_TRUE;
2109 : }
2110 :
2111 125854 : void gf_isom_box_del_parent(GF_List **child_boxes, GF_Box*b)
2112 : {
2113 125854 : if (child_boxes) {
2114 125854 : gf_list_del_item(*child_boxes, b);
2115 125854 : if (!gf_list_count(*child_boxes)) {
2116 75 : gf_list_del(*child_boxes);
2117 75 : *child_boxes = NULL;
2118 : }
2119 : }
2120 125854 : gf_isom_box_del(b);
2121 125854 : }
2122 :
2123 1 : void gf_isom_box_remove_from_parent(GF_Box *parent_box, GF_Box *box)
2124 : {
2125 1 : if (parent_box && parent_box->registry && parent_box->registry->add_rem_fn) {
2126 1 : parent_box->registry->add_rem_fn(parent_box, box, GF_TRUE);
2127 : }
2128 1 : }
2129 :
2130 203412 : GF_Box *gf_isom_box_new_parent(GF_List **parent, u32 code)
2131 : {
2132 203412 : GF_Box *b = gf_isom_box_new(code);
2133 203412 : if (!b) return NULL;
2134 203412 : if (! (*parent) ) (*parent) = gf_list_new();
2135 203412 : gf_list_add(*parent, b);
2136 203412 : return b;
2137 : }
2138 :
2139 889 : void gf_isom_box_freeze_order(GF_Box *box)
2140 : {
2141 889 : u32 i=0;
2142 : GF_Box *child;
2143 889 : if (!box) return;
2144 889 : box->internal_flags |= GF_ISOM_ORDER_FREEZE;
2145 :
2146 2520 : while ((child = gf_list_enum(box->child_boxes, &i))) {
2147 742 : gf_isom_box_freeze_order(child);
2148 : }
2149 :
2150 : }
2151 : #endif /*GPAC_DISABLE_ISOM*/
|
