1 /* Quicktime muxer plugin for GStreamer

     2  * Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>

     3  * Copyright (C) 2008 Mark Nauwelaerts <mnauw@users.sf.net>

     4  *

     5  * This library is free software; you can redistribute it and/or

     6  * modify it under the terms of the GNU Library General Public

     7  * License as published by the Free Software Foundation; either

     8  * version 2 of the License, or (at your option) any later version.

     9  *

    10  * This library is distributed in the hope that it will be useful,

    11  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13  * Library General Public License for more details.

    14  *

    15  * You should have received a copy of the GNU Library General Public

    16  * License along with this library; if not, write to the

    17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    18  * Boston, MA 02111-1307, USA.

    19  */

    20 /*

    21  * Unless otherwise indicated, Source Code is licensed under MIT license.

    22  * See further explanation attached in License Statement (distributed in the file

    23  * LICENSE).

    24  *

    25  * Permission is hereby granted, free of charge, to any person obtaining a copy of

    26  * this software and associated documentation files (the "Software"), to deal in

    27  * the Software without restriction, including without limitation the rights to

    28  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

    29  * of the Software, and to permit persons to whom the Software is furnished to do

    30  * so, subject to the following conditions:

    31  *

    32  * The above copyright notice and this permission notice shall be included in all

    33  * copies or substantial portions of the Software.

    34  *

    35  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

    36  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

    37  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

    38  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

    39  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

    40  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

    41  * SOFTWARE.

    42  */

    43 

    44 #include "atoms.h"

    45 #include <string.h>

    46 #include <glib.h>

    47 

    48 /* only needed for gst_util_uint64_scale */

    49 #include <gst/gst.h>

    50 

    51 /**

    52  * Creates a new AtomsContext for the given flavor.

    53  */

    54 AtomsContext *

    55 atoms_context_new (AtomsTreeFlavor flavor)

    56 {

    57   AtomsContext *context = g_new0 (AtomsContext, 1);

    58   context->flavor = flavor;

    59   return context;

    60 }

    61 

    62 /**

    63  * Frees an AtomsContext and all memory associated with it

    64  */

    65 void

    66 atoms_context_free (AtomsContext * context)

    67 {

    68   g_free (context);

    69 }

    70 

    71 /* -- creation, initialization, clear and free functions -- */

    72 

    73 #define SECS_PER_DAY (24 * 60 * 60)

    74 #define LEAP_YEARS_FROM_1904_TO_1970 17

    75 

    76 static guint64

    77 get_current_qt_time ()

    78 {

    79   GTimeVal timeval;

    80 

    81   g_get_current_time (&timeval);

    82   /* FIXME this should use UTC coordinated time */

    83   return timeval.tv_sec + (((1970 - 1904) * (guint64) 365) +

    84       LEAP_YEARS_FROM_1904_TO_1970) * SECS_PER_DAY;

    85 }

    86 

    87 static void

    88 common_time_info_init (TimeInfo * ti)

    89 {

    90   ti->creation_time = ti->modification_time = get_current_qt_time ();

    91   ti->timescale = 0;

    92   ti->duration = 0;

    93 }

    94 

    95 static void

    96 atom_header_set (Atom * header, guint32 fourcc, gint32 size, gint64 ext_size)

    97 {

    98   header->type = fourcc;

    99   header->size = size;

   100   header->extended_size = ext_size;

   101 }

   102 

   103 static void

   104 atom_clear (Atom * atom)

   105 {

   106 }

   107 

   108 static void

   109 atom_full_init (AtomFull * full, guint32 fourcc, gint32 size, gint64 ext_size,

   110     guint8 version, guint8 flags[3])

   111 {

   112   atom_header_set (&(full->header), fourcc, size, ext_size);

   113   full->version = version;

   114   full->flags[0] = flags[0];

   115   full->flags[1] = flags[1];

   116   full->flags[2] = flags[2];

   117 }

   118 

   119 static void

   120 atom_full_clear (AtomFull * full)

   121 {

   122   atom_clear (&full->header);

   123 }

   124 

   125 static void

   126 atom_full_free (AtomFull * full)

   127 {

   128   atom_full_clear (full);

   129   g_free (full);

   130 }

   131 

   132 static AtomInfo *

   133 build_atom_info_wrapper (Atom * atom, gpointer copy_func, gpointer free_func)

   134 {

   135   AtomInfo *info = NULL;

   136 

   137   if (atom) {

   138     info = g_new0 (AtomInfo, 1);

   139 

   140     info->atom = atom;

   141     info->copy_data_func = copy_func;

   142     info->free_func = free_func;

   143   }

   144 

   145   return info;

   146 }

   147 

   148 static GList *

   149 atom_info_list_prepend_atom (GList * ai, Atom * atom,

   150     AtomCopyDataFunc copy_func, AtomFreeFunc free_func)

   151 {

   152   if (atom)

   153     return g_list_prepend (ai,

   154         build_atom_info_wrapper (atom, (gpointer)copy_func, (gpointer)free_func));

   155   else

   156     return ai;

   157 }

   158 

   159 static void

   160 atom_info_list_free (GList * ai)

   161 {

   162   while (ai) {

   163     AtomInfo *info = (AtomInfo *) ai->data;

   164 

   165     info->free_func (info->atom);

   166     g_free (info);

   167     ai = g_list_delete_link (ai, ai);

   168   }

   169 }

   170 

   171 static AtomData *

   172 atom_data_new (guint32 fourcc)

   173 {

   174   AtomData *data = g_new0 (AtomData, 1);

   175 

   176   atom_header_set (&data->header, fourcc, 0, 0);

   177   return data;

   178 }

   179 

   180 static void

   181 atom_data_alloc_mem (AtomData * data, guint32 size)

   182 {

   183   if (data->data) {

   184     g_free (data->data);

   185   }

   186   data->data = g_new0 (guint8, size);

   187   data->datalen = size;

   188 }

   189 

   190 static AtomData *

   191 atom_data_new_from_gst_buffer (guint32 fourcc, const GstBuffer * buf)

   192 {

   193   AtomData *data = atom_data_new (fourcc);

   194 

   195   atom_data_alloc_mem (data, GST_BUFFER_SIZE (buf));

   196   g_memmove (data->data, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));

   197   return data;

   198 }

   199 

   200 static void

   201 atom_data_free (AtomData * data)

   202 {

   203   atom_clear (&data->header);

   204   g_free (data->data);

   205   g_free (data);

   206 }

   207 

   208 static void

   209 atom_ftyp_init (AtomFTYP * ftyp, guint32 major, guint32 version, GList * brands)

   210 {

   211   gint index;

   212   GList *it = NULL;

   213 

   214   atom_header_set (&ftyp->header, FOURCC_ftyp, 16, 0);

   215   ftyp->major_brand = major;

   216   ftyp->version = version;

   217 

   218   /* always include major brand as compatible brand */

   219   ftyp->compatible_brands_size = g_list_length (brands) + 1;

   220   ftyp->compatible_brands = g_new (guint32, ftyp->compatible_brands_size);

   221 

   222   ftyp->compatible_brands[0] = major;

   223   index = 1;

   224   for (it = brands; it != NULL; it = g_list_next (it)) {

   225     ftyp->compatible_brands[index++] = GPOINTER_TO_UINT (it->data);

   226   }

   227 }

   228 

   229 AtomFTYP *

   230 atom_ftyp_new (AtomsContext * context, guint32 major, guint32 version,

   231     GList * brands)

   232 {

   233   AtomFTYP *ftyp = g_new0 (AtomFTYP, 1);

   234 

   235   atom_ftyp_init (ftyp, major, version, brands);

   236   return ftyp;

   237 }

   238 

   239 void

   240 atom_ftyp_free (AtomFTYP * ftyp)

   241 {

   242   atom_clear (&ftyp->header);

   243   g_free (ftyp->compatible_brands);

   244   ftyp->compatible_brands = NULL;

   245   g_free (ftyp);

   246 }

   247 

   248 static void

   249 atom_esds_init (AtomESDS * esds)

   250 {

   251   guint8 flags[3] = { 0, 0, 0 };

   252 

   253   atom_full_init (&esds->header, FOURCC_esds, 0, 0, 0, flags);

   254   desc_es_init (&esds->es);

   255 }

   256 

   257 static AtomESDS *

   258 atom_esds_new ()

   259 {

   260   AtomESDS *esds = g_new0 (AtomESDS, 1);

   261 

   262   atom_esds_init (esds);

   263   return esds;

   264 }

   265 

   266 static void

   267 atom_esds_free (AtomESDS * esds)

   268 {

   269   atom_full_clear (&esds->header);

   270   desc_es_descriptor_clear (&esds->es);

   271   g_free (esds);

   272 }

   273 

   274 static AtomFRMA *

   275 atom_frma_new ()

   276 {

   277   AtomFRMA *frma = g_new0 (AtomFRMA, 1);

   278 

   279   atom_header_set (&frma->header, FOURCC_frma, 0, 0);

   280   return frma;

   281 }

   282 

   283 static void

   284 atom_frma_free (AtomFRMA * frma)

   285 {

   286   atom_clear (&frma->header);

   287   g_free (frma);

   288 }

   289 

   290 static AtomWAVE *

   291 atom_wave_new ()

   292 {

   293   AtomWAVE *wave = g_new0 (AtomWAVE, 1);

   294 

   295   atom_header_set (&wave->header, FOURCC_wave, 0, 0);

   296   return wave;

   297 }

   298 

   299 static void

   300 atom_wave_free (AtomWAVE * wave)

   301 {

   302   atom_clear (&wave->header);

   303   atom_info_list_free (wave->extension_atoms);

   304   g_free (wave);

   305 }

   306 

   307 static void

   308 atom_sample_entry_init (SampleTableEntry * se, guint32 type)

   309 {

   310   atom_header_set (&se->header, type, 0, 0);

   311 

   312   memset (se->reserved, 0, sizeof (guint8) * 6);

   313   se->data_reference_index = 0;

   314 }

   315 

   316 static void

   317 atom_sample_entry_free (SampleTableEntry * se)

   318 {

   319   atom_clear (&se->header);

   320 }

   321 

   322 static void

   323 sample_entry_mp4a_init (SampleTableEntryMP4A * mp4a)

   324 {

   325   atom_sample_entry_init (&mp4a->se, FOURCC_mp4a);

   326 

   327   mp4a->version = 0;

   328   mp4a->revision_level = 0;

   329   mp4a->vendor = 0;

   330   mp4a->channels = 2;

   331   mp4a->sample_size = 16;

   332   mp4a->compression_id = 0;

   333   mp4a->packet_size = 0;

   334   mp4a->sample_rate = 0;

   335   /* following only used if version is 1 */

   336   mp4a->samples_per_packet = 0;

   337   mp4a->bytes_per_packet = 0;

   338   mp4a->bytes_per_frame = 0;

   339   mp4a->bytes_per_sample = 0;

   340 

   341   mp4a->extension_atoms = NULL;

   342 }

   343 

   344 static SampleTableEntryMP4A *

   345 sample_entry_mp4a_new ()

   346 {

   347   SampleTableEntryMP4A *mp4a = g_new0 (SampleTableEntryMP4A, 1);

   348 

   349   sample_entry_mp4a_init (mp4a);

   350   return mp4a;

   351 }

   352 

   353 static void

   354 sample_entry_mp4a_free (SampleTableEntryMP4A * mp4a)

   355 {

   356   atom_sample_entry_free (&mp4a->se);

   357   atom_info_list_free (mp4a->extension_atoms);

   358   g_free (mp4a);

   359 }

   360 

   361 static void

   362 sample_entry_mp4v_init (SampleTableEntryMP4V * mp4v, AtomsContext * context)

   363 {

   364   atom_sample_entry_init (&mp4v->se, FOURCC_mp4v);

   365 

   366   mp4v->version = 0;

   367   mp4v->revision_level = 0;

   368   mp4v->vendor = 0;

   369 

   370   mp4v->temporal_quality = 0;

   371   mp4v->spatial_quality = 0;

   372 

   373   /* qt and ISO base media do not contradict, and examples agree */

   374   mp4v->horizontal_resolution = 0x00480000;

   375   mp4v->vertical_resolution = 0x00480000;

   376 

   377   mp4v->datasize = 0;

   378   mp4v->frame_count = 1;

   379 

   380   memset (mp4v->compressor, 0, sizeof (guint8) * 32);

   381 

   382   mp4v->depth = 0;

   383   mp4v->color_table_id = 0;

   384 

   385   mp4v->extension_atoms = NULL;

   386 }

   387 

   388 static void

   389 sample_entry_mp4v_free (SampleTableEntryMP4V * mp4v)

   390 {

   391   atom_sample_entry_free (&mp4v->se);

   392   atom_info_list_free (mp4v->extension_atoms);

   393   g_free (mp4v);

   394 }

   395 

   396 static SampleTableEntryMP4V *

   397 sample_entry_mp4v_new (AtomsContext * context)

   398 {

   399   SampleTableEntryMP4V *mp4v = g_new0 (SampleTableEntryMP4V, 1);

   400 

   401   sample_entry_mp4v_init (mp4v, context);

   402   return mp4v;

   403 }

   404 

   405 static void

   406 atom_stsd_init (AtomSTSD * stsd)

   407 {

   408   guint8 flags[3] = { 0, 0, 0 };

   409 

   410   atom_full_init (&stsd->header, FOURCC_stsd, 0, 0, 0, flags);

   411   stsd->entries = NULL;

   412 }

   413 

   414 static void

   415 atom_stsd_clear (AtomSTSD * stsd)

   416 {

   417   GList *walker;

   418 

   419   atom_full_clear (&stsd->header);

   420   walker = stsd->entries;

   421   while (walker) {

   422     GList *aux = walker;

   423     SampleTableEntry *se = (SampleTableEntry *) aux->data;

   424 

   425     walker = g_list_next (walker);

   426     stsd->entries = g_list_remove_link (stsd->entries, aux);

   427 

   428     switch (se->kind) {

   429       case AUDIO:

   430         sample_entry_mp4a_free ((SampleTableEntryMP4A *) se);

   431         break;

   432       case VIDEO:

   433         sample_entry_mp4v_free ((SampleTableEntryMP4V *) se);

   434         break;

   435       default:

   436         /* best possible cleanup */

   437         atom_sample_entry_free (se);

   438     }

   439     g_list_free (aux);

   440   }

   441 }

   442 

   443 static void

   444 atom_ctts_init (AtomCTTS * ctts)

   445 {

   446   guint8 flags[3] = { 0, 0, 0 };

   447 

   448   atom_full_init (&ctts->header, FOURCC_ctts, 0, 0, 0, flags);

   449   ctts->entries = NULL;

   450 }

   451 

   452 static AtomCTTS *

   453 atom_ctts_new ()

   454 {

   455   AtomCTTS *ctts = g_new0 (AtomCTTS, 1);

   456 

   457   atom_ctts_init (ctts);

   458   return ctts;

   459 }

   460 

   461 static void

   462 atom_ctts_free (AtomCTTS * ctts)

   463 {

   464   GList *walker;

   465 

   466   atom_full_clear (&ctts->header);

   467   walker = ctts->entries;

   468   while (walker) {

   469     GList *aux = walker;

   470 

   471     walker = g_list_next (walker);

   472     ctts->entries = g_list_remove_link (ctts->entries, aux);

   473     g_free ((CTTSEntry *) aux->data);

   474     g_list_free (aux);

   475   }

   476   g_free (ctts);

   477 }

   478 

   479 static void

   480 atom_stts_init (AtomSTTS * stts)

   481 {

   482   guint8 flags[3] = { 0, 0, 0 };

   483 

   484   atom_full_init (&stts->header, FOURCC_stts, 0, 0, 0, flags);

   485   stts->entries = NULL;

   486 }

   487 

   488 static void

   489 atom_stts_clear (AtomSTTS * stts)

   490 {

   491   GList *walker;

   492 

   493   atom_full_clear (&stts->header);

   494   walker = stts->entries;

   495   while (walker) {

   496     GList *aux = walker;

   497 

   498     walker = g_list_next (walker);

   499     stts->entries = g_list_remove_link (stts->entries, aux);

   500     g_free ((STTSEntry *) aux->data);

   501     g_list_free (aux);

   502   }

   503   stts->n_entries = 0;

   504 }

   505 

   506 static void

   507 atom_stsz_init (AtomSTSZ * stsz)

   508 {

   509   guint8 flags[3] = { 0, 0, 0 };

   510 

   511   atom_full_init (&stsz->header, FOURCC_stsz, 0, 0, 0, flags);

   512   stsz->sample_size = 0;

   513   stsz->table_size = 0;

   514   stsz->entries = NULL;

   515 }

   516 

   517 static void

   518 atom_stsz_clear (AtomSTSZ * stsz)

   519 {

   520   atom_full_clear (&stsz->header);

   521   g_list_free (stsz->entries);

   522   stsz->entries = NULL;

   523   stsz->table_size = 0;

   524 }

   525 

   526 static void

   527 atom_stsc_init (AtomSTSC * stsc)

   528 {

   529   guint8 flags[3] = { 0, 0, 0 };

   530 

   531   atom_full_init (&stsc->header, FOURCC_stsc, 0, 0, 0, flags);

   532   stsc->entries = NULL;

   533   stsc->n_entries = 0;

   534 }

   535 

   536 static void

   537 atom_stsc_clear (AtomSTSC * stsc)

   538 {

   539   GList *walker;

   540 

   541   atom_full_clear (&stsc->header);

   542   walker = stsc->entries;

   543   while (walker) {

   544     GList *aux = walker;

   545 

   546     walker = g_list_next (walker);

   547     stsc->entries = g_list_remove_link (stsc->entries, aux);

   548     g_free ((STSCEntry *) aux->data);

   549     g_list_free (aux);

   550   }

   551   stsc->n_entries = 0;

   552 }

   553 

   554 static void

   555 atom_co64_init (AtomSTCO64 * co64)

   556 {

   557   guint8 flags[3] = { 0, 0, 0 };

   558 

   559   atom_full_init (&co64->header, FOURCC_co64, 0, 0, 0, flags);

   560   co64->entries = NULL;

   561   co64->n_entries = 0;

   562 }

   563 

   564 static void

   565 atom_stco64_clear (AtomSTCO64 * stco64)

   566 {

   567   GList *walker;

   568 

   569   atom_full_clear (&stco64->header);

   570   walker = stco64->entries;

   571   while (walker) {

   572     GList *aux = walker;

   573 

   574     walker = g_list_next (walker);

   575     stco64->entries = g_list_remove_link (stco64->entries, aux);

   576     g_free ((guint64 *) aux->data);

   577     g_list_free (aux);

   578   }

   579   stco64->n_entries = 0;

   580 }

   581 

   582 static void

   583 atom_stss_init (AtomSTSS * stss)

   584 {

   585   guint8 flags[3] = { 0, 0, 0 };

   586 

   587   atom_full_init (&stss->header, FOURCC_stss, 0, 0, 0, flags);

   588   stss->entries = NULL;

   589   stss->n_entries = 0;

   590 }

   591 

   592 static void

   593 atom_stss_clear (AtomSTSS * stss)

   594 {

   595   atom_full_clear (&stss->header);

   596   g_list_free (stss->entries);

   597   stss->entries = NULL;

   598   stss->n_entries = 0;

   599 }

   600 

   601 static void

   602 atom_stbl_init (AtomSTBL * stbl)

   603 {

   604   atom_header_set (&stbl->header, FOURCC_stbl, 0, 0);

   605 

   606   atom_stts_init (&stbl->stts);

   607   atom_stss_init (&stbl->stss);

   608   atom_stsd_init (&stbl->stsd);

   609   atom_stsz_init (&stbl->stsz);

   610   atom_stsc_init (&stbl->stsc);

   611   stbl->ctts = NULL;

   612 

   613   atom_co64_init (&stbl->stco64);

   614 }

   615 

   616 static void

   617 atom_stbl_clear (AtomSTBL * stbl)

   618 {

   619   atom_clear (&stbl->header);

   620   atom_stsd_clear (&stbl->stsd);

   621   atom_stts_clear (&stbl->stts);

   622   atom_stss_clear (&stbl->stss);

   623   atom_stsc_clear (&stbl->stsc);

   624   atom_stsz_clear (&stbl->stsz);

   625   if (stbl->ctts) {

   626     atom_ctts_free (stbl->ctts);

   627   }

   628   atom_stco64_clear (&stbl->stco64);

   629 }

   630 

   631 static void

   632 atom_vmhd_init (AtomVMHD * vmhd, AtomsContext * context)

   633 {

   634   guint8 flags[3] = { 0, 0, 1 };

   635 

   636   atom_full_init (&vmhd->header, FOURCC_vmhd, 0, 0, 0, flags);

   637   vmhd->graphics_mode = 0x0;

   638   memset (vmhd->opcolor, 0, sizeof (guint16) * 3);

   639 

   640   if (context->flavor == ATOMS_TREE_FLAVOR_MOV) {

   641     vmhd->graphics_mode = 0x40;

   642     vmhd->opcolor[0] = 32768;

   643     vmhd->opcolor[1] = 32768;

   644     vmhd->opcolor[2] = 32768;

   645   }

   646 }

   647 

   648 static AtomVMHD *

   649 atom_vmhd_new (AtomsContext * context)

   650 {

   651   AtomVMHD *vmhd = g_new0 (AtomVMHD, 1);

   652 

   653   atom_vmhd_init (vmhd, context);

   654   return vmhd;

   655 }

   656 

   657 static void

   658 atom_vmhd_free (AtomVMHD * vmhd)

   659 {

   660   atom_full_clear (&vmhd->header);

   661   g_free (vmhd);

   662 }

   663 

   664 static void

   665 atom_smhd_init (AtomSMHD * smhd)

   666 {

   667   guint8 flags[3] = { 0, 0, 0 };

   668 

   669   atom_full_init (&smhd->header, FOURCC_smhd, 0, 0, 0, flags);

   670   smhd->balance = 0;

   671   smhd->reserved = 0;

   672 }

   673 

   674 static AtomSMHD *

   675 atom_smhd_new ()

   676 {

   677   AtomSMHD *smhd = g_new0 (AtomSMHD, 1);

   678 

   679   atom_smhd_init (smhd);

   680   return smhd;

   681 }

   682 

   683 static void

   684 atom_smhd_free (AtomSMHD * smhd)

   685 {

   686   atom_full_clear (&smhd->header);

   687   g_free (smhd);

   688 }

   689 

   690 static void

   691 atom_hmhd_free (AtomHMHD * hmhd)

   692 {

   693   atom_full_clear (&hmhd->header);

   694   g_free (hmhd);

   695 }

   696 

   697 static void

   698 atom_hdlr_init (AtomHDLR * hdlr)

   699 {

   700   guint8 flags[3] = { 0, 0, 0 };

   701 

   702   atom_full_init (&hdlr->header, FOURCC_hdlr, 0, 0, 0, flags);

   703 

   704   hdlr->component_type = 0;

   705   hdlr->handler_type = 0;

   706   hdlr->manufacturer = 0;

   707   hdlr->flags = 0;

   708   hdlr->flags_mask = 0;

   709   hdlr->name = g_strdup ("");

   710 }

   711 

   712 static AtomHDLR *

   713 atom_hdlr_new ()

   714 {

   715   AtomHDLR *hdlr = g_new0 (AtomHDLR, 1);

   716 

   717   atom_hdlr_init (hdlr);

   718   return hdlr;

   719 }

   720 

   721 static void

   722 atom_hdlr_clear (AtomHDLR * hdlr)

   723 {

   724   atom_full_clear (&hdlr->header);

   725   if (hdlr->name) {

   726     g_free (hdlr->name);

   727     hdlr->name = NULL;

   728   }

   729 }

   730 

   731 static void

   732 atom_hdlr_free (AtomHDLR * hdlr)

   733 {

   734   atom_hdlr_clear (hdlr);

   735   g_free (hdlr);

   736 }

   737 

   738 static void

   739 atom_url_init (AtomURL * url)

   740 {

   741   guint8 flags[3] = { 0, 0, 1 };

   742 

   743   atom_full_init (&url->header, FOURCC_url_, 0, 0, 0, flags);

   744   url->location = NULL;

   745 }

   746 

   747 static void

   748 atom_url_free (AtomURL * url)

   749 {

   750   atom_full_clear (&url->header);

   751   if (url->location) {

   752     g_free (url->location);

   753     url->location = NULL;

   754   }

   755   g_free (url);

   756 }

   757 

   758 static AtomURL *

   759 atom_url_new ()

   760 {

   761   AtomURL *url = g_new0 (AtomURL, 1);

   762 

   763   atom_url_init (url);

   764   return url;

   765 }

   766 

   767 static AtomFull *

   768 atom_alis_new ()

   769 {

   770   guint8 flags[3] = { 0, 0, 1 };

   771   AtomFull *alis = g_new0 (AtomFull, 1);

   772 

   773   atom_full_init (alis, FOURCC_alis, 0, 0, 0, flags);

   774   return alis;

   775 }

   776 

   777 static void

   778 atom_dref_init (AtomDREF * dref, AtomsContext * context)

   779 {

   780   guint8 flags[3] = { 0, 0, 0 };

   781 

   782   atom_full_init (&dref->header, FOURCC_dref, 0, 0, 0, flags);

   783 

   784   /* in either case, alis or url init arranges to set self-contained flag */

   785   if (context->flavor == ATOMS_TREE_FLAVOR_MOV) {

   786     /* alis dref for qt */

   787     AtomFull *alis = atom_alis_new ();

   788     dref->entries = g_list_append (dref->entries, alis);

   789   } else {

   790     /* url for iso spec, as 'alis' not specified there */

   791     AtomURL *url = atom_url_new ();

   792     dref->entries = g_list_append (dref->entries, url);

   793   }

   794 }

   795 

   796 static void

   797 atom_dref_clear (AtomDREF * dref)

   798 {

   799   GList *walker;

   800 

   801   atom_full_clear (&dref->header);

   802   walker = dref->entries;

   803   while (walker) {

   804     GList *aux = walker;

   805     Atom *atom = (Atom *) aux->data;

   806 

   807     walker = g_list_next (walker);

   808     dref->entries = g_list_remove_link (dref->entries, aux);

   809     switch (atom->type) {

   810       case FOURCC_alis:

   811         atom_full_free ((AtomFull *) atom);

   812         break;

   813       case FOURCC_url_:

   814         atom_url_free ((AtomURL *) atom);

   815         break;

   816       default:

   817         /* we do nothing, better leak than crash */

   818         break;

   819     }

   820     g_list_free (aux);

   821   }

   822 }

   823 

   824 static void

   825 atom_dinf_init (AtomDINF * dinf, AtomsContext * context)

   826 {

   827   atom_header_set (&dinf->header, FOURCC_dinf, 0, 0);

   828   atom_dref_init (&dinf->dref, context);

   829 }

   830 

   831 static void

   832 atom_dinf_clear (AtomDINF * dinf)

   833 {

   834   atom_clear (&dinf->header);

   835   atom_dref_clear (&dinf->dref);

   836 }

   837 

   838 static void

   839 atom_minf_init (AtomMINF * minf, AtomsContext * context)

   840 {

   841   atom_header_set (&minf->header, FOURCC_minf, 0, 0);

   842 

   843   minf->vmhd = NULL;

   844   minf->smhd = NULL;

   845   minf->hmhd = NULL;

   846 

   847   if (context->flavor == ATOMS_TREE_FLAVOR_MOV) {

   848     minf->hdlr = atom_hdlr_new ();

   849     minf->hdlr->component_type = FOURCC_dhlr;

   850     minf->hdlr->handler_type = FOURCC_alis;

   851   } else {

   852     minf->hdlr = NULL;

   853   }

   854   atom_dinf_init (&minf->dinf, context);

   855   atom_stbl_init (&minf->stbl);

   856 }

   857 

   858 static void

   859 atom_minf_clear_handlers (AtomMINF * minf)

   860 {

   861   if (minf->vmhd) {

   862     atom_vmhd_free (minf->vmhd);

   863     minf->vmhd = NULL;

   864   }

   865   if (minf->smhd) {

   866     atom_smhd_free (minf->smhd);

   867     minf->smhd = NULL;

   868   }

   869   if (minf->hmhd) {

   870     atom_hmhd_free (minf->hmhd);

   871     minf->hmhd = NULL;

   872   }

   873 }

   874 

   875 static void

   876 atom_minf_clear (AtomMINF * minf)

   877 {

   878   atom_clear (&minf->header);

   879   atom_minf_clear_handlers (minf);

   880   if (minf->hdlr) {

   881     atom_hdlr_free (minf->hdlr);

   882   }

   883   atom_dinf_clear (&minf->dinf);

   884   atom_stbl_clear (&minf->stbl);

   885 }

   886 

   887 static void

   888 atom_mdhd_init (AtomMDHD * mdhd)

   889 {

   890   guint8 flags[3] = { 0, 0, 0 };

   891 

   892   atom_full_init (&mdhd->header, FOURCC_mdhd, 0, 0, 0, flags);

   893   common_time_info_init (&mdhd->time_info);

   894   mdhd->language_code = 0;

   895   mdhd->quality = 0;

   896 }

   897 

   898 static void

   899 atom_mdhd_clear (AtomMDHD * mdhd)

   900 {

   901   atom_full_clear (&mdhd->header);

   902 }

   903 

   904 static void

   905 atom_mdia_init (AtomMDIA * mdia, AtomsContext * context)

   906 {

   907   atom_header_set (&mdia->header, FOURCC_mdia, 0, 0);

   908 

   909   atom_mdhd_init (&mdia->mdhd);

   910   atom_hdlr_init (&mdia->hdlr);

   911   atom_minf_init (&mdia->minf, context);

   912 }

   913 

   914 static void

   915 atom_mdia_clear (AtomMDIA * mdia)

   916 {

   917   atom_clear (&mdia->header);

   918   atom_mdhd_clear (&mdia->mdhd);

   919   atom_hdlr_clear (&mdia->hdlr);

   920   atom_minf_clear (&mdia->minf);

   921 }

   922 

   923 static void

   924 atom_tkhd_init (AtomTKHD * tkhd, AtomsContext * context)

   925 {

   926   /*

   927    * flags info

   928    * 1 -> track enabled

   929    * 2 -> track in movie

   930    * 4 -> track in preview

   931    */

   932   guint8 flags[3] = { 0, 0, 7 };

   933 

   934   atom_full_init (&tkhd->header, FOURCC_tkhd, 0, 0, 0, flags);

   935 

   936   tkhd->creation_time = tkhd->modification_time = get_current_qt_time ();

   937   tkhd->duration = 0;

   938   tkhd->track_ID = 0;

   939   tkhd->reserved = 0;

   940 

   941   tkhd->reserved2[0] = tkhd->reserved2[1] = 0;

   942   tkhd->layer = 0;

   943   tkhd->alternate_group = 0;

   944   tkhd->volume = 0;

   945   tkhd->reserved3 = 0;

   946   memset (tkhd->matrix, 0, sizeof (guint32) * 9);

   947   tkhd->matrix[0] = 1 << 16;

   948   tkhd->matrix[4] = 1 << 16;

   949   tkhd->matrix[8] = 16384 << 16;

   950   tkhd->width = 0;

   951   tkhd->height = 0;

   952 }

   953 

   954 static void

   955 atom_tkhd_clear (AtomTKHD * tkhd)

   956 {

   957   atom_full_clear (&tkhd->header);

   958 }

   959 

   960 static void

   961 atom_trak_init (AtomTRAK * trak, AtomsContext * context)

   962 {

   963   atom_header_set (&trak->header, FOURCC_trak, 0, 0);

   964 

   965   atom_tkhd_init (&trak->tkhd, context);

   966   atom_mdia_init (&trak->mdia, context);

   967 }

   968 

   969 AtomTRAK *

   970 atom_trak_new (AtomsContext * context)

   971 {

   972   AtomTRAK *trak = g_new0 (AtomTRAK, 1);

   973 

   974   atom_trak_init (trak, context);

   975   return trak;

   976 }

   977 

   978 static void

   979 atom_trak_free (AtomTRAK * trak)

   980 {

   981   atom_clear (&trak->header);

   982   atom_tkhd_clear (&trak->tkhd);

   983   atom_mdia_clear (&trak->mdia);

   984   g_free (trak);

   985 }

   986 

   987 static void

   988 atom_ilst_init (AtomILST * ilst)

   989 {

   990   atom_header_set (&ilst->header, FOURCC_ilst, 0, 0);

   991   ilst->entries = NULL;

   992 }

   993 

   994 static AtomILST *

   995 atom_ilst_new ()

   996 {

   997   AtomILST *ilst = g_new0 (AtomILST, 1);

   998 

   999   atom_ilst_init (ilst);

  1000   return ilst;

  1001 }

  1002 

  1003 static void

  1004 atom_ilst_free (AtomILST * ilst)

  1005 {

  1006   if (ilst->entries)

  1007     atom_info_list_free (ilst->entries);

  1008   atom_clear (&ilst->header);

  1009   g_free (ilst);

  1010 }

  1011 

  1012 static void

  1013 atom_meta_init (AtomMETA * meta)

  1014 {

  1015   guint8 flags[3] = { 0, 0, 0 };

  1016 

  1017   atom_full_init (&meta->header, FOURCC_meta, 0, 0, 0, flags);

  1018   atom_hdlr_init (&meta->hdlr);

  1019   /* FIXME (ISOM says this is always 0) */

  1020   meta->hdlr.component_type = FOURCC_mhlr;

  1021   meta->hdlr.handler_type = FOURCC_mdir;

  1022   meta->ilst = NULL;

  1023 }

  1024 

  1025 static AtomMETA *

  1026 atom_meta_new ()

  1027 {

  1028   AtomMETA *meta = g_new0 (AtomMETA, 1);

  1029 

  1030   atom_meta_init (meta);

  1031   return meta;

  1032 }

  1033 

  1034 static void

  1035 atom_meta_free (AtomMETA * meta)

  1036 {

  1037   atom_full_clear (&meta->header);

  1038   atom_hdlr_clear (&meta->hdlr);

  1039   if (meta->ilst)

  1040     atom_ilst_free (meta->ilst);

  1041   meta->ilst = NULL;

  1042   g_free (meta);

  1043 }

  1044 

  1045 static void

  1046 atom_udta_init (AtomUDTA * udta)

  1047 {

  1048   atom_header_set (&udta->header, FOURCC_udta, 0, 0);

  1049   udta->meta = NULL;

  1050 }

  1051 

  1052 static AtomUDTA *

  1053 atom_udta_new ()

  1054 {

  1055   AtomUDTA *udta = g_new0 (AtomUDTA, 1);

  1056 

  1057   atom_udta_init (udta);

  1058   return udta;

  1059 }

  1060 

  1061 static void

  1062 atom_udta_free (AtomUDTA * udta)

  1063 {

  1064   atom_clear (&udta->header);

  1065   if (udta->meta)

  1066     atom_meta_free (udta->meta);

  1067   udta->meta = NULL;

  1068   if (udta->entries)

  1069     atom_info_list_free (udta->entries);

  1070   g_free (udta);

  1071 }

  1072 

  1073 static void

  1074 atom_tag_data_init (AtomTagData * data)

  1075 {

  1076   guint8 flags[] = { 0, 0, 0 };

  1077 

  1078   atom_full_init (&data->header, FOURCC_data, 0, 0, 0, flags);

  1079 }

  1080 

  1081 static void

  1082 atom_tag_data_clear (AtomTagData * data)

  1083 {

  1084   atom_full_clear (&data->header);

  1085   g_free (data->data);

  1086   data->datalen = 0;

  1087 }

  1088 

  1089 /*

  1090  * Fourcc is the tag fourcc

  1091  * flags will be truncated to 24bits

  1092  */

  1093 static AtomTag *

  1094 atom_tag_new (guint32 fourcc, guint32 flags_as_uint)

  1095 {

  1096   AtomTag *tag = g_new0 (AtomTag, 1);

  1097 

  1098   tag->header.type = fourcc;

  1099   atom_tag_data_init (&tag->data);

  1100   tag->data.header.flags[2] = flags_as_uint & 0xFF;

  1101   tag->data.header.flags[1] = (flags_as_uint & 0xFF00) >> 8;

  1102   tag->data.header.flags[0] = (flags_as_uint & 0xFF0000) >> 16;

  1103   return tag;

  1104 }

  1105 

  1106 static void

  1107 atom_tag_free (AtomTag * tag)

  1108 {

  1109   atom_clear (&tag->header);

  1110   atom_tag_data_clear (&tag->data);

  1111   g_free (tag);

  1112 }

  1113 

  1114 static void

  1115 atom_mvhd_init (AtomMVHD * mvhd)

  1116 {

  1117   guint8 flags[3] = { 0, 0, 0 };

  1118 

  1119   atom_full_init (&(mvhd->header), FOURCC_mvhd, sizeof (AtomMVHD), 0, 0, flags);

  1120 

  1121   common_time_info_init (&mvhd->time_info);

  1122 

  1123   mvhd->prefered_rate = 1 << 16;

  1124   mvhd->volume = 1 << 8;

  1125   mvhd->reserved3 = 0;

  1126   memset (mvhd->reserved4, 0, sizeof (guint32[2]));

  1127 

  1128   memset (mvhd->matrix, 0, sizeof (guint32[9]));

  1129   mvhd->matrix[0] = 1 << 16;

  1130   mvhd->matrix[4] = 1 << 16;

  1131   mvhd->matrix[8] = 16384 << 16;

  1132 

  1133   mvhd->preview_time = 0;

  1134   mvhd->preview_duration = 0;

  1135   mvhd->poster_time = 0;