/* AVI muxer plugin for GStreamer

 * Copyright (C) 2002 Ronald Bultje <rbultje@ronald.bitfreak.net>

 *           (C) 2006 Mark Nauwelaerts <manauw@skynet.be>

 *

 * 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.

 */

/* based on:

 * - the old avimuxer (by Wim Taymans)

 * - xawtv's aviwriter (by Gerd Knorr)

 * - mjpegtools' avilib (by Rainer Johanni)

 * - openDML large-AVI docs

 */

/**

 * SECTION:element-avimux

 *

 * Muxes raw or compressed audio and/or video streams into an AVI file.

 *

 * <refsect2>

 * <title>Example launch lines</title>

 * <para>(write everything in one line, without the backslash characters)</para>

 * |[

 * gst-launch videotestsrc num-buffers=250 \

 * ! 'video/x-raw-yuv,format=(fourcc)I420,width=320,height=240,framerate=(fraction)25/1' \

 * ! queue ! mux. \

 * audiotestsrc num-buffers=440 ! audioconvert \

 * ! 'audio/x-raw-int,rate=44100,channels=2' ! queue ! mux. \

 * avimux name=mux ! filesink location=test.avi

 * ]| This will create an .AVI file containing an uncompressed video stream

 * with a test picture and an uncompressed audio stream containing a 

 * test sound.

 * |[

 * gst-launch videotestsrc num-buffers=250 \

 * ! 'video/x-raw-yuv,format=(fourcc)I420,width=320,height=240,framerate=(fraction)25/1' \

 * ! xvidenc ! queue ! mux. \

 * audiotestsrc num-buffers=440 ! audioconvert ! 'audio/x-raw-int,rate=44100,channels=2' \

 * ! lame ! queue ! mux. \

 * avimux name=mux ! filesink location=test.avi

 * ]| This will create an .AVI file containing the same test video and sound

 * as above, only that both streams will be compressed this time. This will

 * only work if you have the necessary encoder elements installed of course.

 * </refsect2>

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "gst/gst-i18n-plugin.h"

#include <stdlib.h>

#include <string.h>

#include <gst/video/video.h>

#include "gstavimux.h"

GST_DEBUG_CATEGORY_STATIC (avimux_debug);

#define GST_CAT_DEFAULT avimux_debug

enum

{

  ARG_0,

  ARG_BIGFILE

};

#define DEFAULT_BIGFILE TRUE

static const GstElementDetails gst_avi_mux_details =

GST_ELEMENT_DETAILS ("Avi muxer",

    "Codec/Muxer",

    "Muxes audio and video into an avi stream",

    "Ronald Bultje <rbultje@ronald.bitfreak.net>");

static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS ("video/x-msvideo")

    );

static GstStaticPadTemplate video_sink_factory =

    GST_STATIC_PAD_TEMPLATE ("video_%d",

    GST_PAD_SINK,

    GST_PAD_REQUEST,

    GST_STATIC_CAPS ("video/x-raw-yuv, "

        "format = (fourcc) { YUY2, I420 }, "

        "width = (int) [ 16, 4096 ], "

        "height = (int) [ 16, 4096 ], "

        "framerate = (fraction) [ 0, MAX ]; "

        "image/jpeg, "

        "width = (int) [ 16, 4096 ], "

        "height = (int) [ 16, 4096 ], "

        "framerate = (fraction) [ 0, MAX ]; "

        "video/x-divx, "

        "width = (int) [ 16, 4096 ], "

        "height = (int) [ 16, 4096 ], "

        "framerate = (fraction) [ 0, MAX ], "

        "divxversion = (int) [ 3, 5 ]; "

        "video/x-xvid, "

        "width = (int) [ 16, 4096 ], "

        "height = (int) [ 16, 4096 ], "

        "framerate = (fraction) [ 0, MAX ]; "

        "video/x-3ivx, "

        "width = (int) [ 16, 4096 ], "

        "height = (int) [ 16, 4096 ], "

        "framerate = (fraction) [ 0, MAX ]; "

        "video/x-msmpeg, "

        "width = (int) [ 16, 4096 ], "

        "height = (int) [ 16, 4096 ], "

        "framerate = (fraction) [ 0, MAX ], "

        "msmpegversion = (int) [ 41, 43 ]; "

        "video/mpeg, "

        "width = (int) [ 16, 4096 ], "

        "height = (int) [ 16, 4096 ], "

        "framerate = (fraction) [ 0, MAX ], "

        "mpegversion = (int) { 1, 2, 4}, "

        "systemstream = (boolean) FALSE; "

        "video/x-h263, "

        "width = (int) [ 16, 4096 ], "

        "height = (int) [ 16, 4096 ], "

        "framerate = (fraction) [ 0, MAX ]; "

        "video/x-h264, "

        "width = (int) [ 16, 4096 ], "

        "height = (int) [ 16, 4096 ], "

        "framerate = (fraction) [ 0, MAX ]; "

        "video/x-dv, "

        "width = (int) 720, "

        "height = (int) { 576, 480 }, "

        "framerate = (fraction) [ 0, MAX ], "

        "systemstream = (boolean) FALSE; "

        "video/x-huffyuv, "

        "width = (int) [ 16, 4096 ], "

        "height = (int) [ 16, 4096 ], " "framerate = (fraction) [ 0, MAX ];"

        "video/x-dirac, "

        "width = (int) [ 16, 4096 ], "

        "height = (int) [ 16, 4096 ], " "framerate = (fraction) [ 0, MAX ];"

        "video/x-wmv, "

        "width = (int) [ 16, 4096 ], "

        "height = (int) [ 16, 4096 ], " "framerate = (fraction) [ 0, MAX ], "

        "wmvversion = (int) [ 1, 3]")

    );

static GstStaticPadTemplate audio_sink_factory =

    GST_STATIC_PAD_TEMPLATE ("audio_%d",

    GST_PAD_SINK,

    GST_PAD_REQUEST,

    GST_STATIC_CAPS ("audio/x-raw-int, "

        "endianness = (int) LITTLE_ENDIAN, "

        "signed = (boolean) { TRUE, FALSE }, "

        "width = (int) { 8, 16 }, "

        "depth = (int) { 8, 16 }, "

        "rate = (int) [ 1000, 96000 ], "

        "channels = (int) [ 1, 2 ]; "

        "audio/mpeg, "

        "mpegversion = (int) 1, "

        "layer = (int) [ 1, 3 ], "

        "rate = (int) [ 1000, 96000 ], " "channels = (int) [ 1, 2 ]; "

        "audio/mpeg, "

        "mpegversion = (int) 4, "

        "rate = (int) [ 1000, 96000 ], " "channels = (int) [ 1, 2 ]; "

/*#if 0 VC6 doesn't support #if here ...

        "audio/x-vorbis, "

        "rate = (int) [ 1000, 96000 ], " "channels = (int) [ 1, 2 ]; "

#endif*/

        "audio/x-ac3, "

        "rate = (int) [ 1000, 96000 ], " "channels = (int) [ 1, 2 ]; "

        "audio/x-alaw, "

        "rate = (int) [ 1000, 48000 ], " "channels = (int) [ 1, 2 ]; "

        "audio/x-mulaw, "

        "rate = (int) [ 1000, 48000 ], " "channels = (int) [ 1, 2 ]; "

        "audio/x-wma, "

        "rate = (int) [ 1000, 96000 ], " "channels = (int) [ 1, 2 ], "

        "wmaversion = (int) [ 1, 2 ] ")

    );

static void gst_avi_mux_base_init (gpointer g_class);

static void gst_avi_mux_class_init (GstAviMuxClass * klass);

static void gst_avi_mux_init (GstAviMux * avimux);

static void gst_avi_mux_pad_reset (GstAviPad * avipad, gboolean free);

static GstFlowReturn gst_avi_mux_collect_pads (GstCollectPads * pads,

    GstAviMux * avimux);

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

static GstPad *gst_avi_mux_request_new_pad (GstElement * element,

    GstPadTemplate * templ, const gchar * name);

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

static void gst_avi_mux_set_property (GObject * object,

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

static void gst_avi_mux_get_property (GObject * object,

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

static GstStateChangeReturn gst_avi_mux_change_state (GstElement * element,

    GstStateChange transition);

static GstElementClass *parent_class = NULL;

GType

gst_avi_mux_get_type (void)

{

  static GType avimux_type = 0;

  if (!avimux_type) {

    static const GTypeInfo avimux_info = {

      sizeof (GstAviMuxClass),

      gst_avi_mux_base_init,

      NULL,

      (GClassInitFunc) gst_avi_mux_class_init,

      NULL,

      NULL,

      sizeof (GstAviMux),

      0,

      (GInstanceInitFunc) gst_avi_mux_init,

    };

    static const GInterfaceInfo tag_setter_info = {

      NULL,

      NULL,

      NULL

    };

    avimux_type =

        g_type_register_static (GST_TYPE_ELEMENT, "GstAviMux", &avimux_info, 0);

    g_type_add_interface_static (avimux_type, GST_TYPE_TAG_SETTER,

        &tag_setter_info);

  }

  return avimux_type;

}

static void

gst_avi_mux_base_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&src_factory));

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&audio_sink_factory));

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&video_sink_factory));

  gst_element_class_set_details (element_class, &gst_avi_mux_details);

  GST_DEBUG_CATEGORY_INIT (avimux_debug, "avimux", 0, "Muxer for AVI streams");

}

static void

gst_avi_mux_finalize (GObject * object)

{

  GstAviMux *mux = GST_AVI_MUX (object);

  GSList *node;

  /* completely free each sinkpad */

  node = mux->sinkpads;

  while (node) {

    GstAviPad *avipad = (GstAviPad *) node->data;

    node = node->next;

    gst_avi_mux_pad_reset (avipad, TRUE);

    g_free (avipad);

  }

  g_slist_free (mux->sinkpads);

  mux->sinkpads = NULL;

  g_free (mux->idx);

  mux->idx = NULL;

  gst_object_unref (mux->collect);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static void

gst_avi_mux_class_init (GstAviMuxClass * 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->get_property = gst_avi_mux_get_property;

  gobject_class->set_property = gst_avi_mux_set_property;

  gobject_class->finalize = gst_avi_mux_finalize;

  g_object_class_install_property (gobject_class, ARG_BIGFILE,

      g_param_spec_boolean ("bigfile", "Bigfile Support (>2GB)",

          "Support for openDML-2.0 (big) AVI files", DEFAULT_BIGFILE,

          G_PARAM_READWRITE));

  gstelement_class->request_new_pad =

      GST_DEBUG_FUNCPTR (gst_avi_mux_request_new_pad);

  gstelement_class->release_pad = GST_DEBUG_FUNCPTR (gst_avi_mux_release_pad);

  gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_avi_mux_change_state);

}

/* reset pad to initial state

 * free - if true, release all, not only stream related, data */

static void

gst_avi_mux_pad_reset (GstAviPad * avipad, gboolean free)

{

  /* generic part */

  memset (&(avipad->hdr), 0, sizeof (gst_riff_strh));

  memset (&(avipad->idx[0]), 0, sizeof (avipad->idx));

  if (free) {

    g_free (avipad->tag);

    avipad->tag = NULL;

    g_free (avipad->idx_tag);

    avipad->idx_tag = NULL;

  }

  if (avipad->is_video) {

    GstAviVideoPad *vidpad = (GstAviVideoPad *) avipad;

    avipad->hdr.type = GST_MAKE_FOURCC ('v', 'i', 'd', 's');

    if (vidpad->vids_codec_data) {

      gst_buffer_unref (vidpad->vids_codec_data);

      vidpad->vids_codec_data = NULL;

    }

    memset (&(vidpad->vids), 0, sizeof (gst_riff_strf_vids));

    memset (&(vidpad->vprp), 0, sizeof (gst_riff_vprp));

  } else {

    GstAviAudioPad *audpad = (GstAviAudioPad *) avipad;

    avipad->hdr.type = GST_MAKE_FOURCC ('a', 'u', 'd', 's');

    if (audpad->auds_codec_data) {

      gst_buffer_unref (audpad->auds_codec_data);

      audpad->auds_codec_data = NULL;

    }

    memset (&(audpad->auds), 0, sizeof (gst_riff_strf_auds));

  }

}

static void

gst_avi_mux_reset (GstAviMux * avimux)

{

  GSList *node, *newlist = NULL;

  /* free and reset each sinkpad */

  node = avimux->sinkpads;

  while (node) {

    GstAviPad *avipad = (GstAviPad *) node->data;

    node = node->next;

    gst_avi_mux_pad_reset (avipad, FALSE);

    /* if this pad has collectdata, keep it, otherwise dump it completely */

    if (avipad->collect)

      newlist = g_slist_append (newlist, avipad);

    else {

      gst_avi_mux_pad_reset (avipad, TRUE);

      g_free (avipad);

    }

  }

  /* free the old list of sinkpads, only keep the real collecting ones */

  g_slist_free (avimux->sinkpads);

  avimux->sinkpads = newlist;

  /* avi data */

  avimux->num_frames = 0;

  memset (&(avimux->avi_hdr), 0, sizeof (gst_riff_avih));

  avimux->avi_hdr.max_bps = 10000000;

  avimux->codec_data_size = 0;

  if (avimux->tags_snap) {

    gst_tag_list_free (avimux->tags_snap);

    avimux->tags_snap = NULL;

  }

  g_free (avimux->idx);

  avimux->idx = NULL;

  /* state info */

  avimux->write_header = TRUE;

  /* tags */

  gst_tag_setter_reset_tags (GST_TAG_SETTER (avimux));

}

static void

gst_avi_mux_init (GstAviMux * avimux)

{

  avimux->srcpad = gst_pad_new_from_static_template (&src_factory, "src");

  gst_pad_use_fixed_caps (avimux->srcpad);

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

  /* property */

  avimux->enable_large_avi = DEFAULT_BIGFILE;

  avimux->collect = gst_collect_pads_new ();

  gst_collect_pads_set_function (avimux->collect,

      (GstCollectPadsFunction) (GST_DEBUG_FUNCPTR (gst_avi_mux_collect_pads)),

      avimux);

  /* set to clean state */

  gst_avi_mux_reset (avimux);

}

static gboolean

gst_avi_mux_vidsink_set_caps (GstPad * pad, GstCaps * vscaps)

{

  GstAviMux *avimux;

  GstAviVideoPad *avipad;

  GstAviCollectData *collect_pad;

  GstStructure *structure;

  const gchar *mimetype;

  const GValue *fps, *par;

  const GValue *codec_data;

  gint width, height;

  gint par_n, par_d;

  avimux = GST_AVI_MUX (gst_pad_get_parent (pad));

  /* find stream data */

  collect_pad = (GstAviCollectData *) gst_pad_get_element_private (pad);

  g_assert (collect_pad);

  avipad = (GstAviVideoPad *) collect_pad->avipad;

  g_assert (avipad);

  g_assert (avipad->parent.is_video);

  g_assert (avipad->parent.hdr.type == GST_MAKE_FOURCC ('v', 'i', 'd', 's'));

  GST_DEBUG_OBJECT (avimux, "%s:%s, caps=%" GST_PTR_FORMAT,

      GST_DEBUG_PAD_NAME (pad), vscaps);

  structure = gst_caps_get_structure (vscaps, 0);

  mimetype = gst_structure_get_name (structure);

  /* global */

  avipad->vids.size = sizeof (gst_riff_strf_vids);

  avipad->vids.planes = 1;

  if (!gst_structure_get_int (structure, "width", &width) ||

      !gst_structure_get_int (structure, "height", &height)) {

    goto refuse_caps;

  }

  avipad->vids.width = width;

  avipad->vids.height = height;

  fps = gst_structure_get_value (structure, "framerate");

  if (fps == NULL || !GST_VALUE_HOLDS_FRACTION (fps))

    goto refuse_caps;

  avipad->parent.hdr.rate = gst_value_get_fraction_numerator (fps);

  avipad->parent.hdr.scale = gst_value_get_fraction_denominator (fps);

  /* (pixel) aspect ratio data, if any */

  par = gst_structure_get_value (structure, "pixel-aspect-ratio");

  /* only use video properties header if there is non-trivial aspect info */

  if (par && GST_VALUE_HOLDS_FRACTION (par) &&

      ((par_n = gst_value_get_fraction_numerator (par)) !=

          (par_d = gst_value_get_fraction_denominator (par)))) {

    GValue to_ratio = { 0, };

    guint ratio_n, ratio_d;

    /* some fraction voodoo to obtain simplest possible ratio */

    g_value_init (&to_ratio, GST_TYPE_FRACTION);

    gst_value_set_fraction (&to_ratio, width * par_n, height * par_d);

    ratio_n = gst_value_get_fraction_numerator (&to_ratio);

    ratio_d = gst_value_get_fraction_denominator (&to_ratio);

    GST_DEBUG_OBJECT (avimux, "generating vprp data with aspect ratio %d/%d",

        ratio_n, ratio_d);

    /* simply fill in */

    avipad->vprp.vert_rate = avipad->parent.hdr.rate / avipad->parent.hdr.scale;

    avipad->vprp.hor_t_total = width;

    avipad->vprp.vert_lines = height;

    avipad->vprp.aspect = (ratio_n) << 16 | (ratio_d & 0xffff);

    avipad->vprp.width = width;

    avipad->vprp.height = height;

    avipad->vprp.fields = 1;

    avipad->vprp.field_info[0].compressed_bm_height = height;

    avipad->vprp.field_info[0].compressed_bm_width = width;

    avipad->vprp.field_info[0].valid_bm_height = height;

    avipad->vprp.field_info[0].valid_bm_width = width;

  }

  /* codec initialization data, if any */

  codec_data = gst_structure_get_value (structure, "codec_data");

  if (codec_data) {

    avipad->vids_codec_data = gst_value_get_buffer (codec_data);

    gst_buffer_ref (avipad->vids_codec_data);

    /* keep global track of size */

    avimux->codec_data_size += GST_BUFFER_SIZE (avipad->vids_codec_data);

  }

  if (!strcmp (mimetype, "video/x-raw-yuv")) {

    guint32 format;

    gst_structure_get_fourcc (structure, "format", &format);

    avipad->vids.compression = format;

    switch (format) {

      case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'):

        avipad->vids.bit_cnt = 16;

        break;

      case GST_MAKE_FOURCC ('I', '4', '2', '0'):

        avipad->vids.bit_cnt = 12;

        break;

    }

  } else {

    avipad->vids.bit_cnt = 24;

    avipad->vids.compression = 0;

    /* find format */

    if (!strcmp (mimetype, "video/x-huffyuv")) {

      avipad->vids.compression = GST_MAKE_FOURCC ('H', 'F', 'Y', 'U');

    } else if (!strcmp (mimetype, "image/jpeg")) {

      avipad->vids.compression = GST_MAKE_FOURCC ('M', 'J', 'P', 'G');

    } else if (!strcmp (mimetype, "video/x-divx")) {

      gint divxversion;

      gst_structure_get_int (structure, "divxversion", &divxversion);