gst/quicktime/atoms.h

   1 /* Quicktime muxer plugin for GStreamer
   2  * Copyright (C) 2008 Thiago Sousa 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 /* light-weight context that may influence header atom tree construction */
  55 typedef enum _AtomsTreeFlavor
  56 {
  57   ATOMS_TREE_FLAVOR_MOV,
  58   ATOMS_TREE_FLAVOR_ISOM,
  59   ATOMS_TREE_FLAVOR_3GP
  60 } AtomsTreeFlavor;
  61
  62 typedef struct _AtomsContext
  63 {
  64   AtomsTreeFlavor flavor;
  65 } AtomsContext;
  66
  67 AtomsContext* atoms_context_new  (AtomsTreeFlavor flavor);
  68 void          atoms_context_free (AtomsContext *context);
  69
  70 #define METADATA_DATA_FLAG 0x0
  71 #define METADATA_TEXT_FLAG 0x1
  72
  73 /* atom defs and functions */
  74
  75 /**
  76  * Used for storing time related values for some atoms.
  77  */
  78 typedef struct _TimeInfo
  79 {
  80   guint64 creation_time;
  81   guint64 modification_time;
  82   guint32 timescale;
  83   guint64 duration;
  84 } TimeInfo;
  85
  86 typedef struct _Atom
  87 {
  88   guint32 size;
  89   guint32 type;
  90   guint64 extended_size;
  91 } Atom;
  92
  93 typedef struct _AtomFull
  94 {
  95   Atom header;
  96
  97   guint8 version;
  98   guint8 flags[3];
  99 } AtomFull;
 100
 101 /*
 102  * Generic extension atom
 103  */
 104 typedef struct _AtomData
 105 {
 106   Atom header;
 107
 108   /* not written */
 109   guint32 datalen;
 110   guint8 *data;
 111 } AtomData;
 112
 113 typedef struct _AtomFTYP
 114 {
 115   Atom header;
 116   guint32 major_brand;
 117   guint32 version;
 118   guint32 *compatible_brands;
 119
 120   /* not written */
 121   guint32 compatible_brands_size;
 122 } AtomFTYP;
 123
 124 typedef struct _AtomMVHD
 125 {
 126   AtomFull header;
 127
 128   /* version 0: 32 bits */
 129   TimeInfo time_info;
 130
 131   guint32 prefered_rate;      /* ISO: 0x00010000 */
 132   guint16 volume;             /* ISO: 0x0100 */
 133   guint16 reserved3;          /* ISO: 0x0 */
 134   guint32 reserved4[2];       /* ISO: 0, 0 */
 135   /* ISO: identity matrix =
 136    * { 0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000 } */
 137   guint32 matrix[9];
 138
 139   /* ISO: all 0 */
 140   guint32 preview_time;
 141   guint32 preview_duration;
 142   guint32 poster_time;
 143   guint32 selection_time;
 144   guint32 selection_duration;
 145   guint32 current_time;
 146
 147   guint32 next_track_id;
 148 } AtomMVHD;
 149
 150 typedef struct _AtomTKHD
 151 {
 152   AtomFull header;
 153
 154   /* version 0: 32 bits */
 155   /* like the TimeInfo struct, but it has this track_ID inside */
 156   guint64 creation_time;
 157   guint64 modification_time;
 158   guint32 track_ID;
 159   guint32 reserved;
 160   guint64 duration;
 161
 162   guint32 reserved2[2];
 163   guint16 layer;
 164   guint16 alternate_group;
 165   guint16 volume;
 166   guint16 reserved3;
 167
 168   /* ISO: identity matrix =
 169    * { 0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000 } */
 170   guint32 matrix[9];
 171   guint32 width;
 172   guint32 height;
 173 } AtomTKHD;
 174
 175 typedef struct _AtomMDHD
 176 {
 177   AtomFull header;
 178
 179   /* version 0: 32 bits */
 180   TimeInfo time_info;
 181
 182   /* ISO: packed ISO-639-2/T language code (first bit must be 0) */
 183   guint16 language_code;
 184   /* ISO: 0 */
 185   guint16 quality;
 186 } AtomMDHD;
 187
 188 typedef struct _AtomHDLR
 189 {
 190   AtomFull header;
 191
 192   /* ISO: 0 */
 193   guint32 component_type;
 194   guint32 handler_type;
 195   guint32 manufacturer;
 196   guint32 flags;
 197   guint32 flags_mask;
 198   gchar *name;
 199 } AtomHDLR;
 200
 201 typedef struct _AtomVMHD
 202 {
 203   AtomFull header;          /* ISO: flags = 1 */
 204
 205   guint16 graphics_mode;
 206   /* RGB */
 207   guint16 opcolor[3];
 208 } AtomVMHD;
 209
 210 typedef struct _AtomSMHD
 211 {
 212   AtomFull header;
 213
 214   guint16 balance;
 215   guint16 reserved;
 216 } AtomSMHD;
 217
 218 typedef struct _AtomHMHD
 219 {
 220   AtomFull header;
 221
 222   guint16 max_pdu_size;
 223   guint16 avg_pdu_size;
 224   guint32 max_bitrate;
 225   guint32 avg_bitrate;
 226   guint32 sliding_avg_bitrate;
 227 } AtomHMHD;
 228
 229 typedef struct _AtomURL
 230 {
 231   AtomFull header;
 232
 233   gchar *location;
 234 } AtomURL;
 235
 236 typedef struct _AtomDREF
 237 {
 238   AtomFull header;
 239
 240   GList *entries;
 241 } AtomDREF;
 242
 243 typedef struct _AtomDINF
 244 {
 245   Atom header;
 246
 247   AtomDREF dref;
 248 } AtomDINF;
 249
 250 typedef struct _STTSEntry
 251 {
 252   guint32 sample_count;
 253   gint32 sample_delta;
 254 } STTSEntry;
 255
 256 typedef struct _AtomSTTS
 257 {
 258   AtomFull header;
 259
 260   guint n_entries;
 261   /* list of STTSEntry */
 262   GList *entries;
 263 } AtomSTTS;
 264
 265 typedef struct _AtomSTSS
 266 {
 267   AtomFull header;
 268
 269   guint n_entries;
 270   /* list of sample indexes (guint32) */
 271   GList *entries;
 272 } AtomSTSS;
 273
 274 typedef struct _AtomESDS
 275 {
 276   AtomFull header;
 277
 278   ESDescriptor es;
 279 } AtomESDS;
 280
 281 typedef struct _AtomFRMA
 282 {
 283   Atom header;
 284
 285   guint32 media_type;
 286 } AtomFRMA;
 287
 288 typedef enum _SampleEntryKind
 289 {
 290   UNKNOWN,
 291   AUDIO,
 292   VIDEO
 293 } SampleEntryKind;
 294
 295 typedef struct _SampleTableEntry
 296 {
 297   Atom header;
 298
 299   guint8 reserved[6];
 300   guint16 data_reference_index;
 301
 302   /* sort of entry */
 303   SampleEntryKind kind;
 304 } SampleTableEntry;
 305
 306 typedef struct _AtomHintSampleEntry
 307 {
 308   SampleTableEntry se;
 309   guint32 size;
 310   guint8 *data;
 311 } AtomHintSampleEntry;
 312
 313 typedef struct _SampleTableEntryMP4V
 314 {
 315   SampleTableEntry se;
 316
 317   guint16 version;
 318   guint16 revision_level;
 319
 320   guint32 vendor;                 /* fourcc code */
 321   guint32 temporal_quality;
 322   guint32 spatial_quality;
 323
 324   guint16 width;
 325   guint16 height;
 326
 327   guint32 horizontal_resolution;
 328   guint32 vertical_resolution;
 329   guint32 datasize;
 330
 331   guint16 frame_count;            /* usually 1 */
 332
 333   guint8 compressor[32];         /* pascal string, i.e. first byte = length */
 334
 335   guint16 depth;
 336   guint16 color_table_id;
 337
 338   /* (optional) list of AtomInfo */
 339   GList *extension_atoms;
 340 } SampleTableEntryMP4V;
 341
 342 typedef struct _SampleTableEntryMP4A
 343 {
 344   SampleTableEntry se;
 345
 346   guint16 version;
 347   guint16 revision_level;
 348   guint32 vendor;
 349
 350   guint16 channels;
 351   guint16 sample_size;
 352   guint16 compression_id;
 353   guint16 packet_size;
 354
 355   guint32 sample_rate;            /* fixed point 16.16 */
 356
 357   guint32 samples_per_packet;
 358   guint32 bytes_per_packet;
 359   guint32 bytes_per_frame;
 360   guint32 bytes_per_sample;
 361
 362   /* (optional) list of AtomInfo */
 363   GList *extension_atoms;
 364 } SampleTableEntryMP4A;
 365
 366 typedef struct _SampleTableEntryMP4S
 367 {
 368   SampleTableEntry se;
 369
 370   AtomESDS es;
 371 } SampleTableEntryMP4S;
 372
 373 typedef struct _AtomSTSD
 374 {
 375   AtomFull header;
 376
 377   guint n_entries;
 378   /* list of subclasses of SampleTableEntry */
 379   GList *entries;
 380 } AtomSTSD;
 381
 382 typedef struct _AtomSTSZ
 383 {
 384   AtomFull header;
 385
 386   guint32 sample_size;
 387
 388   /* need the size here because when sample_size is constant,
 389    * the list is empty */
 390   guint32 table_size;
 391   /* list of guint32 */
 392   GList *entries;
 393 } AtomSTSZ;
 394
 395 typedef struct _STSCEntry
 396 {
 397   guint32 first_chunk;
 398   guint32 samples_per_chunk;
 399   guint32 sample_description_index;
 400 } STSCEntry;
 401
 402 typedef struct _AtomSTSC
 403 {
 404   AtomFull header;
 405
 406   guint n_entries;
 407   /* list of STSCEntry */
 408   GList *entries;
 409 } AtomSTSC;
 410
 411
 412 /*
 413  * used for both STCO and CO64
 414  * if used as STCO, entries should be truncated to use only 32bits
 415  */
 416 typedef struct _AtomSTCO64
 417 {
 418   AtomFull header;
 419
 420   guint n_entries;
 421   /* list of guint64 */
 422   GList *entries;
 423 } AtomSTCO64;
 424
 425 typedef struct _CTTSEntry
 426 {
 427   guint32 samplecount;
 428   guint32 sampleoffset;
 429 } CTTSEntry;
 430
 431 typedef struct _AtomCTTS
 432 {
 433   AtomFull header;
 434
 435   /* also entry count here */
 436   guint n_entries;
 437   GList *entries;
 438 } AtomCTTS;
 439
 440 typedef struct _AtomSTBL
 441 {
 442   Atom header;
 443
 444   AtomSTSD stsd;
 445   AtomSTTS stts;
 446   AtomSTSS stss;
 447   AtomSTSC stsc;
 448   AtomSTSZ stsz;
 449   /* NULL if not present */
 450   AtomCTTS *ctts;
 451
 452   AtomSTCO64 stco64;
 453 } AtomSTBL;
 454
 455 typedef struct _AtomMINF
 456 {
 457   Atom header;
 458
 459   /* only (exactly) one of those must be present */
 460   AtomVMHD *vmhd;
 461   AtomSMHD *smhd;
 462   AtomHMHD *hmhd;
 463
 464   AtomHDLR *hdlr;
 465   AtomDINF dinf;
 466   AtomSTBL stbl;
 467 } AtomMINF;
 468
 469 typedef struct _EditListEntry
 470 {
 471   /* duration in movie's timescale */
 472   guint32 duration;
 473   /* start time in media's timescale, -1 for empty */
 474   guint32 media_time;
 475   guint32 media_rate;  /* fixed point 32 bit */
 476 } EditListEntry;
 477
 478 typedef struct _AtomELST
 479 {
 480   AtomFull header;
 481
 482   /* number of entries is implicit */
 483   GSList *entries;
 484 } AtomELST;
 485
 486 typedef struct _AtomEDTS
 487 {
 488   Atom header;
 489   AtomELST elst;
 490 } AtomEDTS;
 491
 492 typedef struct _AtomMDIA
 493 {
 494   Atom header;
 495
 496   AtomMDHD mdhd;
 497   AtomHDLR hdlr;
 498   AtomMINF minf;
 499 } AtomMDIA;
 500
 501 typedef struct _AtomILST
 502 {
 503   Atom header;
 504
 505   /* list of AtomInfo */
 506   GList* entries;
 507 } AtomILST;
 508
 509 typedef struct _AtomTagData
 510 {
 511   AtomFull header;
 512   guint32 reserved;
 513
 514   guint32 datalen;
 515   guint8* data;
 516 } AtomTagData;
 517
 518 typedef struct _AtomTag
 519 {
 520   Atom header;
 521
 522   AtomTagData data;
 523 } AtomTag;
 524
 525 typedef struct _AtomMETA
 526 {
 527   AtomFull header;
 528   AtomHDLR hdlr;
 529   AtomILST *ilst;
 530 } AtomMETA;
 531
 532 typedef struct _AtomUDTA
 533 {
 534   Atom header;
 535
 536   /* list of AtomInfo */
 537   GList* entries;
 538   /* or list is further down */
 539   AtomMETA *meta;
 540 } AtomUDTA;
 541
 542 typedef struct _AtomTRAK
 543 {
 544   Atom header;
 545
 546   AtomTKHD tkhd;
 547   AtomEDTS *edts;
 548   AtomMDIA mdia;
 549
 550   /* some helper info for structural conformity checks */
 551   gboolean is_video;
 552   gboolean is_h264;
 553 } AtomTRAK;
 554
 555 typedef struct _AtomMOOV
 556 {
 557   /* style */
 558   AtomsContext context;
 559
 560   Atom header;
 561
 562   AtomMVHD mvhd;
 563
 564   /* list of AtomTRAK */
 565   GList *traks;
 566   AtomUDTA *udta;
 567 } AtomMOOV;
 568
 569 typedef struct _AtomWAVE
 570 {
 571   Atom header;
 572
 573   /* list of AtomInfo */
 574   GList *extension_atoms;
 575 } AtomWAVE;
 576
 577 /*
 578  * Function to serialize an atom
 579  */
 580 typedef guint64 (*AtomCopyDataFunc) (Atom *atom, guint8 **buffer, guint64 *size, guint64 *offset);
 581
 582 /*
 583  * Releases memory allocated by an atom
 584  */
 585 typedef guint64 (*AtomFreeFunc) (Atom *atom);
 586
 587 /*
 588  * Some atoms might have many optional different kinds of child atoms, so this
 589  * is useful for enabling generic handling of any atom.
 590  * All we need are the two functions (copying it to an array
 591  * for serialization and the memory releasing function).
 592  */
 593 typedef struct _AtomInfo
 594 {
 595   Atom *atom;
 596   AtomCopyDataFunc copy_data_func;
 597   AtomFreeFunc free_func;
 598 } AtomInfo;
 599
 600
 601 guint64    atom_copy_data              (Atom *atom, guint8 **buffer,
 602                                         guint64 *size, guint64* offset);
 603
 604 AtomFTYP*  atom_ftyp_new               (AtomsContext *context, guint32 major,
 605                                         guint32 version, GList *brands);
 606 guint64    atom_ftyp_copy_data         (AtomFTYP *ftyp, guint8 **buffer,
 607                                         guint64 *size, guint64 *offset);
 608 void       atom_ftyp_free              (AtomFTYP *ftyp);
 609
 610 AtomTRAK*  atom_trak_new               (AtomsContext *context);
 611 void       atom_trak_add_samples       (AtomTRAK * trak, guint32 nsamples, guint32 delta,
 612                                         guint32 size, guint64 chunk_offset, gboolean sync,
 613                                         gboolean do_pts, gint64 pts_offset);
 614 void       atom_trak_add_elst_entry    (AtomTRAK * trak, guint32 duration,
 615                                         guint32 media_time, guint32 rate);
 616 guint32    atom_trak_get_timescale     (AtomTRAK *trak);
 617
 618 AtomMOOV*  atom_moov_new               (AtomsContext *context);
 619 void       atom_moov_free              (AtomMOOV *moov);
 620 guint64    atom_moov_copy_data         (AtomMOOV *atom, guint8 **buffer, guint64 *size, guint64* offset);
 621 void       atom_moov_update_timescale  (AtomMOOV *moov, guint32 timescale);
 622 void       atom_moov_update_duration   (AtomMOOV *moov);
 623 void       atom_moov_set_64bits        (AtomMOOV *moov, gboolean large_file);
 624 void       atom_moov_chunks_add_offset (AtomMOOV *moov, guint32 offset);
 625 void       atom_moov_add_trak          (AtomMOOV *moov, AtomTRAK *trak);
 626
 627 /* media sample description related helpers */
 628
 629 typedef struct
 630 {
 631   guint16 version;
 632   guint32 fourcc;
 633   guint width;
 634   guint height;
 635   guint depth;
 636   guint frame_count;
 637   gint color_table_id;
 638   guint par_n;
 639   guint par_d;
 640
 641   GstBuffer *codec_data;
 642 } VisualSampleEntry;
 643
 644 typedef struct
 645 {
 646   guint32 fourcc;
 647   guint version;
 648   gint compression_id;
 649   guint sample_rate;
 650   guint channels;
 651   guint sample_size;
 652   guint bytes_per_packet;
 653   guint samples_per_packet;
 654   guint bytes_per_sample;
 655   guint bytes_per_frame;
 656
 657   GstBuffer *codec_data;
 658 } AudioSampleEntry;
 659
 660 void atom_trak_set_audio_type (AtomTRAK * trak, AtomsContext * context,
 661                                AudioSampleEntry * entry, guint32 scale,
 662                                AtomInfo * ext, gint sample_size);
 663
 664 void atom_trak_set_video_type (AtomTRAK * trak, AtomsContext * context,
 665                                VisualSampleEntry * entry, guint32 rate,
 666                                GList * ext_atoms_list);
 667
 668 AtomInfo *   build_codec_data_extension  (guint32 fourcc, const GstBuffer * codec_data);
 669 AtomInfo *   build_mov_aac_extension     (AtomTRAK * trak, const GstBuffer * codec_data);
 670 AtomInfo *   build_esds_extension        (AtomTRAK * trak, guint8 object_type,
 671                                           guint8 stream_type, const GstBuffer * codec_data);
 672 AtomInfo *   build_jp2h_extension        (AtomTRAK * trak, gint width, gint height,
 673                                           guint32 fourcc);
 674 AtomInfo *   build_amr_extension         ();
 675 AtomInfo *   build_h263_extension        ();
 676 AtomInfo *   build_gama_atom             (gdouble gamma);
 677 AtomInfo *   build_SMI_atom              (const GstBuffer *seqh);
 678
 679
 680 /*
 681  * Meta tags functions
 682  */
 683 void atom_moov_add_str_tag    (AtomMOOV *moov, guint32 fourcc, const gchar *value);
 684 void atom_moov_add_uint_tag   (AtomMOOV *moov, guint32 fourcc, guint32 flags,
 685                                guint32 value);
 686 void atom_moov_add_tag        (AtomMOOV *moov, guint32 fourcc, guint32 flags,
 687                                const guint8 * data, guint size);
 688 void atom_moov_add_blob_tag   (AtomMOOV *moov, guint8 *data, guint size);
 689
 690 void atom_moov_add_3gp_str_tag       (AtomMOOV * moov, guint32 fourcc, const gchar * value);
 691 void atom_moov_add_3gp_uint_tag      (AtomMOOV * moov, guint32 fourcc, guint16 value);
 692 void atom_moov_add_3gp_str_int_tag   (AtomMOOV * moov, guint32 fourcc, const gchar * value,
 693                                       gint16 ivalue);
 694 void atom_moov_add_3gp_tag           (AtomMOOV * moov, guint32 fourcc, guint8 * data,
 695                                       guint size);
 696
 697 #define GST_QT_MUX_DEFAULT_TAG_LANGUAGE   "eng"
 698 guint16  language_code               (const char * lang);
 699
 700 #endif /* __ATOMS_H__ */