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