/* Quicktime muxer plugin for GStreamer

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

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

 *

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

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

 * License as published by the Free Software Foundation; either

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

 *

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

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

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

 * Library General Public License for more details.

 *

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

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

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

 * Boston, MA 02111-1307, USA.

 */

/*

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

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

 * LICENSE).

 *

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

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

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

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

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

 * so, subject to the following conditions:

 *

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

 * copies or substantial portions of the Software.

 *

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

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

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

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

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

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

 * SOFTWARE.

 */

/**

 * SECTION:gstqtmux

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

 *

 * <refsect2>

 * <para>

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

 * </para>

 * <title>Example pipelines</title>

 * <para>

 * <programlisting>

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

 * </programlisting>

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

 * </para>

 * </refsect2>

 *

 * Last reviewed on 2008-08-27

 */

/*

 * Based on avimux

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <glib/gstdio.h>

#include <gst/gst.h>

#include <gst/base/gstcollectpads.h>

#include <sys/types.h>

#ifdef G_OS_WIN32

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

#undef lseek

#define lseek _lseeki64

#undef off_t

#define off_t guint64

#endif

#ifdef HAVE_UNISTD_H

#  include <unistd.h>

#endif

#include "gstqtmux.h"

GST_DEBUG_CATEGORY_STATIC (gst_qt_mux_debug);

#define GST_CAT_DEFAULT gst_qt_mux_debug

/* QTMux signals and args */

enum

{

  /* FILL ME */

  LAST_SIGNAL

};

enum

{

  PROP_0,

  PROP_LARGE_FILE,

  PROP_MOVIE_TIMESCALE,

  PROP_DO_CTTS,

  PROP_FLAVOR,

  PROP_FAST_START,

  PROP_FAST_START_TEMP_FILE

};

/* some spare for header size as well */

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

#define DEFAULT_LARGE_FILE              FALSE

#define DEFAULT_MOVIE_TIMESCALE         1000

#define DEFAULT_DO_CTTS                 FALSE

#define DEFAULT_FAST_START              FALSE

#define DEFAULT_FAST_START_TEMP_FILE    NULL

static void gst_qt_mux_finalize (GObject * object);

static GstStateChangeReturn gst_qt_mux_change_state (GstElement * element,

    GstStateChange transition);

/* property functions */

static void gst_qt_mux_set_property (GObject * object,

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

static void gst_qt_mux_get_property (GObject * object,

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

/* pad functions */

static GstPad *gst_qt_mux_request_new_pad (GstElement * element,

    GstPadTemplate * templ, const gchar * name);

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

/* event */

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

static GstFlowReturn gst_qt_mux_collected (GstCollectPads * pads,

    gpointer user_data);

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

    GstBuffer * buf);

static GstElementClass *parent_class = NULL;

static void

gst_qt_mux_base_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  GstQTMuxClass *klass = (GstQTMuxClass *) g_class;

  GstQTMuxClassParams *params;

  GstElementDetails details;

  GstPadTemplate *videosinktempl, *audiosinktempl, *srctempl;

  params =

      (GstQTMuxClassParams *) g_type_get_qdata (G_OBJECT_CLASS_TYPE (g_class),

      GST_QT_MUX_PARAMS_QDATA);

  g_assert (params != NULL);

  /* construct the element details struct */

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

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

  details.description =

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

      params->prop->long_name);

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

  gst_element_class_set_details (element_class, &details);

  g_free (details.longname);

  g_free (details.klass);

  g_free (details.description);

  /* pad templates */

  srctempl = gst_pad_template_new ("src", GST_PAD_SRC,

      GST_PAD_ALWAYS, params->src_caps);

  gst_element_class_add_pad_template (element_class, srctempl);

  if (params->audio_sink_caps) {

    audiosinktempl = gst_pad_template_new ("audio_%d",

        GST_PAD_SINK, GST_PAD_REQUEST, params->audio_sink_caps);

    gst_element_class_add_pad_template (element_class, audiosinktempl);

  }

  if (params->video_sink_caps) {

    videosinktempl = gst_pad_template_new ("video_%d",

        GST_PAD_SINK, GST_PAD_REQUEST, params->video_sink_caps);

    gst_element_class_add_pad_template (element_class, videosinktempl);

  }

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

}

static void

gst_qt_mux_class_init (GstQTMuxClass * klass)

{

  GObjectClass *gobject_class;

  GstElementClass *gstelement_class;

  gobject_class = (GObjectClass *) klass;

  gstelement_class = (GstElementClass *) klass;

  parent_class = g_type_class_peek_parent (klass);

  gobject_class->finalize = gst_qt_mux_finalize;

  gobject_class->get_property = gst_qt_mux_get_property;

  gobject_class->set_property = gst_qt_mux_set_property;

  g_object_class_install_property (gobject_class, PROP_LARGE_FILE,

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

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

          "providing support for large files",

          DEFAULT_LARGE_FILE, G_PARAM_READWRITE));

  g_object_class_install_property (gobject_class, PROP_MOVIE_TIMESCALE,

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

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

          1, G_MAXUINT32, DEFAULT_MOVIE_TIMESCALE,

          G_PARAM_READWRITE | G_PARAM_CONSTRUCT));

  g_object_class_install_property (gobject_class, PROP_DO_CTTS,

      g_param_spec_boolean ("presentation-time",

          "Include presentation-time info",

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

          " (use with caution)", DEFAULT_DO_CTTS,

          G_PARAM_READWRITE | G_PARAM_CONSTRUCT));

  g_object_class_install_property (gobject_class, PROP_FAST_START,

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

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

          DEFAULT_FAST_START, G_PARAM_READWRITE));

  g_object_class_install_property (gobject_class, PROP_FAST_START_TEMP_FILE,

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

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

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

          DEFAULT_FAST_START_TEMP_FILE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));

  gstelement_class->request_new_pad =

      GST_DEBUG_FUNCPTR (gst_qt_mux_request_new_pad);

  gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_qt_mux_change_state);

  gstelement_class->release_pad = GST_DEBUG_FUNCPTR (gst_qt_mux_release_pad);

}

static void

gst_qt_mux_pad_reset (GstQTPad * qtpad)

{

  qtpad->fourcc = 0;

  qtpad->is_out_of_order = FALSE;

  qtpad->have_dts = FALSE;

  qtpad->sample_size = 0;

  qtpad->sync = FALSE;

  qtpad->last_dts = 0;

  if (qtpad->last_buf)

    gst_buffer_replace (&qtpad->last_buf, NULL);

  /* reference owned elsewhere */

  qtpad->trak = NULL;

}

/*

 * Takes GstQTMux back to its initial state

 */

static void

gst_qt_mux_reset (GstQTMux * qtmux, gboolean alloc)

{

  GSList *walk;

  qtmux->state = GST_QT_MUX_STATE_NONE;

  qtmux->header_size = 0;

  qtmux->mdat_size = 0;

  qtmux->mdat_pos = 0;

  qtmux->longest_chunk = GST_CLOCK_TIME_NONE;

  if (qtmux->ftyp) {

    atom_ftyp_free (qtmux->ftyp);

    qtmux->ftyp = NULL;

  }

  if (qtmux->moov) {

    atom_moov_free (qtmux->moov);

    qtmux->moov = NULL;

  }

  if (qtmux->fast_start_file) {

    fclose (qtmux->fast_start_file);

    qtmux->fast_start_file = NULL;

  }

  gst_tag_setter_reset_tags (GST_TAG_SETTER (qtmux));

  /* reset pad data */

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

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

    gst_qt_mux_pad_reset (qtpad);

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

     * so do not free, but do clear */

    qtpad->trak = NULL;

  }

  if (alloc) {

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

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

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

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

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

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

    }

  }

}

static void

gst_qt_mux_init (GstQTMux * qtmux, GstQTMuxClass * qtmux_klass)

{

  GstElementClass *klass = GST_ELEMENT_CLASS (qtmux_klass);

  GstPadTemplate *templ;

  GstCaps *caps;

  templ = gst_element_class_get_pad_template (klass, "src");

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

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

  gst_pad_set_caps (qtmux->srcpad, caps);

  gst_caps_unref (caps);

  gst_pad_use_fixed_caps (qtmux->srcpad);

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

  qtmux->collect = gst_collect_pads_new ();

  gst_collect_pads_set_function (qtmux->collect,

      (GstCollectPadsFunction) GST_DEBUG_FUNCPTR (gst_qt_mux_collected), qtmux);

  /* properties set to default upon construction */

  /* always need this */

  qtmux->context =

      atoms_context_new (gst_qt_mux_map_format_to_flavor (qtmux_klass->format));

  /* internals to initial state */

  gst_qt_mux_reset (qtmux, TRUE);

}

static void

gst_qt_mux_finalize (GObject * object)

{

  GstQTMux *qtmux = GST_QT_MUX_CAST (object);

  gst_qt_mux_reset (qtmux, FALSE);

  if (qtmux->fast_start_file_path)

    g_free (qtmux->fast_start_file_path);

  atoms_context_free (qtmux->context);

  gst_object_unref (qtmux->collect);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static void

gst_qt_mux_add_mp4_tag (GstQTMux * qtmux, const GstTagList * list,

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

{

  switch (gst_tag_get_type (tag)) {

      /* strings */

    case G_TYPE_STRING:

    {

      gchar *str = NULL;

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

        break;

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

          GST_FOURCC_ARGS (fourcc), str);

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

      g_free (str);

      break;

    }

      /* double */

    case G_TYPE_DOUBLE:

    {

      gdouble value;

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

        break;

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

          GST_FOURCC_ARGS (fourcc), (gint) value);

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

      break;

    }

      /* paired unsigned integers */

    case G_TYPE_UINT:

    {

      guint value;

      guint count;

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

          !gst_tag_list_get_uint (list, tag2, &count))

        break;

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

          GST_FOURCC_ARGS (fourcc), value, count);

      atom_moov_add_uint_tag (qtmux->moov, fourcc, 0,

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

      break;

    }

    default:

      g_assert_not_reached ();

      break;

  }

}

static void

gst_qt_mux_add_mp4_date (GstQTMux * qtmux, const GstTagList * list,

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

{

  GDate *date = NULL;

  GDateYear year;

  GDateMonth month;

  GDateDay day;

  gchar *str;

  g_return_if_fail (gst_tag_get_type (tag) == GST_TYPE_DATE);

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

    return;

  year = g_date_get_year (date);

  month = g_date_get_month (date);

  day = g_date_get_day (date);

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

      day == G_DATE_BAD_DAY) {

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

    return;

  }

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

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

      GST_FOURCC_ARGS (fourcc), str);

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

}

static void

gst_qt_mux_add_mp4_cover (GstQTMux * qtmux, const GstTagList * list,

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

{

  GValue value = { 0, };

  GstBuffer *buf;

  GstCaps *caps;

  GstStructure *structure;

  gint flags = 0;

  g_return_if_fail (gst_tag_get_type (tag) == GST_TYPE_BUFFER);

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

    return;

  buf = gst_value_get_buffer (&value);

  if (!buf)

    goto done;

  caps = gst_buffer_get_caps (buf);

  if (!caps) {

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

    goto done;

  }

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

  structure = gst_caps_get_structure (caps, 0);

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

    flags = 13;

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

    flags = 14;

  gst_caps_unref (caps);

  if (!flags) {

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

    goto done;

  }

  GST_DEBUG_OBJECT (qtmux, "Adding tag %" GST_FOURCC_FORMAT

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

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

      GST_BUFFER_SIZE (buf));

done:

  g_value_unset (&value);

}

static void

gst_qt_mux_add_3gp_str (GstQTMux * qtmux, const GstTagList * list,

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

{

  gchar *str = NULL;

  guint number;

  g_return_if_fail (gst_tag_get_type (tag) == G_TYPE_STRING);

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

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

    return;

  if (tag2)

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

      tag2 = NULL;

  if (!tag2) {

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

        GST_FOURCC_ARGS (fourcc), str);

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

  } else {

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

        GST_FOURCC_ARGS (fourcc), str, number);

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

  }

  g_free (str);

}

static void

gst_qt_mux_add_3gp_date (GstQTMux * qtmux, const GstTagList * list,

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

{

  GDate *date = NULL;

  GDateYear year;

  g_return_if_fail (gst_tag_get_type (tag) == GST_TYPE_DATE);

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

    return;

  year = g_date_get_year (date);

  if (year == G_DATE_BAD_YEAR) {

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