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 

    45 /**

    46  * SECTION:gstqtmux

    47  * @short_description: Muxer for quicktime(.mov) files

    48  *

    49  * <refsect2>

    50  * <para>

    51  * This element merges streams (audio and video) into qt(.mov) files.

    52  * </para>

    53  * <title>Example pipelines</title>

    54  * <para>

    55  * <programlisting>

    56  * gst-launch v4l2src num-buffers=500 ! video/x-raw-yuv,width=320,height=240 ! ffmpegcolorspace ! qtmux ! filesink location=video.mov

    57  * </programlisting>

    58  * Records a video stream captured from a v4l2 device and muxes it into a qt file.

    59  * </para>

    60  * </refsect2>

    61  *

    62  * Last reviewed on 2008-08-27

    63  */

    64 

    65 /*

    66  * Based on avimux

    67  */

    68 

    69 #ifdef HAVE_CONFIG_H

    70 #include "config.h"

    71 #endif

    72 

    73 #include <glib/gstdio.h>

    74 

    75 #include <gst/gst.h>

    76 #include <gst/base/gstcollectpads.h>

    77 

    78 #include <sys/types.h>

    79 #ifdef G_OS_WIN32

    80 #include <io.h>                 /* lseek, open, close, read */

    81 #undef lseek

    82 #define lseek _lseeki64

    83 #undef off_t

    84 #define off_t guint64

    85 #endif

    86 

    87 #ifdef HAVE_UNISTD_H

    88 #  include <unistd.h>

    89 #endif

    90 

    91 #include "gstqtmux.h"

    92 

    93 GST_DEBUG_CATEGORY_STATIC (gst_qt_mux_debug);

    94 #define GST_CAT_DEFAULT gst_qt_mux_debug

    95 

    96 /* QTMux signals and args */

    97 enum

    98 {

    99   /* FILL ME */

   100   LAST_SIGNAL

   101 };

   102 

   103 enum

   104 {

   105   PROP_0,

   106   PROP_LARGE_FILE,

   107   PROP_MOVIE_TIMESCALE,

   108   PROP_DO_CTTS,

   109   PROP_FLAVOR,

   110   PROP_FAST_START,

   111   PROP_FAST_START_TEMP_FILE

   112 };

   113 

   114 /* some spare for header size as well */

   115 #define MDAT_LARGE_FILE_LIMIT           ((guint64) 1024 * 1024 * 1024 * 2)

   116 

   117 #define DEFAULT_LARGE_FILE              FALSE

   118 #define DEFAULT_MOVIE_TIMESCALE         1000

   119 #define DEFAULT_DO_CTTS                 FALSE

   120 #define DEFAULT_FAST_START              FALSE

   121 #define DEFAULT_FAST_START_TEMP_FILE    NULL

   122 

   123 static void gst_qt_mux_finalize (GObject * object);

   124 

   125 static GstStateChangeReturn gst_qt_mux_change_state (GstElement * element,

   126     GstStateChange transition);

   127 

   128 /* property functions */

   129 static void gst_qt_mux_set_property (GObject * object,

   130     guint prop_id, const GValue * value, GParamSpec * pspec);

   131 static void gst_qt_mux_get_property (GObject * object,

   132     guint prop_id, GValue * value, GParamSpec * pspec);

   133 

   134 /* pad functions */

   135 static GstPad *gst_qt_mux_request_new_pad (GstElement * element,

   136     GstPadTemplate * templ, const gchar * name);

   137 static void gst_qt_mux_release_pad (GstElement * element, GstPad * pad);

   138 

   139 /* event */

   140 static gboolean gst_qt_mux_sink_event (GstPad * pad, GstEvent * event);

   141 

   142 static GstFlowReturn gst_qt_mux_collected (GstCollectPads * pads,

   143     gpointer user_data);

   144 static GstFlowReturn gst_qt_mux_add_buffer (GstQTMux * qtmux, GstQTPad * pad,

   145     GstBuffer * buf);

   146 

   147 static GstElementClass *parent_class = NULL;

   148 

   149 static void

   150 gst_qt_mux_base_init (gpointer g_class)

   151 {

   152   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

   153   GstQTMuxClass *klass = (GstQTMuxClass *) g_class;

   154   GstQTMuxClassParams *params;

   155   GstElementDetails details;

   156   GstPadTemplate *videosinktempl, *audiosinktempl, *srctempl;

   157 

   158   params =

   159       (GstQTMuxClassParams *) g_type_get_qdata (G_OBJECT_CLASS_TYPE (g_class),

   160       GST_QT_MUX_PARAMS_QDATA);

   161   g_assert (params != NULL);

   162 

   163   /* construct the element details struct */

   164   details.longname = g_strdup_printf ("%s Muxer", params->prop->long_name);

   165   details.klass = g_strdup ("Codec/Muxer");

   166   details.description =

   167       g_strdup_printf ("Multiplex audio and video into a %s file",

   168       params->prop->long_name);

   169   details.author = "Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>";

   170   gst_element_class_set_details (element_class, &details);

   171   g_free (details.longname);

   172   g_free (details.klass);

   173   g_free (details.description);

   174 

   175   /* pad templates */

   176   srctempl = gst_pad_template_new ("src", GST_PAD_SRC,

   177       GST_PAD_ALWAYS, params->src_caps);

   178   gst_element_class_add_pad_template (element_class, srctempl);

   179 

   180   if (params->audio_sink_caps) {

   181     audiosinktempl = gst_pad_template_new ("audio_%d",

   182         GST_PAD_SINK, GST_PAD_REQUEST, params->audio_sink_caps);

   183     gst_element_class_add_pad_template (element_class, audiosinktempl);

   184   }

   185 

   186   if (params->video_sink_caps) {

   187     videosinktempl = gst_pad_template_new ("video_%d",

   188         GST_PAD_SINK, GST_PAD_REQUEST, params->video_sink_caps);

   189     gst_element_class_add_pad_template (element_class, videosinktempl);

   190   }

   191 

   192   klass->format = params->prop->format;

   193 }

   194 

   195 static void

   196 gst_qt_mux_class_init (GstQTMuxClass * klass)

   197 {

   198   GObjectClass *gobject_class;

   199   GstElementClass *gstelement_class;

   200 

   201   gobject_class = (GObjectClass *) klass;

   202   gstelement_class = (GstElementClass *) klass;

   203 

   204   parent_class = g_type_class_peek_parent (klass);

   205 

   206   gobject_class->finalize = gst_qt_mux_finalize;

   207   gobject_class->get_property = gst_qt_mux_get_property;

   208   gobject_class->set_property = gst_qt_mux_set_property;

   209 

   210   g_object_class_install_property (gobject_class, PROP_LARGE_FILE,

   211       g_param_spec_boolean ("large-file", "Support for large files",

   212           "Uses 64bits to some fields instead of 32bits, "

   213           "providing support for large files",

   214           DEFAULT_LARGE_FILE, G_PARAM_READWRITE));

   215   g_object_class_install_property (gobject_class, PROP_MOVIE_TIMESCALE,

   216       g_param_spec_uint ("movie-timescale", "Movie timescale",

   217           "Timescale to use in the movie (units per second)",

   218           1, G_MAXUINT32, DEFAULT_MOVIE_TIMESCALE,

   219           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));

   220   g_object_class_install_property (gobject_class, PROP_DO_CTTS,

   221       g_param_spec_boolean ("presentation-time",

   222           "Include presentation-time info",

   223           "Calculate and include presentation/composition time (in addition to decoding time)"

   224           " (use with caution)", DEFAULT_DO_CTTS,

   225           G_PARAM_READWRITE | G_PARAM_CONSTRUCT));

   226   g_object_class_install_property (gobject_class, PROP_FAST_START,

   227       g_param_spec_boolean ("faststart", "Format file to faststart",

   228           "If the file should be formated for faststart (headers first). ",

   229           DEFAULT_FAST_START, G_PARAM_READWRITE));

   230   g_object_class_install_property (gobject_class, PROP_FAST_START_TEMP_FILE,

   231       g_param_spec_string ("faststart-file", "File to use for storing buffers",

   232           "File that will be used temporarily to store data from the stream when "

   233           "creating a faststart file. If null a filepath will be created automatically",

   234           DEFAULT_FAST_START_TEMP_FILE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));

   235 

   236   gstelement_class->request_new_pad =

   237       GST_DEBUG_FUNCPTR (gst_qt_mux_request_new_pad);

   238   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_qt_mux_change_state);

   239   gstelement_class->release_pad = GST_DEBUG_FUNCPTR (gst_qt_mux_release_pad);

   240 }

   241 

   242 static void

   243 gst_qt_mux_pad_reset (GstQTPad * qtpad)

   244 {

   245   qtpad->fourcc = 0;

   246   qtpad->is_out_of_order = FALSE;

   247   qtpad->have_dts = FALSE;

   248   qtpad->sample_size = 0;

   249   qtpad->sync = FALSE;

   250   qtpad->last_dts = 0;

   251 

   252   if (qtpad->last_buf)

   253     gst_buffer_replace (&qtpad->last_buf, NULL);

   254 

   255   /* reference owned elsewhere */

   256   qtpad->trak = NULL;

   257 }

   258 

   259 /*

   260  * Takes GstQTMux back to its initial state

   261  */

   262 static void

   263 gst_qt_mux_reset (GstQTMux * qtmux, gboolean alloc)

   264 {

   265   GSList *walk;

   266 

   267   qtmux->state = GST_QT_MUX_STATE_NONE;

   268   qtmux->header_size = 0;

   269   qtmux->mdat_size = 0;

   270   qtmux->mdat_pos = 0;

   271   qtmux->longest_chunk = GST_CLOCK_TIME_NONE;

   272 

   273   if (qtmux->ftyp) {

   274     atom_ftyp_free (qtmux->ftyp);

   275     qtmux->ftyp = NULL;

   276   }

   277   if (qtmux->moov) {

   278     atom_moov_free (qtmux->moov);

   279     qtmux->moov = NULL;

   280   }

   281   if (qtmux->fast_start_file) {

   282     fclose (qtmux->fast_start_file);

   283     qtmux->fast_start_file = NULL;

   284   }

   285   gst_tag_setter_reset_tags (GST_TAG_SETTER (qtmux));

   286 

   287   /* reset pad data */

   288   for (walk = qtmux->collect->data; walk; walk = g_slist_next (walk)) {

   289     GstQTPad *qtpad = (GstQTPad *) walk->data;

   290     gst_qt_mux_pad_reset (qtpad);

   291 

   292     /* hm, moov_free above yanked the traks away from us,

   293      * so do not free, but do clear */

   294     qtpad->trak = NULL;

   295   }

   296 

   297   if (alloc) {

   298     qtmux->moov = atom_moov_new (qtmux->context);

   299     /* ensure all is as nice and fresh as request_new_pad would provide it */

   300     for (walk = qtmux->collect->data; walk; walk = g_slist_next (walk)) {

   301       GstQTPad *qtpad = (GstQTPad *) walk->data;

   302 

   303       qtpad->trak = atom_trak_new (qtmux->context);

   304       atom_moov_add_trak (qtmux->moov, qtpad->trak);

   305     }

   306   }

   307 }

   308 

   309 static void

   310 gst_qt_mux_init (GstQTMux * qtmux, GstQTMuxClass * qtmux_klass)

   311 {

   312   GstElementClass *klass = GST_ELEMENT_CLASS (qtmux_klass);

   313   GstPadTemplate *templ;

   314   GstCaps *caps;

   315 

   316   templ = gst_element_class_get_pad_template (klass, "src");

   317   qtmux->srcpad = gst_pad_new_from_template (templ, "src");

   318   caps = gst_caps_copy (gst_pad_get_pad_template_caps (qtmux->srcpad));

   319   gst_pad_set_caps (qtmux->srcpad, caps);

   320   gst_caps_unref (caps);

   321   gst_pad_use_fixed_caps (qtmux->srcpad);

   322   gst_element_add_pad (GST_ELEMENT (qtmux), qtmux->srcpad);

   323 

   324   qtmux->collect = gst_collect_pads_new ();

   325   gst_collect_pads_set_function (qtmux->collect,

   326       (GstCollectPadsFunction) GST_DEBUG_FUNCPTR (gst_qt_mux_collected), qtmux);

   327 

   328   /* properties set to default upon construction */

   329 

   330   /* always need this */

   331   qtmux->context =

   332       atoms_context_new (gst_qt_mux_map_format_to_flavor (qtmux_klass->format));

   333 

   334   /* internals to initial state */

   335   gst_qt_mux_reset (qtmux, TRUE);

   336 }

   337 

   338 

   339 static void

   340 gst_qt_mux_finalize (GObject * object)

   341 {

   342   GstQTMux *qtmux = GST_QT_MUX_CAST (object);

   343 

   344   gst_qt_mux_reset (qtmux, FALSE);

   345 

   346   if (qtmux->fast_start_file_path)

   347     g_free (qtmux->fast_start_file_path);

   348 

   349   atoms_context_free (qtmux->context);

   350   gst_object_unref (qtmux->collect);

   351 

   352   G_OBJECT_CLASS (parent_class)->finalize (object);

   353 }

   354 

   355 static void

   356 gst_qt_mux_add_mp4_tag (GstQTMux * qtmux, const GstTagList * list,

   357     const char *tag, const char *tag2, guint32 fourcc)

   358 {

   359   switch (gst_tag_get_type (tag)) {

   360       /* strings */

   361     case G_TYPE_STRING:

   362     {

   363       gchar *str = NULL;

   364 

   365       if (!gst_tag_list_get_string (list, tag, &str) || !str)

   366         break;

   367       GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %s",

   368           GST_FOURCC_ARGS (fourcc), str);

   369       atom_moov_add_str_tag (qtmux->moov, fourcc, str);

   370       g_free (str);

   371       break;

   372     }

   373       /* double */

   374     case G_TYPE_DOUBLE:

   375     {

   376       gdouble value;

   377 

   378       if (!gst_tag_list_get_double (list, tag, &value))

   379         break;

   380       GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %u",

   381           GST_FOURCC_ARGS (fourcc), (gint) value);

   382       atom_moov_add_uint_tag (qtmux->moov, fourcc, 21, (gint) value);

   383       break;

   384     }

   385       /* paired unsigned integers */

   386     case G_TYPE_UINT:

   387     {

   388       guint value;

   389       guint count;

   390 

   391       if (!gst_tag_list_get_uint (list, tag, &value) ||

   392           !gst_tag_list_get_uint (list, tag2, &count))

   393         break;

   394       GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %u/%u",

   395           GST_FOURCC_ARGS (fourcc), value, count);

   396       atom_moov_add_uint_tag (qtmux->moov, fourcc, 0,

   397           value << 16 | (count & 0xFFFF));

   398       break;

   399     }

   400     default:

   401       g_assert_not_reached ();

   402       break;

   403   }

   404 }

   405 

   406 static void

   407 gst_qt_mux_add_mp4_date (GstQTMux * qtmux, const GstTagList * list,

   408     const char *tag, const char *tag2, guint32 fourcc)

   409 {

   410   GDate *date = NULL;

   411   GDateYear year;

   412   GDateMonth month;

   413   GDateDay day;

   414   gchar *str;

   415 

   416   g_return_if_fail (gst_tag_get_type (tag) == GST_TYPE_DATE);

   417 

   418   if (!gst_tag_list_get_date (list, tag, &date) || !date)

   419     return;

   420 

   421   year = g_date_get_year (date);

   422   month = g_date_get_month (date);

   423   day = g_date_get_day (date);

   424 

   425   if (year == G_DATE_BAD_YEAR && month == G_DATE_BAD_MONTH &&

   426       day == G_DATE_BAD_DAY) {

   427     GST_WARNING_OBJECT (qtmux, "invalid date in tag");

   428     return;

   429   }

   430 

   431   str = g_strdup_printf ("%u-%u-%u", year, month, day);

   432   GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %s",

   433       GST_FOURCC_ARGS (fourcc), str);

   434   atom_moov_add_str_tag (qtmux->moov, fourcc, str);

   435 }

   436 

   437 static void

   438 gst_qt_mux_add_mp4_cover (GstQTMux * qtmux, const GstTagList * list,

   439     const char *tag, const char *tag2, guint32 fourcc)

   440 {

   441   GValue value = { 0, };

   442   GstBuffer *buf;

   443   GstCaps *caps;

   444   GstStructure *structure;

   445   gint flags = 0;

   446 

   447   g_return_if_fail (gst_tag_get_type (tag) == GST_TYPE_BUFFER);

   448 

   449   if (!gst_tag_list_copy_value (&value, list, tag))

   450     return;

   451 

   452   buf = gst_value_get_buffer (&value);

   453   if (!buf)

   454     goto done;

   455 

   456   caps = gst_buffer_get_caps (buf);

   457   if (!caps) {

   458     GST_WARNING_OBJECT (qtmux, "preview image without caps");

   459     goto done;

   460   }

   461 

   462   GST_DEBUG_OBJECT (qtmux, "preview image caps %" GST_PTR_FORMAT, caps);

   463 

   464   structure = gst_caps_get_structure (caps, 0);

   465   if (gst_structure_has_name (structure, "image/jpeg"))

   466     flags = 13;

   467   else if (gst_structure_has_name (structure, "image/png"))

   468     flags = 14;

   469   gst_caps_unref (caps);

   470 

   471   if (!flags) {

   472     GST_WARNING_OBJECT (qtmux, "preview image format not supported");

   473     goto done;

   474   }

   475 

   476   GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT

   477       " -> image size %d", GST_FOURCC_ARGS (fourcc), GST_BUFFER_SIZE (buf));

   478   atom_moov_add_tag (qtmux->moov, fourcc, flags, GST_BUFFER_DATA (buf),

   479       GST_BUFFER_SIZE (buf));

   480 done:

   481   g_value_unset (&value);

   482 }

   483 

   484 static void

   485 gst_qt_mux_add_3gp_str (GstQTMux * qtmux, const GstTagList * list,

   486     const char *tag, const char *tag2, guint32 fourcc)

   487 {

   488   gchar *str = NULL;

   489   guint number;

   490 

   491   g_return_if_fail (gst_tag_get_type (tag) == G_TYPE_STRING);

   492   g_return_if_fail (!tag2 || gst_tag_get_type (tag2) == G_TYPE_UINT);

   493 

   494   if (!gst_tag_list_get_string (list, tag, &str) || !str)

   495     return;

   496 

   497   if (tag2)

   498     if (!gst_tag_list_get_uint (list, tag2, &number))

   499       tag2 = NULL;

   500 

   501   if (!tag2) {

   502     GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %s",

   503         GST_FOURCC_ARGS (fourcc), str);

   504     atom_moov_add_3gp_str_tag (qtmux->moov, fourcc, str);

   505   } else {

   506     GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %s/%d",

   507         GST_FOURCC_ARGS (fourcc), str, number);

   508     atom_moov_add_3gp_str_int_tag (qtmux->moov, fourcc, str, number);

   509   }

   510 

   511   g_free (str);

   512 }

   513 

   514 static void

   515 gst_qt_mux_add_3gp_date (GstQTMux * qtmux, const GstTagList * list,

   516     const char *tag, const char *tag2, guint32 fourcc)

   517 {

   518   GDate *date = NULL;

   519   GDateYear year;

   520 

   521   g_return_if_fail (gst_tag_get_type (tag) == GST_TYPE_DATE);

   522 

   523   if (!gst_tag_list_get_date (list, tag, &date) || !date)

   524     return;

   525 

   526   year = g_date_get_year (date);

   527 

   528   if (year == G_DATE_BAD_YEAR) {

   529     GST_WARNING_OBJECT (qtmux, "invalid date in tag");

   530     return;

   531   }

   532 

   533   GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %d",

   534       GST_FOURCC_ARGS (fourcc), year);

   535   atom_moov_add_3gp_uint_tag (qtmux->moov, fourcc, year);

   536 }

   537 

   538 static void

   539 gst_qt_mux_add_3gp_location (GstQTMux * qtmux, const GstTagList * list,

   540     const char *tag, const char *tag2, guint32 fourcc)

   541 {

   542   gdouble latitude = -360, longitude = -360, altitude = 0;

   543   gchar *location = NULL;

   544   guint8 *data, *ddata;

   545   gint size = 0, len = 0;

   546   gboolean ret = FALSE;

   547 

   548   g_return_if_fail (strcmp (tag, GST_TAG_GEO_LOCATION_NAME) == 0);

   549 

   550   ret = gst_tag_list_get_string (list, tag, &location);

   551   ret |= gst_tag_list_get_double (list, GST_TAG_GEO_LOCATION_LONGITUDE,

   552       &longitude);

   553   ret |= gst_tag_list_get_double (list, GST_TAG_GEO_LOCATION_LATITUDE,

   554       &latitude);

   555   ret |= gst_tag_list_get_double (list, GST_TAG_GEO_LOCATION_ELEVATION,

   556       &altitude);

   557 

   558   if (!ret)

   559     return;

   560 

   561   if (location)

   562     len = strlen (location);

   563   size += len + 1 + 2;

   564 

   565   /* role + (long, lat, alt) + body + notes */

   566   size += 1 + 3 * 4 + 1 + 1;

   567 

   568   data = ddata = g_malloc (size);

   569 

   570   /* language tag */

   571   GST_WRITE_UINT16_BE (data, language_code (GST_QT_MUX_DEFAULT_TAG_LANGUAGE));

   572   /* location */

   573   if (location)

   574     memcpy (data + 2, location, len);

   575   GST_WRITE_UINT8 (data + 2 + len, 0);

   576   data += len + 1 + 2;

   577   /* role */

   578   GST_WRITE_UINT8 (data, 0);

   579   /* long, lat, alt */

   580   GST_WRITE_UINT32_BE (data + 1, (guint32) (longitude * 65536.0));

   581   GST_WRITE_UINT32_BE (data + 5, (guint32) (latitude * 65536.0));

   582   GST_WRITE_UINT32_BE (data + 9, (guint32) (altitude * 65536.0));

   583   /* neither astronomical body nor notes */

   584   GST_WRITE_UINT16_BE (data + 13, 0);

   585 

   586   GST_DEBUG_OBJECT (qtmux, "Adding tag 'loci'");

   587   atom_moov_add_3gp_tag (qtmux->moov, fourcc, ddata, size);

   588   g_free (ddata);

   589 }

   590 

   591 static void

   592 gst_qt_mux_add_3gp_keywords (GstQTMux * qtmux, const GstTagList * list,

   593     const char *tag, const char *tag2, guint32 fourcc)

   594 {

   595   gchar *keywords = NULL;

   596   guint8 *data, *ddata;

   597   gint size = 0, i;

   598   gchar **kwds;

   599 

   600   g_return_if_fail (strcmp (tag, GST_TAG_KEYWORDS) == 0);

   601 

   602   if (!gst_tag_list_get_string (list, tag, &keywords) || !keywords)

   603     return;

   604 

   605   kwds = g_strsplit (keywords, ",", 0);

   606 

   607   size = 0;

   608   for (i = 0; kwds[i]; i++) {

   609     /* size byte + null-terminator */

   610     size += strlen (kwds[i]) + 1 + 1;

   611   }

   612 

   613   /* language tag + count + keywords */

   614   size += 2 + 1;

   615 

   616   data = ddata = g_malloc (size);

   617 

   618   /* language tag */

   619   GST_WRITE_UINT16_BE (data, language_code (GST_QT_MUX_DEFAULT_TAG_LANGUAGE));

   620   /* count */

   621   GST_WRITE_UINT8 (data + 2, i);

   622   data += 3;

   623   /* keywords */

   624   for (i = 0; kwds[i]; ++i) {

   625     gint len = strlen (kwds[i]);

   626 

   627     GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT " -> %s",

   628         GST_FOURCC_ARGS (fourcc), kwds[i]);

   629     /* size */

   630     GST_WRITE_UINT8 (data, len + 1);

   631     memcpy (data + 1, kwds[i], len + 1);

   632     data += len + 2;

   633   }

   634 

   635   g_strfreev (kwds);

   636 

   637   atom_moov_add_3gp_tag (qtmux->moov, fourcc, ddata, size);

   638   g_free (ddata);

   639 }

   640 

   641 

   642 typedef void (*GstQTMuxAddTagFunc) (GstQTMux * mux, const GstTagList * list,

   643     const char *tag, const char *tag2, guint32 fourcc);

   644 

   645 /*

   646  * Struct to record mappings from gstreamer tags to fourcc codes

   647  */

   648 typedef struct _GstTagToFourcc

   649 {

   650   guint32 fourcc;

   651   const gchar *gsttag;

   652   const gchar *gsttag2;

   653   const GstQTMuxAddTagFunc func;

   654 } GstTagToFourcc;

   655 

   656 /* tag list tags to fourcc matching */

   657 static const GstTagToFourcc tag_matches_mp4[] = {

   658   {FOURCC__alb, GST_TAG_ALBUM, NULL, gst_qt_mux_add_mp4_tag},

   659   {FOURCC__ART, GST_TAG_ARTIST, NULL, gst_qt_mux_add_mp4_tag},

   660   {FOURCC__cmt, GST_TAG_COMMENT, NULL, gst_qt_mux_add_mp4_tag},

   661   {FOURCC__wrt, GST_TAG_COMPOSER, NULL, gst_qt_mux_add_mp4_tag},

   662   {FOURCC__gen, GST_TAG_GENRE, NULL, gst_qt_mux_add_mp4_tag},

   663   {FOURCC__nam, GST_TAG_TITLE, NULL, gst_qt_mux_add_mp4_tag},

   664   {FOURCC__des, GST_TAG_DESCRIPTION, NULL, gst_qt_mux_add_mp4_tag},

   665   {FOURCC__too, GST_TAG_ENCODER, NULL, gst_qt_mux_add_mp4_tag},

   666   {FOURCC_cprt, GST_TAG_COPYRIGHT, NULL, gst_qt_mux_add_mp4_tag},

   667   {FOURCC_keyw, GST_TAG_KEYWORDS, NULL, gst_qt_mux_add_mp4_tag},

   668   {FOURCC__day, GST_TAG_DATE, NULL, gst_qt_mux_add_mp4_date},

   669   {FOURCC_tmpo, GST_TAG_BEATS_PER_MINUTE, NULL, gst_qt_mux_add_mp4_tag},

   670   {FOURCC_trkn, GST_TAG_TRACK_NUMBER, GST_TAG_TRACK_COUNT,

   671       gst_qt_mux_add_mp4_tag},

   672   {FOURCC_disk, GST_TAG_ALBUM_VOLUME_NUMBER, GST_TAG_ALBUM_VOLUME_COUNT,

   673       gst_qt_mux_add_mp4_tag},

   674   {FOURCC_covr, GST_TAG_PREVIEW_IMAGE, NULL, gst_qt_mux_add_mp4_cover},

   675   {0, NULL,}

   676 };

   677 

   678 static const GstTagToFourcc tag_matches_3gp[] = {

   679   {FOURCC_titl, GST_TAG_TITLE, NULL, gst_qt_mux_add_3gp_str},

   680   {FOURCC_dscp, GST_TAG_DESCRIPTION, NULL, gst_qt_mux_add_3gp_str},

   681   {FOURCC_cprt, GST_TAG_COPYRIGHT, NULL, gst_qt_mux_add_3gp_str},

   682   {FOURCC_perf, GST_TAG_ARTIST, NULL, gst_qt_mux_add_3gp_str},

   683   {FOURCC_auth, GST_TAG_COMPOSER, NULL, gst_qt_mux_add_3gp_str},

   684   {FOURCC_gnre, GST_TAG_GENRE, NULL, gst_qt_mux_add_3gp_str},

   685   {FOURCC_kywd, GST_TAG_KEYWORDS, NULL, gst_qt_mux_add_3gp_keywords},

   686   {FOURCC_yrrc, GST_TAG_DATE, NULL, gst_qt_mux_add_3gp_date},

   687   {FOURCC_albm, GST_TAG_ALBUM, GST_TAG_TRACK_NUMBER, gst_qt_mux_add_3gp_str},

   688   {FOURCC_loci, GST_TAG_GEO_LOCATION_NAME, NULL, gst_qt_mux_add_3gp_location},

   689   {0, NULL,}

   690 };

   691 

   692 /* qtdemux produces these for atoms it cannot parse */

   693 #define GST_QT_DEMUX_PRIVATE_TAG "private-qt-tag"

   694 

   695 static void

   696 gst_qt_mux_add_metadata_tags (GstQTMux * qtmux, const GstTagList * list)

   697 {

   698   GstQTMuxClass *qtmux_klass = (GstQTMuxClass *) (G_OBJECT_GET_CLASS (qtmux));

   699   guint32 fourcc;

   700   gint i;

   701   const gchar *tag, *tag2;

   702   const GstTagToFourcc *tag_matches;

   703 

   704   switch (qtmux_klass->format) {

   705     case GST_QT_MUX_FORMAT_3GP:

   706       tag_matches = tag_matches_3gp;

   707       break;

   708     case GST_QT_MUX_FORMAT_MJ2:

   709       tag_matches = NULL;

   710       break;

   711     default:

   712       /* sort of iTunes style for mp4 and QT (?) */

   713       tag_matches = tag_matches_mp4;

   714       break;

   715   }

   716 

   717   if (!tag_matches)

   718     return;

   719 

   720   for (i = 0; tag_matches[i].fourcc; i++) {

   721     fourcc = tag_matches[i].fourcc;

   722     tag = tag_matches[i].gsttag;

   723     tag2 = tag_matches[i].gsttag2;

   724 

   725     g_assert (tag_matches[i].func);

   726     tag_matches[i].func (qtmux, list, tag, tag2, fourcc);

   727   }

   728 

   729   /* add unparsed blobs if present */

   730   if (gst_tag_exists (GST_QT_DEMUX_PRIVATE_TAG)) {

   731     guint num_tags;

   732 

   733     num_tags = gst_tag_list_get_tag_size (list, GST_QT_DEMUX_PRIVATE_TAG);

   734     for (i = 0; i < num_tags; ++i) {

   735       const GValue *val;

   736       GstBuffer *buf;

   737       GstCaps *caps = NULL;

   738 

   739       val = gst_tag_list_get_value_index (list, GST_QT_DEMUX_PRIVATE_TAG, i);

   740       buf = (GstBuffer *) gst_value_get_mini_object (val);

   741 

   742       if (buf && (caps = gst_buffer_get_caps (buf))) {

   743         GstStructure *s;

   744         const gchar *style = NULL;

   745 

   746         GST_DEBUG_OBJECT (qtmux, "Found private tag %d/%d; size %d, caps %"

   747             GST_PTR_FORMAT, i, num_tags, GST_BUFFER_SIZE (buf), caps);

   748         s = gst_caps_get_structure (caps, 0);

   749         if (s && (style = gst_structure_get_string (s, "style"))) {

   750           /* try to prevent some style tag ending up into another variant

   751            * (todo: make into a list if more cases) */

   752           if ((strcmp (style, "itunes") == 0 &&

   753                   qtmux_klass->format == GST_QT_MUX_FORMAT_MP4) ||

   754               (strcmp (style, "iso") == 0 &&

   755                   qtmux_klass->format == GST_QT_MUX_FORMAT_3GP)) {

   756             GST_DEBUG_OBJECT (qtmux, "Adding private tag");

   757             atom_moov_add_blob_tag (qtmux->moov, GST_BUFFER_DATA (buf),

   758                 GST_BUFFER_SIZE (buf));

   759           }

   760         }

   761         gst_caps_unref (caps);

   762       }

   763     }

   764   }

   765 

   766   return;

   767 }

   768 

   769 /*

   770  * Gets the tagsetter iface taglist and puts the known tags

   771  * into the output stream

   772  */

   773 static void

   774 gst_qt_mux_setup_metadata (GstQTMux * qtmux)

   775 {

   776   const GstTagList *tags;

   777 

   778   tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (qtmux));

   779 

   780   GST_LOG_OBJECT (qtmux, "tags: %" GST_PTR_FORMAT, tags);

   781 

   782   if (tags && !gst_tag_list_is_empty (tags)) {

   783     GST_DEBUG_OBJECT (qtmux, "Formatting tags");

   784     gst_qt_mux_add_metadata_tags (qtmux, tags);

   785   } else {

   786     GST_DEBUG_OBJECT (qtmux, "No tags received");

   787   }

   788 }

   789 

   790 static GstFlowReturn

   791 gst_qt_mux_send_buffer (GstQTMux * qtmux, GstBuffer * buf, guint64 * offset,

   792     gboolean mind_fast)

   793 {

   794   GstFlowReturn res;

   795   guint8 *data;

   796   guint size;

   797 

   798   g_return_val_if_fail (buf != NULL, GST_FLOW_ERROR);

   799 

   800   data = GST_BUFFER_DATA (buf);

   801   size = GST_BUFFER_SIZE (buf);

   802 

   803   GST_LOG_OBJECT (qtmux, "sending buffer size %d", size);

   804 

   805   if (mind_fast && qtmux->fast_start_file) {

   806     gint ret;

   807 

   808     GST_LOG_OBJECT (qtmux, "to temporary file");

   809     ret = fwrite (data, sizeof (guint8), size, qtmux->fast_start_file);

   810     gst_buffer_unref (buf);

   811     if (ret != size)

   812       goto write_error;

   813     else

   814       res = GST_FLOW_OK;

   815   } else {

   816     GST_LOG_OBJECT (qtmux, "downstream");

   817 

   818     gst_buffer_set_caps (buf, GST_PAD_CAPS (qtmux->srcpad));

   819     res = gst_pad_push (qtmux->srcpad, buf);

   820   }

   821 

   822   if (G_LIKELY (offset))

   823     *offset += size;

   824 

   825   return res;

   826 

   827   /* ERRORS */

   828 write_error:

   829   {

   830     GST_ELEMENT_ERROR (qtmux, RESOURCE, WRITE,

   831         ("Failed to write to temporary file"), GST_ERROR_SYSTEM);

   832     return GST_FLOW_ERROR;

   833   }

   834 }

   835 

   836 static GstFlowReturn

   837 gst_qt_mux_send_buffered_data (GstQTMux * qtmux, guint64 * offset)

   838 {

   839   GstFlowReturn ret = GST_FLOW_OK;

   840   GstBuffer *buf = NULL;

   841 

   842   if (fflush (qtmux->fast_start_file))

   843     goto flush_failed;

   844 

   845 #ifdef HAVE_FSEEKO

   846   if (fseeko (qtmux->fast_start_file, (off_t) 0, SEEK_SET) != 0)

   847     goto seek_failed;

   848 #elif defined (G_OS_UNIX) || defined (G_OS_WIN32)

   849   if (lseek (fileno (qtmux->fast_start_file), (off_t) 0,

   850           SEEK_SET) == (off_t) - 1)

   851     goto seek_failed;

   852 #else

   853   if (fseek (qtmux->fast_start_file, (long) 0, SEEK_SET) != 0)

   854     goto seek_failed;

   855 #endif

   856 

   857   /* hm, this could all take a really really long time,

   858    * but there may not be another way to get moov atom first

   859    * (somehow optimize copy?) */

   860   GST_DEBUG_OBJECT (qtmux, "Sending buffered data");

   861   while (ret == GST_FLOW_OK) {

   862     gint r;

   863     const int bufsize = 4096;

   864 

   865     buf = gst_buffer_new_and_alloc (bufsize);

   866     r = fread (GST_BUFFER_DATA (buf), sizeof (guint8), bufsize,

   867         qtmux->fast_start_file);

   868     if (r == 0)

   869       break;

   870     GST_BUFFER_SIZE (buf) = r;

   871     GST_LOG_OBJECT (qtmux, "Pushing buffered buffer of size %d", r);

   872     ret = gst_qt_mux_send_buffer (qtmux, buf, offset, FALSE);

   873     buf = NULL;

   874   }

   875   if (buf)

   876     gst_buffer_unref (buf);

   877 

   878 exit:

   879   /* best cleaning up effort, eat possible error */

   880   fclose (qtmux->fast_start_file);

   881   qtmux->fast_start_file = NULL;

   882 

   883   /* FIXME maybe delete temporary file, or let the system handle that ? */

   884 

   885   return ret;

   886 

   887   /* ERRORS */

   888 flush_failed:

   889   {

   890     GST_ELEMENT_ERROR (qtmux, RESOURCE, WRITE,

   891         ("Failed to flush temporary file"), GST_ERROR_SYSTEM);

   892     ret = GST_FLOW_ERROR;

   893     goto exit;

   894   }

   895 seek_failed:

   896   {

   897     GST_ELEMENT_ERROR (qtmux, RESOURCE, SEEK,

   898         ("Failed to seek temporary file"), GST_ERROR_SYSTEM);

   899     ret = GST_FLOW_ERROR;

   900     goto exit;

   901   }

   902 }

   903 

   904 /*

   905  * Sends the initial mdat atom fields (size fields and fourcc type),

   906  * the subsequent buffers are considered part of it's data.

   907  * As we can't predict the amount of data that we are going to place in mdat

   908  * we need to record the position of the size field in the stream so we can

   909  * seek back to it later and update when the streams have finished.

   910  */

   911 static GstFlowReturn

   912 gst_qt_mux_send_mdat_header (GstQTMux * qtmux, guint64 * off, guint64 size,

   913     gboolean extended)

   914 {

   915   Atom *node_header;

   916   GstBuffer *buf;

   917   guint8 *data = NULL;

   918   guint64 offset = 0;

   919 

   920   GST_DEBUG_OBJECT (qtmux, "Sending mdat's atom header, "

   921       "size %" G_GUINT64_FORMAT, size);

   922 

   923   node_header = g_malloc0 (sizeof (Atom));

   924   node_header->type = FOURCC_mdat;

   925   if (extended) {

   926     /* use extended size */

   927     node_header->size = 1;

   928     node_header->extended_size = 0;

   929     if (size)

   930       node_header->extended_size = size + 16;

   931   } else {

   932     node_header->size = size + 8;

   933   }

   934 

   935   size = offset = 0;

   936   if (atom_copy_data (node_header, &data, &size, &offset) == 0)

   937     goto serialize_error;

   938 

   939   buf = gst_buffer_new ();

   940   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

   941   GST_BUFFER_SIZE (buf) = offset;

   942 

   943   g_free (node_header);

   944 

   945   GST_LOG_OBJECT (qtmux, "Pushing mdat start");

   946   return gst_qt_mux_send_buffer (qtmux, buf, off, FALSE);

   947 

   948   /* ERRORS */

   949 serialize_error:

   950   {

   951     GST_ELEMENT_ERROR (qtmux, STREAM, MUX, (NULL),

   952         ("Failed to serialize ftyp"));

   953     return GST_FLOW_ERROR;

   954   }

   955 }

   956 

   957 /*

   958  * We get the position of the mdat size field, seek back to it

   959  * and overwrite with the real value

   960  */

   961 static GstFlowReturn

   962 gst_qt_mux_update_mdat_size (GstQTMux * qtmux, guint64 mdat_pos,

   963     guint64 mdat_size, guint64 * offset)

   964 {

   965   GstEvent *event;

   966   GstBuffer *buf;

   967   gboolean large_file;

   968 

   969   large_file = (mdat_size > MDAT_LARGE_FILE_LIMIT);

   970 

   971   if (large_file)

   972     mdat_pos += 8;

   973 

   974   /* seek and rewrite the header */

   975   event = gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES,

   976       mdat_pos, GST_CLOCK_TIME_NONE, 0);

   977   gst_pad_push_event (qtmux->srcpad, event);

   978 

   979   if (large_file) {

   980     buf = gst_buffer_new_and_alloc (sizeof (guint64));

   981     GST_WRITE_UINT64_BE (GST_BUFFER_DATA (buf), mdat_size + 16);

   982   } else {

   983     guint8 *data;

   984 

   985     buf = gst_buffer_new_and_alloc (16);

   986     data = GST_BUFFER_DATA (buf);

   987     GST_WRITE_UINT32_BE (data, 8);

   988     GST_WRITE_UINT32_LE (data + 4, FOURCC_free);

   989     GST_WRITE_UINT32_BE (data + 8, mdat_size + 8);

   990     GST_WRITE_UINT32_LE (data + 12, FOURCC_mdat);

   991   }

   992 

   993   return gst_qt_mux_send_buffer (qtmux, buf, offset, FALSE);

   994 }

   995 

   996 static GstFlowReturn

   997 gst_qt_mux_send_ftyp (GstQTMux * qtmux, guint64 * off)

   998 {

   999   GstBuffer *buf;

  1000   guint64 size = 0, offset = 0;

  1001   guint8 *data = NULL;

  1002 

  1003   GST_DEBUG_OBJECT (qtmux, "Sending ftyp atom");

  1004 

  1005   if (!atom_ftyp_copy_data (qtmux->ftyp, &data, &size, &offset))

  1006     goto serialize_error;

  1007 

  1008   buf = gst_buffer_new ();

  1009   GST_BUFFER_DATA (buf) = GST_BUFFER_MALLOCDATA (buf) = data;

  1010   GST_BUFFER_SIZE (buf) = offset;

  1011 

  1012   GST_LOG_OBJECT (qtmux, "Pushing ftyp");

  1013   return gst_qt_mux_send_buffer (qtmux, buf, off, FALSE);

  1014 

  1015   /* ERRORS */

  1016 serialize_error:

  1017   {

  1018     GST_ELEMENT_ERROR (qtmux, STREAM, MUX, (NULL),

  1019         ("Failed to serialize ftyp"));

  1020     return GST_FLOW_ERROR;

  1021   }

  1022 }

  1023 

  1024 static GstFlowReturn

  1025 gst_qt_mux_prepare_and_send_ftyp (GstQTMux * qtmux)

  1026 {

  1027   GstFlowReturn ret = GST_FLOW_OK;

  1028   GstQTMuxClass *qtmux_klass = (GstQTMuxClass *) (G_OBJECT_GET_CLASS (qtmux));

  1029   guint32 major, version;

  1030   GList *comp;

  1031   GstBuffer *prefix;

  1032 

  1033   GST_DEBUG_OBJECT (qtmux, "Preparing to send ftyp atom");

  1034 

  1035   /* init and send context and ftyp based on current property state */

  1036   if (qtmux->ftyp)

  1037     atom_ftyp_free (qtmux->ftyp);

  1038   gst_qt_mux_map_format_to_header (qtmux_klass->format, &prefix, &major,

  1039       &version, &comp, qtmux->moov, qtmux->longest_chunk,

  1040       qtmux->fast_start_file != NULL);

  1041   qtmux->ftyp = atom_ftyp_new (qtmux->context, major, version, comp);

  1042   if (comp)

  1043     g_list_free (comp);

  1044   if (prefix) {

  1045     ret = gst_qt_mux_send_buffer (qtmux, prefix, &qtmux->header_size, FALSE);

  1046     if (ret != GST_FLOW_OK)

  1047       return ret;

  1048   }

  1049   return gst_qt_mux_send_ftyp (qtmux, &qtmux->header_size);

  1050 }

  1051 

  1052 static GstFlowReturn

  1053 gst_qt_mux_start_file (GstQTMux * qtmux)

  1054 {

  1055   GstFlowReturn ret = GST_FLOW_OK;

  1056 

  1057   GST_DEBUG_OBJECT (qtmux, "starting file");

  1058 

  1059   /* let downstream know we think in BYTES and expect to do seeking later on */

  1060   gst_pad_push_event (qtmux->srcpad,

  1061       gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_BYTES, 0, -1, 0));

  1062 

  1063   /* 

  1064    * send mdat header if already needed, and mark position for later update.

  1065    * We don't send ftyp now if we are on fast start mode, because we can

  1066    * better fine tune using the information we gather to create the whole moov

  1067    * atom.

  1068    */

  1069   if (qtmux->fast_start) {

  1070     GST_OBJECT_LOCK (qtmux);

  1071     qtmux->fast_start_file = g_fopen (qtmux->fast_start_file_path, "wb+");

  1072     if (!qtmux->fast_start_file)

  1073       goto open_failed;

  1074     GST_OBJECT_UNLOCK (qtmux);

  1075 

  1076     /* send a dummy buffer for preroll */

  1077     ret = gst_qt_mux_send_buffer (qtmux, gst_buffer_new (), NULL, FALSE);

  1078     if (ret != GST_FLOW_OK)

  1079       goto exit;

  1080 

  1081   } else {

  1082     ret = gst_qt_mux_prepare_and_send_ftyp (qtmux);

  1083     if (ret != GST_FLOW_OK) {

  1084       goto exit;

  1085     }

  1086 

  1087     /* extended to ensure some spare space */

  1088     qtmux->mdat_pos = qtmux->header_size;

  1089     ret = gst_qt_mux_send_mdat_header (qtmux, &qtmux->header_size, 0, TRUE);

  1090   }

  1091 

  1092 exit:

  1093   return ret;

  1094 

  1095   /* ERRORS */

  1096 open_failed:

  1097   {

  1098     GST_ELEMENT_ERROR (qtmux, RESOURCE, OPEN_READ_WRITE,

  1099         (("Could not open temporary file \"%s\""), qtmux->fast_start_file_path),

  1100         GST_ERROR_SYSTEM);

  1101     GST_OBJECT_UNLOCK (qtmux);

  1102     return GST_FLOW_ERROR;

  1103   }

  1104 }

  1105 

  1106 static GstFlowReturn

  1107 gst_qt_mux_stop_file (GstQTMux * qtmux)

  1108 {

  1109   gboolean ret = GST_FLOW_OK;

  1110   GstBuffer *buffer = NULL;

  1111   guint64 offset = 0, size = 0;

  1112   guint8 *data;

  1113   GSList *walk;

  1114   gboolean large_file;

  1115   guint32 timescale;

  1116 

  1117   GST_DEBUG_OBJECT (qtmux, "Updating remaining values and sending last data");

  1118 

  1119   /* pushing last buffers for each pad */

  1120   for (walk = qtmux->collect->data; walk; walk = g_slist_next (walk)) {

  1121     GstCollectData *cdata = (GstCollectData *) walk->data;

  1122     GstQTPad *qtpad = (GstQTPad *) cdata;

  1123 

  1124     /* send last buffer */

  1125     GST_DEBUG_OBJECT (qtmux, "Sending the last buffer for pad %s",

  1126         GST_PAD_NAME (qtpad->collect.pad));

  1127     ret = gst_qt_mux_add_buffer (qtmux, qtpad, NULL);

  1128     if (ret != GST_FLOW_OK)

  1129       GST_WARNING_OBJECT (qtmux, "Failed to send last buffer for %s, "

  1130           "flow return: %s", GST_PAD_NAME (qtpad->collect.pad),

  1131           gst_flow_get_name (ret));

  1132   }

  1133 

  1134   GST_OBJECT_LOCK (qtmux);