1 /*
2 * GPAC - Multimedia Framework C SDK
3 *
4 * Authors: Jean Le Feuvre
5 * Copyright (c) Telecom ParisTech 2000-2012
6 * All rights reserved
7 *
8 * This file is part of GPAC / MPEG-4 ObjectDescriptor 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/odf_dev.h>
27 #include <gpac/constants.h>
28 /*for import flags*/
29 #include <gpac/media_tools.h>
30 #include <gpac/network.h>
31
32 #ifndef GPAC_DISABLE_OD_DUMP
33
34 #define OD_MAX_TREE 100
35
36 #define OD_FORMAT_INDENT( ind_buf, indent ) \
37 { \
38 u32 z; \
39 assert(OD_MAX_TREE>indent); \
40 for (z=0; z<indent; z++) ind_buf[z] = ' '; \
41 ind_buf[z] = 0; \
42 } \
43
44 GF_EXPORT
gf_odf_dump_com(GF_ODCom * com,FILE * trace,u32 indent,Bool XMTDump)45 GF_Err gf_odf_dump_com(GF_ODCom *com, FILE *trace, u32 indent, Bool XMTDump)
46 {
47 switch (com->tag) {
48 case GF_ODF_OD_UPDATE_TAG:
49 return gf_odf_dump_od_update((GF_ODUpdate *)com, trace, indent, XMTDump);
50 case GF_ODF_OD_REMOVE_TAG:
51 return gf_odf_dump_od_remove((GF_ODRemove *)com, trace, indent, XMTDump);
52 case GF_ODF_ESD_UPDATE_TAG:
53 return gf_odf_dump_esd_update((GF_ESDUpdate *)com, trace, indent, XMTDump);
54 case GF_ODF_ESD_REMOVE_TAG:
55 return gf_odf_dump_esd_remove((GF_ESDRemove *)com, trace, indent, XMTDump);
56 #ifndef GPAC_MINIMAL_ODF
57 case GF_ODF_IPMP_UPDATE_TAG:
58 return gf_odf_dump_ipmp_update((GF_IPMPUpdate *)com, trace, indent, XMTDump);
59 case GF_ODF_IPMP_REMOVE_TAG:
60 return gf_odf_dump_ipmp_remove((GF_IPMPRemove *)com, trace, indent, XMTDump);
61 default:
62 return gf_odf_dump_base_command((GF_BaseODCom *) com, trace, indent, XMTDump);
63 #else
64 default:
65 return GF_NOT_SUPPORTED;
66 #endif
67 }
68 }
69
70 //unused
71 #if 0
72 GF_Err gf_odf_dump_au(char *data, u32 dataLength, FILE *trace, u32 indent, Bool XMTDump)
73 {
74 GF_ODCom *com;
75 GF_ODCodec *odread = gf_odf_codec_new();
76 gf_odf_codec_set_au(odread, data, dataLength);
77 gf_odf_codec_decode(odread);
78
79 while (1) {
80 com = gf_odf_codec_get_com(odread);
81 if (!com) break;
82
83 gf_odf_dump_com(com, trace, indent, XMTDump);
84 gf_odf_com_del(&com);
85 }
86 gf_odf_codec_del(odread);
87 return GF_OK;
88 }
89 #endif
90
91 GF_EXPORT
gf_odf_dump_com_list(GF_List * commandList,FILE * trace,u32 indent,Bool XMTDump)92 GF_Err gf_odf_dump_com_list(GF_List *commandList, FILE *trace, u32 indent, Bool XMTDump)
93 {
94 GF_ODCom *com;
95 u32 i;
96 i=0;
97 while ((com = (GF_ODCom *)gf_list_enum(commandList, &i))) {
98 gf_odf_dump_com(com, trace, indent, XMTDump);
99 }
100 return GF_OK;
101 }
102
103
104 GF_EXPORT
gf_odf_dump_desc(GF_Descriptor * desc,FILE * trace,u32 indent,Bool XMTDump)105 GF_Err gf_odf_dump_desc(GF_Descriptor *desc, FILE *trace, u32 indent, Bool XMTDump)
106 {
107 switch (desc->tag) {
108 case GF_ODF_IOD_TAG :
109 return gf_odf_dump_iod((GF_InitialObjectDescriptor *)desc, trace, indent, XMTDump);
110 case GF_ODF_ESD_TAG :
111 return gf_odf_dump_esd((GF_ESD *)desc, trace, indent, XMTDump);
112 case GF_ODF_DCD_TAG :
113 return gf_odf_dump_dcd((GF_DecoderConfig *)desc, trace, indent, XMTDump);
114 case GF_ODF_SLC_TAG:
115 return gf_odf_dump_slc((GF_SLConfig *)desc, trace, indent, XMTDump);
116 case GF_ODF_ISOM_IOD_TAG:
117 return gf_odf_dump_isom_iod((GF_IsomInitialObjectDescriptor *)desc, trace, indent, XMTDump);
118 case GF_ODF_ISOM_OD_TAG:
119 return gf_odf_dump_isom_od((GF_IsomObjectDescriptor *)desc, trace, indent, XMTDump);
120 case GF_ODF_OD_TAG:
121 return gf_odf_dump_od((GF_ObjectDescriptor *)desc, trace, indent, XMTDump);
122 case GF_ODF_ESD_INC_TAG:
123 return gf_odf_dump_esd_inc((GF_ES_ID_Inc *)desc, trace, indent, XMTDump);
124 case GF_ODF_ESD_REF_TAG:
125 return gf_odf_dump_esd_ref((GF_ES_ID_Ref *)desc, trace, indent, XMTDump);
126 #ifndef GPAC_MINIMAL_ODF
127 case GF_ODF_CC_TAG:
128 return gf_odf_dump_cc((GF_CCDescriptor *)desc, trace, indent, XMTDump);
129 case GF_ODF_CC_DATE_TAG:
130 return gf_odf_dump_cc_date((GF_CC_Date *)desc, trace, indent, XMTDump);
131 case GF_ODF_CC_NAME_TAG:
132 return gf_odf_dump_cc_name((GF_CC_Name *)desc, trace, indent, XMTDump);
133 case GF_ODF_CI_TAG:
134 return gf_odf_dump_ci((GF_CIDesc *)desc, trace, indent, XMTDump);
135 case GF_ODF_TEXT_TAG:
136 return gf_odf_dump_exp_text((GF_ExpandedTextual *)desc, trace, indent, XMTDump);
137 case GF_ODF_EXT_PL_TAG:
138 return gf_odf_dump_pl_ext((GF_PLExt *)desc, trace, indent, XMTDump);
139 case GF_ODF_IPI_PTR_TAG:
140 case GF_ODF_ISOM_IPI_PTR_TAG:
141 return gf_odf_dump_ipi_ptr((GF_IPIPtr *)desc, trace, indent, XMTDump);
142 case GF_ODF_IPMP_TAG:
143 return gf_odf_dump_ipmp((GF_IPMP_Descriptor *)desc, trace, indent, XMTDump);
144 case GF_ODF_IPMP_PTR_TAG:
145 return gf_odf_dump_ipmp_ptr((GF_IPMPPtr *)desc, trace, indent, XMTDump);
146 case GF_ODF_KW_TAG:
147 return gf_odf_dump_kw((GF_KeyWord *)desc, trace, indent, XMTDump);
148 case GF_ODF_LANG_TAG:
149 case GF_ODF_GPAC_LANG:
150 return gf_odf_dump_lang((GF_Language *)desc, trace, indent, XMTDump);
151 case GF_ODF_OCI_DATE_TAG:
152 return gf_odf_dump_oci_date((GF_OCI_Data *)desc, trace, indent, XMTDump);
153 case GF_ODF_OCI_NAME_TAG:
154 return gf_odf_dump_oci_name((GF_OCICreators *)desc, trace, indent, XMTDump);
155 case GF_ODF_PL_IDX_TAG:
156 return gf_odf_dump_pl_idx((GF_PL_IDX *)desc, trace, indent, XMTDump);
157 case GF_ODF_QOS_TAG:
158 return gf_odf_dump_qos((GF_QoS_Descriptor *)desc, trace, indent, XMTDump);
159 case GF_ODF_RATING_TAG:
160 return gf_odf_dump_rating((GF_Rating *)desc, trace, indent, XMTDump);
161 case GF_ODF_REG_TAG:
162 return gf_odf_dump_reg((GF_Registration *)desc, trace, indent, XMTDump);
163 case GF_ODF_SHORT_TEXT_TAG:
164 return gf_odf_dump_short_text((GF_ShortTextual *)desc, trace, indent, XMTDump);
165 case GF_ODF_SMPTE_TAG:
166 return gf_odf_dump_smpte_camera((GF_SMPTECamera *)desc, trace, indent, XMTDump);
167 case GF_ODF_SCI_TAG:
168 return gf_odf_dump_sup_cid((GF_SCIDesc *)desc, trace, indent, XMTDump);
169 case GF_ODF_SEGMENT_TAG:
170 return gf_odf_dump_segment((GF_Segment *)desc, trace, indent, XMTDump);
171 case GF_ODF_MEDIATIME_TAG:
172 return gf_odf_dump_mediatime((GF_MediaTime *)desc, trace, indent, XMTDump);
173 case GF_ODF_IPMP_TL_TAG:
174 return gf_odf_dump_ipmp_tool_list((GF_IPMP_ToolList*)desc, trace, indent, XMTDump);
175 case GF_ODF_IPMP_TOOL_TAG:
176 return gf_odf_dump_ipmp_tool((GF_IPMP_Tool*)desc, trace, indent, XMTDump);
177 #endif //GPAC_MINIMAL_ODF
178 case GF_ODF_TEXT_CFG_TAG:
179 return gf_odf_dump_txtcfg((GF_TextConfig *)desc, trace, indent, XMTDump);
180 case GF_ODF_MUXINFO_TAG:
181 return gf_odf_dump_muxinfo((GF_MuxInfo *)desc, trace, indent, XMTDump);
182 case GF_ODF_BIFS_CFG_TAG:
183 return gf_odf_dump_bifs_cfg((GF_BIFSConfig *)desc, trace, indent, XMTDump);
184 case GF_ODF_LASER_CFG_TAG:
185 return gf_odf_dump_laser_cfg((GF_LASERConfig *)desc, trace, indent, XMTDump);
186 case GF_ODF_UI_CFG_TAG:
187 return gf_odf_dump_ui_cfg((GF_UIConfig *)desc, trace, indent, XMTDump);
188 case GF_ODF_AUX_VIDEO_DATA:
189 return gf_odf_dump_aux_vid((GF_AuxVideoDescriptor *)desc, trace, indent, XMTDump);
190 default:
191 return gf_odf_dump_default((GF_DefaultDescriptor *)desc, trace, indent, XMTDump);
192 }
193 return GF_OK;
194 }
195
196
197
StartDescDump(FILE * trace,const char * descName,u32 indent,Bool XMTDump)198 static void StartDescDump(FILE *trace, const char *descName, u32 indent, Bool XMTDump)
199 {
200 char ind_buf[OD_MAX_TREE];
201 OD_FORMAT_INDENT(ind_buf, indent);
202
203 if (!XMTDump) {
204 gf_fprintf(trace, "%s {\n", descName);
205 } else {
206 gf_fprintf(trace, "%s<%s ", ind_buf, descName);
207 }
208 }
209
EndDescDump(FILE * trace,const char * descName,u32 indent,Bool XMTDump)210 static void EndDescDump(FILE *trace, const char *descName, u32 indent, Bool XMTDump)
211 {
212 char ind_buf[OD_MAX_TREE];
213 OD_FORMAT_INDENT(ind_buf, indent);
214
215 if (!XMTDump) {
216 gf_fprintf(trace, "%s}\n", ind_buf);
217 } else {
218 gf_fprintf(trace, "%s</%s>\n", ind_buf, descName);
219 }
220 }
221
222 /*special element open for XML only, appends "<eltName " - used because XMT-A OD representations use lots of
223 subdescs not present in BT*/
StartSubElement(FILE * trace,const char * eltName,u32 indent,Bool XMTDump)224 static void StartSubElement(FILE *trace, const char *eltName, u32 indent, Bool XMTDump)
225 {
226 if (XMTDump) {
227 char ind_buf[OD_MAX_TREE];
228 OD_FORMAT_INDENT(ind_buf, indent);
229 gf_fprintf(trace, "%s<%s ", ind_buf, eltName);
230 }
231 }
232 /*special close for XML only, appends "/>" - used because XMT-A OD representations use lots of
233 subdescs not present in BT*/
EndSubElement(FILE * trace,u32 indent,Bool XMTDump)234 static void EndSubElement(FILE *trace, u32 indent, Bool XMTDump)
235 {
236 if (XMTDump) gf_fprintf(trace, "/>\n");
237 }
238
EndAttributes(FILE * trace,u32 indent,Bool XMTDump)239 static void EndAttributes(FILE *trace, u32 indent, Bool XMTDump)
240 {
241 if (XMTDump) gf_fprintf(trace, ">\n");
242 }
243
StartElement(FILE * trace,const char * attName,u32 indent,Bool XMTDump,Bool IsList)244 static void StartElement(FILE *trace, const char *attName, u32 indent, Bool XMTDump, Bool IsList)
245 {
246 char ind_buf[OD_MAX_TREE];
247 OD_FORMAT_INDENT(ind_buf, indent);
248 if (!XMTDump) {
249 if (IsList)
250 gf_fprintf(trace, "%s%s [\n", ind_buf, attName);
251 else
252 gf_fprintf(trace, "%s%s ", ind_buf, attName);
253 } else {
254 gf_fprintf(trace, "%s<%s>\n", ind_buf, attName);
255 }
256 }
257
EndElement(FILE * trace,const char * attName,u32 indent,Bool XMTDump,Bool IsList)258 static void EndElement(FILE *trace, const char *attName, u32 indent, Bool XMTDump, Bool IsList)
259 {
260 char ind_buf[OD_MAX_TREE];
261 OD_FORMAT_INDENT(ind_buf, indent);
262 if (!XMTDump) {
263 if (IsList) gf_fprintf(trace, "%s]\n", ind_buf);
264 } else {
265 gf_fprintf(trace, "%s</%s>\n", ind_buf, attName);
266 }
267 }
268
StartAttribute(FILE * trace,const char * attName,u32 indent,Bool XMTDump)269 static void StartAttribute(FILE *trace, const char *attName, u32 indent, Bool XMTDump)
270 {
271 char ind_buf[OD_MAX_TREE];
272 OD_FORMAT_INDENT(ind_buf, indent);
273 if (!XMTDump) {
274 gf_fprintf(trace, "%s%s ", ind_buf, attName);
275 } else {
276 gf_fprintf(trace, "%s=\"", attName);
277 }
278 }
EndAttribute(FILE * trace,u32 indent,Bool XMTDump)279 static void EndAttribute(FILE *trace, u32 indent, Bool XMTDump)
280 {
281 if (!XMTDump) {
282 gf_fprintf(trace, "\n");
283 } else {
284 gf_fprintf(trace, "\" ");
285 }
286 }
287
DumpInt(FILE * trace,const char * attName,u32 val,u32 indent,Bool XMTDump)288 static void DumpInt(FILE *trace, const char *attName, u32 val, u32 indent, Bool XMTDump)
289 {
290 if (!val) return;
291 StartAttribute(trace, attName, indent, XMTDump);
292 gf_fprintf(trace, "%d", val);
293 EndAttribute(trace, indent, XMTDump);
294 }
295
DumpIntForce(FILE * trace,const char * attName,u32 val,u32 indent,Bool XMTDump)296 static void DumpIntForce(FILE *trace, const char *attName, u32 val, u32 indent, Bool XMTDump)
297 {
298 StartAttribute(trace, attName, indent, XMTDump);
299 gf_fprintf(trace, "%d", val);
300 EndAttribute(trace, indent, XMTDump);
301 }
302
DumpIntHex(FILE * trace,const char * attName,u32 val,u32 indent,Bool XMTDump,Bool single_byte)303 static void DumpIntHex(FILE *trace, const char *attName, u32 val, u32 indent, Bool XMTDump, Bool single_byte)
304 {
305 StartAttribute(trace, attName, indent, XMTDump);
306 if (single_byte) {
307 gf_fprintf(trace, "0x%02X", val);
308 } else {
309 gf_fprintf(trace, "0x%08X", val);
310 }
311 EndAttribute(trace, indent, XMTDump);
312 }
313
314 #ifndef GPAC_MINIMAL_ODF
DumpFloat(FILE * trace,const char * attName,Float val,u32 indent,Bool XMTDump)315 static void DumpFloat(FILE *trace, const char *attName, Float val, u32 indent, Bool XMTDump)
316 {
317 StartAttribute(trace, attName, indent, XMTDump);
318 gf_fprintf(trace, "%g", val);
319 EndAttribute(trace, indent, XMTDump);
320 }
321
DumpDouble(FILE * trace,const char * attName,Double val,u32 indent,Bool XMTDump)322 static void DumpDouble(FILE *trace, const char *attName, Double val, u32 indent, Bool XMTDump)
323 {
324 StartAttribute(trace, attName, indent, XMTDump);
325 gf_fprintf(trace, "%g", val);
326 EndAttribute(trace, indent, XMTDump);
327 }
DumpBin128(FILE * trace,const char * name,char * data,u32 indent,Bool XMTDump)328 static void DumpBin128(FILE *trace, const char *name, char *data, u32 indent, Bool XMTDump)
329 {
330 u32 i;
331 if (!name ||!data) return;
332 StartAttribute(trace, name, indent, XMTDump);
333 gf_fprintf(trace, "0x");
334 i=0;
335 while (!data[i] && (i<16)) i++;
336 if (i==16) {
337 gf_fprintf(trace, "00");
338 } else {
339 for (; i<16; i++) gf_fprintf(trace, "%02X", (unsigned char) data[i]);
340 }
341 EndAttribute(trace, indent, XMTDump);
342 }
343
344 #endif
345
DumpBool(FILE * trace,const char * attName,u32 val,u32 indent,Bool XMTDump)346 static void DumpBool(FILE *trace, const char *attName, u32 val, u32 indent, Bool XMTDump)
347 {
348 if (!val) return;
349
350 StartAttribute(trace, attName, indent, XMTDump);
351 gf_fprintf(trace, "%s", "true");
352 EndAttribute(trace, indent, XMTDump);
353 }
354
DumpString(FILE * trace,const char * attName,char * val,u32 indent,Bool XMTDump)355 static void DumpString(FILE *trace, const char *attName, char *val, u32 indent, Bool XMTDump)
356 {
357 if (!val) return;
358 StartAttribute(trace, attName, indent, XMTDump);
359 if (!XMTDump) gf_fprintf(trace, "\"");
360 gf_fprintf(trace, "%s", val);
361 if (!XMTDump) gf_fprintf(trace, "\"");
362 EndAttribute(trace, indent, XMTDump);
363 }
364
DumpData(FILE * trace,const char * name,char * data,u64 dataLength,u32 indent,Bool XMTDump)365 static void DumpData(FILE *trace, const char *name, char *data, u64 dataLength, u32 indent, Bool XMTDump)
366 {
367 u64 i;
368 if (!name ||!data) return;
369 StartAttribute(trace, name, indent, XMTDump);
370 if (XMTDump) gf_fprintf(trace, "data:application/octet-string,");
371 for (i=0; i<dataLength; i++) {
372 gf_fprintf(trace, "%%");
373 gf_fprintf(trace, "%02X", (unsigned char) data[i]);
374 }
375 EndAttribute(trace, indent, XMTDump);
376 }
377
DumpDescList(GF_List * list,FILE * trace,u32 indent,const char * ListName,Bool XMTDump,Bool no_skip_empty)378 GF_Err DumpDescList(GF_List *list, FILE *trace, u32 indent, const char *ListName, Bool XMTDump, Bool no_skip_empty)
379 {
380 u32 i, count;
381 char ind_buf[OD_MAX_TREE];
382 if (!list) return GF_OK;
383 count = gf_list_count(list);
384 if (!no_skip_empty && !count) return GF_OK;
385 StartElement(trace, ListName, indent, XMTDump, GF_TRUE);
386 indent++;
387 OD_FORMAT_INDENT(ind_buf, indent);
388 for (i=0; i<count; i++) {
389 GF_Descriptor *desc = (GF_Descriptor *)gf_list_get(list, i);
390 //add offset if not XMT
391 if (!XMTDump) gf_fprintf(trace, "%s", ind_buf);
392 gf_odf_dump_desc(desc, trace, indent, XMTDump);
393 }
394 indent--;
395 EndElement(trace, ListName, indent, XMTDump, GF_TRUE);
396 return GF_OK;
397 }
398
399
DumpDescListFilter(GF_List * list,FILE * trace,u32 indent,const char * ListName,Bool XMTDump,u8 tag_only)400 GF_Err DumpDescListFilter(GF_List *list, FILE *trace, u32 indent, const char *ListName, Bool XMTDump, u8 tag_only)
401 {
402 u32 i, count, num_desc;
403 GF_Descriptor *desc;
404 char ind_buf[OD_MAX_TREE];
405 if (!list) return GF_OK;
406
407 count = gf_list_count(list);
408 num_desc = 0;
409 for (i=0; i<count; i++) {
410 desc = (GF_Descriptor *)gf_list_get(list, i);
411 if (desc->tag == tag_only) num_desc++;
412 }
413 if (!num_desc) return GF_OK;
414
415 StartElement(trace, ListName, indent, XMTDump, GF_TRUE);
416 indent++;
417 OD_FORMAT_INDENT(ind_buf, indent);
418 for (i=0; i<count; i++) {
419 desc = (GF_Descriptor *)gf_list_get(list, i);
420 if (desc->tag == tag_only) {
421 //add offset if not XMT
422 if (!XMTDump) gf_fprintf(trace, "%s", ind_buf);
423 gf_odf_dump_desc(desc, trace, indent, XMTDump);
424 }
425 }
426 indent--;
427 EndElement(trace, ListName, indent, XMTDump, GF_TRUE);
428 return GF_OK;
429 }
430
gf_odf_dump_iod(GF_InitialObjectDescriptor * iod,FILE * trace,u32 indent,Bool XMTDump)431 GF_Err gf_odf_dump_iod(GF_InitialObjectDescriptor *iod, FILE *trace, u32 indent, Bool XMTDump)
432 {
433 StartDescDump(trace, "InitialObjectDescriptor", indent, XMTDump);
434 indent++;
435
436 StartAttribute(trace, "objectDescriptorID", indent, XMTDump);
437 if (XMTDump) {
438 gf_fprintf(trace, "od%d", iod->objectDescriptorID);
439 EndAttribute(trace, indent, XMTDump);
440 DumpInt(trace, "binaryID", iod->objectDescriptorID, indent, XMTDump);
441 } else {
442 gf_fprintf(trace, "%d", iod->objectDescriptorID);
443 EndAttribute(trace, indent, XMTDump);
444 }
445
446 EndAttributes(trace, indent, XMTDump);
447
448 StartSubElement(trace, "Profiles", indent, XMTDump);
449
450 DumpInt(trace, "audioProfileLevelIndication", iod->audio_profileAndLevel, indent, XMTDump);
451 DumpInt(trace, "visualProfileLevelIndication", iod->visual_profileAndLevel, indent, XMTDump);
452 DumpInt(trace, "sceneProfileLevelIndication", iod->scene_profileAndLevel, indent, XMTDump);
453 DumpInt(trace, "graphicsProfileLevelIndication", iod->graphics_profileAndLevel, indent, XMTDump);
454 DumpInt(trace, "ODProfileLevelIndication", iod->OD_profileAndLevel, indent, XMTDump);
455 DumpBool(trace, "includeInlineProfileLevelFlag", iod->inlineProfileFlag, indent, XMTDump);
456
457 EndSubElement(trace, indent, XMTDump);
458
459 if (iod->URLString) {
460 StartSubElement(trace, "URL", indent, XMTDump);
461 DumpString(trace, "URLstring", iod->URLString, indent, XMTDump);
462 EndSubElement(trace, indent, XMTDump);
463 }
464
465 if (XMTDump) {
466 StartElement(trace, "Descr", indent, XMTDump, GF_TRUE);
467 indent++;
468 }
469 //ESDescr
470 DumpDescList(iod->ESDescriptors, trace, indent, "esDescr", XMTDump, GF_FALSE);
471 DumpDescList(iod->OCIDescriptors, trace, indent, "ociDescr", XMTDump, GF_FALSE);
472 DumpDescListFilter(iod->IPMP_Descriptors, trace, indent, "ipmpDescrPtr", XMTDump, GF_ODF_IPMP_PTR_TAG);
473 DumpDescListFilter(iod->IPMP_Descriptors, trace, indent, "ipmpDescr", XMTDump, GF_ODF_IPMP_TAG);
474
475 DumpDescList(iod->extensionDescriptors, trace, indent, "extDescr", XMTDump, GF_FALSE);
476
477 if (iod->IPMPToolList) {
478 StartElement(trace, "toolListDescr" , indent, XMTDump, GF_FALSE);
479 gf_odf_dump_desc((GF_Descriptor*)iod->IPMPToolList, trace, indent + (XMTDump ? 1 : 0), XMTDump);
480 EndElement(trace, "toolListDescr" , indent, XMTDump, GF_FALSE);
481 }
482
483 if (XMTDump) {
484 indent--;
485 EndElement(trace, "Descr", indent, XMTDump, GF_TRUE);
486 }
487 indent--;
488 EndDescDump(trace, "InitialObjectDescriptor", indent, XMTDump);
489 return GF_OK;
490 }
491
gf_odf_dump_esd(GF_ESD * esd,FILE * trace,u32 indent,Bool XMTDump)492 GF_Err gf_odf_dump_esd(GF_ESD *esd, FILE *trace, u32 indent, Bool XMTDump)
493 {
494 GF_MuxInfo *mi;
495 u32 i;
496 StartDescDump(trace, "ES_Descriptor", indent, XMTDump);
497 indent++;
498
499 StartAttribute(trace, "ES_ID", indent, XMTDump);
500 if (XMTDump) {
501 gf_fprintf(trace, "es%d", esd->ESID);
502 EndAttribute(trace, indent, XMTDump);
503 DumpInt(trace, "binaryID", esd->ESID, indent, XMTDump);
504 } else {
505 gf_fprintf(trace, "%d", esd->ESID);
506 EndAttribute(trace, indent, XMTDump);
507 }
508 DumpInt(trace, "streamPriority", esd->streamPriority, indent, XMTDump);
509
510 if (XMTDump) {
511 if (esd->dependsOnESID) {
512 StartAttribute(trace, "dependsOn_ES_ID", indent, XMTDump);
513 gf_fprintf(trace, "es%d", esd->dependsOnESID);
514 EndAttribute(trace, indent, XMTDump);
515 }
516
517 if (esd->OCRESID) {
518 StartAttribute(trace, "OCR_ES_ID", indent, XMTDump);
519 gf_fprintf(trace, "es%d", esd->OCRESID);
520 EndAttribute(trace, indent, XMTDump);
521 }
522 } else {
523 if (esd->dependsOnESID) DumpInt(trace, "dependsOn_ES_ID", esd->dependsOnESID, indent, XMTDump);
524 if (esd->OCRESID) DumpInt(trace, "OCR_ES_ID", esd->OCRESID, indent, XMTDump);
525 }
526
527 EndAttributes(trace, indent, XMTDump);
528
529 if (esd->URLString) {
530 StartSubElement(trace, "URL", indent, XMTDump);
531 DumpString(trace, "URLstring", esd->URLString, indent, XMTDump);
532 EndSubElement(trace, indent, XMTDump);
533 }
534 if (esd->decoderConfig) {
535 StartElement(trace, "decConfigDescr" , indent, XMTDump, GF_FALSE);
536 gf_odf_dump_desc((GF_Descriptor*)esd->decoderConfig, trace, indent + (XMTDump ? 1 : 0), XMTDump);
537 EndElement(trace, "decConfigDescr" , indent, XMTDump, GF_FALSE);
538 }
539 if (esd->slConfig) {
540 StartElement(trace, "slConfigDescr" , indent, XMTDump, GF_FALSE);
541 gf_odf_dump_desc((GF_Descriptor*)esd->slConfig, trace, indent + (XMTDump ? 1 : 0), XMTDump);
542 EndElement(trace, "slConfigDescr" , indent, XMTDump, GF_FALSE);
543 } else {
544 StartElement(trace, "slConfigDescr" , indent, XMTDump, GF_FALSE);
545 StartDescDump(trace, "SLConfigDescriptor", indent, XMTDump);
546 EndAttributes(trace, indent, XMTDump);
547 EndDescDump(trace, "SLConfigDescriptor", indent, XMTDump);
548 EndElement(trace, "slConfigDescr" , indent, XMTDump, GF_FALSE);
549 }
550 if (esd->ipiPtr) {
551 StartElement(trace, "ipiPtr" , indent, XMTDump, GF_FALSE);
552 gf_odf_dump_desc((GF_Descriptor*)esd->ipiPtr, trace, indent + (XMTDump ? 1 : 0), XMTDump);
553 EndElement(trace, "ipiPtr" , indent, XMTDump, GF_FALSE);
554 }
555
556 DumpDescList(esd->IPIDataSet, trace, indent, "ipIDS", XMTDump, GF_FALSE);
557 DumpDescList(esd->IPMPDescriptorPointers, trace, indent, "ipmpDescrPtr", XMTDump, GF_FALSE);
558
559 if (esd->qos) {
560 StartElement(trace, "qosDescr" , indent, XMTDump, GF_FALSE);
561 gf_odf_dump_desc((GF_Descriptor*)esd->qos, trace, indent + (XMTDump ? 1 : 0), XMTDump);
562 EndElement(trace, "qosDescr" , indent, XMTDump, GF_FALSE);
563 }
564 if (esd->langDesc) {
565 StartElement(trace, "langDescr" , indent, XMTDump, GF_FALSE);
566 gf_odf_dump_desc((GF_Descriptor*)esd->langDesc, trace, indent + (XMTDump ? 1 : 0), XMTDump);
567 EndElement(trace, "langDescr" , indent, XMTDump, GF_FALSE);
568 }
569
570 if (esd->RegDescriptor) {
571 StartElement(trace, "regDescr" , indent, XMTDump, GF_FALSE);
572 gf_odf_dump_desc((GF_Descriptor*)esd->RegDescriptor, trace, indent + (XMTDump ? 1 : 0), XMTDump);
573 EndElement(trace, "regDescr" , indent, XMTDump, GF_FALSE);
574 }
575
576 mi = NULL;
577 i=0;
578 while ((mi = (GF_MuxInfo *)gf_list_enum(esd->extensionDescriptors, &i))) {
579 if (mi->tag == GF_ODF_MUXINFO_TAG) {
580 gf_list_rem(esd->extensionDescriptors, i-1);
581 break;
582 }
583 mi = NULL;
584 }
585
586 DumpDescList(esd->extensionDescriptors, trace, indent, "extDescr", XMTDump, GF_FALSE);
587
588 if (mi) {
589 gf_list_insert(esd->extensionDescriptors, mi, i);
590 if (XMTDump) {
591 gf_odf_dump_desc((GF_Descriptor*)mi, trace, indent, GF_TRUE);
592 } else {
593 StartElement(trace, "muxInfo", indent, GF_FALSE, GF_FALSE);
594 gf_odf_dump_desc((GF_Descriptor*)mi, trace, indent, GF_FALSE);
595 EndElement(trace, "muxInfo", indent, GF_FALSE, GF_FALSE);
596 }
597 }
598
599 indent--;
600 EndDescDump(trace, "ES_Descriptor", indent, XMTDump);
601 return GF_OK;
602 }
603
gf_odf_dump_bifs_cfg(GF_BIFSConfig * dsi,FILE * trace,u32 indent,Bool XMTDump)604 GF_Err gf_odf_dump_bifs_cfg(GF_BIFSConfig *dsi, FILE *trace, u32 indent, Bool XMTDump)
605 {
606 u32 i, count;
607 StartDescDump(trace, (dsi->version==1) ? "BIFSConfig" : "BIFSv2Config", indent, XMTDump);
608 indent++;
609
610 if (dsi->version==2) {
611 DumpBool(trace, "use3DMeshCoding", 0, indent, XMTDump);
612 DumpBool(trace, "usePredictiveMFField", 0, indent, XMTDump);
613 }
614 DumpInt(trace, "nodeIDbits", dsi->nodeIDbits, indent, XMTDump);
615 DumpInt(trace, "routeIDbits", dsi->routeIDbits, indent, XMTDump);
616 if (dsi->version==2) DumpInt(trace, "protoIDbits", dsi->protoIDbits, indent, XMTDump);
617
618 count = gf_list_count(dsi->elementaryMasks);
619 if (count) {
620 EndAttributes(trace, indent, XMTDump);
621
622 /*TODO check XMT-A syntax for anim mask*/
623 StartDescDump(trace, "AnimationMask" , indent, XMTDump);
624 DumpBool(trace, "randomAccess", dsi->randomAccess, indent, XMTDump);
625 EndAttributes(trace, indent, XMTDump);
626 for (i=0; i<count; i++) {
627 GF_ElementaryMask *em = (GF_ElementaryMask *)gf_list_get(dsi->elementaryMasks, i);
628 StartDescDump(trace, "ElementaryMask" , indent, XMTDump);
629 if (em->node_id) DumpInt(trace, "atNode", em->node_id, indent, XMTDump);
630 else if (em->node_name) DumpString(trace, "atNode", em->node_name, indent, XMTDump);
631 EndAttributes(trace, indent, XMTDump);
632 if (XMTDump) EndDescDump(trace, "ElementaryMask", indent, GF_TRUE);
633 else EndDescDump(trace, "ElementaryMask", indent, GF_FALSE);
634 }
635 EndDescDump(trace, "AnimationMask", indent, XMTDump);
636 indent--;
637 EndDescDump(trace, (dsi->version==1) ? "BIFSConfig" : "BIFSv2Config", indent, XMTDump);
638 return GF_OK;
639 }
640 if (XMTDump) {
641 EndAttributes(trace, indent, XMTDump);
642 indent++;
643 StartDescDump(trace, "commandStream" , indent, XMTDump);
644 DumpBool(trace, "pixelMetric", dsi->pixelMetrics, indent, XMTDump);
645 EndAttributes(trace, indent, XMTDump);
646 } else {
647 DumpBool(trace, "isCommandStream", 1, indent, XMTDump);
648 DumpBool(trace, "pixelMetric", dsi->pixelMetrics, indent, XMTDump);
649 }
650 if (dsi->pixelWidth && dsi->pixelHeight) {
651 if (XMTDump) {
652 indent++;
653 StartDescDump(trace, "size" , indent, XMTDump);
654 }
655
656 DumpInt(trace, "pixelWidth", dsi->pixelWidth, indent, XMTDump);
657 DumpInt(trace, "pixelHeight", dsi->pixelHeight, indent, XMTDump);
658 if (XMTDump) {
659 EndSubElement(trace, indent, XMTDump);
660 indent--;
661 }
662 }
663
664 if (XMTDump) {
665 EndDescDump(trace, "commandStream", indent, XMTDump);
666 indent--;
667 }
668 indent--;
669 EndDescDump(trace, (dsi->version==1) ? "BIFSConfig" : "BIFSv2Config", indent, XMTDump);
670 return GF_OK;
671 }
672
DumpRawBIFSConfig(GF_DefaultDescriptor * dsi,FILE * trace,u32 indent,Bool XMTDump,u32 oti)673 GF_Err DumpRawBIFSConfig(GF_DefaultDescriptor *dsi, FILE *trace, u32 indent, Bool XMTDump, u32 oti)
674 {
675 GF_BitStream *bs;
676 u32 flag;
677
678 bs = gf_bs_new(dsi->data, dsi->dataLength, GF_BITSTREAM_READ);
679
680 StartDescDump(trace, (oti==1) ? "BIFSConfig" : "BIFSv2Config", indent, XMTDump);
681 indent++;
682
683 if (oti==2) {
684 DumpBool(trace, "use3DMeshCoding", gf_bs_read_int(bs, 1), indent, XMTDump);
685 DumpBool(trace, "usePredictiveMFField", gf_bs_read_int(bs, 1), indent, XMTDump);
686 }
687 DumpInt(trace, "nodeIDbits", gf_bs_read_int(bs, 5), indent, XMTDump);
688 DumpInt(trace, "routeIDbits", gf_bs_read_int(bs, 5), indent, XMTDump);
689
690 if (oti==2)
691 DumpInt(trace, "protoIDbits", gf_bs_read_int(bs, 5), indent, XMTDump);
692
693 flag = gf_bs_read_int(bs, 1);
694 if (!flag) {
695 gf_bs_del(bs);
696 return GF_NOT_SUPPORTED;
697 }
698
699 if (XMTDump) {
700 EndAttributes(trace, indent, XMTDump);
701 indent++;
702 StartDescDump(trace, "commandStream" , indent, XMTDump);
703 DumpBool(trace, "pixelMetric", gf_bs_read_int(bs, 1), indent, XMTDump);
704 EndAttributes(trace, indent, XMTDump);
705 } else {
706 DumpBool(trace, "isCommandStream", 1, indent, XMTDump);
707 DumpBool(trace, "pixelMetric", gf_bs_read_int(bs, 1), indent, XMTDump);
708 }
709
710 if (gf_bs_read_int(bs, 1)) {
711
712 if (XMTDump) {
713 indent++;
714 StartDescDump(trace, "size" , indent, XMTDump);
715 }
716
717 DumpInt(trace, "pixelWidth", gf_bs_read_int(bs, 16), indent, XMTDump);
718 DumpInt(trace, "pixelHeight", gf_bs_read_int(bs, 16), indent, XMTDump);
719 if (XMTDump) {
720 EndSubElement(trace, indent, XMTDump);
721 indent--;
722 }
723
724 }
725
726 if (XMTDump) {
727 EndDescDump(trace, "commandStream", indent, XMTDump);
728 indent--;
729 }
730 indent--;
731 EndDescDump(trace, (oti==1) ? "BIFSConfig" : "BIFSv2Config", indent, XMTDump);
732
733 gf_bs_del(bs);
734 return GF_OK;
735 }
736
gf_odf_dump_laser_cfg(GF_LASERConfig * dsi,FILE * trace,u32 indent,Bool XMTDump)737 GF_Err gf_odf_dump_laser_cfg(GF_LASERConfig *dsi, FILE *trace, u32 indent, Bool XMTDump)
738 {
739 gf_fprintf(trace, "<lsr:LASeRHeader profile=\"%s\" pointsCodec=\"%s\"",
740 dsi->profile ? "mini" : "full",
741 dsi->pointsCodec ? "Unknown" : "ExpGolombPointsCodec");
742
743 if (dsi->colorComponentBits) gf_fprintf(trace, " colorComponentBits=\"%d\"", dsi->colorComponentBits);
744 if (dsi->newSceneIndicator) gf_fprintf(trace, " newSceneIndicator=\"true\"");
745 if (dsi->coord_bits) gf_fprintf(trace, " coordBits=\"%d\"", dsi->coord_bits);
746 if (dsi->fullRequestHost) gf_fprintf(trace, " useFullRequestHost=\"true\"");
747 if (dsi->pathComponents) gf_fprintf(trace, " pathComponents=\"%d\"", dsi->pathComponents);
748 if (dsi->time_resolution && (dsi->time_resolution!=1000) ) gf_fprintf(trace, " timeResolution=\"%d\"", dsi->time_resolution);
749 if (dsi->resolution) gf_fprintf(trace, " resolution=\"%d\"", dsi->resolution);
750 if (dsi->scale_bits_minus_coord_bits) gf_fprintf(trace, " scaleBits_minus_coordBits=\"%d\"", dsi->scale_bits_minus_coord_bits);
751 gf_fprintf(trace, "/>\n");
752 return GF_OK;
753 }
754
755
756 GF_EXPORT
gf_odf_dump_txtcfg(GF_TextConfig * desc,FILE * trace,u32 indent,Bool XMTDump)757 GF_Err gf_odf_dump_txtcfg(GF_TextConfig *desc, FILE *trace, u32 indent, Bool XMTDump)
758 {
759 u32 i, count;
760 char ind_buf[OD_MAX_TREE];
761 if (!trace || !desc) return GF_BAD_PARAM;
762 StartDescDump(trace, "TextConfig", indent, XMTDump);
763 indent++;
764 DumpIntHex(trace, "3GPPBaseFormat", desc->Base3GPPFormat, indent, XMTDump, GF_TRUE);
765 DumpIntHex(trace, "MPEGExtendedFormat", desc->MPEGExtendedFormat, indent, XMTDump, GF_TRUE);
766 DumpIntHex(trace, "profileLevel", desc->profileLevel, indent, XMTDump, GF_TRUE);
767 DumpInt(trace, "durationClock", desc->timescale, indent, XMTDump);
768 DumpInt(trace, "layer", desc->layer, indent, XMTDump);
769 DumpInt(trace, "text_width", desc->text_width, indent, XMTDump);
770 DumpInt(trace, "text_height", desc->text_height, indent, XMTDump);
771 if (desc->video_width) DumpInt(trace, "video_width", desc->video_width, indent, XMTDump);
772 if (desc->video_height) DumpInt(trace, "video_height", desc->video_height, indent, XMTDump);
773 if (desc->horiz_offset) DumpInt(trace, "horizontal_offset", desc->horiz_offset, indent, XMTDump);
774 if (desc->vert_offset) DumpInt(trace, "vertical_offset", desc->vert_offset, indent, XMTDump);
775
776 StartElement(trace, "SampleDescriptions", indent, XMTDump, GF_TRUE);
777 indent++;
778 OD_FORMAT_INDENT(ind_buf, indent);
779
780 count = gf_list_count(desc->sample_descriptions);
781 for (i=0; i<count; i++) {
782 char szStyles[1024];
783 u32 j;
784 GF_TextSampleDescriptor *sd = (GF_TextSampleDescriptor *)gf_list_get(desc->sample_descriptions, i);
785 if (!XMTDump) gf_fprintf(trace, "%s", ind_buf);
786 StartDescDump(trace, "TextSampleDescriptor", indent, XMTDump);
787 indent++;
788 DumpIntHex(trace, "displayFlags", sd->displayFlags, indent, XMTDump, GF_FALSE);
789 DumpInt(trace, "horiz_justif", sd->horiz_justif, indent, XMTDump);
790 DumpInt(trace, "vert_justif", sd->vert_justif, indent, XMTDump);
791 DumpIntHex(trace, "back_color", sd->back_color, indent, XMTDump, GF_FALSE);
792 DumpInt(trace, "top", sd->default_pos.top, indent, XMTDump);
793 DumpInt(trace, "bottom", sd->default_pos.bottom, indent, XMTDump);
794 DumpInt(trace, "left", sd->default_pos.left, indent, XMTDump);
795 DumpInt(trace, "right", sd->default_pos.right, indent, XMTDump);
796 DumpInt(trace, "style_font_ID", sd->default_style.fontID, indent, XMTDump);
797 DumpInt(trace, "style_font_size", sd->default_style.font_size, indent, XMTDump);
798 DumpIntHex(trace, "style_text_color", sd->default_style.text_color, indent, XMTDump, GF_FALSE);
799 strcpy(szStyles, "");
800 if (sd->default_style.style_flags & GF_TXT_STYLE_BOLD) strcat(szStyles, "bold ");
801 if (sd->default_style.style_flags & GF_TXT_STYLE_ITALIC) strcat(szStyles, "italic ");
802 if (sd->default_style.style_flags & GF_TXT_STYLE_UNDERLINED) strcat(szStyles, "underlined ");
803 if (strlen(szStyles)) DumpString(trace, "style_flag", szStyles, indent, XMTDump);
804
805 for (j=0; j<sd->font_count; j++) {
806 DumpInt(trace, "fontID", sd->fonts[j].fontID, indent, XMTDump);
807 DumpString(trace, "fontName", sd->fonts[i].fontName, indent, XMTDump);
808 }
809
810 indent--;
811 EndDescDump(trace, "TextSampleDescriptor", indent, XMTDump);
812 }
813
814 indent--;
815 EndElement(trace, "SampleDescriptions", indent, XMTDump, GF_TRUE);
816
817 indent--;
818 EndDescDump(trace, "TextConfig", indent, XMTDump);
819 return GF_OK;
820 }
821
gf_odf_dump_ui_cfg(GF_UIConfig * uid,FILE * trace,u32 indent,Bool XMTDump)822 GF_Err gf_odf_dump_ui_cfg(GF_UIConfig *uid, FILE *trace, u32 indent, Bool XMTDump)
823 {
824 char devName[255];
825 u32 i;
826
827 StartDescDump(trace, "UIConfig" , indent, XMTDump);
828 indent++;
829 DumpString(trace, "deviceName", uid->deviceName, indent, XMTDump);
830
831 if (!stricmp(devName, "StringSensor") && uid->termChar) {
832 devName[0] = uid->termChar;
833 devName[1] = 0;
834 DumpString(trace, "termChar", devName, indent, XMTDump);
835 devName[0] = uid->delChar;
836 DumpString(trace, "delChar", devName, indent, XMTDump);
837 }
838 if (uid->ui_data_length) {
839 if (!stricmp(uid->deviceName, "HTKSensor")) {
840 u32 nb_word, nbPhone, c, j;
841 GF_BitStream *bs = gf_bs_new(uid->ui_data, uid->ui_data_length, GF_BITSTREAM_READ);
842 char szPh[3];
843 StartAttribute(trace, "uiData", indent, XMTDump);
844 if (!XMTDump) gf_fprintf(trace, "\"");
845 gf_fprintf(trace, "HTK:");
846 szPh[2] = 0;
847 nb_word = gf_bs_read_int(bs, 8);
848 for (i=0; i<nb_word; i++) {
849 nbPhone = gf_bs_read_int(bs, 8);
850 if (i) gf_fprintf(trace, ";");
851 while ((c=gf_bs_read_int(bs, 8))) gf_fprintf(trace, "%c", c);
852 gf_fprintf(trace, " ");
853 for (j=0; j<nbPhone; j++) {
854 gf_bs_read_data(bs, szPh, 2);
855 if (j) gf_fprintf(trace, " ");
856 if (!stricmp(szPh, "vc")) gf_fprintf(trace, "vcl");
857 else gf_fprintf(trace, "%s", szPh);
858 }
859 }
860 if (!XMTDump) gf_fprintf(trace, "\"");
861 EndAttribute(trace, indent, XMTDump);
862 gf_bs_del(bs);
863 } else {
864 DumpData(trace, "uiData", uid->ui_data, uid->ui_data_length, indent, XMTDump);
865 }
866 }
867
868 indent--;
869 EndAttributes(trace, indent, XMTDump);
870 EndDescDump(trace, "UIConfig", indent, XMTDump);
871 return GF_OK;
872 }
873
DumpRawUIConfig(GF_DefaultDescriptor * dsi,FILE * trace,u32 indent,Bool XMTDump,u32 oti)874 GF_Err DumpRawUIConfig(GF_DefaultDescriptor *dsi, FILE *trace, u32 indent, Bool XMTDump, u32 oti)
875 {
876 char devName[255];
877 u32 i;
878 u64 len;
879 GF_BitStream *bs;
880
881 bs = gf_bs_new(dsi->data, dsi->dataLength, GF_BITSTREAM_READ);
882
883 StartDescDump(trace, "UIConfig" , indent, XMTDump);
884 indent++;
885 len = gf_bs_read_int(bs, 8);
886 for (i=0; i<len; i++) devName[i] = gf_bs_read_int(bs, 8);
887 devName[i] = 0;
888 DumpString(trace, "deviceName", devName, indent, XMTDump);
889
890 if (!stricmp(devName, "StringSensor") && gf_bs_available(bs)) {
891 devName[0] = gf_bs_read_int(bs, 8);
892 devName[1] = 0;
893 DumpString(trace, "termChar", devName, indent, XMTDump);
894 devName[0] = gf_bs_read_int(bs, 8);
895 DumpString(trace, "delChar", devName, indent, XMTDump);
896 }
897 len = gf_bs_available(bs);
898 if (len) {
899 if (!stricmp(devName, "HTKSensor")) {
900 u32 nb_word, nbPhone, c, j;
901 char szPh[3];
902 StartAttribute(trace, "uiData", indent, XMTDump);
903 if (!XMTDump) gf_fprintf(trace, "\"");
904 gf_fprintf(trace, "HTK:");
905 szPh[2] = 0;
906 nb_word = gf_bs_read_int(bs, 8);
907 for (i=0; i<nb_word; i++) {
908 nbPhone = gf_bs_read_int(bs, 8);
909 if (i) gf_fprintf(trace, ";");
910 while ((c=gf_bs_read_int(bs, 8))) gf_fprintf(trace, "%c", c);
911 gf_fprintf(trace, " ");
912 for (j=0; j<nbPhone; j++) {
913 gf_bs_read_data(bs, szPh, 2);
914 if (j) gf_fprintf(trace, " ");
915 if (!stricmp(szPh, "vc")) gf_fprintf(trace, "vcl");
916 else gf_fprintf(trace, "%s", szPh);
917 }
918 }
919 if (!XMTDump) gf_fprintf(trace, "\"");
920 EndAttribute(trace, indent, XMTDump);
921 } else {
922 char *data = dsi->data;
923 data += gf_bs_get_position(bs);
924 DumpData(trace, "uiData", data, len, indent, XMTDump);
925 }
926 }
927
928 indent--;
929 EndAttributes(trace, indent, XMTDump);
930 EndDescDump(trace, "UIConfig", indent, XMTDump);
931 gf_bs_del(bs);
932 return GF_OK;
933 }
934
OD_DumpDSI(GF_DefaultDescriptor * dsi,FILE * trace,u32 indent,Bool XMTDump,u32 streamType,u32 oti)935 GF_Err OD_DumpDSI(GF_DefaultDescriptor *dsi, FILE *trace, u32 indent, Bool XMTDump, u32 streamType, u32 oti)
936 {
937 switch (streamType) {
938 case GF_STREAM_SCENE:
939 if (oti<=2) return DumpRawBIFSConfig(dsi, trace, indent, XMTDump, oti);
940 break;
941 case GF_STREAM_INTERACT:
942 return DumpRawUIConfig(dsi, trace, indent, XMTDump, oti);
943 case GF_STREAM_TEXT:
944 if (oti==0x08) {
945 GF_TextConfig *cfg = (GF_TextConfig *) gf_odf_desc_new(GF_ODF_TEXT_CFG_TAG);
946 GF_Err e = gf_odf_get_text_config(dsi->data, dsi->dataLength, (u8) oti, cfg);
947 if (!e) gf_odf_dump_desc((GF_Descriptor*)cfg, trace, indent, XMTDump);
948 gf_odf_desc_del((GF_Descriptor *) cfg);
949 }
950 break;
951 default:
952 break;
953 }
954 return gf_odf_dump_desc((GF_Descriptor*)dsi, trace, indent, XMTDump);
955 }
956
gf_odf_dump_dcd(GF_DecoderConfig * dcd,FILE * trace,u32 indent,Bool XMTDump)957 GF_Err gf_odf_dump_dcd(GF_DecoderConfig *dcd, FILE *trace, u32 indent, Bool XMTDump)
958 {
959 StartDescDump(trace, "DecoderConfigDescriptor", indent, XMTDump);
960 indent++;
961
962 DumpIntForce(trace, "objectTypeIndication", dcd->objectTypeIndication, indent, XMTDump);
963 DumpInt(trace, "streamType", dcd->streamType, indent, XMTDump);
964 DumpInt(trace, "upStream", dcd->upstream, indent, XMTDump);
965 DumpInt(trace, "bufferSizeDB", dcd->bufferSizeDB, indent, XMTDump);
966 DumpInt(trace, "maxBitrate", dcd->maxBitrate, indent, XMTDump);
967 DumpInt(trace, "avgBitrate", dcd->avgBitrate, indent, XMTDump);
968 EndAttributes(trace, indent, XMTDump);
969
970 if (dcd->decoderSpecificInfo) {
971 if (dcd->decoderSpecificInfo->tag==GF_ODF_DSI_TAG) {
972 if (dcd->decoderSpecificInfo->dataLength) {
973 StartElement(trace, "decSpecificInfo" , indent, XMTDump, GF_FALSE);
974 OD_DumpDSI(dcd->decoderSpecificInfo, trace, indent + (XMTDump ? 1 : 0), XMTDump, dcd->streamType, dcd->objectTypeIndication);
975 EndElement(trace, "decSpecificInfo" , indent, XMTDump, GF_FALSE);
976 }
977 } else {
978 StartElement(trace, "decSpecificInfo" , indent, XMTDump, GF_FALSE);
979 gf_odf_dump_desc((GF_Descriptor*)dcd->decoderSpecificInfo, trace, indent + (XMTDump ? 1 : 0), XMTDump);
980 EndElement(trace, "decSpecificInfo" , indent, XMTDump, GF_FALSE);
981 }
982 }
983 DumpDescList(dcd->profileLevelIndicationIndexDescriptor, trace, indent, "profileLevelIndicationIndexDescr", XMTDump, GF_FALSE);
984 indent--;
985 EndDescDump(trace, "DecoderConfigDescriptor", indent, XMTDump);
986
987 return GF_OK;
988 }
989
gf_odf_dump_slc(GF_SLConfig * sl,FILE * trace,u32 indent,Bool XMTDump)990 GF_Err gf_odf_dump_slc(GF_SLConfig *sl, FILE *trace, u32 indent, Bool XMTDump)
991 {
992
993 StartDescDump(trace, "SLConfigDescriptor", indent, XMTDump);
994 EndAttributes(trace, indent, XMTDump);
995 indent++;
996
997 if (sl->predefined) {
998 StartSubElement(trace, "predefined" , indent, XMTDump);
999 DumpInt(trace, XMTDump ? "value" : "predefined", sl->predefined, indent, XMTDump);
1000 EndSubElement(trace, indent, XMTDump);
1001 }
1002 if (XMTDump) StartSubElement(trace, "custom" , indent, XMTDump);
1003
1004 if (!sl->predefined) {
1005 DumpBool(trace, "useAccessUnitStartFlag", sl->useAccessUnitStartFlag, indent, XMTDump);
1006 DumpBool(trace, "useAccessUnitEndFlag", sl->useAccessUnitEndFlag, indent, XMTDump);
1007 DumpBool(trace, "useRandomAccessPointFlag", sl->useRandomAccessPointFlag, indent, XMTDump);
1008 DumpBool(trace, "usePaddingFlag", sl->usePaddingFlag, indent, XMTDump);
1009 if (!XMTDump) DumpBool(trace, "useTimeStampsFlag", sl->useTimestampsFlag, indent, XMTDump);
1010 DumpBool(trace, "useIdleFlag", sl->useIdleFlag, indent, XMTDump);
1011 if (!XMTDump) DumpBool(trace, "durationFlag", sl->durationFlag, indent, XMTDump);
1012 DumpInt(trace, "timeStampResolution", sl->timestampResolution, indent, XMTDump);
1013 DumpInt(trace, "OCRResolution", sl->OCRResolution, indent, XMTDump);
1014 DumpInt(trace, "timeStampLength", sl->timestampLength, indent, XMTDump);
1015 DumpInt(trace, "OCRLength", sl->OCRLength, indent, XMTDump);
1016 DumpInt(trace, "AU_Length", sl->AULength, indent, XMTDump);
1017 DumpInt(trace, "instantBitrateLength", sl->instantBitrateLength, indent, XMTDump);
1018 DumpInt(trace, "degradationPriorityLength", sl->degradationPriorityLength, indent, XMTDump);
1019 DumpInt(trace, "AU_SeqNumLength", sl->AUSeqNumLength, indent, XMTDump);
1020 DumpInt(trace, "packetSeqNumLength", sl->packetSeqNumLength, indent, XMTDump);
1021 }
1022 EndAttributes(trace, indent, XMTDump);
1023
1024 indent++;
1025 if (sl->durationFlag) {
1026 StartSubElement(trace, "Duration" , indent, XMTDump);
1027 DumpInt(trace, "timescale", sl->timeScale, indent, XMTDump);
1028 DumpInt(trace, "accessUnitDuration", sl->AUDuration, indent, XMTDump);
1029 DumpInt(trace, "compositionUnitDuration", sl->CUDuration, indent, XMTDump);
1030 EndSubElement(trace, indent, XMTDump);
1031 }
1032 if (! sl->useTimestampsFlag) {
1033 StartSubElement(trace, "noUseTimeStamps" , indent, XMTDump);
1034 DumpInt(trace, "startDecodingTimeStamp", (u32) sl->startDTS, indent, XMTDump);
1035 DumpInt(trace, "startCompositionTimeStamp", (u32) sl->startCTS, indent, XMTDump);
1036 EndSubElement(trace, indent, XMTDump);
1037 }
1038 indent--;
1039 if (XMTDump) EndElement(trace, "custom" , indent, XMTDump, GF_TRUE);
1040
1041 indent--;
1042 EndDescDump(trace, "SLConfigDescriptor", indent, XMTDump);
1043 return GF_OK;
1044 }
1045
gf_odf_dump_default(GF_DefaultDescriptor * dd,FILE * trace,u32 indent,Bool XMTDump)1046 GF_Err gf_odf_dump_default(GF_DefaultDescriptor *dd, FILE *trace, u32 indent, Bool XMTDump)
1047 {
1048 if (dd->tag == GF_ODF_DSI_TAG) {
1049 StartDescDump(trace, "DecoderSpecificInfo", indent, XMTDump);
1050 indent++;
1051 if (XMTDump) {
1052 DumpString(trace, "type", "auto", indent, XMTDump);
1053 DumpData(trace, "src", dd->data, dd->dataLength, indent, XMTDump);
1054 } else {
1055 DumpData(trace, "info", dd->data, dd->dataLength, indent, XMTDump);
1056 }
1057 indent--;
1058 if (XMTDump) {
1059 EndSubElement(trace, indent, GF_TRUE);
1060 } else {
1061 EndDescDump(trace, "", indent, GF_FALSE);
1062 }
1063 } else {
1064 StartDescDump(trace, "DefaultDescriptor", indent, XMTDump);
1065 indent++;
1066 DumpData(trace, "data", dd->data, dd->dataLength, indent, XMTDump);
1067 indent--;
1068 EndSubElement(trace, indent, XMTDump);
1069 }
1070 return GF_OK;
1071 }
1072
1073
gf_odf_dump_esd_inc(GF_ES_ID_Inc * esd_inc,FILE * trace,u32 indent,Bool XMTDump)1074 GF_Err gf_odf_dump_esd_inc(GF_ES_ID_Inc *esd_inc, FILE *trace, u32 indent, Bool XMTDump)
1075 {
1076 StartDescDump(trace, "ES_ID_Inc", indent, XMTDump);
1077 indent++;
1078 DumpInt(trace, "trackID", esd_inc->trackID, indent, XMTDump);
1079 indent--;
1080 EndAttributes(trace, indent, XMTDump);
1081 EndDescDump(trace, "ES_ID_Inc", indent, XMTDump);
1082 return GF_OK;
1083 }
1084
gf_odf_dump_esd_ref(GF_ES_ID_Ref * esd_ref,FILE * trace,u32 indent,Bool XMTDump)1085 GF_Err gf_odf_dump_esd_ref(GF_ES_ID_Ref *esd_ref, FILE *trace, u32 indent, Bool XMTDump)
1086 {
1087 StartDescDump(trace, "ES_ID_Ref", indent, XMTDump);
1088 indent++;
1089 DumpInt(trace, "trackRef", esd_ref->trackRef, indent, XMTDump);
1090 indent--;
1091 EndAttributes(trace, indent, XMTDump);
1092 EndDescDump(trace, "ES_ID_Ref", indent, XMTDump);
1093 return GF_OK;
1094 }
1095
1096 #ifndef GPAC_MINIMAL_ODF
1097
gf_odf_dump_cc(GF_CCDescriptor * ccd,FILE * trace,u32 indent,Bool XMTDump)1098 GF_Err gf_odf_dump_cc(GF_CCDescriptor *ccd, FILE *trace, u32 indent, Bool XMTDump)
1099 {
1100 StartDescDump(trace, "ContentClassificationDescriptor", indent, XMTDump);
1101 DumpInt(trace, "classificationEntity", ccd->classificationEntity, indent, XMTDump);
1102 DumpInt(trace, "classificationTable", ccd->classificationTable, indent, XMTDump);
1103 DumpData(trace, "ccd->contentClassificationData", ccd->contentClassificationData, ccd->dataLength, indent, XMTDump);
1104 EndAttributes(trace, indent, XMTDump);
1105 EndDescDump(trace, "ContentClassificationDescriptor", indent, XMTDump);
1106 return GF_OK;
1107 }
1108
gf_odf_dump_cc_date(GF_CC_Date * cdd,FILE * trace,u32 indent,Bool XMTDump)1109 GF_Err gf_odf_dump_cc_date(GF_CC_Date *cdd, FILE *trace, u32 indent, Bool XMTDump)
1110 {
1111 StartDescDump(trace, "ContentClassificationDescriptor", indent, XMTDump);
1112 DumpString(trace, "creationDate", cdd->contentCreationDate, indent, XMTDump);
1113 EndAttributes(trace, indent, XMTDump);
1114 EndDescDump(trace, "ContentClassificationDescriptor", indent, XMTDump);
1115 return GF_OK;
1116 }
1117
gf_odf_dump_cc_name(GF_CC_Name * cnd,FILE * trace,u32 indent,Bool XMTDump)1118 GF_Err gf_odf_dump_cc_name(GF_CC_Name *cnd, FILE *trace, u32 indent, Bool XMTDump)
1119 {
1120 u32 i;
1121 GF_ContentCreatorInfo *p;
1122
1123 StartDescDump(trace, "ContentCreatorNameDescriptor", indent, XMTDump);
1124 EndAttributes(trace, indent, XMTDump);
1125 indent++;
1126 i=0;
1127 while ((p = (GF_ContentCreatorInfo *)gf_list_enum(cnd->ContentCreators, &i))) {
1128 StartSubElement(trace, "Creator", indent, XMTDump);
1129 DumpInt(trace, "languageCode", p->langCode, indent, XMTDump);
1130 DumpBool(trace, "isUTF8", p->isUTF8, indent, XMTDump);
1131 DumpString(trace, "Name", p->contentCreatorName, indent, XMTDump);
1132 EndSubElement(trace, indent, XMTDump);
1133 }
1134 indent--;
1135 EndDescDump(trace, "ContentCreatorNameDescriptor", indent, XMTDump);
1136 return GF_OK;
1137 }
1138
gf_odf_dump_ci(GF_CIDesc * cid,FILE * trace,u32 indent,Bool XMTDump)1139 GF_Err gf_odf_dump_ci(GF_CIDesc *cid, FILE *trace, u32 indent, Bool XMTDump)
1140 {
1141 StartDescDump(trace, "ContentIdentificationDescriptor", indent, XMTDump);
1142 DumpBool(trace, "protectedContent", cid->protectedContent, indent, XMTDump);
1143 EndAttributes(trace, indent, XMTDump);
1144 indent++;
1145 if (cid->contentTypeFlag) {
1146 StartSubElement(trace, "contentType", indent, XMTDump);
1147 DumpInt(trace, "contentType", cid->contentType, indent, XMTDump);
1148 EndSubElement(trace, indent, XMTDump);
1149 }
1150 if (cid->contentIdentifierFlag) {
1151 StartSubElement(trace, "contentIdentifierType", indent, XMTDump);
1152 DumpInt(trace, "contentIdentifierType", cid->contentIdentifierType, indent, XMTDump);
1153 DumpString(trace, "contentIdentifier", cid->contentIdentifier, indent, XMTDump);
1154 EndSubElement(trace, indent, XMTDump);
1155 }
1156
1157 indent--;
1158 EndDescDump(trace, "ContentIdentificationDescriptor", indent, XMTDump);
1159 return GF_OK;
1160 }
1161
1162
gf_odf_dump_exp_text(GF_ExpandedTextual * etd,FILE * trace,u32 indent,Bool XMTDump)1163 GF_Err gf_odf_dump_exp_text(GF_ExpandedTextual *etd, FILE *trace, u32 indent, Bool XMTDump)
1164 {
1165 u32 i, count;
1166
1167 StartDescDump(trace, "ExpandedTextualDescriptor", indent, XMTDump);
1168 indent++;
1169 DumpInt(trace, "languageCode", etd->langCode, indent, XMTDump);
1170 DumpBool(trace, "isUTF8", etd->isUTF8, indent, XMTDump);
1171 DumpString(trace, "nonItemText", etd->NonItemText, indent, XMTDump);
1172 EndAttributes(trace, indent, XMTDump);
1173
1174 count = gf_list_count(etd->itemDescriptionList);
1175 for (i=0; i<count; i++) {
1176 GF_ETD_ItemText *it1 = (GF_ETD_ItemText *)gf_list_get(etd->itemDescriptionList, i);
1177 GF_ETD_ItemText *it2 = (GF_ETD_ItemText *)gf_list_get(etd->itemTextList, i);
1178 if (!it1 || !it2) break;
1179 StartSubElement(trace, "item", indent, XMTDump);
1180 DumpString(trace, "description", it1->text, indent, XMTDump);
1181 DumpString(trace, "text", it2->text, indent, XMTDump);
1182 EndSubElement(trace, indent, XMTDump);
1183 }
1184 indent--;
1185 EndDescDump(trace, "ExpandedTextualDescriptor", indent, XMTDump);
1186 return GF_OK;
1187 }
1188
gf_odf_dump_pl_ext(GF_PLExt * pld,FILE * trace,u32 indent,Bool XMTDump)1189 GF_Err gf_odf_dump_pl_ext(GF_PLExt *pld, FILE *trace, u32 indent, Bool XMTDump)
1190 {
1191 StartDescDump(trace, "ExtensionProfileLevelDescriptor", indent, XMTDump);
1192 indent++;
1193 DumpInt(trace, "profileLevelIndicationIndex", pld->profileLevelIndicationIndex, indent, XMTDump);
1194 DumpInt(trace, "ODProfileLevelIndication", pld->ODProfileLevelIndication, indent, XMTDump);
1195 DumpInt(trace, "sceneProfileLevelIndication", pld->SceneProfileLevelIndication, indent, XMTDump);
1196 DumpInt(trace, "audioProfileLevelIndication", pld->AudioProfileLevelIndication, indent, XMTDump);
1197 DumpInt(trace, "visualProfileLevelIndication", pld->VisualProfileLevelIndication, indent, XMTDump);
1198 DumpInt(trace, "graphicsProfileLevelIndication", pld->GraphicsProfileLevelIndication, indent, XMTDump);
1199 DumpInt(trace, "MPEGJProfileLevelIndication", pld->MPEGJProfileLevelIndication, indent, XMTDump);
1200 indent--;
1201 EndSubElement(trace, indent, XMTDump);
1202 return GF_OK;
1203 }
1204
gf_odf_dump_ipi_ptr(GF_IPIPtr * ipid,FILE * trace,u32 indent,Bool XMTDump)1205 GF_Err gf_odf_dump_ipi_ptr(GF_IPIPtr *ipid, FILE *trace, u32 indent, Bool XMTDump)
1206 {
1207 StartDescDump(trace, "IPI_DescrPointer", indent, XMTDump);
1208 indent++;
1209 DumpInt(trace, "IPI_ES_Id", ipid->IPI_ES_Id, indent, XMTDump);
1210 indent--;
1211 EndSubElement(trace, indent, XMTDump);
1212 return GF_OK;
1213 }
1214
gf_odf_dump_ipmp(GF_IPMP_Descriptor * ipmp,FILE * trace,u32 indent,Bool XMTDump)1215 GF_Err gf_odf_dump_ipmp(GF_IPMP_Descriptor *ipmp, FILE *trace, u32 indent, Bool XMTDump)
1216 {
1217 u32 i, count;
1218 StartDescDump(trace, "IPMP_Descriptor", indent, XMTDump);
1219 indent++;
1220
1221 DumpIntHex(trace, "IPMP_DescriptorID", ipmp->IPMP_DescriptorID, indent, XMTDump, GF_TRUE);
1222 DumpIntHex(trace, "IPMPS_Type", ipmp->IPMPS_Type, indent, XMTDump, GF_FALSE);
1223
1224
1225 if ((ipmp->IPMP_DescriptorID==0xFF) && (ipmp->IPMPS_Type==0xFFFF)) {
1226 DumpIntHex(trace, "IPMP_DescriptorIDEx", ipmp->IPMP_DescriptorIDEx, indent, XMTDump, GF_FALSE);
1227 /*how the heck do we represent toolID??*/
1228 DumpBin128(trace, "IPMP_ToolID", (char*)ipmp->IPMP_ToolID, indent, XMTDump);
1229 DumpInt(trace, "controlPointCode", ipmp->control_point, indent, XMTDump);
1230 if (ipmp->control_point) DumpInt(trace, "sequenceCode", ipmp->cp_sequence_code, indent, XMTDump);
1231 EndAttributes(trace, indent, XMTDump);
1232 #ifndef GPAC_MINIMAL_ODF
1233 /*parse IPMPX data*/
1234 StartElement(trace, "IPMPX_Data", indent, XMTDump, GF_TRUE);
1235 indent++;
1236 count = gf_list_count(ipmp->ipmpx_data);
1237 for (i=0; i<count; i++) {
1238 GF_IPMPX_Data *p = (GF_IPMPX_Data *)gf_list_get(ipmp->ipmpx_data, i);
1239 gf_ipmpx_dump_data(p, trace, indent, XMTDump);
1240 }
1241 indent--;
1242 EndElement(trace, "IPMPX_Data", indent, XMTDump, GF_TRUE);
1243 #endif
1244 }
1245 else if (!ipmp->IPMPS_Type) {
1246 DumpString(trace, "URLString", ipmp->opaque_data, indent, XMTDump);
1247 } else {
1248 DumpData(trace, "IPMP_data", ipmp->opaque_data, ipmp->opaque_data_size, indent, XMTDump);
1249 }
1250 indent--;
1251 EndDescDump(trace, "IPMP_Descriptor", indent, XMTDump);
1252 return GF_OK;
1253 }
1254
gf_odf_dump_ipmp_ptr(GF_IPMPPtr * ipmpd,FILE * trace,u32 indent,Bool XMTDump)1255 GF_Err gf_odf_dump_ipmp_ptr(GF_IPMPPtr *ipmpd, FILE *trace, u32 indent, Bool XMTDump)
1256 {
1257 StartDescDump(trace, "IPMP_DescriptorPointer", indent, XMTDump);
1258 indent++;
1259 if (ipmpd->IPMP_DescriptorID == 0xFF) {
1260 DumpInt(trace, "IPMP_DescriptorID", 0xFF, indent, XMTDump);
1261 DumpInt(trace, "IPMP_DescriptorIDEx", ipmpd->IPMP_DescriptorIDEx, indent, XMTDump);
1262 DumpInt(trace, "IPMP_ES_ID", ipmpd->IPMP_ES_ID, indent, XMTDump);
1263 } else {
1264 DumpInt(trace, "IPMP_DescriptorID", ipmpd->IPMP_DescriptorID, indent, XMTDump);
1265 }
1266 indent--;
1267 if (XMTDump)
1268 EndSubElement(trace, indent, XMTDump);
1269 else
1270 EndDescDump(trace, "IPMP_DescriptorPointer", indent, XMTDump);
1271 return GF_OK;
1272 }
1273
gf_odf_dump_kw(GF_KeyWord * kwd,FILE * trace,u32 indent,Bool XMTDump)1274 GF_Err gf_odf_dump_kw(GF_KeyWord *kwd, FILE *trace, u32 indent, Bool XMTDump)
1275 {
1276 GF_KeyWordItem *p;
1277 u32 i;
1278
1279 StartDescDump(trace, "KeyWordDescriptor", indent, XMTDump);
1280 indent++;
1281 DumpInt(trace, "languageCode", kwd->languageCode, indent, XMTDump);
1282 DumpBool(trace, "isUTF8", kwd->isUTF8, indent, XMTDump);
1283 EndAttributes(trace, indent, XMTDump);
1284
1285 i=0;
1286 while ((p = (GF_KeyWordItem *)gf_list_enum(kwd->keyWordsList, &i))) {
1287 StartSubElement(trace, "keyWord", indent, XMTDump);
1288 DumpString(trace, "value", p->keyWord, indent, XMTDump);
1289 EndSubElement(trace, indent, XMTDump);
1290 }
1291 indent--;
1292 EndDescDump(trace, "KeyWordDescriptor", indent, XMTDump);
1293 return GF_OK;
1294 }
1295
gf_odf_dump_lang(GF_Language * ld,FILE * trace,u32 indent,Bool XMTDump)1296 GF_Err gf_odf_dump_lang(GF_Language *ld, FILE *trace, u32 indent, Bool XMTDump)
1297 {
1298 char sLan[4];
1299 StartDescDump(trace, "LanguageDescriptor", indent, XMTDump);
1300 indent++;
1301 sLan[0] = (ld->langCode>>16)&0xFF;
1302 sLan[1] = (ld->langCode>>8)&0xFF;
1303 sLan[2] = (ld->langCode)&0xFF;
1304 sLan[3] = 0;
1305 DumpString(trace, "languageCode", sLan, indent, XMTDump);
1306 indent--;
1307 EndSubElement(trace, indent, XMTDump);
1308 if (!XMTDump) EndDescDump(trace, "LanguageDescriptor", indent, XMTDump);
1309 return GF_OK;
1310 }
1311 #endif// GPAC_MINIMAL_ODF
1312
gf_odf_dump_aux_vid(GF_AuxVideoDescriptor * ld,FILE * trace,u32 indent,Bool XMTDump)1313 GF_Err gf_odf_dump_aux_vid(GF_AuxVideoDescriptor *ld, FILE *trace, u32 indent, Bool XMTDump)
1314 {
1315 StartDescDump(trace, "AuxiliaryVideoData", indent, XMTDump);
1316 indent++;
1317
1318 DumpIntHex(trace, "aux_video_type", ld->aux_video_type, indent, XMTDump, GF_TRUE);
1319 DumpInt(trace, "position_offset_h", ld->position_offset_h, indent, XMTDump);
1320 DumpInt(trace, "position_offset_v", ld->position_offset_v, indent, XMTDump);
1321 DumpInt(trace, "knear", ld->knear, indent, XMTDump);
1322 DumpInt(trace, "kfar", ld->kfar, indent, XMTDump);
1323 DumpInt(trace, "parallax_zero", ld->parallax_zero, indent, XMTDump);
1324 DumpInt(trace, "parallax_scale", ld->parallax_scale, indent, XMTDump);
1325 DumpInt(trace, "dref", ld->dref, indent, XMTDump);
1326 DumpInt(trace, "wref", ld->wref, indent, XMTDump);
1327 indent--;
1328 EndSubElement(trace, indent, XMTDump);
1329 if (!XMTDump) EndDescDump(trace, "AuxiliaryVideoData", indent, XMTDump);
1330 return GF_OK;
1331 }
1332
gf_odf_dump_isom_iod(GF_IsomInitialObjectDescriptor * iod,FILE * trace,u32 indent,Bool XMTDump)1333 GF_Err gf_odf_dump_isom_iod(GF_IsomInitialObjectDescriptor *iod, FILE *trace, u32 indent, Bool XMTDump)
1334 {
1335
1336
1337 StartDescDump(trace, "MP4InitialObjectDescriptor", indent, XMTDump);
1338 indent++;
1339
1340 StartAttribute(trace, "objectDescriptorID", indent, XMTDump);
1341
1342
1343 if (XMTDump) {
1344 gf_fprintf(trace, "od%d", iod->objectDescriptorID);
1345 EndAttribute(trace, indent, XMTDump);
1346 DumpInt(trace, "binaryID", iod->objectDescriptorID, indent, XMTDump);
1347 } else {
1348 gf_fprintf(trace, "%d", iod->objectDescriptorID);
1349 EndAttribute(trace, indent, XMTDump);
1350 }
1351
1352 EndAttributes(trace, indent, XMTDump);
1353
1354
1355 StartSubElement(trace, "Profile", indent, GF_TRUE);
1356
1357 DumpInt(trace, "audioProfileLevelIndication", iod->audio_profileAndLevel, indent, XMTDump);
1358 DumpInt(trace, "visualProfileLevelIndication", iod->visual_profileAndLevel, indent, XMTDump);
1359 DumpInt(trace, "sceneProfileLevelIndication", iod->scene_profileAndLevel, indent, XMTDump);
1360 DumpInt(trace, "graphicsProfileLevelIndication", iod->graphics_profileAndLevel, indent, XMTDump);
1361 DumpInt(trace, "ODProfileLevelIndication", iod->OD_profileAndLevel, indent, XMTDump);
1362 DumpBool(trace, "includeInlineProfileLevelFlag", iod->inlineProfileFlag, indent, XMTDump);
1363
1364 EndSubElement(trace, indent, XMTDump);
1365
1366 if (iod->URLString) {
1367 StartSubElement(trace, "URL", indent, XMTDump);
1368 DumpString(trace, "URLstring", iod->URLString, indent, XMTDump);
1369 EndSubElement(trace, indent, XMTDump);
1370 }
1371
1372 if (XMTDump) {
1373 StartElement(trace, "Descr", indent, XMTDump, GF_TRUE);
1374 indent++;
1375 }
1376 //ESDescr
1377 if (gf_list_count(iod->ES_ID_IncDescriptors)) {
1378 DumpDescList(iod->ES_ID_IncDescriptors, trace, indent, "esDescrInc", XMTDump, GF_FALSE);
1379 } else {
1380 DumpDescList(iod->ES_ID_RefDescriptors, trace, indent, "esDescrRef", XMTDump, GF_FALSE);
1381 }
1382 DumpDescList(iod->OCIDescriptors, trace, indent, "ociDescr", XMTDump, GF_FALSE);
1383 DumpDescListFilter(iod->IPMP_Descriptors, trace, indent, "ipmpDescrPtr", XMTDump, GF_ODF_IPMP_PTR_TAG);
1384 DumpDescListFilter(iod->IPMP_Descriptors, trace, indent, "ipmpDescr", XMTDump, GF_ODF_IPMP_TAG);
1385
1386 DumpDescList(iod->extensionDescriptors, trace, indent, "extDescr", XMTDump, GF_FALSE);
1387
1388 if (iod->IPMPToolList) {
1389 StartElement(trace, "toolListDescr" , indent, XMTDump, GF_FALSE);
1390 gf_odf_dump_desc((GF_Descriptor*)iod->IPMPToolList, trace, indent + (XMTDump ? 1 : 0), XMTDump);
1391 EndElement(trace, "toolListDescr" , indent, XMTDump, GF_FALSE);
1392 }
1393
1394 if (XMTDump) {
1395 indent--;
1396 EndElement(trace, "Descr", indent, XMTDump, GF_TRUE);
1397 }
1398 indent--;
1399 EndDescDump(trace, "MP4InitialObjectDescriptor", indent, XMTDump);
1400 return GF_OK;
1401 }
1402
gf_odf_dump_od(GF_ObjectDescriptor * od,FILE * trace,u32 indent,Bool XMTDump)1403 GF_Err gf_odf_dump_od(GF_ObjectDescriptor *od, FILE *trace, u32 indent, Bool XMTDump)
1404 {
1405 StartDescDump(trace, "ObjectDescriptor", indent, XMTDump);
1406 indent++;
1407 StartAttribute(trace, "objectDescriptorID", indent, XMTDump);
1408 if (XMTDump) {
1409 gf_fprintf(trace, "od%d", od->objectDescriptorID);
1410 EndAttribute(trace, indent, XMTDump);
1411 DumpInt(trace, "binaryID", od->objectDescriptorID, indent, XMTDump);
1412 } else {
1413 gf_fprintf(trace, "%d", od->objectDescriptorID);
1414 EndAttribute(trace, indent, XMTDump);
1415 }
1416 EndAttributes(trace, indent, XMTDump);
1417 if (od->URLString) {
1418 StartSubElement(trace, "URL", indent, XMTDump);
1419 DumpString(trace, "URLstring", od->URLString, indent, XMTDump);
1420 EndSubElement(trace, indent, XMTDump);
1421 }
1422
1423 if (XMTDump) {
1424 StartElement(trace, "Descr", indent, XMTDump, GF_TRUE);
1425 indent++;
1426 }
1427 //ESDescr
1428 DumpDescList(od->ESDescriptors, trace, indent, "esDescr", XMTDump, GF_FALSE);
1429 DumpDescList(od->OCIDescriptors, trace, indent, "ociDescr", XMTDump, GF_FALSE);
1430 DumpDescListFilter(od->IPMP_Descriptors, trace, indent, "ipmpDescrPtr", XMTDump, GF_ODF_IPMP_PTR_TAG);
1431 DumpDescListFilter(od->IPMP_Descriptors, trace, indent, "ipmpDescr", XMTDump, GF_ODF_IPMP_TAG);
1432
1433 DumpDescList(od->extensionDescriptors, trace, indent, "extDescr", XMTDump, GF_FALSE);
1434
1435 if (XMTDump) {
1436 indent--;
1437 EndElement(trace, "Descr", indent, XMTDump, GF_TRUE);
1438 }
1439 indent--;
1440 EndDescDump(trace, "ObjectDescriptor", indent, XMTDump);
1441 return GF_OK;
1442 }
1443
gf_odf_dump_isom_od(GF_IsomObjectDescriptor * od,FILE * trace,u32 indent,Bool XMTDump)1444 GF_Err gf_odf_dump_isom_od(GF_IsomObjectDescriptor *od, FILE *trace, u32 indent, Bool XMTDump)
1445 {
1446 StartDescDump(trace, "MP4ObjectDescriptor", indent, XMTDump);
1447 indent++;
1448 StartAttribute(trace, "objectDescriptorID", indent, XMTDump);
1449 if (XMTDump) {
1450 gf_fprintf(trace, "od%d", od->objectDescriptorID);
1451 EndAttribute(trace, indent, XMTDump);
1452 DumpInt(trace, "binaryID", od->objectDescriptorID, indent, XMTDump);
1453 } else {
1454 gf_fprintf(trace, "%d", od->objectDescriptorID);
1455 EndAttribute(trace, indent, XMTDump);
1456 }
1457 EndAttributes(trace, indent, XMTDump);
1458 if (od->URLString) {
1459 StartSubElement(trace, "URL", indent, XMTDump);
1460 DumpString(trace, "URLstring", od->URLString, indent, XMTDump);
1461 EndSubElement(trace, indent, XMTDump);
1462 }
1463
1464 if (XMTDump) {
1465 StartElement(trace, "Descr", indent, XMTDump, GF_TRUE);
1466 indent++;
1467 }
1468 //ESDescr
1469 if (gf_list_count(od->ES_ID_IncDescriptors)) {
1470 DumpDescList(od->ES_ID_IncDescriptors, trace, indent, "esDescrInc", XMTDump, GF_FALSE);
1471 } else {
1472 DumpDescList(od->ES_ID_RefDescriptors, trace, indent, "esDescrRef", XMTDump, GF_FALSE);
1473 }
1474 DumpDescList(od->OCIDescriptors, trace, indent, "ociDescr", XMTDump, GF_FALSE);
1475 DumpDescListFilter(od->IPMP_Descriptors, trace, indent, "ipmpDescrPtr", XMTDump, GF_ODF_IPMP_PTR_TAG);
1476 DumpDescListFilter(od->IPMP_Descriptors, trace, indent, "ipmpDescr", XMTDump, GF_ODF_IPMP_TAG);
1477 DumpDescList(od->extensionDescriptors, trace, indent, "extDescr", XMTDump, GF_FALSE);
1478
1479 if (XMTDump) {
1480 indent--;
1481 EndElement(trace, "Descr", indent, XMTDump, GF_TRUE);
1482 }
1483 indent--;
1484 EndDescDump(trace, "MP4ObjectDescriptor", indent, XMTDump);
1485 return GF_OK;
1486 }
1487
1488 #ifndef GPAC_MINIMAL_ODF
gf_odf_dump_oci_date(GF_OCI_Data * ocd,FILE * trace,u32 indent,Bool XMTDump)1489 GF_Err gf_odf_dump_oci_date(GF_OCI_Data *ocd, FILE *trace, u32 indent, Bool XMTDump)
1490 {
1491 StartDescDump(trace, "OCICreationDateDescriptor", indent, XMTDump);
1492 indent++;
1493 DumpString(trace, "OCICreationDate", ocd->OCICreationDate, indent, XMTDump);
1494 indent--;
1495 EndSubElement(trace, indent, XMTDump);
1496 return GF_OK;
1497 }
1498
gf_odf_dump_oci_name(GF_OCICreators * ocn,FILE * trace,u32 indent,Bool XMTDump)1499 GF_Err gf_odf_dump_oci_name(GF_OCICreators *ocn, FILE *trace, u32 indent, Bool XMTDump)
1500 {
1501 GF_OCICreator_item *p;
1502 u32 i;
1503
1504 StartDescDump(trace, "OCICreatorNameDescriptor", indent, XMTDump);
1505 indent++;
1506 i=0;
1507 while ((p = (GF_OCICreator_item *)gf_list_enum(ocn->OCICreators, &i))) {
1508 StartSubElement(trace, "Creator", indent, XMTDump);
1509 DumpInt(trace, "languageCode", p->langCode, indent, XMTDump);
1510 DumpBool(trace, "isUTF8", p->isUTF8, indent, XMTDump);
1511 DumpString(trace, "name", p->OCICreatorName, indent, XMTDump);
1512 EndSubElement(trace, indent, XMTDump);
1513 }
1514 indent--;
1515 EndDescDump(trace, "OCICreatorNameDescriptor", indent, XMTDump);
1516 return GF_OK;
1517 }
1518
gf_odf_dump_pl_idx(GF_PL_IDX * plid,FILE * trace,u32 indent,Bool XMTDump)1519 GF_Err gf_odf_dump_pl_idx(GF_PL_IDX *plid, FILE *trace, u32 indent, Bool XMTDump)
1520 {
1521 StartDescDump(trace, "ProfileLevelIndicationIndexDescriptor", indent, XMTDump);
1522 indent++;
1523 DumpInt(trace, "profileLevelIndicationIndex", plid->profileLevelIndicationIndex, indent, XMTDump);
1524 indent--;
1525 EndSubElement(trace, indent, XMTDump);
1526 return GF_OK;
1527 }
1528
gf_odf_dump_qos(GF_QoS_Descriptor * qos,FILE * trace,u32 indent,Bool XMTDump)1529 GF_Err gf_odf_dump_qos(GF_QoS_Descriptor *qos, FILE *trace, u32 indent, Bool XMTDump)
1530 {
1531 StartDescDump(trace, "QoS_Descriptor", indent, XMTDump);
1532 indent++;
1533
1534 if (qos->predefined) {
1535 StartSubElement(trace, "predefined", indent, XMTDump);
1536 DumpInt(trace, "value", qos->predefined, indent, XMTDump);
1537 EndSubElement(trace, indent, XMTDump);
1538 } else {
1539 u32 i=0;
1540 GF_QoS_Default *p;
1541 while ((p = (GF_QoS_Default *)gf_list_enum(qos->QoS_Qualifiers, &i))) {
1542 switch (p->tag) {
1543 case QoSMaxDelayTag:
1544 StartSubElement(trace, "QoSMaxDelay", indent, XMTDump);
1545 DumpInt(trace, "value", ((GF_QoS_MaxDelay *)p)->MaxDelay, indent, XMTDump);
1546 EndSubElement(trace, indent, XMTDump);
1547 break;
1548 case QoSPrefMaxDelayTag:
1549 StartSubElement(trace, "QoSPrefMaxDelay", indent, XMTDump);
1550 DumpInt(trace, "value", ((GF_QoS_PrefMaxDelay *)p)->PrefMaxDelay, indent, XMTDump);
1551 EndSubElement(trace, indent, XMTDump);
1552 break;
1553 case QoSLossProbTag:
1554 StartSubElement(trace, "QoSLossProb", indent, XMTDump);
1555 DumpFloat(trace, "value", ((GF_QoS_LossProb *)p)->LossProb, indent, XMTDump);
1556 EndSubElement(trace, indent, XMTDump);
1557 break;
1558 case QoSMaxGapLossTag:
1559 StartSubElement(trace, "QoSMaxGapLoss", indent, XMTDump);
1560 DumpInt(trace, "value", ((GF_QoS_MaxGapLoss *)p)->MaxGapLoss, indent, XMTDump);
1561 EndSubElement(trace, indent, XMTDump);
1562 break;
1563 case QoSMaxAUSizeTag:
1564 StartSubElement(trace, "QoSMaxAUSize", indent, XMTDump);
1565 DumpInt(trace, "value", ((GF_QoS_MaxAUSize *)p)->MaxAUSize, indent, XMTDump);
1566 EndSubElement(trace, indent, XMTDump);
1567 break;
1568 case QoSAvgAUSizeTag:
1569 StartSubElement(trace, "QoSAvgAUSize", indent, XMTDump);
1570 DumpInt(trace, "value", ((GF_QoS_AvgAUSize *)p)->AvgAUSize, indent, XMTDump);
1571 EndSubElement(trace, indent, XMTDump);
1572 break;
1573 case QoSMaxAURateTag:
1574 StartSubElement(trace, "QoSMaxAURate", indent, XMTDump);
1575 DumpInt(trace, "value", ((GF_QoS_MaxAURate *)p)->MaxAURate, indent, XMTDump);
1576 EndSubElement(trace, indent, XMTDump);
1577 break;
1578 default:
1579 StartSubElement(trace, "QoSCustom", indent, XMTDump);
1580 DumpInt(trace, "tag", p->tag, indent, XMTDump);
1581 DumpData(trace, "customData", ((GF_QoS_Private *)p)->Data, ((GF_QoS_Private *)p)->DataLength, indent, XMTDump);
1582 EndSubElement(trace, indent, XMTDump);
1583 break;
1584 }
1585 }
1586 }
1587 indent--;
1588 EndDescDump(trace, "QoS_Descriptor", indent, XMTDump);
1589 return GF_OK;
1590 }
1591
gf_odf_dump_rating(GF_Rating * rd,FILE * trace,u32 indent,Bool XMTDump)1592 GF_Err gf_odf_dump_rating(GF_Rating *rd, FILE *trace, u32 indent, Bool XMTDump)
1593 {
1594 StartDescDump(trace, "RatingDescriptor", indent, XMTDump);
1595 indent++;
1596 DumpInt(trace, "ratingEntity", rd->ratingEntity, indent, XMTDump);
1597 DumpInt(trace, "ratingCriteria", rd->ratingCriteria, indent, XMTDump);
1598 DumpData(trace, "ratingInfo", rd->ratingInfo, rd->infoLength, indent, XMTDump);
1599 indent--;
1600 EndSubElement(trace, indent, XMTDump);
1601 return GF_OK;
1602 }
1603
gf_odf_dump_reg(GF_Registration * reg,FILE * trace,u32 indent,Bool XMTDump)1604 GF_Err gf_odf_dump_reg(GF_Registration *reg, FILE *trace, u32 indent, Bool XMTDump)
1605 {
1606 StartDescDump(trace, "RegistrationDescriptor", indent, XMTDump);
1607 indent++;
1608 DumpInt(trace, "formatIdentifier", reg->formatIdentifier, indent, XMTDump);
1609 DumpData(trace, "additionalIdentificationInfo", reg->additionalIdentificationInfo, reg->dataLength, indent, XMTDump);
1610 indent--;
1611 EndSubElement(trace, indent, XMTDump);
1612 return GF_OK;
1613 }
1614
gf_odf_dump_short_text(GF_ShortTextual * std,FILE * trace,u32 indent,Bool XMTDump)1615 GF_Err gf_odf_dump_short_text(GF_ShortTextual *std, FILE *trace, u32 indent, Bool XMTDump)
1616 {
1617 StartDescDump(trace, "ShortTextualDescriptor", indent, XMTDump);
1618 indent++;
1619 DumpInt(trace, "languageCode", std->langCode, indent, XMTDump);
1620 DumpBool(trace, "isUTF8", std->isUTF8, indent, XMTDump);
1621 EndAttributes(trace, indent, XMTDump);
1622 StartSubElement(trace, "event", indent, XMTDump);
1623 DumpString(trace, "name", std->eventName, indent, XMTDump);
1624 DumpString(trace, "text", std->eventText, indent, XMTDump);
1625 EndSubElement(trace, indent, XMTDump);
1626 indent--;
1627 EndDescDump(trace, "ShortTextualDescriptor", indent, XMTDump);
1628 return GF_OK;
1629 }
1630
gf_odf_dump_smpte_camera(GF_SMPTECamera * cpd,FILE * trace,u32 indent,Bool XMTDump)1631 GF_Err gf_odf_dump_smpte_camera(GF_SMPTECamera *cpd, FILE *trace, u32 indent, Bool XMTDump)
1632 {
1633 GF_SmpteParam *p;
1634 u32 i;
1635
1636 StartDescDump(trace, "SMPTECameraPositionDescriptor", indent, XMTDump);
1637 indent++;
1638 DumpInt(trace, "cameraID", cpd->cameraID, indent, XMTDump);
1639 EndAttributes(trace, indent, XMTDump);
1640
1641 i=0;
1642 while ((p = (GF_SmpteParam *)gf_list_enum(cpd->ParamList, &i))) {
1643 StartSubElement(trace, "parameter", indent, XMTDump);
1644 DumpInt(trace, "id", p->paramID, indent, XMTDump);
1645 DumpInt(trace, "value", p->param, indent, XMTDump);
1646 EndSubElement(trace, indent, XMTDump);
1647 }
1648 indent--;
1649 EndDescDump(trace, "SMPTECameraPositionDescriptor", indent, XMTDump);
1650 return GF_OK;
1651 }
1652
gf_odf_dump_sup_cid(GF_SCIDesc * scid,FILE * trace,u32 indent,Bool XMTDump)1653 GF_Err gf_odf_dump_sup_cid(GF_SCIDesc *scid, FILE *trace, u32 indent, Bool XMTDump)
1654 {
1655 StartDescDump(trace, "SupplementaryContentIdentification", indent, XMTDump);
1656 indent++;
1657 DumpInt(trace, "languageCode", scid->languageCode, indent, XMTDump);
1658 DumpString(trace, "supplContentIdentiferTitle", scid->supplContentIdentifierTitle, indent, XMTDump);
1659 DumpString(trace, "supplContentIdentiferValue", scid->supplContentIdentifierValue, indent, XMTDump);
1660 indent--;
1661 EndSubElement(trace, indent, XMTDump);
1662 return GF_OK;
1663 }
1664
1665
gf_odf_dump_segment(GF_Segment * sd,FILE * trace,u32 indent,Bool XMTDump)1666 GF_Err gf_odf_dump_segment(GF_Segment *sd, FILE *trace, u32 indent, Bool XMTDump)
1667 {
1668 StartDescDump(trace, "SegmentDescriptor", indent, XMTDump);
1669 indent++;
1670 DumpDouble(trace, "startTime", sd->startTime, indent, XMTDump);
1671 DumpDouble(trace, "duration", sd->Duration, indent, XMTDump);
1672 DumpString(trace, "name", sd->SegmentName, indent, XMTDump);
1673 indent--;
1674 if (XMTDump)
1675 EndSubElement(trace, indent, XMTDump);
1676 else
1677 EndDescDump(trace, "SegmentDescriptor", indent, XMTDump);
1678 return GF_OK;
1679 }
1680
gf_odf_dump_mediatime(GF_MediaTime * mt,FILE * trace,u32 indent,Bool XMTDump)1681 GF_Err gf_odf_dump_mediatime(GF_MediaTime *mt, FILE *trace, u32 indent, Bool XMTDump)
1682 {
1683 StartDescDump(trace, "MediaTimeDescriptor", indent, XMTDump);
1684 indent++;
1685 DumpDouble(trace, "mediaTimestamp ", mt->mediaTimeStamp, indent, XMTDump);
1686 indent--;
1687 EndSubElement(trace, indent, XMTDump);
1688 return GF_OK;
1689 }
1690
1691 #endif //GPAC_MINIMAL_ODF
1692
gf_odf_dump_muxinfo(GF_MuxInfo * mi,FILE * trace,u32 indent,Bool XMTDump)1693 GF_Err gf_odf_dump_muxinfo(GF_MuxInfo *mi, FILE *trace, u32 indent, Bool XMTDump)
1694 {
1695 char *full_path = gf_url_get_absolute_path( mi->file_name, mi->src_url );
1696
1697 if (!XMTDump) {
1698 StartDescDump(trace, "MuxInfo", indent, GF_FALSE);
1699 indent++;
1700 if (full_path) {
1701 DumpString(trace, "fileName", full_path, indent, GF_FALSE);
1702 gf_free(full_path);
1703 } else if (mi->file_name) {
1704 DumpString(trace, "fileName", mi->file_name, indent, GF_FALSE);
1705 }
1706 if (mi->streamFormat) DumpString(trace, "streamFormat", mi->streamFormat, indent, GF_FALSE);
1707 if (mi->GroupID) DumpInt(trace, "GroupID", mi->GroupID, indent, GF_FALSE);
1708 if (mi->startTime) DumpInt(trace, "startTime", mi->startTime, indent, GF_FALSE);
1709 if (mi->duration) DumpInt(trace, "duration", mi->duration, indent, GF_FALSE);
1710 #if 0
1711 if (mi->import_flags & GF_IMPORT_USE_DATAREF) DumpBool(trace, "useDataReference", 1, indent, GF_FALSE);
1712 if (mi->import_flags & GF_IMPORT_NO_FRAME_DROP) DumpBool(trace, "noFrameDrop", 1, indent, GF_FALSE);
1713 if (mi->import_flags & GF_IMPORT_SBR_IMPLICIT) DumpString(trace, "SBR_Type", "implicit", indent, GF_FALSE);
1714 else if (mi->import_flags & GF_IMPORT_SBR_EXPLICIT) DumpString(trace, "SBR_Type", "explicit", indent, GF_FALSE);
1715 #endif
1716
1717 if (mi->textNode) DumpString(trace, "textNode", mi->textNode, indent, GF_FALSE);
1718 if (mi->fontNode) DumpString(trace, "fontNode", mi->fontNode, indent, GF_FALSE);
1719
1720 indent--;
1721 EndDescDump(trace, "MuxInfo", indent, GF_FALSE);
1722 return GF_OK;
1723 }
1724
1725 StartDescDump(trace, "StreamSource", indent, GF_TRUE);
1726 indent++;
1727 if (full_path) {
1728 DumpString(trace, "url", full_path, indent, GF_TRUE);
1729 gf_free(full_path);
1730 } else if (mi->file_name) {
1731 DumpString(trace, "url", mi->file_name, indent, GF_TRUE);
1732 }
1733 EndAttributes(trace, indent, GF_TRUE);
1734
1735 StartDescDump(trace, "MP4MuxHints", indent, GF_TRUE);
1736 if (mi->GroupID) DumpInt(trace, "GroupID", mi->GroupID, indent, GF_TRUE);
1737 if (mi->startTime) DumpInt(trace, "startTime", mi->startTime, indent, GF_TRUE);
1738 if (mi->duration) DumpInt(trace, "duration", mi->duration, indent, GF_TRUE);
1739 #ifndef GPAC_DISABLE_MEDIA_IMPORT
1740 if (mi->import_flags & GF_IMPORT_USE_DATAREF) DumpBool(trace, "useDataReference", 1, indent, GF_TRUE);
1741 if (mi->import_flags & GF_IMPORT_NO_FRAME_DROP) DumpBool(trace, "noFrameDrop", 1, indent, GF_TRUE);
1742 if (mi->import_flags & GF_IMPORT_SBR_IMPLICIT) DumpString(trace, "SBR_Type", "implicit", indent, GF_TRUE);
1743 else if (mi->import_flags & GF_IMPORT_SBR_EXPLICIT) DumpString(trace, "SBR_Type", "explicit", indent, GF_TRUE);
1744 #endif /*GPAC_DISABLE_MEDIA_IMPORT*/
1745
1746 if (mi->textNode) DumpString(trace, "textNode", mi->textNode, indent, GF_TRUE);
1747 if (mi->fontNode) DumpString(trace, "fontNode", mi->fontNode, indent, GF_TRUE);
1748 EndSubElement(trace, indent, GF_TRUE);
1749
1750 indent--;
1751 EndElement(trace, "StreamSource" , indent, GF_TRUE, GF_TRUE);
1752 return GF_OK;
1753 }
1754
1755 #ifndef GPAC_MINIMAL_ODF
gf_odf_dump_ipmp_tool_list(GF_IPMP_ToolList * tl,FILE * trace,u32 indent,Bool XMTDump)1756 GF_Err gf_odf_dump_ipmp_tool_list(GF_IPMP_ToolList *tl, FILE *trace, u32 indent, Bool XMTDump)
1757 {
1758 StartDescDump(trace, "IPMP_ToolListDescriptor", indent, XMTDump);
1759 EndAttributes(trace, indent, XMTDump);
1760 indent++;
1761 DumpDescList(tl->ipmp_tools, trace, indent, "ipmpTool", XMTDump, GF_FALSE);
1762 indent--;
1763 EndDescDump(trace, "IPMP_ToolListDescriptor", indent, XMTDump);
1764 return GF_OK;
1765 }
1766
gf_odf_dump_ipmp_tool(GF_IPMP_Tool * t,FILE * trace,u32 indent,Bool XMTDump)1767 GF_Err gf_odf_dump_ipmp_tool(GF_IPMP_Tool*t, FILE *trace, u32 indent, Bool XMTDump)
1768 {
1769 StartDescDump(trace, "IPMP_Tool", indent, XMTDump);
1770 indent++;
1771 DumpBin128(trace, "IPMP_ToolID", (char*)t->IPMP_ToolID, indent, XMTDump);
1772 if (t->tool_url) DumpString(trace, "ToolURL", t->tool_url, indent, XMTDump);
1773 if (t->toolParamDesc) {
1774 StartElement(trace, "toolParamDesc" , indent, XMTDump, GF_FALSE);
1775 #ifndef GPAC_MINIMAL_ODF
1776 gf_ipmpx_dump_data((GF_IPMPX_Data *)t->toolParamDesc, trace, indent + (XMTDump ? 1 : 0), XMTDump);
1777 #endif
1778 EndElement(trace, "toolParamDesc" , indent, XMTDump, GF_FALSE);
1779 }
1780 EndAttributes(trace, indent, XMTDump);
1781 indent--;
1782 EndDescDump(trace, "IPMP_Tool", indent, XMTDump);
1783 return GF_OK;
1784 }
1785 #endif //GPAC_MINIMAL_ODF
1786
1787
gf_odf_dump_od_update(GF_ODUpdate * com,FILE * trace,u32 indent,Bool XMTDump)1788 GF_Err gf_odf_dump_od_update(GF_ODUpdate *com, FILE *trace, u32 indent, Bool XMTDump)
1789 {
1790 if (XMTDump) {
1791 StartDescDump(trace, "ObjectDescriptorUpdate", indent, XMTDump);
1792 EndAttributes(trace, indent, XMTDump);
1793 indent++;
1794 DumpDescList(com->objectDescriptors, trace, indent+1, "OD", XMTDump, GF_FALSE);
1795 indent--;
1796 EndDescDump(trace, "ObjectDescriptorUpdate", indent, XMTDump);
1797 } else {
1798 DumpDescList(com->objectDescriptors, trace, indent, "UPDATE OD", XMTDump, GF_TRUE);
1799 }
1800 return GF_OK;
1801 }
1802
gf_odf_dump_od_remove(GF_ODRemove * com,FILE * trace,u32 indent,Bool XMTDump)1803 GF_Err gf_odf_dump_od_remove(GF_ODRemove *com, FILE *trace, u32 indent, Bool XMTDump)
1804 {
1805 u32 i;
1806
1807 if (XMTDump) {
1808 StartDescDump(trace, "ObjectDescriptorRemove", indent, XMTDump);
1809 indent++;
1810 StartAttribute(trace, "objectDescriptorId", indent, XMTDump);
1811 } else {
1812 char ind_buf[OD_MAX_TREE];
1813 OD_FORMAT_INDENT(ind_buf, indent);
1814 gf_fprintf(trace, "%sREMOVE OD [", ind_buf);
1815 }
1816 for (i=0; i<com->NbODs; i++) {
1817 if (i) gf_fprintf(trace, " ");
1818 gf_fprintf(trace, "%s%d", XMTDump ? "od" : "", com->OD_ID[i]);
1819 }
1820 if (XMTDump) {
1821 EndAttribute(trace, indent, XMTDump);
1822 indent--;
1823 EndSubElement(trace, indent, XMTDump);
1824 } else {
1825 gf_fprintf(trace, "]\n");
1826 }
1827 return GF_OK;
1828 }
1829
gf_odf_dump_esd_update(GF_ESDUpdate * com,FILE * trace,u32 indent,Bool XMTDump)1830 GF_Err gf_odf_dump_esd_update(GF_ESDUpdate *com, FILE *trace, u32 indent, Bool XMTDump)
1831 {
1832 if (XMTDump) {
1833 StartDescDump(trace, "ES_DescriptorUpdate", indent, XMTDump);
1834 StartAttribute(trace, "objectDescriptorId", indent, XMTDump);
1835 gf_fprintf(trace, "od%d", com->ODID);
1836 EndAttribute(trace, indent, XMTDump);
1837 EndAttributes(trace, indent, XMTDump);
1838 } else {
1839 char ind_buf[OD_MAX_TREE];
1840 OD_FORMAT_INDENT(ind_buf, indent);
1841 gf_fprintf(trace, "%sUPDATE ESD in %d\n", ind_buf, com->ODID);
1842 }
1843 indent++;
1844 DumpDescList(com->ESDescriptors, trace, indent+1, "esDescr", XMTDump, GF_TRUE);
1845 indent--;
1846 if (XMTDump) {
1847 EndDescDump(trace, "ES_DescriptorUpdate", indent, XMTDump);
1848 } else {
1849 gf_fprintf(trace, "\n");
1850 }
1851 return GF_OK;
1852 }
1853
gf_odf_dump_esd_remove(GF_ESDRemove * com,FILE * trace,u32 indent,Bool XMTDump)1854 GF_Err gf_odf_dump_esd_remove(GF_ESDRemove *com, FILE *trace, u32 indent, Bool XMTDump)
1855 {
1856 u32 i;
1857
1858 if (XMTDump) {
1859 StartDescDump(trace, "ES_DescriptorRemove", indent, XMTDump);
1860 StartAttribute(trace, "objectDescriptorId", indent, XMTDump);
1861 gf_fprintf(trace, "od%d", com->ODID);
1862 EndAttribute(trace, indent, XMTDump);
1863 StartAttribute(trace, "ES_ID", indent, XMTDump);
1864 } else {
1865 char ind_buf[OD_MAX_TREE];
1866 OD_FORMAT_INDENT(ind_buf, indent);
1867 gf_fprintf(trace, "%sREMOVE ESD FROM %d [", ind_buf, com->ODID);
1868 }
1869 for (i=0; i<com->NbESDs; i++) {
1870 if (i) gf_fprintf(trace, " ");
1871 if (XMTDump) gf_fprintf(trace, "es");
1872 gf_fprintf(trace, "%d", com->ES_ID[i]);
1873 }
1874 if (XMTDump) {
1875 EndAttribute(trace, indent, XMTDump);
1876 indent--;
1877 EndSubElement(trace, indent, XMTDump);
1878 } else {
1879 gf_fprintf(trace, "]\n");
1880 }
1881 return GF_OK;
1882 }
1883
1884 #ifndef GPAC_MINIMAL_ODF
gf_odf_dump_ipmp_update(GF_IPMPUpdate * com,FILE * trace,u32 indent,Bool XMTDump)1885 GF_Err gf_odf_dump_ipmp_update(GF_IPMPUpdate *com, FILE *trace, u32 indent, Bool XMTDump)
1886 {
1887 if (XMTDump) {
1888 StartDescDump(trace, "IPMP_DescriptorUpdate", indent, XMTDump);
1889 EndAttributes(trace, indent, XMTDump);
1890 indent++;
1891 DumpDescList(com->IPMPDescList, trace, indent+1, "ipmpDesc", XMTDump, GF_FALSE);
1892 indent--;
1893 EndDescDump(trace, "IPMP_DescriptorUpdate", indent, XMTDump);
1894 } else {
1895 DumpDescList(com->IPMPDescList, trace, indent, "UPDATE IPMPD", XMTDump, GF_TRUE);
1896 }
1897 return GF_OK;
1898 }
1899
gf_odf_dump_ipmp_remove(GF_IPMPRemove * com,FILE * trace,u32 indent,Bool XMTDump)1900 GF_Err gf_odf_dump_ipmp_remove(GF_IPMPRemove *com, FILE *trace, u32 indent, Bool XMTDump)
1901 {
1902 u32 i;
1903
1904 StartDescDump(trace, "IPMP_DescriptorRemove", indent, XMTDump);
1905 indent++;
1906
1907 StartAttribute(trace, "IPMP_DescriptorID", indent, XMTDump);
1908 for (i=0; i<com->NbIPMPDs; i++) {
1909 if (i) gf_fprintf(trace, " ");
1910 gf_fprintf(trace, "%d", com->IPMPDescID[i]);
1911 }
1912 EndAttribute(trace, indent, XMTDump);
1913 indent--;
1914 EndSubElement(trace, indent, XMTDump);
1915 return GF_OK;
1916 }
1917
gf_odf_dump_base_command(GF_BaseODCom * com,FILE * trace,u32 indent,Bool XMTDump)1918 GF_Err gf_odf_dump_base_command(GF_BaseODCom *com, FILE *trace, u32 indent, Bool XMTDump)
1919 {
1920 StartDescDump(trace, "BaseODCommand", indent, XMTDump);
1921 indent++;
1922
1923 DumpData(trace, "custom", com->data, com->dataSize, indent, XMTDump);
1924 indent--;
1925 EndSubElement(trace, indent, XMTDump);
1926 return GF_OK;
1927 }
1928
1929
1930 GF_EXPORT
gf_oci_dump_event(OCIEvent * ev,FILE * trace,u32 indent,Bool XMTDump)1931 GF_Err gf_oci_dump_event(OCIEvent *ev, FILE *trace, u32 indent, Bool XMTDump)
1932 {
1933 u8 H, M, S, hS, rien;
1934 u16 evID;
1935 u32 i;
1936
1937 StartDescDump(trace, "OCI_Event", indent, XMTDump);
1938 indent++;
1939 gf_oci_event_get_id(ev, &evID);
1940 DumpInt(trace, "eventID", evID, indent, XMTDump);
1941
1942 gf_oci_event_get_start_time(ev, &H, &M, &S, &hS, &rien);
1943 DumpBool(trace, "absoluteTimeFlag", rien, indent, XMTDump);
1944 StartAttribute(trace, "startingTime", indent, XMTDump);
1945 gf_fprintf(trace, "%d:%d:%d:%d", H, M, S, hS);
1946 EndAttribute(trace, indent, XMTDump);
1947
1948 gf_oci_event_get_duration(ev, &H, &M, &S, &hS);
1949 StartAttribute(trace, "duration", indent, XMTDump);
1950 gf_fprintf(trace, "%d:%d:%d:%d", H, M, S, hS);
1951 EndAttribute(trace, indent, XMTDump);
1952
1953 StartElement(trace, "OCIDescr", indent, XMTDump, GF_TRUE);
1954 for (i=0; i<gf_oci_event_get_desc_count(ev); i++) {
1955 GF_Descriptor *desc = gf_oci_event_get_desc(ev, i);
1956 gf_odf_dump_desc(desc, trace, indent+1, XMTDump);
1957 }
1958 EndElement(trace, "OCIDescr", indent, XMTDump, GF_TRUE);
1959 indent--;
1960 EndDescDump(trace, "OCI_Event", indent, XMTDump);
1961
1962 return GF_OK;
1963 }
1964
1965
1966 GF_EXPORT
gf_oci_dump_au(u8 version,u8 * au,u32 au_length,FILE * trace,u32 indent,Bool XMTDump)1967 GF_Err gf_oci_dump_au(u8 version, u8 *au, u32 au_length, FILE *trace, u32 indent, Bool XMTDump)
1968 {
1969 GF_Err e;
1970 OCICodec *codec = gf_oci_codec_new(0, version);
1971 if (!codec) return GF_BAD_PARAM;
1972
1973 e = gf_oci_codec_decode(codec, au, au_length);
1974
1975 if (!e) {
1976 while (1) {
1977 OCIEvent *ev = gf_oci_codec_get_event(codec);
1978 if (!ev) break;
1979 gf_oci_dump_event(ev, trace, indent, XMTDump);
1980 }
1981 }
1982 gf_oci_codec_del(codec);
1983 return e;
1984 }
1985
1986 #endif /*GPAC_MINIMAL_ODF*/
1987
1988 #endif /*GPAC_DISABLE_OD_DUMP*/
1989