fourcc: remove fourcc from caps
[platform/upstream/gstreamer.git] / gst / isomp4 / atoms.h
1 /* Quicktime muxer plugin for GStreamer
2  * Copyright (C) 2008-2010 Thiago Santos <thiagoss@embedded.ufcg.edu.br>
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public
15  * License along with this library; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA 02111-1307, USA.
18  */
19 /*
20  * Unless otherwise indicated, Source Code is licensed under MIT license.
21  * See further explanation attached in License Statement (distributed in the file
22  * LICENSE).
23  *
24  * Permission is hereby granted, free of charge, to any person obtaining a copy of
25  * this software and associated documentation files (the "Software"), to deal in
26  * the Software without restriction, including without limitation the rights to
27  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
28  * of the Software, and to permit persons to whom the Software is furnished to do
29  * so, subject to the following conditions:
30  *
31  * The above copyright notice and this permission notice shall be included in all
32  * copies or substantial portions of the Software.
33  *
34  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
35  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
36  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
37  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
38  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
39  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
40  * SOFTWARE.
41  */
42
43 #ifndef __ATOMS_H__
44 #define __ATOMS_H__
45
46 #include <glib.h>
47 #include <string.h>
48
49 #include "descriptors.h"
50 #include "properties.h"
51 #include "fourcc.h"
52 #include "ftypcc.h"
53
54 /* helper storage struct */
55 #define ATOM_ARRAY(struct_type) \
56 struct { \
57   guint size; \
58   guint len; \
59   struct_type *data; \
60 }
61
62 /* storage helpers */
63
64 #define atom_array_init(array, reserve)                                       \
65 G_STMT_START {                                                                \
66   (array)->len = 0;                                                           \
67   (array)->size = reserve;                                                    \
68   (array)->data = g_malloc (sizeof (*(array)->data) * reserve);               \
69 } G_STMT_END
70
71 #define atom_array_append(array, elmt, inc)                                   \
72 G_STMT_START {                                                                \
73   g_assert ((array)->data);                                                   \
74   g_assert (inc > 0);                                                         \
75   if (G_UNLIKELY ((array)->len == (array)->size)) {                           \
76     (array)->size += inc;                                                     \
77     (array)->data =                                                           \
78         g_realloc ((array)->data, sizeof (*((array)->data)) * (array)->size); \
79   }                                                                           \
80   (array)->data[(array)->len] = elmt;                                         \
81   (array)->len++;                                                             \
82 } G_STMT_END
83
84 #define atom_array_get_len(array)                  ((array)->len)
85 #define atom_array_index(array, index)             ((array)->data[index])
86
87 #define atom_array_clear(array)                                               \
88 G_STMT_START {                                                                \
89   (array)->size = (array)->len = 0;                                           \
90   g_free ((array)->data);                                                     \
91   (array)->data = NULL;                                                       \
92 } G_STMT_END
93
94 /* light-weight context that may influence header atom tree construction */
95 typedef enum _AtomsTreeFlavor
96 {
97   ATOMS_TREE_FLAVOR_MOV,
98   ATOMS_TREE_FLAVOR_ISOM,
99   ATOMS_TREE_FLAVOR_3GP,
100   ATOMS_TREE_FLAVOR_ISML
101 } AtomsTreeFlavor;
102
103 typedef struct _AtomsContext
104 {
105   AtomsTreeFlavor flavor;
106 } AtomsContext;
107
108 AtomsContext* atoms_context_new  (AtomsTreeFlavor flavor);
109 void          atoms_context_free (AtomsContext *context);
110
111 #define METADATA_DATA_FLAG 0x0
112 #define METADATA_TEXT_FLAG 0x1
113
114 /* atom defs and functions */
115
116 /**
117  * Used for storing time related values for some atoms.
118  */
119 typedef struct _TimeInfo
120 {
121   guint64 creation_time;
122   guint64 modification_time;
123   guint32 timescale;
124   guint64 duration;
125 } TimeInfo;
126
127 typedef struct _Atom
128 {
129   guint32 size;
130   guint32 type;
131   guint64 extended_size;
132 } Atom;
133
134 typedef struct _AtomFull
135 {
136   Atom header;
137
138   guint8 version;
139   guint8 flags[3];
140 } AtomFull;
141
142 /*
143  * Generic extension atom
144  */
145 typedef struct _AtomData
146 {
147   Atom header;
148
149   /* not written */
150   guint32 datalen;
151
152   guint8 *data;
153 } AtomData;
154
155 typedef struct _AtomUUID
156 {
157   Atom header;
158
159   guint8 uuid[16];
160
161   /* not written */
162   guint32 datalen;
163
164   guint8 *data;
165 } AtomUUID;
166
167 typedef struct _AtomFTYP
168 {
169   Atom header;
170   guint32 major_brand;
171   guint32 version;
172   guint32 *compatible_brands;
173
174   /* not written */
175   guint32 compatible_brands_size;
176 } AtomFTYP;
177
178 typedef struct _AtomMVHD
179 {
180   AtomFull header;
181
182   /* version 0: 32 bits */
183   TimeInfo time_info;
184
185   guint32 prefered_rate;      /* ISO: 0x00010000 */
186   guint16 volume;             /* ISO: 0x0100 */
187   guint16 reserved3;          /* ISO: 0x0 */
188   guint32 reserved4[2];       /* ISO: 0, 0 */
189   /* ISO: identity matrix =
190    * { 0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000 } */
191   guint32 matrix[9];
192
193   /* ISO: all 0 */
194   guint32 preview_time;
195   guint32 preview_duration;
196   guint32 poster_time;
197   guint32 selection_time;
198   guint32 selection_duration;
199   guint32 current_time;
200
201   guint32 next_track_id;
202 } AtomMVHD;
203
204 typedef struct _AtomTKHD
205 {
206   AtomFull header;
207
208   /* version 0: 32 bits */
209   /* like the TimeInfo struct, but it has this track_ID inside */
210   guint64 creation_time;
211   guint64 modification_time;
212   guint32 track_ID;
213   guint32 reserved;
214   guint64 duration;
215
216   guint32 reserved2[2];
217   guint16 layer;
218   guint16 alternate_group;
219   guint16 volume;
220   guint16 reserved3;
221
222   /* ISO: identity matrix =
223    * { 0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000 } */
224   guint32 matrix[9];
225   guint32 width;
226   guint32 height;
227 } AtomTKHD;
228
229 typedef struct _AtomMDHD
230 {
231   AtomFull header;
232
233   /* version 0: 32 bits */
234   TimeInfo time_info;
235
236   /* ISO: packed ISO-639-2/T language code (first bit must be 0) */
237   guint16 language_code;
238   /* ISO: 0 */
239   guint16 quality;
240 } AtomMDHD;
241
242 typedef struct _AtomHDLR
243 {
244   AtomFull header;
245
246   /* ISO: 0 */
247   guint32 component_type;
248   guint32 handler_type;
249   guint32 manufacturer;
250   guint32 flags;
251   guint32 flags_mask;
252   gchar *name;
253 } AtomHDLR;
254
255 typedef struct _AtomVMHD
256 {
257   AtomFull header;          /* ISO: flags = 1 */
258
259   guint16 graphics_mode;
260   /* RGB */
261   guint16 opcolor[3];
262 } AtomVMHD;
263
264 typedef struct _AtomSMHD
265 {
266   AtomFull header;
267
268   guint16 balance;
269   guint16 reserved;
270 } AtomSMHD;
271
272 typedef struct _AtomHMHD
273 {
274   AtomFull header;
275
276   guint16 max_pdu_size;
277   guint16 avg_pdu_size;
278   guint32 max_bitrate;
279   guint32 avg_bitrate;
280   guint32 sliding_avg_bitrate;
281 } AtomHMHD;
282
283 typedef struct _AtomURL
284 {
285   AtomFull header;
286
287   gchar *location;
288 } AtomURL;
289
290 typedef struct _AtomDREF
291 {
292   AtomFull header;
293
294   GList *entries;
295 } AtomDREF;
296
297 typedef struct _AtomDINF
298 {
299   Atom header;
300
301   AtomDREF dref;
302 } AtomDINF;
303
304 typedef struct _STTSEntry
305 {
306   guint32 sample_count;
307   gint32 sample_delta;
308 } STTSEntry;
309
310 typedef struct _AtomSTTS
311 {
312   AtomFull header;
313
314   ATOM_ARRAY (STTSEntry) entries;
315 } AtomSTTS;
316
317 typedef struct _AtomSTSS
318 {
319   AtomFull header;
320
321   ATOM_ARRAY (guint32) entries;
322 } AtomSTSS;
323
324 typedef struct _AtomESDS
325 {
326   AtomFull header;
327
328   ESDescriptor es;
329 } AtomESDS;
330
331 typedef struct _AtomFRMA
332 {
333   Atom header;
334
335   guint32 media_type;
336 } AtomFRMA;
337
338 typedef enum _SampleEntryKind
339 {
340   UNKNOWN,
341   AUDIO,
342   VIDEO
343 } SampleEntryKind;
344
345 typedef struct _SampleTableEntry
346 {
347   Atom header;
348
349   guint8 reserved[6];
350   guint16 data_reference_index;
351
352   /* sort of entry */
353   SampleEntryKind kind;
354 } SampleTableEntry;
355
356 typedef struct _AtomHintSampleEntry
357 {
358   SampleTableEntry se;
359   guint32 size;
360   guint8 *data;
361 } AtomHintSampleEntry;
362
363 typedef struct _SampleTableEntryMP4V
364 {
365   SampleTableEntry se;
366
367   guint16 version;
368   guint16 revision_level;
369
370   guint32 vendor;                 /* fourcc code */
371   guint32 temporal_quality;
372   guint32 spatial_quality;
373
374   guint16 width;
375   guint16 height;
376
377   guint32 horizontal_resolution;
378   guint32 vertical_resolution;
379   guint32 datasize;
380
381   guint16 frame_count;            /* usually 1 */
382
383   guint8 compressor[32];         /* pascal string, i.e. first byte = length */
384
385   guint16 depth;
386   guint16 color_table_id;
387
388   /* (optional) list of AtomInfo */
389   GList *extension_atoms;
390 } SampleTableEntryMP4V;
391
392 typedef struct _SampleTableEntryMP4A
393 {
394   SampleTableEntry se;
395
396   guint16 version;
397   guint16 revision_level;
398   guint32 vendor;
399
400   guint16 channels;
401   guint16 sample_size;
402   guint16 compression_id;
403   guint16 packet_size;
404
405   guint32 sample_rate;            /* fixed point 16.16 */
406
407   guint32 samples_per_packet;
408   guint32 bytes_per_packet;
409   guint32 bytes_per_frame;
410   guint32 bytes_per_sample;
411
412   /* (optional) list of AtomInfo */
413   GList *extension_atoms;
414 } SampleTableEntryMP4A;
415
416 typedef struct _SampleTableEntryMP4S
417 {
418   SampleTableEntry se;
419
420   AtomESDS es;
421 } SampleTableEntryMP4S;
422
423 typedef struct _AtomSTSD
424 {
425   AtomFull header;
426
427   guint n_entries;
428   /* list of subclasses of SampleTableEntry */
429   GList *entries;
430 } AtomSTSD;
431
432 typedef struct _AtomSTSZ
433 {
434   AtomFull header;
435
436   guint32 sample_size;
437
438   /* need the size here because when sample_size is constant,
439    * the list is empty */
440   guint32 table_size;
441   ATOM_ARRAY (guint32) entries;
442 } AtomSTSZ;
443
444 typedef struct _STSCEntry
445 {
446   guint32 first_chunk;
447   guint32 samples_per_chunk;
448   guint32 sample_description_index;
449 } STSCEntry;
450
451 typedef struct _AtomSTSC
452 {
453   AtomFull header;
454
455   ATOM_ARRAY (STSCEntry) entries;
456 } AtomSTSC;
457
458
459 /*
460  * used for both STCO and CO64
461  * if used as STCO, entries should be truncated to use only 32bits
462  */
463 typedef struct _AtomSTCO64
464 {
465   AtomFull header;
466
467   ATOM_ARRAY (guint64) entries;
468 } AtomSTCO64;
469
470 typedef struct _CTTSEntry
471 {
472   guint32 samplecount;
473   guint32 sampleoffset;
474 } CTTSEntry;
475
476 typedef struct _AtomCTTS
477 {
478   AtomFull header;
479
480   /* also entry count here */
481   ATOM_ARRAY (CTTSEntry) entries;
482   gboolean do_pts;
483 } AtomCTTS;
484
485 typedef struct _AtomSTBL
486 {
487   Atom header;
488
489   AtomSTSD stsd;
490   AtomSTTS stts;
491   AtomSTSS stss;
492   AtomSTSC stsc;
493   AtomSTSZ stsz;
494   /* NULL if not present */
495   AtomCTTS *ctts;
496
497   AtomSTCO64 stco64;
498 } AtomSTBL;
499
500 typedef struct _AtomMINF
501 {
502   Atom header;
503
504   /* only (exactly) one of those must be present */
505   AtomVMHD *vmhd;
506   AtomSMHD *smhd;
507   AtomHMHD *hmhd;
508
509   AtomHDLR *hdlr;
510   AtomDINF dinf;
511   AtomSTBL stbl;
512 } AtomMINF;
513
514 typedef struct _EditListEntry
515 {
516   /* duration in movie's timescale */
517   guint32 duration;
518   /* start time in media's timescale, -1 for empty */
519   guint32 media_time;
520   guint32 media_rate;  /* fixed point 32 bit */
521 } EditListEntry;
522
523 typedef struct _AtomELST
524 {
525   AtomFull header;
526
527   /* number of entries is implicit */
528   GSList *entries;
529 } AtomELST;
530
531 typedef struct _AtomEDTS
532 {
533   Atom header;
534   AtomELST elst;
535 } AtomEDTS;
536
537 typedef struct _AtomMDIA
538 {
539   Atom header;
540
541   AtomMDHD mdhd;
542   AtomHDLR hdlr;
543   AtomMINF minf;
544 } AtomMDIA;
545
546 typedef struct _AtomILST
547 {
548   Atom header;
549
550   /* list of AtomInfo */
551   GList* entries;
552 } AtomILST;
553
554 typedef struct _AtomTagData
555 {
556   AtomFull header;
557   guint32 reserved;
558
559   guint32 datalen;
560   guint8* data;
561 } AtomTagData;
562
563 typedef struct _AtomTag
564 {
565   Atom header;
566
567   AtomTagData data;
568 } AtomTag;
569
570 typedef struct _AtomMETA
571 {
572   AtomFull header;
573   AtomHDLR hdlr;
574   AtomILST *ilst;
575 } AtomMETA;
576
577 typedef struct _AtomUDTA
578 {
579   Atom header;
580
581   /* list of AtomInfo */
582   GList* entries;
583   /* or list is further down */
584   AtomMETA *meta;
585 } AtomUDTA;
586
587 enum TrFlags
588 {
589   TR_DATA_OFFSET              = 0x01,     /* data-offset-present */
590   TR_FIRST_SAMPLE_FLAGS       = 0x04,     /* first-sample-flags-present */
591   TR_SAMPLE_DURATION          = 0x0100,   /* sample-duration-present */
592   TR_SAMPLE_SIZE              = 0x0200,   /* sample-size-present */
593   TR_SAMPLE_FLAGS             = 0x0400,   /* sample-flags-present */
594   TR_COMPOSITION_TIME_OFFSETS = 0x0800    /* sample-composition-time-offsets-presents */
595 };
596
597 enum TfFlags
598 {
599   TF_BASE_DATA_OFFSET         = 0x01,     /* base-data-offset-present */
600   TF_SAMPLE_DESCRIPTION_INDEX = 0x02,     /* sample-description-index-present */
601   TF_DEFAULT_SAMPLE_DURATION  = 0x08,     /* default-sample-duration-present */
602   TF_DEFAULT_SAMPLE_SIZE      = 0x010,    /* default-sample-size-present */
603   TF_DEFAULT_SAMPLE_FLAGS     = 0x020,    /* default-sample-flags-present */
604   TF_DURATION_IS_EMPTY        = 0x010000  /* sample-composition-time-offsets-presents */
605 };
606
607 typedef struct _AtomTRAK
608 {
609   Atom header;
610
611   AtomTKHD tkhd;
612   AtomEDTS *edts;
613   AtomMDIA mdia;
614
615   /* some helper info for structural conformity checks */
616   gboolean is_video;
617   gboolean is_h264;
618 } AtomTRAK;
619
620 typedef struct _AtomTREX
621 {
622   AtomFull header;
623
624   guint32 track_ID;
625   guint32 default_sample_description_index;
626   guint32 default_sample_duration;
627   guint32 default_sample_size;
628   guint32 default_sample_flags;
629 } AtomTREX;
630
631 typedef struct _AtomMEHD
632 {
633   AtomFull header;
634
635   guint64 fragment_duration;
636 } AtomMEHD;
637
638
639 typedef struct _AtomMVEX
640 {
641   Atom header;
642
643   AtomMEHD mehd;
644
645   /* list of AtomTREX */
646   GList *trexs;
647 } AtomMVEX;
648
649 typedef struct _AtomMFHD
650 {
651   AtomFull header;
652
653   guint32 sequence_number;
654 } AtomMFHD;
655
656 typedef struct _AtomTFHD
657 {
658   AtomFull header;
659
660   guint32 track_ID;
661   guint64 base_data_offset;
662   guint32 sample_description_index;
663   guint32 default_sample_duration;
664   guint32 default_sample_size;
665   guint32 default_sample_flags;
666 } AtomTFHD;
667
668 typedef struct _TRUNSampleEntry
669 {
670   guint32 sample_duration;
671   guint32 sample_size;
672   guint32 sample_flags;
673   guint32 sample_composition_time_offset;
674 } TRUNSampleEntry;
675
676 typedef struct _AtomTRUN
677 {
678   AtomFull header;
679
680   guint32 sample_count;
681   gint32 data_offset;
682   guint32 first_sample_flags;
683
684   /* array of fields */
685   ATOM_ARRAY (TRUNSampleEntry) entries;
686 } AtomTRUN;
687
688 typedef struct _AtomSDTP
689 {
690   AtomFull header;
691
692   /* not serialized */
693   guint32 sample_count;
694
695   /* array of fields */
696   ATOM_ARRAY (guint8) entries;
697 } AtomSDTP;
698
699 typedef struct _AtomTRAF
700 {
701   Atom header;
702
703   AtomTFHD tfhd;
704
705   /* list of AtomTRUN */
706   GList *truns;
707   /* list of AtomSDTP */
708   GList *sdtps;
709 } AtomTRAF;
710
711 typedef struct _AtomMOOF
712 {
713   Atom header;
714
715   AtomMFHD mfhd;
716
717   /* list of AtomTRAF */
718   GList *trafs;
719 } AtomMOOF;
720
721
722 typedef struct _AtomMOOV
723 {
724   /* style */
725   AtomsContext context;
726
727   Atom header;
728
729   AtomMVHD mvhd;
730   AtomMVEX mvex;
731
732   /* list of AtomTRAK */
733   GList *traks;
734   AtomUDTA *udta;
735
736   gboolean fragmented;
737 } AtomMOOV;
738
739 typedef struct _AtomWAVE
740 {
741   Atom header;
742
743   /* list of AtomInfo */
744   GList *extension_atoms;
745 } AtomWAVE;
746
747 typedef struct _TFRAEntry
748 {
749   guint64 time;
750   guint64 moof_offset;
751   guint32 traf_number;
752   guint32 trun_number;
753   guint32 sample_number;
754 } TFRAEntry;
755
756 typedef struct _AtomTFRA
757 {
758   AtomFull header;
759
760   guint32 track_ID;
761   guint32 lengths;
762   /* array of entries */
763   ATOM_ARRAY (TFRAEntry) entries;
764 } AtomTFRA;
765
766 typedef struct _AtomMFRA
767 {
768   Atom header;
769
770   /* list of tfra */
771   GList *tfras;
772 } AtomMFRA;
773
774 /*
775  * Function to serialize an atom
776  */
777 typedef guint64 (*AtomCopyDataFunc) (Atom *atom, guint8 **buffer, guint64 *size, guint64 *offset);
778
779 /*
780  * Releases memory allocated by an atom
781  */
782 typedef guint64 (*AtomFreeFunc) (Atom *atom);
783
784 /*
785  * Some atoms might have many optional different kinds of child atoms, so this
786  * is useful for enabling generic handling of any atom.
787  * All we need are the two functions (copying it to an array
788  * for serialization and the memory releasing function).
789  */
790 typedef struct _AtomInfo
791 {
792   Atom *atom;
793   AtomCopyDataFunc copy_data_func;
794   AtomFreeFunc free_func;
795 } AtomInfo;
796
797
798 guint64    atom_copy_data              (Atom *atom, guint8 **buffer,
799                                         guint64 *size, guint64* offset);
800
801 AtomFTYP*  atom_ftyp_new               (AtomsContext *context, guint32 major,
802                                         guint32 version, GList *brands);
803 guint64    atom_ftyp_copy_data         (AtomFTYP *ftyp, guint8 **buffer,
804                                         guint64 *size, guint64 *offset);
805 void       atom_ftyp_free              (AtomFTYP *ftyp);
806
807 AtomTRAK*  atom_trak_new               (AtomsContext *context);
808 void       atom_trak_add_samples       (AtomTRAK * trak, guint32 nsamples, guint32 delta,
809                                         guint32 size, guint64 chunk_offset, gboolean sync,
810                                         gint64 pts_offset);
811 void       atom_trak_add_elst_entry    (AtomTRAK * trak, guint32 duration,
812                                         guint32 media_time, guint32 rate);
813 guint32    atom_trak_get_timescale     (AtomTRAK *trak);
814 guint32    atom_trak_get_id            (AtomTRAK * trak);
815 void       atom_stbl_add_samples       (AtomSTBL * stbl, guint32 nsamples,
816                                         guint32 delta, guint32 size,
817                                         guint64 chunk_offset, gboolean sync,
818                                         gint64 pts_offset);
819
820 AtomMOOV*  atom_moov_new               (AtomsContext *context);
821 void       atom_moov_free              (AtomMOOV *moov);
822 guint64    atom_moov_copy_data         (AtomMOOV *atom, guint8 **buffer, guint64 *size, guint64* offset);
823 void       atom_moov_update_timescale  (AtomMOOV *moov, guint32 timescale);
824 void       atom_moov_update_duration   (AtomMOOV *moov);
825 void       atom_moov_set_fragmented    (AtomMOOV *moov, gboolean fragmented);
826 void       atom_moov_chunks_add_offset (AtomMOOV *moov, guint32 offset);
827 void       atom_moov_add_trak          (AtomMOOV *moov, AtomTRAK *trak);
828
829 guint64    atom_mvhd_copy_data         (AtomMVHD * atom, guint8 ** buffer,
830                                         guint64 * size, guint64 * offset);
831 void       atom_stco64_chunks_add_offset (AtomSTCO64 * stco64, guint32 offset);
832 guint64    atom_trak_copy_data         (AtomTRAK * atom, guint8 ** buffer,
833                                         guint64 * size, guint64 * offset);
834 void       atom_stbl_clear             (AtomSTBL * stbl);
835 void       atom_stbl_init              (AtomSTBL * stbl);
836 guint64    atom_stss_copy_data         (AtomSTSS *atom, guint8 **buffer,
837                                         guint64 *size, guint64* offset);
838 guint64    atom_stts_copy_data         (AtomSTTS *atom, guint8 **buffer,
839                                         guint64 *size, guint64* offset);
840 guint64    atom_stsc_copy_data         (AtomSTSC *atom, guint8 **buffer,
841                                         guint64 *size, guint64* offset);
842 guint64    atom_stsz_copy_data         (AtomSTSZ *atom, guint8 **buffer,
843                                         guint64 *size, guint64* offset);
844 guint64    atom_ctts_copy_data         (AtomCTTS *atom, guint8 **buffer,
845                                         guint64 *size, guint64* offset);
846 guint64    atom_stco64_copy_data       (AtomSTCO64 *atom, guint8 **buffer,
847                                         guint64 *size, guint64* offset);
848 AtomMOOF*  atom_moof_new               (AtomsContext *context, guint32 sequence_number);
849 void       atom_moof_free              (AtomMOOF *moof);
850 guint64    atom_moof_copy_data         (AtomMOOF *moof, guint8 **buffer, guint64 *size, guint64* offset);
851 AtomTRAF * atom_traf_new               (AtomsContext * context, guint32 track_ID);
852 void       atom_traf_free              (AtomTRAF * traf);
853 void       atom_traf_add_samples       (AtomTRAF * traf, guint32 delta,
854                                         guint32 size, gboolean sync, gint64 pts_offset,
855                                         gboolean sdtp_sync);
856 guint32    atom_traf_get_sample_num    (AtomTRAF * traf);
857 void       atom_moof_add_traf          (AtomMOOF *moof, AtomTRAF *traf);
858
859 AtomMFRA*  atom_mfra_new               (AtomsContext *context);
860 void       atom_mfra_free              (AtomMFRA *mfra);
861 AtomTFRA*  atom_tfra_new               (AtomsContext *context, guint32 track_ID);
862 void       atom_tfra_add_entry         (AtomTFRA *tfra, guint64 dts, guint32 sample_num);
863 void       atom_tfra_update_offset     (AtomTFRA * tfra, guint64 offset);
864 void       atom_mfra_add_tfra          (AtomMFRA *mfra, AtomTFRA *tfra);
865 guint64    atom_mfra_copy_data         (AtomMFRA *mfra, guint8 **buffer, guint64 *size, guint64* offset);
866
867
868 /* media sample description related helpers */
869
870 typedef struct
871 {
872   guint16 version;
873   guint32 fourcc;
874   guint width;
875   guint height;
876   guint depth;
877   guint frame_count;
878   gint color_table_id;
879   guint par_n;
880   guint par_d;
881
882   GstBuffer *codec_data;
883 } VisualSampleEntry;
884
885 typedef struct
886 {
887   guint32 fourcc;
888   guint version;
889   gint compression_id;
890   guint sample_rate;
891   guint channels;
892   guint sample_size;
893   guint bytes_per_packet;
894   guint samples_per_packet;
895   guint bytes_per_sample;
896   guint bytes_per_frame;
897
898   GstBuffer *codec_data;
899 } AudioSampleEntry;
900
901 void atom_trak_set_audio_type (AtomTRAK * trak, AtomsContext * context,
902                                AudioSampleEntry * entry, guint32 scale,
903                                AtomInfo * ext, gint sample_size);
904
905 void atom_trak_set_video_type (AtomTRAK * trak, AtomsContext * context,
906                                VisualSampleEntry * entry, guint32 rate,
907                                GList * ext_atoms_list);
908
909 AtomInfo *   build_codec_data_extension  (guint32 fourcc, const GstBuffer * codec_data);
910 AtomInfo *   build_mov_aac_extension     (AtomTRAK * trak, const GstBuffer * codec_data,
911                                           guint32 avg_bitrate, guint32 max_bitrate);
912 AtomInfo *   build_mov_alac_extension    (AtomTRAK * trak, const GstBuffer * codec_data);
913 AtomInfo *   build_esds_extension        (AtomTRAK * trak, guint8 object_type,
914                                           guint8 stream_type, const GstBuffer * codec_data,
915                                           guint32 avg_bitrate, guint32 max_bitrate);
916 AtomInfo *   build_btrt_extension        (guint32 buffer_size_db, guint32 avg_bitrate,
917                                           guint32 max_bitrate);
918 AtomInfo *   build_jp2h_extension        (AtomTRAK * trak, gint width, gint height,
919                                           const gchar *colorspace, gint ncomp,
920                                           const GValue * cmap_array,
921                                           const GValue * cdef_array);
922
923 AtomInfo *   build_jp2x_extension        (const GstBuffer * prefix);
924 AtomInfo *   build_fiel_extension        (gint fields);
925 AtomInfo *   build_amr_extension         (void);
926 AtomInfo *   build_h263_extension        (void);
927 AtomInfo *   build_gama_atom             (gdouble gamma);
928 AtomInfo *   build_SMI_atom              (const GstBuffer *seqh);
929 AtomInfo *   build_ima_adpcm_extension   (gint channels, gint rate,
930                                           gint blocksize);
931 AtomInfo *   build_uuid_xmp_atom         (GstBuffer * xmp);
932
933
934 /*
935  * Meta tags functions
936  */
937 void atom_moov_add_str_tag    (AtomMOOV *moov, guint32 fourcc, const gchar *value);
938 void atom_moov_add_uint_tag   (AtomMOOV *moov, guint32 fourcc, guint32 flags,
939                                guint32 value);
940 void atom_moov_add_tag        (AtomMOOV *moov, guint32 fourcc, guint32 flags,
941                                const guint8 * data, guint size);
942 void atom_moov_add_blob_tag   (AtomMOOV *moov, guint8 *data, guint size);
943
944 void atom_moov_add_3gp_str_tag       (AtomMOOV * moov, guint32 fourcc, const gchar * value);
945 void atom_moov_add_3gp_uint_tag      (AtomMOOV * moov, guint32 fourcc, guint16 value);
946 void atom_moov_add_3gp_str_int_tag   (AtomMOOV * moov, guint32 fourcc, const gchar * value,
947                                       gint16 ivalue);
948 void atom_moov_add_3gp_tag           (AtomMOOV * moov, guint32 fourcc, guint8 * data,
949                                       guint size);
950
951 void atom_moov_add_xmp_tags          (AtomMOOV * moov, GstBuffer * xmp);
952
953 #define GST_QT_MUX_DEFAULT_TAG_LANGUAGE   "eng"
954 guint16  language_code               (const char * lang);
955
956 #endif /* __ATOMS_H__ */