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