* modules/demux/mp4/*: added FOURCC_dvc (DV - NTSC), FOURCC_dvp (DV - PAL)
[vlc.git] / modules / demux / mp4 / libmp4.h
1 /*****************************************************************************
2  * libmp4.h : LibMP4 library for mp4 module for vlc
3  *****************************************************************************
4  * Copyright (C) 2001 VideoLAN
5  * $Id: libmp4.h,v 1.6 2003/02/18 23:34:14 gbazin Exp $
6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
7  * 
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  * 
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
21  *****************************************************************************/
22
23 #define FOURCC_uuid VLC_FOURCC( 'u', 'u', 'i', 'd' )
24
25 #define FOURCC_ftyp VLC_FOURCC( 'f', 't', 'y', 'p' )
26 #define FOURCC_moov VLC_FOURCC( 'm', 'o', 'o', 'v' )
27 #define FOURCC_cmov VLC_FOURCC( 'c', 'm', 'o', 'v' )
28 #define FOURCC_dcom VLC_FOURCC( 'd', 'c', 'o', 'm' )
29 #define FOURCC_cmvd VLC_FOURCC( 'c', 'm', 'v', 'd' )
30     
31 #define FOURCC_moof VLC_FOURCC( 'm', 'o', 'o', 'f' )
32 #define FOURCC_mdat VLC_FOURCC( 'm', 'd', 'a', 't' )
33 #define FOURCC_skip VLC_FOURCC( 's', 'k', 'i', 'p' )
34 #define FOURCC_free VLC_FOURCC( 'f', 'r', 'e', 'e' )
35 #define FOURCC_udta VLC_FOURCC( 'u', 'd', 't', 'a' )
36 #define FOURCC_wide VLC_FOURCC( 'w', 'i', 'd', 'e' )
37
38 #define FOURCC_trak VLC_FOURCC( 't', 'r', 'a', 'k' )
39 #define FOURCC_mvhd VLC_FOURCC( 'm', 'v', 'h', 'd' )
40 #define FOURCC_tkhd VLC_FOURCC( 't', 'k', 'h', 'd' )
41 #define FOURCC_tref VLC_FOURCC( 't', 'r', 'e', 'f' )
42 #define FOURCC_mdia VLC_FOURCC( 'm', 'd', 'i', 'a' )
43 #define FOURCC_mdhd VLC_FOURCC( 'm', 'd', 'h', 'd' )
44 #define FOURCC_hdlr VLC_FOURCC( 'h', 'd', 'l', 'r' )
45 #define FOURCC_minf VLC_FOURCC( 'm', 'i', 'n', 'f' )
46 #define FOURCC_vmhd VLC_FOURCC( 'v', 'm', 'h', 'd' )
47 #define FOURCC_smhd VLC_FOURCC( 's', 'm', 'h', 'd' )
48 #define FOURCC_hmhd VLC_FOURCC( 'h', 'm', 'h', 'd' )
49 #define FOURCC_dinf VLC_FOURCC( 'd', 'i', 'n', 'f' )
50 #define FOURCC_url  VLC_FOURCC( 'u', 'r', 'l', ' ' )
51 #define FOURCC_urn  VLC_FOURCC( 'u', 'r', 'n', ' ' )
52 #define FOURCC_dref VLC_FOURCC( 'd', 'r', 'e', 'f' )
53 #define FOURCC_stbl VLC_FOURCC( 's', 't', 'b', 'l' )
54 #define FOURCC_stts VLC_FOURCC( 's', 't', 't', 's' )
55 #define FOURCC_ctts VLC_FOURCC( 'c', 't', 't', 's' )
56 #define FOURCC_stsd VLC_FOURCC( 's', 't', 's', 'd' )
57 #define FOURCC_stsz VLC_FOURCC( 's', 't', 's', 'z' )
58 #define FOURCC_stz2 VLC_FOURCC( 's', 't', 'z', '2' )
59 #define FOURCC_stsc VLC_FOURCC( 's', 't', 's', 'c' )
60 #define FOURCC_stco VLC_FOURCC( 's', 't', 'c', 'o' )
61 #define FOURCC_co64 VLC_FOURCC( 'c', 'o', '6', '4' )
62 #define FOURCC_stss VLC_FOURCC( 's', 't', 's', 's' )
63 #define FOURCC_stsh VLC_FOURCC( 's', 't', 's', 'h' )
64 #define FOURCC_stdp VLC_FOURCC( 's', 't', 'd', 'p' )
65 #define FOURCC_padb VLC_FOURCC( 'p', 'a', 'd', 'b' )
66 #define FOURCC_edts VLC_FOURCC( 'e', 'd', 't', 's' )
67 #define FOURCC_elst VLC_FOURCC( 'e', 'l', 's', 't' )
68 #define FOURCC_udta VLC_FOURCC( 'u', 'd', 't', 'a' )
69 #define FOURCC_mvex VLC_FOURCC( 'm', 'v', 'e', 'x' )
70 #define FOURCC_trex VLC_FOURCC( 't', 'r', 'e', 'x' )
71 #define FOURCC_mfhd VLC_FOURCC( 'm', 'f', 'h', 'd' )
72 #define FOURCC_traf VLC_FOURCC( 't', 'r', 'a', 'f' )
73 #define FOURCC_tfhd VLC_FOURCC( 't', 'f', 'h', 'd' )
74 #define FOURCC_trun VLC_FOURCC( 't', 'r', 'u', 'n' )
75 #define FOURCC_cprt VLC_FOURCC( 'c', 'p', 'r', 't' )
76 #define FOURCC_iods VLC_FOURCC( 'i', 'o', 'd', 's' )
77
78 #define FOURCC_nmhd VLC_FOURCC( 'n', 'm', 'h', 'd' )
79 #define FOURCC_mp4v VLC_FOURCC( 'm', 'p', '4', 'v' )
80 #define FOURCC_mp4a VLC_FOURCC( 'm', 'p', '4', 'a' )
81 #define FOURCC_mp4s VLC_FOURCC( 'm', 'p', '4', 's' )
82 #define FOURCC_vide VLC_FOURCC( 'v', 'i', 'd', 'e' )
83 #define FOURCC_soun VLC_FOURCC( 's', 'o', 'u', 'n' )
84 #define FOURCC_hint VLC_FOURCC( 'h', 'i', 'n', 't' )
85     
86 #define FOURCC_dpnd VLC_FOURCC( 'd', 'p', 'n', 'd' )
87 #define FOURCC_ipir VLC_FOURCC( 'i', 'p', 'i', 'r' )
88 #define FOURCC_mpod VLC_FOURCC( 'm', 'p', 'o', 'd' )
89 #define FOURCC_hnti VLC_FOURCC( 'h', 'n', 't', 'i' )
90 #define FOURCC_rtp  VLC_FOURCC( 'r', 't', 'p', ' ' )
91
92 #define FOURCC_isom VLC_FOURCC( 'i', 's', 'o', 'm' )
93 #define FOURCC_esds VLC_FOURCC( 'e', 's', 'd', 's' )
94
95 #define FOURCC_zlib VLC_FOURCC( 'z', 'l', 'i', 'b' )
96 #define FOURCC_SVQ1 VLC_FOURCC( 'S', 'V', 'Q', '1' )
97 #define FOURCC__mp3 VLC_FOURCC( '.', 'm', 'p', '3' )
98 #define FOURCC_ms55 VLC_FOURCC( 'm', 's', 0x0, 0x55 )
99 #define FOURCC_3IV1 VLC_FOURCC( '3', 'I', 'V', '1' )
100 #define FOURCC_3IV2 VLC_FOURCC( '3', 'I', 'V', '2' )
101 #define FOURCC_h263 VLC_FOURCC( 'h', '2', '6', '3' )
102 #define FOURCC_DIVX VLC_FOURCC( 'D', 'I', 'V', 'X' )
103 #define FOURCC_cvid VLC_FOURCC( 'c', 'v', 'i', 'd' )
104 #define FOURCC_mjpa VLC_FOURCC( 'm', 'j', 'p', 'a' )
105 #define FOURCC_mjpb VLC_FOURCC( 'm', 'j', 'q', 't' )
106 #define FOURCC_mjqt VLC_FOURCC( 'm', 'j', 'h', 't' )
107 #define FOURCC_mjht VLC_FOURCC( 'm', 'j', 'p', 'b' )
108 #define FOURCC_dvc  VLC_FOURCC( 'd', 'v', 'c', ' ' )
109 #define FOURCC_dvp  VLC_FOURCC( 'd', 'v', 'p', ' ' )
110 #define FOURCC_twos VLC_FOURCC( 't', 'w', 'o', 's' )
111
112 #define FOURCC_jpeg VLC_FOURCC( 'j', 'p', 'e', 'g' )
113
114
115 #define FOURCC_rmra VLC_FOURCC( 'r', 'm', 'r', 'a' )
116 #define FOURCC_rmda VLC_FOURCC( 'r', 'm', 'd', 'a' )
117 #define FOURCC_rdrf VLC_FOURCC( 'r', 'd', 'r', 'f' )
118 #define FOURCC_rmdr VLC_FOURCC( 'r', 'm', 'd', 'r' )
119 #define FOURCC_rmvc VLC_FOURCC( 'r', 'm', 'v', 'c' )
120 #define FOURCC_rmcd VLC_FOURCC( 'r', 'm', 'c', 'd' )
121 #define FOURCC_rmqu VLC_FOURCC( 'r', 'm', 'q', 'u' )
122 #define FOURCC_alis VLC_FOURCC( 'a', 'l', 'i', 's' )
123
124 /* Do you want some debug information on all read boxes ? */
125 #define MP4_VERBOSE  1
126
127 /* memory stream and file stream object */
128
129 typedef struct MP4_Stream_s
130 {
131     int     b_memory;   /* do we uses a memory buffer */
132
133     input_thread_t *p_input;
134     
135     off_t   i_start; /* in the buffer position for memory stream */
136     off_t   i_stop;
137     uint8_t *p_buffer;
138
139 } MP4_Stream_t;
140     
141 struct MP4_Box_s;
142
143
144 /* uuid Universal Unique IDentifiers */
145 typedef struct UUID_s 
146 {
147     uint8_t b[16];
148 } UUID_t;
149
150 /* specific structure for all boxes */
151
152 typedef struct MP4_Box_data_ftyp_s
153 {
154     uint32_t i_major_brand;
155     uint32_t i_minor_version;
156
157     uint32_t i_compatible_brands_count;
158     uint32_t *i_compatible_brands;
159
160 } MP4_Box_data_ftyp_t;
161
162 typedef struct MP4_Box_data_mvhd_s
163 {
164     uint8_t  i_version;
165     uint32_t i_flags;
166         
167     uint64_t i_creation_time;
168     uint64_t i_modification_time;
169     uint32_t i_timescale;
170     uint64_t i_duration;
171
172     int32_t  i_rate;
173     int16_t  i_volume;
174     int16_t  i_reserved1;
175     uint32_t i_reserved2[2];
176     int32_t  i_matrix[9];
177     uint32_t i_predefined[6];
178     uint32_t i_next_track_id;
179
180 } MP4_Box_data_mvhd_t;
181
182 #define MP4_TRACK_ENABLED    0x000001
183 #define MP4_TRACK_IN_MOVIE   0x000002
184 #define MP4_TRACK_IN_PREVIEW 0x000004
185 typedef struct MP4_Box_data_tkhd_s
186 {
187     uint8_t  i_version;
188     uint32_t i_flags;
189         
190     uint64_t i_creation_time;
191     uint64_t i_modification_time;
192     uint32_t i_track_ID;
193     uint32_t i_reserved;
194     uint64_t i_duration;
195     
196     uint32_t i_reserved2[2];
197     int16_t  i_layer;
198     int16_t  i_predefined;
199     
200     int16_t  i_volume;
201     uint16_t i_reserved3;
202     int32_t  i_matrix[9];
203     int32_t  i_width;
204     int32_t  i_height;
205     
206 } MP4_Box_data_tkhd_t;
207
208 typedef struct MP4_Box_data_mdhd_s
209 {
210     uint8_t  i_version;
211     uint32_t i_flags;
212         
213     uint64_t i_creation_time;
214     uint64_t i_modification_time;
215     uint32_t i_timescale;
216     uint64_t i_duration;
217
218     /* one bit for pad */
219     /* unsigned int(5)[3] language difference with 0x60*/
220     unsigned char i_language[3]; 
221     uint16_t i_predefined;
222
223 } MP4_Box_data_mdhd_t;
224
225 typedef struct MP4_Box_data_hdlr_s
226 {
227     uint8_t  i_version;
228     uint32_t i_flags;
229     
230     uint32_t i_predefined;
231     uint32_t i_handler_type; /* "vide" "soun" "hint" "odsm" 
232                            "crsm" "sdsm" "m7sm" "ocsm" 
233                            "ipsm" "mjsm" */
234     
235     unsigned char *psz_name; /* in UTF-8 */
236
237 } MP4_Box_data_hdlr_t;
238
239 typedef struct MP4_Box_data_vmhd_s
240 {
241     uint8_t  i_version;
242     uint32_t i_flags;
243     
244     int16_t  i_graphics_mode;
245     int16_t  i_opcolor[3];    
246
247 } MP4_Box_data_vmhd_t;
248
249 typedef struct MP4_Box_data_smhd_s
250 {
251     uint8_t  i_version;
252     uint32_t i_flags;
253     
254     int16_t  i_balance;
255     int16_t  i_reserved;
256
257 } MP4_Box_data_smhd_t;
258
259 typedef struct MP4_Box_data_hmhd_s
260 {
261     uint8_t  i_version;
262     uint32_t i_flags;
263        
264     uint16_t i_max_PDU_size;
265     uint16_t i_avg_PDU_size;
266     uint32_t i_max_bitrate;
267     uint32_t i_avg_bitrate;
268     uint32_t i_reserved;
269
270 } MP4_Box_data_hmhd_t;
271
272 typedef struct MP4_Box_data_url_s
273 {
274     uint8_t  i_version;
275     uint32_t i_flags;
276     
277     unsigned char *psz_location;
278     
279 } MP4_Box_data_url_t;
280
281 typedef struct MP4_Box_data_urn_s
282 {
283     uint8_t  i_version;
284     uint32_t i_flags;
285
286     unsigned char *psz_name;
287     unsigned char *psz_location;
288     
289 } MP4_Box_data_urn_t;
290
291 typedef struct MP4_Box_data_dref_s
292 {
293     uint8_t  i_version;
294     uint32_t i_flags;
295
296     uint32_t i_entry_count;
297 /* XXX it's also a container with i_entry_count entry */
298 } MP4_Box_data_dref_t;
299
300 typedef struct MP4_Box_data_stts_s
301 {
302     uint8_t  i_version;
303     uint32_t i_flags;
304
305     uint32_t i_entry_count;
306     uint32_t *i_sample_count; /* these are array */
307     int32_t  *i_sample_delta;
308
309 } MP4_Box_data_stts_t;
310
311 typedef struct MP4_Box_data_ctts_s
312 {
313     uint8_t  i_version;
314     uint32_t i_flags;
315     
316     uint32_t i_entry_count;
317
318     uint32_t *i_sample_count; /* these are array */
319     int32_t  *i_sample_offset;
320
321 } MP4_Box_data_ctts_t;
322
323
324 typedef struct MP4_Box_data_sample_soun_s
325 {
326     uint8_t  i_reserved1[6];
327     uint16_t i_data_reference_index;
328
329     uint32_t i_reserved2[2];
330     uint16_t i_channelcount;
331     uint16_t i_samplesize;
332     uint16_t i_predefined;
333     uint16_t i_reserved3;
334     uint16_t i_sampleratehi; /* timescale of track */
335     uint16_t i_sampleratelo;
336     
337 } MP4_Box_data_sample_soun_t;
338
339 typedef struct MP4_Box_data_sample_vide_s
340 {
341     uint8_t  i_reserved1[6];
342     uint16_t i_data_reference_index;
343
344     uint16_t i_predefined1;
345     uint16_t i_reserved2;
346     uint32_t i_predefined2[3];
347
348     int16_t  i_width;
349     int16_t  i_height;
350
351     uint32_t i_horizresolution;
352     uint32_t i_vertresolution;
353
354     uint32_t i_reserved3;
355     uint16_t i_predefined3;
356     
357     uint8_t  i_compressorname[32];
358     int16_t  i_depth;
359
360     int16_t  i_predefined4;
361     
362 } MP4_Box_data_sample_vide_t;
363
364 typedef struct MP4_Box_data_sample_hint_s
365 {
366     uint8_t  i_reserved1[6];
367     uint16_t i_data_reference_index;
368
369     uint8_t *p_data;
370
371 } MP4_Box_data_sample_hint_t;
372
373 typedef struct MP4_Box_data_moviehintinformation_rtp_s
374 {
375     uint32_t i_description_format;
376     unsigned char *psz_text;
377
378 } MP4_Box_data_moviehintinformation_rtp_t;
379
380
381
382 typedef struct MP4_Box_data_stsd_s
383 {
384     uint8_t  i_version;
385     uint32_t i_flags;
386     
387     uint32_t i_entry_count;
388
389     /* it contains SampleEntry handled as if it was Box */
390     
391 } MP4_Box_data_stsd_t;
392
393
394 typedef struct MP4_Box_data_stsz_s
395 {
396     uint8_t  i_version;
397     uint32_t i_flags;
398
399     uint32_t i_sample_size;
400     uint32_t i_sample_count;
401    
402     uint32_t *i_entry_size; /* array , empty if i_sample_size != 0 */
403
404 } MP4_Box_data_stsz_t;
405
406 typedef struct MP4_Box_data_stz2_s
407 {
408     uint8_t  i_version;
409     uint32_t i_flags;
410
411     uint32_t i_sample_size; /* 24 bits */
412     uint8_t  i_field_size;
413     uint32_t i_sample_count;
414
415     uint32_t *i_entry_size; /* array: unsigned int(i_field_size) entry_size */
416
417 } MP4_Box_data_stz2_t;
418
419 typedef struct MP4_Box_data_stsc_s
420 {
421     uint8_t  i_version;
422     uint32_t i_flags;
423
424     uint32_t i_entry_count;
425
426     uint32_t *i_first_chunk; /* theses are arrays */
427     uint32_t *i_samples_per_chunk;
428     uint32_t *i_sample_description_index;
429     
430 } MP4_Box_data_stsc_t;
431
432
433 typedef struct MP4_Box_data_co64_s
434 {
435     uint8_t  i_version;
436     uint32_t i_flags;
437
438     uint32_t i_entry_count;
439     
440     uint64_t *i_chunk_offset;
441
442 } MP4_Box_data_co64_t;
443
444
445 typedef struct MP4_Box_data_stss_s
446 {
447     uint8_t  i_version;
448     uint32_t i_flags;
449     
450     uint32_t i_entry_count;
451     
452     uint32_t *i_sample_number;
453     
454 } MP4_Box_data_stss_t;
455
456 typedef struct MP4_Box_data_stsh_s
457 {
458     uint8_t  i_version;
459     uint32_t i_flags;
460
461     uint32_t i_entry_count;
462     
463     uint32_t *i_shadowed_sample_number;
464     uint32_t *i_sync_sample_number;
465
466 } MP4_Box_data_stsh_t;
467
468 typedef struct MP4_Box_data_stdp_s
469 {
470     uint8_t  i_version;
471     uint32_t i_flags;
472
473     uint16_t *i_priority;
474
475 } MP4_Box_data_stdp_t;
476
477 typedef struct MP4_Box_data_padb_s
478 {
479     uint8_t  i_version;
480     uint32_t i_flags;
481
482     uint32_t i_sample_count;
483
484     uint16_t *i_reserved1;   /* 1bit  */
485     uint16_t *i_pad2;        /* 3bits */
486     uint16_t *i_reserved2;   /* 1bit  */
487     uint16_t *i_pad1;        /* 3bits */
488     
489
490 } MP4_Box_data_padb_t;
491
492
493 typedef struct MP4_Box_data_elst_s
494 {
495     uint8_t  i_version;
496     uint32_t i_flags;
497
498     uint32_t i_entry_count;
499
500     uint64_t *i_segment_duration;
501     int64_t  *i_media_time;
502     uint16_t *i_media_rate_integer;
503     uint16_t *i_media_rate_fraction;
504
505     
506 } MP4_Box_data_elst_t;
507
508 typedef struct MP4_Box_data_cprt_s
509 {
510     uint8_t  i_version;
511     uint32_t i_flags;
512     /* 1 pad bit */
513     unsigned char i_language[3];
514     
515     unsigned char *psz_notice;
516 } MP4_Box_data_cprt_t;
517
518
519 /* DecoderConfigDescriptor */
520 typedef struct MP4_descriptor_decoder_config_s
521 {
522     uint8_t i_objectTypeIndication;
523     uint8_t i_streamType;
524     int     b_upStream;
525     int     i_buffer_sizeDB;
526     int     i_max_bitrate;
527     int     i_avg_bitrate;
528     
529     int     i_decoder_specific_info_len;
530     uint8_t *p_decoder_specific_info;
531     /* some other stuff */
532     
533 } MP4_descriptor_decoder_config_t;
534
535 typedef struct MP4_descriptor_SL_config_s
536 {
537
538     int i_dummy; /* ANSI C forbids empty structures */
539     
540 } MP4_descriptor_SL_config_t;
541
542
543 typedef struct MP4_descriptor_ES_s
544 {
545     uint16_t i_ES_ID;
546     int      b_stream_dependence;
547     int      b_url;
548     int      b_OCRstream;
549     int      i_stream_priority;
550
551     int      i_depend_on_ES_ID; /* if b_stream_dependence set */
552
553     unsigned char *psz_URL;
554
555     uint16_t i_OCR_ES_ID;       /* if b_OCRstream */
556     MP4_descriptor_decoder_config_t *p_decConfigDescr;
557     
558     MP4_descriptor_SL_config_t *p_slConfigDescr;
559
560     /* some other stuff ... */
561
562 } MP4_descriptor_ES_t;
563
564 /* ES descriptor */
565 typedef struct MP4_Box_data_esds_s
566 {
567     uint8_t  i_version;
568     uint32_t i_flags;
569     
570     MP4_descriptor_ES_t es_descriptor;
571     
572 } MP4_Box_data_esds_t;
573
574
575 typedef struct MP4_Box_data_dcom_s
576 {
577     uint32_t i_algorithm; /* fourcc */
578     
579 } MP4_Box_data_dcom_t;
580
581 typedef struct MP4_Box_data_cmvd_s
582 {
583     uint32_t i_uncompressed_size;
584     uint32_t i_compressed_size;
585
586     int     b_compressed; /* Set to 1 if compressed data, 0 if uncompressed */
587     uint8_t *p_data;
588
589 } MP4_Box_data_cmvd_t;
590
591 typedef struct MP4_Box_data_cmov_s
592 {
593     struct MP4_Box_s *p_moov; /* uncompressed moov */
594
595 } MP4_Box_data_cmov_t;
596
597 typedef struct MP4_Box_data_rdrf_s
598 {
599     uint8_t  i_version;
600     uint32_t i_flags;
601
602     uint32_t i_ref_type;
603     char     *psz_ref;
604
605 } MP4_Box_data_rdrf_t;
606
607 typedef struct MP4_Box_data_rmdr_s
608 {
609     uint8_t  i_version;
610     uint32_t i_flags;
611
612     uint32_t i_rate;
613
614 } MP4_Box_data_rmdr_t;
615
616 typedef struct MP4_Box_data_rmvc_s
617 {
618     uint8_t  i_version;
619     uint32_t i_flags;
620
621     uint32_t i_gestaltType;
622     uint32_t i_val1;
623     uint32_t i_val2;
624     uint16_t i_checkType;   /* 0: val1 is version min
625                                1: gestalt value & val2 == val1 */
626
627 } MP4_Box_data_rmvc_t;
628
629 typedef struct MP4_Box_data_rmcd_s
630 {
631     uint8_t  i_version;
632     uint32_t i_flags;
633
634
635 } MP4_Box_data_rmcd_t;
636
637 typedef struct MP4_Box_data_rmqu_s
638 {
639     uint32_t i_quality;
640
641 } MP4_Box_data_rmqu_t;
642
643 /*
644 typedef struct MP4_Box_data__s
645 {
646     uint8_t  i_version;
647     uint32_t i_flags;
648
649 } MP4_Box_data__t;
650
651 */
652
653 typedef union MP4_Box_data_s
654 {
655     MP4_Box_data_ftyp_t *p_ftyp;
656     MP4_Box_data_mvhd_t *p_mvhd;
657     MP4_Box_data_tkhd_t *p_tkhd;
658     MP4_Box_data_mdhd_t *p_mdhd;
659     MP4_Box_data_hdlr_t *p_hdlr;
660     MP4_Box_data_vmhd_t *p_vmhd;
661     MP4_Box_data_smhd_t *p_smhd;
662     MP4_Box_data_hmhd_t *p_hmhd;
663     MP4_Box_data_url_t  *p_url;
664     MP4_Box_data_urn_t  *p_urn;
665     MP4_Box_data_dref_t *p_dref;
666     MP4_Box_data_stts_t *p_stts;
667     MP4_Box_data_ctts_t *p_ctts;
668     MP4_Box_data_stsd_t *p_stsd;
669         MP4_Box_data_sample_vide_t *p_sample_vide;
670         MP4_Box_data_sample_soun_t *p_sample_soun;
671         MP4_Box_data_sample_hint_t *p_sample_hint;
672
673         MP4_Box_data_esds_t *p_esds;
674
675     MP4_Box_data_stsz_t *p_stsz;
676     MP4_Box_data_stz2_t *p_stz2;
677     MP4_Box_data_stsc_t *p_stsc;
678     MP4_Box_data_co64_t *p_co64;
679     MP4_Box_data_stss_t *p_stss;
680     MP4_Box_data_stsh_t *p_stsh;
681     MP4_Box_data_stdp_t *p_stdp;
682     MP4_Box_data_padb_t *p_padb;
683     MP4_Box_data_elst_t *p_elst;
684     MP4_Box_data_cprt_t *p_cprt;
685
686     MP4_Box_data_dcom_t *p_dcom;
687     MP4_Box_data_cmvd_t *p_cmvd;
688     MP4_Box_data_cmov_t *p_cmov;
689
690     MP4_Box_data_moviehintinformation_rtp_t p_moviehintinformation_rtp;
691
692     MP4_Box_data_rdrf_t *p_rdrf;
693     MP4_Box_data_rmdr_t *p_rmdr;
694     MP4_Box_data_rmqu_t *p_rmqu;
695     MP4_Box_data_rmvc_t *p_rmvc;
696
697     void                *p_data; /* for unknow type */
698 } MP4_Box_data_t;
699
700
701
702 /* the most basic structure */
703 typedef struct MP4_Box_s
704 {
705     off_t        i_pos;      /* absolute position */
706     
707     uint32_t     i_type;
708     uint32_t     i_shortsize;
709
710     UUID_t       i_uuid;  /* Set if i_type == "uuid" */
711     
712     uint64_t     i_size; /* always set so use it */
713
714     MP4_Box_data_t   data;   /* union of pointers on extended data depending    
715                                 on i_type (or i_usertype) */
716
717     struct MP4_Box_s *p_father; /* pointer on the father Box */
718
719     struct MP4_Box_s *p_first;  /* pointer on the first child Box */
720     struct MP4_Box_s *p_last;
721
722     struct MP4_Box_s *p_next;   /* pointer on the next boxes at the same level */
723
724 } MP4_Box_t;
725
726 /*---------------------------------------------------------------------------*/
727 /*                                                                           */
728 /****----------------------- High level functions ------------------------****/
729 /*                                                                           */
730 /*---------------------------------------------------------------------------*/
731
732 /*****************************************************************************
733  * Function for manipulate stream easily
734  *****************************************************************************/
735
736 off_t MP4_TellAbsolute( input_thread_t *p_input );
737 int   MP4_SeekAbsolute( input_thread_t *p_input, off_t i_pos);
738 int   MP4_ReadData( input_thread_t *p_input, uint8_t *p_buff, int i_size );
739
740 /*****************************************************************************
741  * MP4_BoxGetRoot : Parse the entire file, and create all boxes in memory
742  *****************************************************************************
743  *  The first box is a virtual box "root" and is the father for all first 
744  *  level boxes 
745  *
746  *  RETURN : 1 if succes and 0 if it failed
747  *****************************************************************************/
748 int MP4_BoxGetRoot( input_thread_t *p_input, MP4_Box_t *p_root );
749
750 /*****************************************************************************
751  * MP4_FreeBox : free memory allocated after read with MP4_ReadBox
752  *               or MP4_BoxGetRoot, this means also children boxes
753  * XXX : all children have to be allocated by a malloc !! and 
754  *         p_box isn't freeing  
755  *****************************************************************************/
756 void MP4_BoxFree( input_thread_t *p_input, MP4_Box_t *p_box );
757
758 /*****************************************************************************
759  * MP4_DumpBoxStructure: print the structure of the p_box
760  *****************************************************************************
761  * Usefull while debugging
762  *****************************************************************************/
763 void MP4_BoxDumpStructure( input_thread_t *p_input, MP4_Box_t *p_box );
764
765
766 /*****************************************************************************
767  * MP4_BoxGet: find a box given a path relative to p_box
768  *****************************************************************************
769  * Path Format: . .. / as usual
770  *              [number] to specifie box number ex: trak[12]
771  *              
772  * ex: /moov/trak[12]
773  *     ../mdia 
774  *****************************************************************************/
775 MP4_Box_t *MP4_BoxGet( MP4_Box_t *p_box, char *psz_fmt, ... );
776     
777 /*****************************************************************************
778  * MP4_BoxCount: find number of box given a path relative to p_box
779  *****************************************************************************
780  * Path Format: . .. / as usual
781  *              [number] to specifie box number ex: trak[12]
782  *              
783  * ex: /moov/trak
784  *     ../mdia 
785  *****************************************************************************/
786 int MP4_BoxCount( MP4_Box_t *p_box, char *psz_fmt, ... );
787
788
789
790 /*---------------------------------------------------------------------------*/
791 /*                                                                           */
792 /****---------------------- Medium level functions -----------------------****/
793 /*                                                                           */
794 /*---------------------------------------------------------------------------*/
795
796 #if 0
797 /*****************************************************************************
798  * MP4_CountBox: given a box, count how many child have the requested type 
799  * FIXME : support GUUID 
800  *****************************************************************************/
801 int MP4_CountBox( MP4_Box_t *p_box, uint32_t i_type );
802 #endif
803
804 /*****************************************************************************
805  * MP4_FindBox:  find first box with i_type child of p_box
806  *      return NULL if not found
807  *****************************************************************************/
808 MP4_Box_t *MP4_FindBox( MP4_Box_t *p_box, uint32_t i_type );
809
810 #if 0
811 /*****************************************************************************
812  * MP4_FindNextBox:  find next box with thesame type and at the same level 
813  *                  than p_box
814  *****************************************************************************/
815 MP4_Box_t *MP4_FindNextBox( MP4_Box_t *p_box );
816
817 /*****************************************************************************
818  * MP4_FindNbBox:  find the box i_number 
819  *****************************************************************************/
820 MP4_Box_t *MP4_FindNbBox( MP4_Box_t *p_box, uint32_t i_number );
821 #endif
822
823 /*---------------------------------------------------------------------------*/
824 /****----------------------- Lower level functions -----------------------****/
825 /****                                                                     ****/
826 /****------Use them only when you known what they really do and need------****/
827 /****                                                                     ****/
828 /****---------------------------------------------------------------------****/
829 /*---------------------------------------------------------------------------*/
830
831
832 /****  ------- First some function to make abstract from input --------  */
833
834 /****************************************************************************
835  * MP4_InputStream create an stram with an input
836  *
837  ****************************************************************************/
838 MP4_Stream_t *MP4_InputStream( input_thread_t *p_input );
839
840 /****************************************************************************
841  * MP4_MemoryStream create a memory stream
842  * if p_buffer == NULL, will allocate a buffer of i_size, else 
843  *     it uses p_buffer XXX you have to unallocate yourself !
844  *
845  ****************************************************************************/
846 MP4_Stream_t *MP4_MemoryStream( input_thread_t *p_input,
847                                 int i_size, uint8_t *p_buffer );
848
849 /****************************************************************************
850  * MP4_ReadStream read from a MP4_Stream_t
851  *
852  ****************************************************************************/
853 int MP4_ReadStream( MP4_Stream_t *p_stream, uint8_t *p_buff, int i_size );
854
855 /****************************************************************************
856  * MP4_PeekStream guess it ;)
857  *
858  ****************************************************************************/
859 int MP4_PeekStream( MP4_Stream_t *p_stream, uint8_t **pp_peek, int i_size );
860     
861 /****************************************************************************
862  * MP4_TellStream give absolute position in the stream
863  * XXX for a memory stream give position from begining of the buffer
864  ****************************************************************************/
865 off_t MP4_TellStream( MP4_Stream_t *p_stream );
866
867 /****************************************************************************
868  * MP4_SeekStream seek in a MP4_Stream_t
869  *
870  ****************************************************************************/
871 int MP4_SeekStream( MP4_Stream_t *p_stream, off_t i_pos);
872
873
874
875 /*****************************************************************************
876  * MP4_ReadBox : parse the actual box and the children if they exist
877  *  
878  *  RETURN : 1 if succes and 0 if it failed
879  *****************************************************************************/
880 int MP4_ReadBox( MP4_Stream_t *p_stream, MP4_Box_t *p_box, MP4_Box_t *p_father );
881
882
883 /*****************************************************************************
884  * MP4_ReadBoxCommon : Load only common parameters for all boxes 
885  *****************************************************************************
886  * p_box need to be an already allocated MP4_Box_t, and all data 
887  *  will only be peek not read
888  *
889  * RETURN : 0 if it fail, 1 otherwise
890  *****************************************************************************/
891 int MP4_ReadBoxCommon( MP4_Stream_t *p_stream, MP4_Box_t *p_box );
892
893
894 /*****************************************************************************
895  * MP4_MP4_GotoBox : Go to this particular box 
896  *****************************************************************************
897  * RETURN : 0 if it fail, 1 otherwise
898  *****************************************************************************/
899 int MP4_GotoBox( MP4_Stream_t *p_stream, MP4_Box_t *p_box );
900
901     
902 /*****************************************************************************
903  * MP4_MP4_NextBox : Go to the next box wiithin p_box->p_father 
904  *****************************************************************************
905  * if p_box == NULL, go to the next box in witch we are( at the begining ).
906  *****************************************************************************/
907 int MP4_NextBox( MP4_Stream_t *p_stream, MP4_Box_t *p_box );
908
909