gst/avi/gstavimux.c

   1 /* AVI muxer plugin for GStreamer
   2  * Copyright (C) 2002 Ronald Bultje <rbultje@ronald.bitfreak.net>
   3  *           (C) 2006 Mark Nauwelaerts <manauw@skynet.be>
   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 /* based on:
  22  * - the old avimuxer (by Wim Taymans)
  23  * - xawtv's aviwriter (by Gerd Knorr)
  24  * - mjpegtools' avilib (by Rainer Johanni)
  25  * - openDML large-AVI docs
  26  */
  27
  28 /**
  29  * SECTION:element-avimux
  30  *
  31  * Muxes raw or compressed audio and/or video streams into an AVI file.
  32  *
  33  * <refsect2>
  34  * <title>Example launch lines</title>
  35  * <para>(write everything in one line, without the backslash characters)</para>
  36  * |[
  37  * gst-launch videotestsrc num-buffers=250 \
  38  * ! 'video/x-raw,format=(string)I420,width=320,height=240,framerate=(fraction)25/1' \
  39  * ! queue ! mux. \
  40  * audiotestsrc num-buffers=440 ! audioconvert \
  41  * ! 'audio/x-raw,rate=44100,channels=2' ! queue ! mux. \
  42  * avimux name=mux ! filesink location=test.avi
  43  * ]| This will create an .AVI file containing an uncompressed video stream
  44  * with a test picture and an uncompressed audio stream containing a
  45  * test sound.
  46  * |[
  47  * gst-launch videotestsrc num-buffers=250 \
  48  * ! 'video/x-raw,format=(string)I420,width=320,height=240,framerate=(fraction)25/1' \
  49  * ! xvidenc ! queue ! mux. \
  50  * audiotestsrc num-buffers=440 ! audioconvert ! 'audio/x-raw,rate=44100,channels=2' \
  51  * ! lame ! queue ! mux. \
  52  * avimux name=mux ! filesink location=test.avi
  53  * ]| This will create an .AVI file containing the same test video and sound
  54  * as above, only that both streams will be compressed this time. This will
  55  * only work if you have the necessary encoder elements installed of course.
  56  * </refsect2>
  57  */
  58
  59 #ifdef HAVE_CONFIG_H
  60 #include "config.h"
  61 #endif
  62
  63 #include "gst/gst-i18n-plugin.h"
  64 #include <stdio.h>
  65 #include <stdlib.h>
  66 #include <string.h>
  67
  68 #include <gst/video/video.h>
  69 #include <gst/audio/audio.h>
  70 #include <gst/base/gstbytewriter.h>
  71
  72 #include "gstavimux.h"
  73
  74 GST_DEBUG_CATEGORY_STATIC (avimux_debug);
  75 #define GST_CAT_DEFAULT avimux_debug
  76
  77 enum
  78 {
  79   ARG_0,
  80   ARG_BIGFILE
  81 };
  82
  83 #define DEFAULT_BIGFILE TRUE
  84
  85 static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
  86     GST_PAD_SRC,
  87     GST_PAD_ALWAYS,
  88     GST_STATIC_CAPS ("video/x-msvideo")
  89     );
  90
  91 static GstStaticPadTemplate video_sink_factory =
  92     GST_STATIC_PAD_TEMPLATE ("video_%u",
  93     GST_PAD_SINK,
  94     GST_PAD_REQUEST,
  95     GST_STATIC_CAPS ("video/x-raw, "
  96         "format = (string) { YUY2, I420 }, "
  97         "width = (int) [ 16, 4096 ], "
  98         "height = (int) [ 16, 4096 ], "
  99         "framerate = (fraction) [ 0, MAX ]; "
 100         "image/jpeg, "
 101         "width = (int) [ 16, 4096 ], "
 102         "height = (int) [ 16, 4096 ], "
 103         "framerate = (fraction) [ 0, MAX ]; "
 104         "video/x-divx, "
 105         "width = (int) [ 16, 4096 ], "
 106         "height = (int) [ 16, 4096 ], "
 107         "framerate = (fraction) [ 0, MAX ], "
 108         "divxversion = (int) [ 3, 5 ]; "
 109         "video/x-xvid, "
 110         "width = (int) [ 16, 4096 ], "
 111         "height = (int) [ 16, 4096 ], "
 112         "framerate = (fraction) [ 0, MAX ]; "
 113         "video/x-3ivx, "
 114         "width = (int) [ 16, 4096 ], "
 115         "height = (int) [ 16, 4096 ], "
 116         "framerate = (fraction) [ 0, MAX ]; "
 117         "video/x-msmpeg, "
 118         "width = (int) [ 16, 4096 ], "
 119         "height = (int) [ 16, 4096 ], "
 120         "framerate = (fraction) [ 0, MAX ], "
 121         "msmpegversion = (int) [ 41, 43 ]; "
 122         "video/mpeg, "
 123         "width = (int) [ 16, 4096 ], "
 124         "height = (int) [ 16, 4096 ], "
 125         "framerate = (fraction) [ 0, MAX ], "
 126         "mpegversion = (int) { 1, 2, 4}, "
 127         "systemstream = (boolean) FALSE; "
 128         "video/x-h263, "
 129         "width = (int) [ 16, 4096 ], "
 130         "height = (int) [ 16, 4096 ], "
 131         "framerate = (fraction) [ 0, MAX ]; "
 132         "video/x-h264, "
 133         "stream-format = (string) byte-stream, "
 134         "alignment = (string) au, "
 135         "width = (int) [ 16, 4096 ], "
 136         "height = (int) [ 16, 4096 ], "
 137         "framerate = (fraction) [ 0, MAX ]; "
 138         "video/x-dv, "
 139         "width = (int) 720, "
 140         "height = (int) { 576, 480 }, "
 141         "framerate = (fraction) [ 0, MAX ], "
 142         "systemstream = (boolean) FALSE; "
 143         "video/x-huffyuv, "
 144         "width = (int) [ 16, 4096 ], "
 145         "height = (int) [ 16, 4096 ], " "framerate = (fraction) [ 0, MAX ];"
 146         "video/x-wmv, "
 147         "width = (int) [ 16, 4096 ], "
 148         "height = (int) [ 16, 4096 ], " "framerate = (fraction) [ 0, MAX ], "
 149         "wmvversion = (int) [ 1, 3];"
 150         "image/x-jpc, "
 151         "width = (int) [ 1, 2147483647 ], "
 152         "height = (int) [ 1, 2147483647 ], "
 153         "framerate = (fraction) [ 0, MAX ];"
 154         "video/x-vp8, "
 155         "width = (int) [ 1, 2147483647 ], "
 156         "height = (int) [ 1, 2147483647 ], "
 157         "framerate = (fraction) [ 0, MAX ]")
 158     );
 159
 160 static GstStaticPadTemplate audio_sink_factory =
 161     GST_STATIC_PAD_TEMPLATE ("audio_%u",
 162     GST_PAD_SINK,
 163     GST_PAD_REQUEST,
 164     GST_STATIC_CAPS ("audio/x-raw, "
 165         "format = (string) { U8, S16LE }, "
 166         "rate = (int) [ 1000, 96000 ], "
 167         "channels = (int) [ 1, 2 ]; "
 168         "audio/mpeg, "
 169         "mpegversion = (int) 1, "
 170         "layer = (int) [ 1, 3 ], "
 171         "rate = (int) [ 1000, 96000 ], " "channels = (int) [ 1, 2 ]; "
 172         "audio/mpeg, "
 173         "mpegversion = (int) 4, "
 174         "stream-format = (string) raw, "
 175         "rate = (int) [ 1000, 96000 ], " "channels = (int) [ 1, 2 ]; "
 176 /*#if 0 VC6 doesn't support #if here ...
 177         "audio/x-vorbis, "
 178         "rate = (int) [ 1000, 96000 ], " "channels = (int) [ 1, 2 ]; "
 179 #endif*/
 180         "audio/x-ac3, "
 181         "rate = (int) [ 1000, 96000 ], " "channels = (int) [ 1, 2 ]; "
 182         "audio/x-alaw, "
 183         "rate = (int) [ 1000, 48000 ], " "channels = (int) [ 1, 2 ]; "
 184         "audio/x-mulaw, "
 185         "rate = (int) [ 1000, 48000 ], " "channels = (int) [ 1, 2 ]; "
 186         "audio/x-wma, "
 187         "rate = (int) [ 1000, 96000 ], " "channels = (int) [ 1, 2 ], "
 188         "wmaversion = (int) [ 1, 2 ] ")
 189     );
 190
 191 static void gst_avi_mux_pad_reset (GstAviPad * avipad, gboolean free);
 192
 193 static GstFlowReturn gst_avi_mux_collect_pads (GstCollectPads2 * pads,
 194     GstAviMux * avimux);
 195 static gboolean gst_avi_mux_handle_event (GstCollectPads2 * pad,
 196     GstCollectData2 * data, GstEvent * event, gpointer user_data);
 197 static GstPad *gst_avi_mux_request_new_pad (GstElement * element,
 198     GstPadTemplate * templ, const gchar * name, const GstCaps * caps);
 199 static void gst_avi_mux_release_pad (GstElement * element, GstPad * pad);
 200 static void gst_avi_mux_set_property (GObject * object,
 201     guint prop_id, const GValue * value, GParamSpec * pspec);
 202 static void gst_avi_mux_get_property (GObject * object,
 203     guint prop_id, GValue * value, GParamSpec * pspec);
 204 static GstStateChangeReturn gst_avi_mux_change_state (GstElement * element,
 205     GstStateChange transition);
 206
 207 #define gst_avi_mux_parent_class parent_class
 208 G_DEFINE_TYPE_WITH_CODE (GstAviMux, gst_avi_mux, GST_TYPE_ELEMENT,
 209     G_IMPLEMENT_INTERFACE (GST_TYPE_TAG_SETTER, NULL));
 210
 211 static void
 212 gst_avi_mux_finalize (GObject * object)
 213 {
 214   GstAviMux *mux = GST_AVI_MUX (object);
 215   GSList *node;
 216
 217   /* completely free each sinkpad */
 218   node = mux->sinkpads;
 219   while (node) {
 220     GstAviPad *avipad = (GstAviPad *) node->data;
 221
 222     node = node->next;
 223
 224     gst_avi_mux_pad_reset (avipad, TRUE);
 225     g_free (avipad);
 226   }
 227   g_slist_free (mux->sinkpads);
 228   mux->sinkpads = NULL;
 229
 230   g_free (mux->idx);
 231   mux->idx = NULL;
 232
 233   gst_object_unref (mux->collect);
 234
 235   G_OBJECT_CLASS (parent_class)->finalize (object);
 236 }
 237
 238 static void
 239 gst_avi_mux_class_init (GstAviMuxClass * klass)
 240 {
 241   GObjectClass *gobject_class;
 242   GstElementClass *gstelement_class;
 243
 244   gobject_class = (GObjectClass *) klass;
 245   gstelement_class = (GstElementClass *) klass;
 246
 247   GST_DEBUG_CATEGORY_INIT (avimux_debug, "avimux", 0, "Muxer for AVI streams");
 248
 249   gobject_class->get_property = gst_avi_mux_get_property;
 250   gobject_class->set_property = gst_avi_mux_set_property;
 251   gobject_class->finalize = gst_avi_mux_finalize;
 252
 253   g_object_class_install_property (gobject_class, ARG_BIGFILE,
 254       g_param_spec_boolean ("bigfile", "Bigfile Support (>2GB)",
 255           "Support for openDML-2.0 (big) AVI files", DEFAULT_BIGFILE,
 256           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 257
 258   gstelement_class->request_new_pad =
 259       GST_DEBUG_FUNCPTR (gst_avi_mux_request_new_pad);
 260   gstelement_class->release_pad = GST_DEBUG_FUNCPTR (gst_avi_mux_release_pad);
 261   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_avi_mux_change_state);
 262
 263   gst_element_class_add_pad_template (gstelement_class,
 264       gst_static_pad_template_get (&src_factory));
 265   gst_element_class_add_pad_template (gstelement_class,
 266       gst_static_pad_template_get (&audio_sink_factory));
 267   gst_element_class_add_pad_template (gstelement_class,
 268       gst_static_pad_template_get (&video_sink_factory));
 269
 270   gst_element_class_set_details_simple (gstelement_class, "Avi muxer",
 271       "Codec/Muxer",
 272       "Muxes audio and video into an avi stream",
 273       "GStreamer maintainers <gstreamer-devel@lists.sourceforge.net>");
 274 }
 275
 276 /* reset pad to initial state
 277  * free - if true, release all, not only stream related, data */
 278 static void
 279 gst_avi_mux_pad_reset (GstAviPad * avipad, gboolean free)
 280 {
 281   /* generic part */
 282   memset (&(avipad->hdr), 0, sizeof (gst_riff_strh));
 283
 284   memset (&(avipad->idx[0]), 0, sizeof (avipad->idx));
 285
 286   if (free) {
 287     g_free (avipad->tag);
 288     avipad->tag = NULL;
 289     g_free (avipad->idx_tag);
 290     avipad->idx_tag = NULL;
 291   }
 292
 293   if (avipad->is_video) {
 294     GstAviVideoPad *vidpad = (GstAviVideoPad *) avipad;
 295
 296     avipad->hdr.type = GST_MAKE_FOURCC ('v', 'i', 'd', 's');
 297     if (vidpad->vids_codec_data) {
 298       gst_buffer_unref (vidpad->vids_codec_data);
 299       vidpad->vids_codec_data = NULL;
 300     }
 301
 302     if (vidpad->prepend_buffer) {
 303       gst_buffer_unref (vidpad->prepend_buffer);
 304       vidpad->prepend_buffer = NULL;
 305     }
 306
 307     memset (&(vidpad->vids), 0, sizeof (gst_riff_strf_vids));
 308     memset (&(vidpad->vprp), 0, sizeof (gst_riff_vprp));
 309   } else {
 310     GstAviAudioPad *audpad = (GstAviAudioPad *) avipad;
 311
 312     audpad->samples = 0;
 313
 314     avipad->hdr.type = GST_MAKE_FOURCC ('a', 'u', 'd', 's');
 315     if (audpad->auds_codec_data) {
 316       gst_buffer_unref (audpad->auds_codec_data);
 317       audpad->auds_codec_data = NULL;
 318     }
 319
 320     memset (&(audpad->auds), 0, sizeof (gst_riff_strf_auds));
 321   }
 322 }
 323
 324 static void
 325 gst_avi_mux_reset (GstAviMux * avimux)
 326 {
 327   GSList *node, *newlist = NULL;
 328
 329   /* free and reset each sinkpad */
 330   node = avimux->sinkpads;
 331   while (node) {
 332     GstAviPad *avipad = (GstAviPad *) node->data;
 333
 334     node = node->next;
 335
 336     gst_avi_mux_pad_reset (avipad, FALSE);
 337     /* if this pad has collectdata, keep it, otherwise dump it completely */
 338     if (avipad->collect)
 339       newlist = g_slist_append (newlist, avipad);
 340     else {
 341       gst_avi_mux_pad_reset (avipad, TRUE);
 342       g_free (avipad);
 343     }
 344   }
 345
 346   /* free the old list of sinkpads, only keep the real collecting ones */
 347   g_slist_free (avimux->sinkpads);
 348   avimux->sinkpads = newlist;
 349
 350   /* avi data */
 351   avimux->num_frames = 0;
 352   memset (&(avimux->avi_hdr), 0, sizeof (gst_riff_avih));
 353   avimux->avi_hdr.max_bps = 10000000;
 354   avimux->codec_data_size = 0;
 355
 356   if (avimux->tags_snap) {
 357     gst_tag_list_free (avimux->tags_snap);
 358     avimux->tags_snap = NULL;
 359   }
 360
 361   g_free (avimux->idx);
 362   avimux->idx = NULL;
 363
 364   /* state info */
 365   avimux->write_header = TRUE;
 366
 367   /* tags */
 368   gst_tag_setter_reset_tags (GST_TAG_SETTER (avimux));
 369 }
 370
 371 static void
 372 gst_avi_mux_init (GstAviMux * avimux)
 373 {
 374   avimux->srcpad = gst_pad_new_from_static_template (&src_factory, "src");
 375   gst_pad_use_fixed_caps (avimux->srcpad);
 376   gst_element_add_pad (GST_ELEMENT (avimux), avimux->srcpad);
 377
 378   /* property */
 379   avimux->enable_large_avi = DEFAULT_BIGFILE;
 380
 381   avimux->collect = gst_collect_pads2_new ();
 382   gst_collect_pads2_set_function (avimux->collect,
 383       (GstCollectPads2Function) (GST_DEBUG_FUNCPTR (gst_avi_mux_collect_pads)),
 384       avimux);
 385   gst_collect_pads2_set_event_function (avimux->collect,
 386       (GstCollectPads2EventFunction) (GST_DEBUG_FUNCPTR
 387           (gst_avi_mux_handle_event)), avimux);
 388
 389   /* set to clean state */
 390   gst_avi_mux_reset (avimux);
 391 }
 392
 393 static gboolean
 394 gst_avi_mux_vidsink_set_caps (GstPad * pad, GstCaps * vscaps)
 395 {
 396   GstAviMux *avimux;
 397   GstAviVideoPad *avipad;
 398   GstAviCollectData *collect_pad;
 399   GstStructure *structure;
 400   const gchar *mimetype;
 401   const GValue *fps, *par;
 402   const GValue *codec_data;
 403   gint width, height;
 404   gint par_n, par_d;
 405   gboolean codec_data_in_headers = TRUE;
 406
 407   avimux = GST_AVI_MUX (gst_pad_get_parent (pad));
 408
 409   /* find stream data */
 410   collect_pad = (GstAviCollectData *) gst_pad_get_element_private (pad);
 411   g_assert (collect_pad);
 412   avipad = (GstAviVideoPad *) collect_pad->avipad;
 413   g_assert (avipad);
 414   g_assert (avipad->parent.is_video);
 415   g_assert (avipad->parent.hdr.type == GST_MAKE_FOURCC ('v', 'i', 'd', 's'));
 416
 417   GST_DEBUG_OBJECT (avimux, "%s:%s, caps=%" GST_PTR_FORMAT,
 418       GST_DEBUG_PAD_NAME (pad), vscaps);
 419
 420   structure = gst_caps_get_structure (vscaps, 0);
 421   mimetype = gst_structure_get_name (structure);
 422
 423   /* global */
 424   avipad->vids.size = sizeof (gst_riff_strf_vids);
 425   avipad->vids.planes = 1;
 426   if (!gst_structure_get_int (structure, "width", &width) ||
 427       !gst_structure_get_int (structure, "height", &height)) {
 428     goto refuse_caps;
 429   }
 430
 431   avipad->vids.width = width;
 432   avipad->vids.height = height;
 433
 434   fps = gst_structure_get_value (structure, "framerate");
 435   if (fps == NULL || !GST_VALUE_HOLDS_FRACTION (fps))
 436     goto refuse_caps;
 437
 438   avipad->parent.hdr.rate = gst_value_get_fraction_numerator (fps);
 439   avipad->parent.hdr.scale = gst_value_get_fraction_denominator (fps);
 440
 441   /* (pixel) aspect ratio data, if any */
 442   par = gst_structure_get_value (structure, "pixel-aspect-ratio");
 443   /* only use video properties header if there is non-trivial aspect info */
 444   if (par && GST_VALUE_HOLDS_FRACTION (par) &&
 445       ((par_n = gst_value_get_fraction_numerator (par)) !=
 446           (par_d = gst_value_get_fraction_denominator (par)))) {
 447     GValue to_ratio = { 0, };
 448     guint ratio_n, ratio_d;
 449
 450     /* some fraction voodoo to obtain simplest possible ratio */
 451     g_value_init (&to_ratio, GST_TYPE_FRACTION);
 452     gst_value_set_fraction (&to_ratio, width * par_n, height * par_d);
 453     ratio_n = gst_value_get_fraction_numerator (&to_ratio);
 454     ratio_d = gst_value_get_fraction_denominator (&to_ratio);
 455     GST_DEBUG_OBJECT (avimux, "generating vprp data with aspect ratio %d/%d",
 456         ratio_n, ratio_d);
 457     /* simply fill in */
 458     avipad->vprp.vert_rate = avipad->parent.hdr.rate / avipad->parent.hdr.scale;
 459     avipad->vprp.hor_t_total = width;
 460     avipad->vprp.vert_lines = height;
 461     avipad->vprp.aspect = (ratio_n) << 16 | (ratio_d & 0xffff);
 462     avipad->vprp.width = width;
 463     avipad->vprp.height = height;
 464     avipad->vprp.fields = 1;
 465     avipad->vprp.field_info[0].compressed_bm_height = height;
 466     avipad->vprp.field_info[0].compressed_bm_width = width;
 467     avipad->vprp.field_info[0].valid_bm_height = height;
 468     avipad->vprp.field_info[0].valid_bm_width = width;
 469   }
 470
 471   if (!strcmp (mimetype, "video/x-raw")) {
 472     const gchar *format;
 473     GstVideoFormat fmt;
 474
 475     format = gst_structure_get_string (structure, "format");
 476     fmt = gst_video_format_from_string (format);
 477
 478     switch (fmt) {
 479       case GST_VIDEO_FORMAT_YUY2:
 480         avipad->vids.compression = GST_MAKE_FOURCC ('Y', 'U', 'Y', '2');
 481         avipad->vids.bit_cnt = 16;
 482         break;
 483       case GST_VIDEO_FORMAT_I420:
 484         avipad->vids.compression = GST_MAKE_FOURCC ('I', '4', '2', '0');
 485         avipad->vids.bit_cnt = 12;
 486         break;
 487       default:
 488         break;
 489     }
 490   } else {
 491     avipad->vids.bit_cnt = 24;
 492     avipad->vids.compression = 0;
 493
 494     /* find format */
 495     if (!strcmp (mimetype, "video/x-huffyuv")) {
 496       avipad->vids.compression = GST_MAKE_FOURCC ('H', 'F', 'Y', 'U');
 497     } else if (!strcmp (mimetype, "image/jpeg")) {
 498       avipad->vids.compression = GST_MAKE_FOURCC ('M', 'J', 'P', 'G');
 499     } else if (!strcmp (mimetype, "video/x-divx")) {
 500       gint divxversion;
 501
 502       gst_structure_get_int (structure, "divxversion", &divxversion);
 503       switch (divxversion) {
 504         case 3:
 505           avipad->vids.compression = GST_MAKE_FOURCC ('D', 'I', 'V', '3');
 506           break;
 507         case 4:
 508           avipad->vids.compression = GST_MAKE_FOURCC ('D', 'I', 'V', 'X');
 509           break;
 510         case 5:
 511           avipad->vids.compression = GST_MAKE_FOURCC ('D', 'X', '5', '0');
 512           break;
 513       }
 514     } else if (!strcmp (mimetype, "video/x-xvid")) {
 515       avipad->vids.compression = GST_MAKE_FOURCC ('X', 'V', 'I', 'D');
 516     } else if (!strcmp (mimetype, "video/x-3ivx")) {
 517       avipad->vids.compression = GST_MAKE_FOURCC ('3', 'I', 'V', '2');
 518     } else if (gst_structure_has_name (structure, "video/x-msmpeg")) {
 519       gint msmpegversion;
 520
 521       gst_structure_get_int (structure, "msmpegversion", &msmpegversion);
 522       switch (msmpegversion) {
 523         case 41:
 524           avipad->vids.compression = GST_MAKE_FOURCC ('M', 'P', 'G', '4');
 525           break;
 526         case 42:
 527           avipad->vids.compression = GST_MAKE_FOURCC ('M', 'P', '4', '2');
 528           break;
 529         case 43:
 530           avipad->vids.compression = GST_MAKE_FOURCC ('M', 'P', '4', '3');
 531           break;
 532         default:
 533           GST_INFO ("unhandled msmpegversion : %d, fall back to fourcc=MPEG",
 534               msmpegversion);
 535           avipad->vids.compression = GST_MAKE_FOURCC ('M', 'P', 'E', 'G');
 536           break;
 537       }
 538     } else if (!strcmp (mimetype, "video/x-dv")) {
 539       avipad->vids.compression = GST_MAKE_FOURCC ('D', 'V', 'S', 'D');
 540     } else if (!strcmp (mimetype, "video/x-h263")) {
 541       avipad->vids.compression = GST_MAKE_FOURCC ('H', '2', '6', '3');
 542     } else if (!strcmp (mimetype, "video/x-h264")) {
 543       avipad->vids.compression = GST_MAKE_FOURCC ('H', '2', '6', '4');
 544     } else if (!strcmp (mimetype, "video/mpeg")) {
 545       gint mpegversion;
 546
 547       gst_structure_get_int (structure, "mpegversion", &mpegversion);
 548
 549       switch (mpegversion) {
 550         case 2:
 551           avipad->vids.compression = GST_MAKE_FOURCC ('M', 'P', 'G', '2');
 552           break;
 553         case 4:
 554           /* mplayer/ffmpeg might not work with DIVX, but with FMP4 */
 555           avipad->vids.compression = GST_MAKE_FOURCC ('D', 'I', 'V', 'X');
 556
 557           /* DIVX/XVID in AVI store the codec_data chunk as part of the
 558              first data buffer. So for this case, we prepend the codec_data
 559              blob (if any) to that first buffer */
 560           codec_data_in_headers = FALSE;
 561           break;
 562         default:
 563           GST_INFO ("unhandled mpegversion : %d, fall back to fourcc=MPEG",
 564               mpegversion);
 565           avipad->vids.compression = GST_MAKE_FOURCC ('M', 'P', 'E', 'G');
 566           break;
 567       }
 568     } else if (!strcmp (mimetype, "video/x-wmv")) {
 569       gint wmvversion;
 570
 571       if (gst_structure_get_int (structure, "wmvversion", &wmvversion)) {
 572         switch (wmvversion) {
 573           case 1:
 574             avipad->vids.compression = GST_MAKE_FOURCC ('W', 'M', 'V', '1');
 575             break;
 576           case 2:
 577             avipad->vids.compression = GST_MAKE_FOURCC ('W', 'M', 'V', '2');
 578             break;
 579           case 3:
 580             avipad->vids.compression = GST_MAKE_FOURCC ('W', 'M', 'V', '3');
 581           default:
 582             break;
 583         }
 584       }
 585     } else if (!strcmp (mimetype, "image/x-jpc")) {
 586       avipad->vids.compression = GST_MAKE_FOURCC ('M', 'J', '2', 'C');
 587     } else if (!strcmp (mimetype, "video/x-vp8")) {
 588       avipad->vids.compression = GST_MAKE_FOURCC ('V', 'P', '8', '0');
 589     }
 590
 591     if (!avipad->vids.compression)
 592       goto refuse_caps;
 593   }
 594
 595   /* codec initialization data, if any */
 596   codec_data = gst_structure_get_value (structure, "codec_data");
 597   if (codec_data) {
 598     if (codec_data_in_headers) {
 599       avipad->vids_codec_data = gst_value_get_buffer (codec_data);
 600       gst_buffer_ref (avipad->vids_codec_data);
 601       /* keep global track of size */
 602       avimux->codec_data_size += gst_buffer_get_size (avipad->vids_codec_data);
 603     } else {
 604       avipad->prepend_buffer =
 605           gst_buffer_ref (gst_value_get_buffer (codec_data));
 606     }
 607   }
 608
 609   avipad->parent.hdr.fcc_handler = avipad->vids.compression;
 610   avipad->vids.image_size = avipad->vids.height * avipad->vids.width;
 611   /* hm, maybe why avi only handles one stream well ... */
 612   avimux->avi_hdr.width = avipad->vids.width;
 613   avimux->avi_hdr.height = avipad->vids.height;
 614   avimux->avi_hdr.us_frame = 1000000. * avipad->parent.hdr.scale /
 615       avipad->parent.hdr.rate;
 616
 617   gst_object_unref (avimux);
 618   return TRUE;
 619
 620 refuse_caps:
 621   {
 622     GST_WARNING_OBJECT (avimux, "refused caps %" GST_PTR_FORMAT, vscaps);
 623     gst_object_unref (avimux);
 624     return FALSE;
 625   }
 626 }
 627
 628 static GstFlowReturn
 629 gst_avi_mux_audsink_scan_mpeg_audio (GstAviMux * avimux, GstAviPad * avipad,
 630     GstBuffer * buffer)
 631 {
 632   GstMapInfo map;
 633   guint spf;
 634   guint32 header;
 635   gulong layer;
 636   gulong version;
 637   gint lsf, mpg25;
 638
 639   gst_buffer_map (buffer, &map, GST_MAP_READ);
 640   if (map.size < 4)
 641     goto not_parsed;
 642
 643   header = GST_READ_UINT32_BE (map.data);
 644
 645   if ((header & 0xffe00000) != 0xffe00000)
 646     goto not_parsed;
 647
 648   /* thanks go to mp3parse */
 649   if (header & (1 << 20)) {
 650     lsf = (header & (1 << 19)) ? 0 : 1;
 651     mpg25 = 0;
 652   } else {
 653     lsf = 1;
 654     mpg25 = 1;
 655   }
 656
 657   version = 1 + lsf + mpg25;
 658   layer = 4 - ((header >> 17) & 0x3);
 659
 660   /* see http://www.codeproject.com/audio/MPEGAudioInfo.asp */
 661   if (layer == 1)
 662     spf = 384;
 663   else if (layer == 2)
 664     spf = 1152;
 665   else if (version == 1) {
 666     spf = 1152;
 667   } else {
 668     /* MPEG-2 or "2.5" */
 669     spf = 576;
 670   }
 671
 672   if (G_UNLIKELY (avipad->hdr.scale <= 1))
 673     avipad->hdr.scale = spf;
 674   else if (G_UNLIKELY (avipad->hdr.scale != spf)) {
 675     GST_WARNING_OBJECT (avimux, "input mpeg audio has varying frame size");
 676     goto cbr_fallback;
 677   }
 678 done:
 679   gst_buffer_unmap (buffer, &map);
 680
 681   return GST_FLOW_OK;
 682
 683   /* EXITS */
 684 not_parsed:
 685   {
 686     GST_WARNING_OBJECT (avimux, "input mpeg audio is not parsed");
 687     /* fall-through */
 688   }
 689 cbr_fallback:
 690   {
 691     GST_WARNING_OBJECT (avimux, "falling back to CBR muxing");
 692     avipad->hdr.scale = 1;
 693     /* no need to check further */
 694     avipad->hook = NULL;
 695     goto done;
 696   }
 697 }
 698
 699 static void
 700 gst_avi_mux_audsink_set_fields (GstAviMux * avimux, GstAviAudioPad * avipad)
 701 {
 702   if (avipad->parent.hdr.scale > 1) {
 703     /* vbr case: fixed duration per frame/chunk */
 704     avipad->parent.hdr.rate = avipad->auds.rate;
 705     avipad->parent.hdr.samplesize = 0;
 706     /* FIXME ?? some rumours say this should be largest audio chunk size */
 707     avipad->auds.blockalign = avipad->parent.hdr.scale;
 708   } else {
 709     /* by spec, hdr.rate is av_bps related, is calculated that way in stop_file,
 710      * and reduces to sample rate in PCM like cases */
 711     avipad->parent.hdr.rate = avipad->auds.av_bps / avipad->auds.blockalign;
 712     avipad->parent.hdr.samplesize = avipad->auds.blockalign;
 713     avipad->parent.hdr.scale = 1;
 714   }
 715 }
 716
 717 static gboolean
 718 gst_avi_mux_audsink_set_caps (GstPad * pad, GstCaps * vscaps)
 719 {
 720   GstAviMux *avimux;
 721   GstAviAudioPad *avipad;
 722   GstAviCollectData *collect_pad;
 723   GstStructure *structure;
 724   const gchar *mimetype;
 725   const GValue *codec_data;
 726   gint channels, rate;
 727
 728   avimux = GST_AVI_MUX (gst_pad_get_parent (pad));
 729
 730   /* find stream data */
 731   collect_pad = (GstAviCollectData *) gst_pad_get_element_private (pad);
 732   g_assert (collect_pad);
 733   avipad = (GstAviAudioPad *) collect_pad->avipad;
 734   g_assert (avipad);
 735   g_assert (!avipad->parent.is_video);
 736   g_assert (avipad->parent.hdr.type == GST_MAKE_FOURCC ('a', 'u', 'd', 's'));
 737
 738   GST_DEBUG_OBJECT (avimux, "%s:%s, caps=%" GST_PTR_FORMAT,
 739       GST_DEBUG_PAD_NAME (pad), vscaps);
 740
 741   structure = gst_caps_get_structure (vscaps, 0);
 742   mimetype = gst_structure_get_name (structure);
 743
 744   /* we want these for all */
 745   if (!gst_structure_get_int (structure, "channels", &channels) ||
 746       !gst_structure_get_int (structure, "rate", &rate)) {
 747     goto refuse_caps;
 748   }
 749
 750   avipad->auds.channels = channels;
 751   avipad->auds.rate = rate;
 752
 753   /* codec initialization data, if any */
 754   codec_data = gst_structure_get_value (structure, "codec_data");
 755   if (codec_data) {
 756     avipad->auds_codec_data = gst_value_get_buffer (codec_data);
 757     gst_buffer_ref (avipad->auds_codec_data);
 758     /* keep global track of size */
 759     avimux->codec_data_size += gst_buffer_get_size (avipad->auds_codec_data);
 760   }
 761
 762   if (!strcmp (mimetype, "audio/x-raw")) {
 763     const gchar *format;
 764     GstAudioFormat fmt;
 765
 766     format = gst_structure_get_string (structure, "format");
 767     fmt = gst_audio_format_from_string (format);
 768
 769     switch (fmt) {
 770       case GST_AUDIO_FORMAT_U8:
 771         avipad->auds.blockalign = 8;
 772         avipad->auds.size = 8;
 773         break;
 774       case GST_AUDIO_FORMAT_S16:
 775         avipad->auds.blockalign = 16;
 776         avipad->auds.size = 16;
 777         break;
 778       default:
 779         goto refuse_caps;
 780     }
 781
 782     avipad->auds.format = GST_RIFF_WAVE_FORMAT_PCM;
 783     /* set some more info straight */
 784     avipad->auds.blockalign /= 8;
 785     avipad->auds.blockalign *= avipad->auds.channels;
 786     avipad->auds.av_bps = avipad->auds.blockalign * avipad->auds.rate;
 787   } else {
 788     avipad->auds.format = 0;
 789     /* set some defaults */
 790     avipad->auds.blockalign = 1;
 791     avipad->auds.av_bps = 0;
 792     avipad->auds.size = 16;
 793
 794     if (!strcmp (mimetype, "audio/mpeg")) {
 795       gint mpegversion;
 796
 797       gst_structure_get_int (structure, "mpegversion", &mpegversion);
 798       switch (mpegversion) {
 799         case 1:{
 800           gint layer = 3;
 801           gboolean parsed = FALSE;
 802
 803           gst_structure_get_int (structure, "layer", &layer);
 804           gst_structure_get_boolean (structure, "parsed", &parsed);
 805           switch (layer) {
 806             case 3:
 807               avipad->auds.format = GST_RIFF_WAVE_FORMAT_MPEGL3;
 808               break;
 809             case 1:
 810             case 2:
 811               avipad->auds.format = GST_RIFF_WAVE_FORMAT_MPEGL12;
 812               break;
 813           }
 814           if (parsed) {
 815             /* treat as VBR, should also cover CBR case;
 816              * setup hook to parse frame header and determine spf */
 817             avipad->parent.hook = gst_avi_mux_audsink_scan_mpeg_audio;
 818           } else {
 819             GST_WARNING_OBJECT (avimux, "unparsed MPEG audio input (?), "
 820                 "doing CBR muxing");
 821           }
 822           break;
 823         }
 824         case 4:
 825         {
 826           GstBuffer *codec_data_buf = avipad->auds_codec_data;
 827           const gchar *stream_format;
 828           guint codec;
 829           guint8 data[2];
 830
 831           stream_format = gst_structure_get_string (structure, "stream-format");
 832           if (stream_format) {
 833             if (strcmp (stream_format, "raw") != 0) {
 834               GST_WARNING_OBJECT (avimux, "AAC's stream format '%s' is not "
 835                   "supported, please use 'raw'", stream_format);
 836               break;
 837             }
 838           } else {
 839             GST_WARNING_OBJECT (avimux, "AAC's stream-format not specified, "
 840                 "assuming 'raw'");
 841           }
 842
 843           /* vbr case needs some special handling */
 844           if (!codec_data_buf || gst_buffer_get_size (codec_data_buf) < 2) {
 845             GST_WARNING_OBJECT (avimux, "no (valid) codec_data for AAC audio");
 846             break;
 847           }
 848           avipad->auds.format = GST_RIFF_WAVE_FORMAT_AAC;
 849           /* need to determine frame length */
 850           gst_buffer_extract (codec_data_buf, 0, data, 2);
 851           codec = GST_READ_UINT16_BE (data);
 852           avipad->parent.hdr.scale = (codec & 0x4) ? 960 : 1024;
 853           break;
 854         }
 855       }
 856     } else if (!strcmp (mimetype, "audio/x-vorbis")) {
 857       avipad->auds.format = GST_RIFF_WAVE_FORMAT_VORBIS3;
 858     } else if (!strcmp (mimetype, "audio/x-ac3")) {
 859       avipad->auds.format = GST_RIFF_WAVE_FORMAT_A52;
 860     } else if (!strcmp (mimetype, "audio/x-alaw")) {
 861       avipad->auds.format = GST_RIFF_WAVE_FORMAT_ALAW;
 862       avipad->auds.size = 8;
 863       avipad->auds.blockalign = avipad->auds.channels;
 864       avipad->auds.av_bps = avipad->auds.blockalign * avipad->auds.rate;
 865     } else if (!strcmp (mimetype, "audio/x-mulaw")) {
 866       avipad->auds.format = GST_RIFF_WAVE_FORMAT_MULAW;
 867       avipad->auds.size = 8;
 868       avipad->auds.blockalign = avipad->auds.channels;
 869       avipad->auds.av_bps = avipad->auds.blockalign * avipad->auds.rate;
 870     } else if (!strcmp (mimetype, "audio/x-wma")) {
 871       gint version;
 872       gint bitrate;
 873       gint block_align;
 874
 875       if (gst_structure_get_int (structure, "wmaversion", &version)) {
 876         switch (version) {
 877           case 1:
 878             avipad->auds.format = GST_RIFF_WAVE_FORMAT_WMAV1;
 879             break;
 880           case 2:
 881             avipad->auds.format = GST_RIFF_WAVE_FORMAT_WMAV2;
 882             break;
 883           default:
 884             break;
 885         }
 886       }
 887
 888       if (avipad->auds.format != 0) {
 889         if (gst_structure_get_int (structure, "block_align", &block_align)) {
 890           avipad->auds.blockalign = block_align;
 891         }
 892         if (gst_structure_get_int (structure, "bitrate", &bitrate)) {
 893           avipad->auds.av_bps = bitrate / 8;
 894         }
 895       }
 896     }
 897   }
 898
 899   if (!avipad->auds.format)
 900     goto refuse_caps;
 901
 902   avipad->parent.hdr.fcc_handler = avipad->auds.format;
 903   gst_avi_mux_audsink_set_fields (avimux, avipad);
 904
 905   gst_object_unref (avimux);
 906   return TRUE;
 907
 908 refuse_caps:
 909   {
 910     GST_WARNING_OBJECT (avimux, "refused caps %" GST_PTR_FORMAT, vscaps);
 911     gst_object_unref (avimux);
 912     return FALSE;
 913   }
 914 }
 915
 916
 917 static GstPad *
 918 gst_avi_mux_request_new_pad (GstElement * element,
 919     GstPadTemplate * templ, const gchar * req_name, const GstCaps * caps)
 920 {
 921   GstAviMux *avimux;
 922   GstPad *newpad;
 923   GstAviPad *avipad;
 924   GstElementClass *klass;
 925   gchar *name = NULL;
 926   const gchar *pad_name = NULL;
 927   gint pad_id;
 928
 929   g_return_val_if_fail (templ != NULL, NULL);
 930
 931   if (templ->direction != GST_PAD_SINK)
 932     goto wrong_direction;
 933
 934   g_return_val_if_fail (GST_IS_AVI_MUX (element), NULL);
 935   avimux = GST_AVI_MUX (element);
 936
 937   if (!avimux->write_header)
 938     goto too_late;
 939
 940   klass = GST_ELEMENT_GET_CLASS (element);
 941
 942   if (templ == gst_element_class_get_pad_template (klass, "audio_%u")) {
 943     /* don't mix named and unnamed pads, if the pad already exists we fail when
 944      * trying to add it */
 945     if (req_name != NULL && sscanf (req_name, "audio_%u", &pad_id) == 1) {
 946       pad_name = req_name;
 947     } else {
 948       name = g_strdup_printf ("audio_%u", avimux->audio_pads++);
 949       pad_name = name;
 950     }
 951
 952     /* init pad specific data */
 953     avipad = g_malloc0 (sizeof (GstAviAudioPad));
 954     avipad->is_video = FALSE;
 955     avipad->hdr.type = GST_MAKE_FOURCC ('a', 'u', 'd', 's');
 956     /* audio goes last */
 957     avimux->sinkpads = g_slist_append (avimux->sinkpads, avipad);
 958   } else if (templ == gst_element_class_get_pad_template (klass, "video_%u")) {
 959     /* though streams are pretty generic and relatively self-contained,
 960      * some video info goes in a single avi header -and therefore mux struct-
 961      * so video restricted to one stream */
 962     if (avimux->video_pads > 0)
 963       goto too_many_video_pads;
 964
 965     /* setup pad */
 966     pad_name = "video_0";
 967     avimux->video_pads++;
 968
 969     /* init pad specific data */
 970     avipad = g_malloc0 (sizeof (GstAviVideoPad));
 971     avipad->is_video = TRUE;
 972     avipad->hdr.type = GST_MAKE_FOURCC ('v', 'i', 'd', 's');
 973     /* video goes first */
 974     avimux->sinkpads = g_slist_prepend (avimux->sinkpads, avipad);
 975   } else
 976     goto wrong_template;
 977
 978   newpad = gst_pad_new_from_template (templ, pad_name);
 979
 980   g_free (name);
 981
 982   avipad->collect = gst_collect_pads2_add_pad (avimux->collect,
 983       newpad, sizeof (GstAviCollectData));
 984   ((GstAviCollectData *) (avipad->collect))->avipad = avipad;
 985
 986   if (!gst_element_add_pad (element, newpad))
 987     goto pad_add_failed;
 988
 989   GST_DEBUG_OBJECT (newpad, "Added new request pad");
 990
 991   return newpad;
 992
 993   /* ERRORS */
 994 wrong_direction:
 995   {
 996     g_warning ("avimux: request pad that is not a SINK pad\n");
 997     return NULL;
 998   }
 999 too_late:
1000   {
1001     g_warning ("avimux: request pad cannot be added after streaming started\n");
1002     return NULL;
1003   }
1004 wrong_template:
1005   {
1006     g_warning ("avimux: this is not our template!\n");
1007     return NULL;
1008   }
1009 too_many_video_pads:
1010   {
1011     GST_WARNING_OBJECT (avimux, "Can only have one video stream");
1012     return NULL;
1013   }
1014 pad_add_failed:
1015   {
1016     GST_WARNING_OBJECT (avimux, "Adding the new pad '%s' failed", pad_name);
1017     gst_object_unref (newpad);
1018     return NULL;
1019   }
1020 }
1021
1022 static void
1023 gst_avi_mux_release_pad (GstElement * element, GstPad * pad)
1024 {
1025   GstAviMux *avimux = GST_AVI_MUX (element);
1026   GSList *node;
1027
1028   node = avimux->sinkpads;
1029   while (node) {
1030     GstAviPad *avipad = (GstAviPad *) node->data;
1031
1032     if (avipad->collect->pad == pad) {
1033       /* pad count should not be adjusted,
1034        * as it also represent number of streams present */
1035       avipad->collect = NULL;
1036       GST_DEBUG_OBJECT (avimux, "removed pad '%s'", GST_PAD_NAME (pad));
1037       gst_collect_pads2_remove_pad (avimux->collect, pad);
1038       gst_element_remove_pad (element, pad);
1039       /* if not started yet, we can remove any sign this pad ever existed */
1040       /* in this case _start will take care of the real pad count */
1041       if (avimux->write_header) {
1042         avimux->sinkpads = g_slist_remove (avimux->sinkpads, avipad);
1043         gst_avi_mux_pad_reset (avipad, TRUE);
1044         g_free (avipad);
1045       }
1046       return;
1047     }
1048
1049     node = node->next;
1050   }
1051
1052   g_warning ("Unknown pad %s", GST_PAD_NAME (pad));
1053 }
1054
1055 static inline guint
1056 gst_avi_mux_start_chunk (GstByteWriter * bw, const gchar * tag, guint32 fourcc)
1057 {
1058   guint chunk_offset;
1059
1060   if (tag)
1061     gst_byte_writer_put_data (bw, (const guint8 *) tag, 4);
1062   else
1063     gst_byte_writer_put_uint32_le (bw, fourcc);
1064
1065   chunk_offset = gst_byte_writer_get_pos (bw);
1066   /* real chunk size comes later */
1067   gst_byte_writer_put_uint32_le (bw, 0);
1068
1069   return chunk_offset;
1070 }
1071
1072 static inline void
1073 gst_avi_mux_end_chunk (GstByteWriter * bw, guint chunk_offset)
1074 {
1075   guint size;
1076
1077   size = gst_byte_writer_get_pos (bw);
1078
1079   gst_byte_writer_set_pos (bw, chunk_offset);
1080   gst_byte_writer_put_uint32_le (bw, size - chunk_offset - 4);
1081   gst_byte_writer_set_pos (bw, size);
1082
1083   /* arrange for even padding */
1084   if (size & 1)
1085     gst_byte_writer_put_uint8 (bw, 0);
1086 }
1087
1088 /* maybe some of these functions should be moved to riff.h? */
1089
1090 static void
1091 gst_avi_mux_write_tag (const GstTagList * list, const gchar * tag,
1092     gpointer data)
1093 {
1094   const struct
1095   {
1096     guint32 fcc;
1097     const gchar *tag;
1098   } rifftags[] = {
1099     {
1100     GST_RIFF_INFO_IARL, GST_TAG_LOCATION}, {
1101     GST_RIFF_INFO_IART, GST_TAG_ARTIST}, {
1102     GST_RIFF_INFO_ICMT, GST_TAG_COMMENT}, {
1103     GST_RIFF_INFO_ICOP, GST_TAG_COPYRIGHT}, {
1104     GST_RIFF_INFO_ICRD, GST_TAG_DATE}, {
1105     GST_RIFF_INFO_IGNR, GST_TAG_GENRE}, {
1106     GST_RIFF_INFO_IKEY, GST_TAG_KEYWORDS}, {
1107     GST_RIFF_INFO_INAM, GST_TAG_TITLE}, {
1108     GST_RIFF_INFO_ISFT, GST_TAG_ENCODER}, {
1109     GST_RIFF_INFO_ISRC, GST_TAG_ISRC}, {
1110     0, NULL}
1111   };
1112   gint n;
1113   gchar *str;
1114   GstByteWriter *bw = data;
1115   guint chunk;
1116
1117   for (n = 0; rifftags[n].fcc != 0; n++) {
1118     if (!strcmp (rifftags[n].tag, tag) &&
1119         gst_tag_list_get_string (list, tag, &str) && str) {
1120       chunk = gst_avi_mux_start_chunk (bw, NULL, rifftags[n].fcc);
1121       gst_byte_writer_put_string (bw, str);
1122       gst_avi_mux_end_chunk (bw, chunk);
1123       g_free (str);
1124       break;
1125     }
1126   }
1127 }
1128
1129 static GstBuffer *
1130 gst_avi_mux_riff_get_avi_header (GstAviMux * avimux)
1131 {
1132   const GstTagList *tags;
1133   GstBuffer *buffer;
1134   gint size = 0;
1135   GstByteWriter bw;
1136   GSList *node;
1137   guint avih, riff, hdrl;
1138   GstMapInfo map;
1139
1140   GST_DEBUG_OBJECT (avimux, "creating avi header, data_size %u, idx_size %u",
1141       avimux->data_size, avimux->idx_size);
1142
1143   if (avimux->tags_snap)
1144     tags = avimux->tags_snap;
1145   else {
1146     /* need to make snapshot of current state of tags to ensure the same set
1147      * is used next time around during header rewrite at the end */
1148     tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (avimux));
1149     if (tags)
1150       tags = avimux->tags_snap = gst_tag_list_copy (tags);
1151   }
1152
1153   gst_byte_writer_init_with_size (&bw, 1024, FALSE);
1154
1155   /* avi header metadata */
1156   riff = gst_avi_mux_start_chunk (&bw, "RIFF", 0);
1157   gst_byte_writer_put_data (&bw, (guint8 *) "AVI ", 4);
1158   hdrl = gst_avi_mux_start_chunk (&bw, "LIST", 0);
1159   gst_byte_writer_put_data (&bw, (guint8 *) "hdrl", 4);
1160
1161   avih = gst_avi_mux_start_chunk (&bw, "avih", 0);
1162   /* the AVI header itself */
1163   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.us_frame);
1164   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.max_bps);
1165   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.pad_gran);
1166   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.flags);
1167   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.tot_frames);
1168   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.init_frames);
1169   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.streams);
1170   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.bufsize);
1171   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.width);
1172   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.height);
1173   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.scale);
1174   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.rate);
1175   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.start);
1176   gst_byte_writer_put_uint32_le (&bw, avimux->avi_hdr.length);
1177   gst_avi_mux_end_chunk (&bw, avih);
1178
1179   /* stream data */
1180   node = avimux->sinkpads;
1181   while (node) {
1182     GstAviPad *avipad = (GstAviPad *) node->data;
1183     GstAviVideoPad *vidpad = (GstAviVideoPad *) avipad;
1184     GstAviAudioPad *audpad = (GstAviAudioPad *) avipad;
1185     gint codec_size = 0;
1186     guint strh, strl, strf, indx;
1187
1188     /* stream list metadata */
1189     strl = gst_avi_mux_start_chunk (&bw, "LIST", 0);
1190     gst_byte_writer_put_data (&bw, (guint8 *) "strl", 4);
1191
1192     /* generic header */
1193     strh = gst_avi_mux_start_chunk (&bw, "strh", 0);
1194     gst_byte_writer_put_uint32_le (&bw, avipad->hdr.type);
1195     gst_byte_writer_put_uint32_le (&bw, avipad->hdr.fcc_handler);
1196     gst_byte_writer_put_uint32_le (&bw, avipad->hdr.flags);
1197     gst_byte_writer_put_uint32_le (&bw, avipad->hdr.priority);
1198     gst_byte_writer_put_uint32_le (&bw, avipad->hdr.init_frames);
1199     gst_byte_writer_put_uint32_le (&bw, avipad->hdr.scale);
1200     gst_byte_writer_put_uint32_le (&bw, avipad->hdr.rate);
1201     gst_byte_writer_put_uint32_le (&bw, avipad->hdr.start);
1202     gst_byte_writer_put_uint32_le (&bw, avipad->hdr.length);
1203     gst_byte_writer_put_uint32_le (&bw, avipad->hdr.bufsize);
1204     gst_byte_writer_put_uint32_le (&bw, avipad->hdr.quality);
1205     gst_byte_writer_put_uint32_le (&bw, avipad->hdr.samplesize);
1206     gst_byte_writer_put_uint16_le (&bw, 0);
1207     gst_byte_writer_put_uint16_le (&bw, 0);
1208     gst_byte_writer_put_uint16_le (&bw, 0);
1209     gst_byte_writer_put_uint16_le (&bw, 0);
1210     gst_avi_mux_end_chunk (&bw, strh);
1211
1212     if (avipad->is_video) {
1213       codec_size = vidpad->vids_codec_data ?
1214           gst_buffer_get_size (vidpad->vids_codec_data) : 0;
1215       /* the video header */
1216       strf = gst_avi_mux_start_chunk (&bw, "strf", 0);
1217       /* the actual header */
1218       gst_byte_writer_put_uint32_le (&bw, vidpad->vids.size + codec_size);
1219       gst_byte_writer_put_uint32_le (&bw, vidpad->vids.width);
1220       gst_byte_writer_put_uint32_le (&bw, vidpad->vids.height);
1221       gst_byte_writer_put_uint16_le (&bw, vidpad->vids.planes);
1222       gst_byte_writer_put_uint16_le (&bw, vidpad->vids.bit_cnt);
1223       gst_byte_writer_put_uint32_le (&bw, vidpad->vids.compression);
1224       gst_byte_writer_put_uint32_le (&bw, vidpad->vids.image_size);
1225       gst_byte_writer_put_uint32_le (&bw, vidpad->vids.xpels_meter);
1226       gst_byte_writer_put_uint32_le (&bw, vidpad->vids.ypels_meter);
1227       gst_byte_writer_put_uint32_le (&bw, vidpad->vids.num_colors);
1228       gst_byte_writer_put_uint32_le (&bw, vidpad->vids.imp_colors);
1229       if (vidpad->vids_codec_data) {
1230         gst_buffer_map (vidpad->vids_codec_data, &map, GST_MAP_READ);
1231         gst_byte_writer_put_data (&bw, map.data, map.size);
1232         gst_buffer_unmap (vidpad->vids_codec_data, &map);
1233       }
1234       gst_avi_mux_end_chunk (&bw, strf);
1235
1236       /* add video property data, mainly for aspect ratio, if any */
1237       if (vidpad->vprp.aspect) {
1238         gint f;
1239         guint vprp;
1240
1241         /* let's be on the safe side */
1242         vidpad->vprp.fields = MIN (vidpad->vprp.fields,
1243             GST_RIFF_VPRP_VIDEO_FIELDS);
1244         /* the vprp header */
1245         vprp = gst_avi_mux_start_chunk (&bw, "vprp", 0);
1246         /* the actual data */
1247         gst_byte_writer_put_uint32_le (&bw, vidpad->vprp.format_token);
1248         gst_byte_writer_put_uint32_le (&bw, vidpad->vprp.standard);
1249         gst_byte_writer_put_uint32_le (&bw, vidpad->vprp.vert_rate);
1250         gst_byte_writer_put_uint32_le (&bw, vidpad->vprp.hor_t_total);
1251         gst_byte_writer_put_uint32_le (&bw, vidpad->vprp.vert_lines);
1252         gst_byte_writer_put_uint32_le (&bw, vidpad->vprp.aspect);
1253         gst_byte_writer_put_uint32_le (&bw, vidpad->vprp.width);
1254         gst_byte_writer_put_uint32_le (&bw, vidpad->vprp.height);
1255         gst_byte_writer_put_uint32_le (&bw, vidpad->vprp.fields);
1256
1257         for (f = 0; f < vidpad->vprp.fields; ++f) {
1258           gst_riff_vprp_video_field_desc *fd;
1259
1260           fd = &(vidpad->vprp.field_info[f]);
1261           gst_byte_writer_put_uint32_le (&bw, fd->compressed_bm_height);
1262           gst_byte_writer_put_uint32_le (&bw, fd->compressed_bm_width);
1263           gst_byte_writer_put_uint32_le (&bw, fd->valid_bm_height);
1264           gst_byte_writer_put_uint32_le (&bw, fd->valid_bm_width);
1265           gst_byte_writer_put_uint32_le (&bw, fd->valid_bm_x_offset);
1266           gst_byte_writer_put_uint32_le (&bw, fd->valid_bm_y_offset);
1267           gst_byte_writer_put_uint32_le (&bw, fd->video_x_t_offset);
1268           gst_byte_writer_put_uint32_le (&bw, fd->video_y_start);
1269         }
1270         gst_avi_mux_end_chunk (&bw, vprp);
1271       }
1272     } else {
1273       codec_size = audpad->auds_codec_data ?
1274           gst_buffer_get_size (audpad->auds_codec_data) : 0;
1275       /* the audio header */
1276       strf = gst_avi_mux_start_chunk (&bw, "strf", 0);
1277       /* the actual header */
1278       gst_byte_writer_put_uint16_le (&bw, audpad->auds.format);
1279       gst_byte_writer_put_uint16_le (&bw, audpad->auds.channels);
1280       gst_byte_writer_put_uint32_le (&bw, audpad->auds.rate);
1281       gst_byte_writer_put_uint32_le (&bw, audpad->auds.av_bps);
1282       gst_byte_writer_put_uint16_le (&bw, audpad->auds.blockalign);
1283       gst_byte_writer_put_uint16_le (&bw, audpad->auds.size);
1284       gst_byte_writer_put_uint16_le (&bw, codec_size);
1285       if (audpad->auds_codec_data) {
1286         gst_buffer_map (audpad->auds_codec_data, &map, GST_MAP_READ);
1287         gst_byte_writer_put_data (&bw, map.data, map.size);
1288         gst_buffer_unmap (vidpad->vids_codec_data, &map);
1289       }
1290       gst_avi_mux_end_chunk (&bw, strf);
1291     }
1292
1293     /* odml superindex chunk */
1294     if (avipad->idx_index > 0)
1295       indx = gst_avi_mux_start_chunk (&bw, "indx", 0);
1296     else
1297       indx = gst_avi_mux_start_chunk (&bw, "JUNK", 0);
1298     gst_byte_writer_put_uint16_le (&bw, 4);     /* bytes per entry */
1299     gst_byte_writer_put_uint8 (&bw, 0); /* index subtype */
1300     gst_byte_writer_put_uint8 (&bw, GST_AVI_INDEX_OF_INDEXES);  /* index type */
1301     gst_byte_writer_put_uint32_le (&bw, avipad->idx_index);     /* entries in use */
1302     gst_byte_writer_put_data (&bw, (guint8 *) avipad->tag, 4);  /* stream id */
1303     gst_byte_writer_put_uint32_le (&bw, 0);     /* reserved */
1304     gst_byte_writer_put_uint32_le (&bw, 0);     /* reserved */
1305     gst_byte_writer_put_uint32_le (&bw, 0);     /* reserved */
1306     gst_byte_writer_put_data (&bw, (guint8 *) avipad->idx,
1307         GST_AVI_SUPERINDEX_COUNT * sizeof (gst_avi_superindex_entry));
1308     gst_avi_mux_end_chunk (&bw, indx);
1309
1310     /* end strl for this stream */
1311     gst_avi_mux_end_chunk (&bw, strl);
1312
1313     node = node->next;
1314   }
1315
1316   if (avimux->video_pads > 0) {
1317     guint odml, dmlh;
1318     /* odml header */
1319     odml = gst_avi_mux_start_chunk (&bw, "LIST", 0);
1320     gst_byte_writer_put_data (&bw, (guint8 *) "odml", 4);
1321     dmlh = gst_avi_mux_start_chunk (&bw, "dmlh", 0);
1322     gst_byte_writer_put_uint32_le (&bw, avimux->total_frames);
1323     gst_avi_mux_end_chunk (&bw, dmlh);
1324     gst_avi_mux_end_chunk (&bw, odml);
1325   }
1326
1327   /* end hdrl */
1328   gst_avi_mux_end_chunk (&bw, hdrl);
1329
1330   /* tags */
1331   if (tags) {
1332     guint info;
1333
1334     info = gst_avi_mux_start_chunk (&bw, "LIST", 0);
1335     gst_byte_writer_put_data (&bw, (guint8 *) "INFO", 4);
1336
1337     gst_tag_list_foreach (tags, gst_avi_mux_write_tag, &bw);
1338     if (info + 8 == gst_byte_writer_get_pos (&bw)) {
1339       /* no tags writen, remove the empty INFO LIST as it is useless
1340        * and prevents playback in vlc */
1341       gst_byte_writer_set_pos (&bw, info - 4);
1342     } else {
1343       gst_avi_mux_end_chunk (&bw, info);
1344     }
1345   }
1346
1347   /* pop RIFF */
1348   gst_avi_mux_end_chunk (&bw, riff);
1349
1350   /* avi data header */
1351   gst_byte_writer_put_data (&bw, (guint8 *) "LIST", 4);
1352   gst_byte_writer_put_uint32_le (&bw, avimux->data_size);
1353   gst_byte_writer_put_data (&bw, (guint8 *) "movi", 4);
1354
1355   /* now get the data */
1356   buffer = gst_byte_writer_reset_and_get_buffer (&bw);
1357
1358   /* ... but RIFF includes more than just header */
1359   gst_buffer_map (buffer, &map, GST_MAP_READWRITE);
1360   size = GST_READ_UINT32_LE (map.data + 4);
1361   size += 8 + avimux->data_size + avimux->idx_size;
1362   GST_WRITE_UINT32_LE (map.data + 4, size);
1363
1364   GST_MEMDUMP_OBJECT (avimux, "avi header", map.data, map.size);
1365   gst_buffer_unmap (buffer, &map);
1366
1367   return buffer;
1368 }
1369
1370 static GstBuffer *
1371 gst_avi_mux_riff_get_avix_header (guint32 datax_size)
1372 {
1373   GstBuffer *buffer;
1374   GstMapInfo map;
1375
1376   buffer = gst_buffer_new_and_alloc (24);
1377
1378   gst_buffer_map (buffer, &map, GST_MAP_WRITE);
1379   memcpy (map.data + 0, "RIFF", 4);
1380   GST_WRITE_UINT32_LE (map.data + 4, datax_size + 3 * 4);
1381   memcpy (map.data + 8, "AVIX", 4);
1382   memcpy (map.data + 12, "LIST", 4);
1383   GST_WRITE_UINT32_LE (map.data + 16, datax_size);
1384   memcpy (map.data + 20, "movi", 4);
1385   gst_buffer_unmap (buffer, &map);
1386
1387   return buffer;
1388 }
1389
1390 static inline GstBuffer *
1391 gst_avi_mux_riff_get_header (GstAviPad * avipad, guint32 video_frame_size)
1392 {
1393   GstBuffer *buffer;
1394   GstMapInfo map;
1395
1396   buffer = gst_buffer_new_and_alloc (8);
1397
1398   gst_buffer_map (buffer, &map, GST_MAP_WRITE);
1399   memcpy (map.data + 0, avipad->tag, 4);
1400   GST_WRITE_UINT32_LE (map.data + 4, video_frame_size);
1401   gst_buffer_unmap (buffer, &map);
1402
1403   return buffer;
1404 }
1405
1406 /* write an odml index chunk in the movi list */
1407 static GstFlowReturn
1408 gst_avi_mux_write_avix_index (GstAviMux * avimux, GstAviPad * avipad,
1409     gchar * code, gchar * chunk, gst_avi_superindex_entry * super_index,
1410     gint * super_index_count)
1411 {
1412   GstFlowReturn res;
1413   GstBuffer *buffer;
1414   guint8 *data;
1415   gst_riff_index_entry *entry;
1416   gint i;
1417   guint32 size, entry_count;
1418   gboolean is_pcm = FALSE;
1419   guint32 pcm_samples = 0;
1420   GstMapInfo map;
1421
1422   /* check if it is pcm */
1423   if (avipad && !avipad->is_video) {
1424     GstAviAudioPad *audiopad = (GstAviAudioPad *) avipad;
1425     if (audiopad->auds.format == GST_RIFF_WAVE_FORMAT_PCM) {
1426       pcm_samples = audiopad->samples;
1427       is_pcm = TRUE;
1428     }
1429   }
1430
1431   /* allocate the maximum possible */
1432   buffer = gst_buffer_new_and_alloc (32 + 8 * avimux->idx_index);
1433
1434   gst_buffer_map (buffer, &map, GST_MAP_WRITE);
1435   data = map.data;
1436
1437   /* general index chunk info */
1438   memcpy (map.data + 0, chunk, 4);      /* chunk id */
1439   GST_WRITE_UINT32_LE (map.data + 4, 0);        /* chunk size; fill later */
1440   GST_WRITE_UINT16_LE (map.data + 8, 2);        /* index entry is 2 words */
1441   map.data[10] = 0;             /* index subtype */
1442   map.data[11] = GST_AVI_INDEX_OF_CHUNKS;       /* index type: AVI_INDEX_OF_CHUNKS */
1443   GST_WRITE_UINT32_LE (map.data + 12, 0);       /* entries in use; fill later */
1444   memcpy (map.data + 16, code, 4);      /* stream to which index refers */
1445   GST_WRITE_UINT64_LE (map.data + 20, avimux->avix_start);      /* base offset */
1446   GST_WRITE_UINT32_LE (map.data + 28, 0);       /* reserved */
1447   map.data += 32;
1448
1449   /* now the actual index entries */
1450   i = avimux->idx_index;
1451   entry = avimux->idx;
1452   while (i > 0) {
1453     if (memcmp (&entry->id, code, 4) == 0) {
1454       /* enter relative offset to the data (!) */
1455       GST_WRITE_UINT32_LE (map.data, GUINT32_FROM_LE (entry->offset) + 8);
1456       /* msb is set if not (!) keyframe */
1457       GST_WRITE_UINT32_LE (map.data + 4, GUINT32_FROM_LE (entry->size)
1458           | (GUINT32_FROM_LE (entry->flags)
1459               & GST_RIFF_IF_KEYFRAME ? 0 : 1U << 31));
1460       map.data += 8;
1461     }
1462     i--;
1463     entry++;
1464   }
1465
1466   /* ok, now we know the size and no of entries, fill in where needed */
1467   size = map.data - data;
1468   GST_WRITE_UINT32_LE (data + 4, size - 8);
1469   entry_count = (size - 32) / 8;
1470   GST_WRITE_UINT32_LE (data + 12, entry_count);
1471   gst_buffer_unmap (buffer, &map);
1472   gst_buffer_resize (buffer, 0, size);
1473
1474   /* send */
1475   if ((res = gst_pad_push (avimux->srcpad, buffer)) != GST_FLOW_OK)
1476     return res;
1477
1478   /* keep track of this in superindex (if room) ... */
1479   if (*super_index_count < GST_AVI_SUPERINDEX_COUNT) {
1480     i = *super_index_count;
1481     super_index[i].offset = GUINT64_TO_LE (avimux->total_data);
1482     super_index[i].size = GUINT32_TO_LE (size);
1483     if (is_pcm) {
1484       super_index[i].duration = GUINT32_TO_LE (pcm_samples);
1485     } else {
1486       super_index[i].duration = GUINT32_TO_LE (entry_count);
1487     }
1488     (*super_index_count)++;
1489   } else
1490     GST_WARNING_OBJECT (avimux, "No more room in superindex of stream %s",
1491         code);
1492
1493   /* ... and in size */
1494   avimux->total_data += size;
1495   if (avimux->is_bigfile)
1496     avimux->datax_size += size;
1497   else
1498     avimux->data_size += size;
1499
1500   return GST_FLOW_OK;
1501 }
1502
1503 /* some other usable functions (thankyou xawtv ;-) ) */
1504
1505 static void
1506 gst_avi_mux_add_index (GstAviMux * avimux, GstAviPad * avipad, guint32 flags,
1507     guint32 size)
1508 {
1509   gchar *code = avipad->tag;
1510   if (avimux->idx_index == avimux->idx_count) {
1511     avimux->idx_count += 256;
1512     avimux->idx =
1513         g_realloc (avimux->idx,
1514         avimux->idx_count * sizeof (gst_riff_index_entry));
1515   }
1516
1517   /* in case of pcm audio, we need to count the number of samples for
1518    * putting in the indx entries */
1519   if (!avipad->is_video) {
1520     GstAviAudioPad *audiopad = (GstAviAudioPad *) avipad;
1521     if (audiopad->auds.format == GST_RIFF_WAVE_FORMAT_PCM) {
1522       audiopad->samples += size / audiopad->auds.blockalign;
1523     }
1524   }
1525
1526   memcpy (&(avimux->idx[avimux->idx_index].id), code, 4);
1527   avimux->idx[avimux->idx_index].flags = GUINT32_TO_LE (flags);
1528   avimux->idx[avimux->idx_index].offset = GUINT32_TO_LE (avimux->idx_offset);
1529   avimux->idx[avimux->idx_index].size = GUINT32_TO_LE (size);
1530   avimux->idx_index++;
1531 }
1532
1533 static GstFlowReturn
1534 gst_avi_mux_write_index (GstAviMux * avimux)
1535 {
1536   GstFlowReturn res;
1537   GstBuffer *buffer;
1538   GstMapInfo map;
1539   guint8 *data;
1540   gsize size;
1541
1542   buffer = gst_buffer_new_and_alloc (8);
1543
1544   gst_buffer_map (buffer, &map, GST_MAP_WRITE);
1545   memcpy (map.data + 0, "idx1", 4);
1546   GST_WRITE_UINT32_LE (map.data + 4,
1547       avimux->idx_index * sizeof (gst_riff_index_entry));
1548   gst_buffer_unmap (buffer, &map);
1549
1550   res = gst_pad_push (avimux->srcpad, buffer);
1551   if (res != GST_FLOW_OK)
1552     return res;
1553
1554   buffer = gst_buffer_new ();
1555
1556   size = avimux->idx_index * sizeof (gst_riff_index_entry);
1557   data = (guint8 *) avimux->idx;
1558   avimux->idx = NULL;           /* will be free()'ed by gst_buffer_unref() */
1559
1560   gst_buffer_take_memory (buffer, -1,
1561       gst_memory_new_wrapped (0, data, g_free, size, 0, size));
1562
1563   avimux->total_data += size + 8;
1564
1565   res = gst_pad_push (avimux->srcpad, buffer);
1566   if (res != GST_FLOW_OK)
1567     return res;
1568
1569   avimux->idx_size += avimux->idx_index * sizeof (gst_riff_index_entry) + 8;
1570
1571   /* update header */
1572   avimux->avi_hdr.flags |= GST_RIFF_AVIH_HASINDEX;
1573   return GST_FLOW_OK;
1574 }
1575
1576 static GstFlowReturn
1577 gst_avi_mux_bigfile (GstAviMux * avimux, gboolean last)
1578 {
1579   GstFlowReturn res = GST_FLOW_OK;
1580   GstBuffer *header;
1581   GSList *node;
1582
1583   /* first some odml standard index chunks in the movi list */
1584   node = avimux->sinkpads;
1585   while (node) {
1586     GstAviPad *avipad = (GstAviPad *) node->data;
1587
1588     node = node->next;
1589
1590     res = gst_avi_mux_write_avix_index (avimux, avipad, avipad->tag,
1591         avipad->idx_tag, avipad->idx, &avipad->idx_index);
1592     if (res != GST_FLOW_OK)
1593       return res;
1594   }
1595
1596   if (avimux->is_bigfile) {
1597     GstSegment segment;
1598
1599     gst_segment_init (&segment, GST_FORMAT_BYTES);
1600
1601     /* search back */
1602     segment.start = avimux->avix_start;
1603     segment.time = avimux->avix_start;
1604     gst_pad_push_event (avimux->srcpad, gst_event_new_segment (&segment));
1605
1606     /* rewrite AVIX header */
1607     header = gst_avi_mux_riff_get_avix_header (avimux->datax_size);
1608     res = gst_pad_push (avimux->srcpad, header);
1609
1610     /* go back to current location, at least try */
1611     segment.start = avimux->total_data;
1612     segment.time = avimux->total_data;
1613     gst_pad_push_event (avimux->srcpad, gst_event_new_segment (&segment));
1614
1615     if (res != GST_FLOW_OK)
1616       return res;
1617   } else {                      /* write a standard index in the first riff chunk */
1618     res = gst_avi_mux_write_index (avimux);
1619     /* the index data/buffer is freed by pushing it */
1620     avimux->idx_count = 0;
1621     if (res != GST_FLOW_OK)
1622       return res;
1623   }
1624
1625   avimux->avix_start = avimux->total_data;
1626
1627   if (last)
1628     return res;
1629
1630   avimux->is_bigfile = TRUE;
1631   avimux->numx_frames = 0;
1632   avimux->datax_size = 4;       /* movi tag */
1633   avimux->idx_index = 0;
1634   node = avimux->sinkpads;
1635   while (node) {
1636     GstAviPad *avipad = (GstAviPad *) node->data;
1637     node = node->next;
1638     if (!avipad->is_video) {
1639       GstAviAudioPad *audiopad = (GstAviAudioPad *) avipad;
1640       audiopad->samples = 0;
1641     }
1642   }
1643
1644   header = gst_avi_mux_riff_get_avix_header (0);
1645   avimux->total_data += gst_buffer_get_size (header);
1646   /* avix_start is used as base offset for the odml index chunk */
1647   avimux->idx_offset = avimux->total_data - avimux->avix_start;
1648
1649   return gst_pad_push (avimux->srcpad, header);
1650 }
1651
1652 /* enough header blabla now, let's go on to actually writing the headers */
1653
1654 static GstFlowReturn
1655 gst_avi_mux_start_file (GstAviMux * avimux)
1656 {
1657   GstFlowReturn res;
1658   GstBuffer *header;
1659   GSList *node;
1660   GstCaps *caps;
1661   GstSegment segment;
1662
1663   avimux->total_data = 0;
1664   avimux->total_frames = 0;
1665   avimux->data_size = 4;        /* movi tag */
1666   avimux->datax_size = 0;
1667   avimux->num_frames = 0;
1668   avimux->numx_frames = 0;
1669   avimux->avix_start = 0;
1670
1671   avimux->idx_index = 0;
1672   avimux->idx_offset = 0;       /* see 10 lines below */
1673   avimux->idx_size = 0;
1674   avimux->idx_count = 0;
1675   avimux->idx = NULL;
1676
1677   /* state */
1678   avimux->write_header = FALSE;
1679   avimux->restart = FALSE;
1680
1681   /* init streams, see what we've got */
1682   node = avimux->sinkpads;
1683   avimux->audio_pads = avimux->video_pads = 0;
1684   while (node) {
1685     GstAviPad *avipad = (GstAviPad *) node->data;
1686
1687     node = node->next;
1688
1689     if (!avipad->is_video) {
1690       /* audio stream numbers must start at 1 iff there is a video stream 0;
1691        * request_pad inserts video pad at head of list, so this test suffices */
1692       if (avimux->video_pads)
1693         avimux->audio_pads++;
1694       avipad->tag = g_strdup_printf ("%02uwb", avimux->audio_pads);
1695       avipad->idx_tag = g_strdup_printf ("ix%02u", avimux->audio_pads);
1696       if (!avimux->video_pads)
1697         avimux->audio_pads++;
1698     } else {
1699       avipad->tag = g_strdup_printf ("%02udb", avimux->video_pads);
1700       avipad->idx_tag = g_strdup_printf ("ix%02u", avimux->video_pads++);
1701     }
1702   }
1703
1704   caps = gst_caps_copy (gst_pad_get_pad_template_caps (avimux->srcpad));
1705   gst_pad_set_caps (avimux->srcpad, caps);
1706   gst_caps_unref (caps);
1707
1708   /* let downstream know we think in BYTES and expect to do seeking later on */
1709   gst_segment_init (&segment, GST_FORMAT_BYTES);
1710   gst_pad_push_event (avimux->srcpad, gst_event_new_segment (&segment));
1711
1712   /* header */
1713   avimux->avi_hdr.streams = g_slist_length (avimux->sinkpads);
1714   avimux->is_bigfile = FALSE;
1715
1716   header = gst_avi_mux_riff_get_avi_header (avimux);
1717   avimux->total_data += gst_buffer_get_size (header);
1718
1719   res = gst_pad_push (avimux->srcpad, header);
1720
1721   avimux->idx_offset = avimux->total_data;
1722
1723   return res;
1724 }
1725
1726 static GstFlowReturn
1727 gst_avi_mux_stop_file (GstAviMux * avimux)
1728 {
1729   GstFlowReturn res = GST_FLOW_OK;
1730   GstBuffer *header;
1731   GSList *node;
1732   GstSegment segment;
1733
1734   /* if bigfile, rewrite header, else write indexes */
1735   /* don't bail out at once if error, still try to re-write header */
1736   if (avimux->video_pads > 0) {
1737     if (avimux->is_bigfile) {
1738       res = gst_avi_mux_bigfile (avimux, TRUE);
1739     } else {
1740       res = gst_avi_mux_write_index (avimux);
1741     }
1742   }
1743
1744   /* we do our best to make it interleaved at least ... */
1745   if (avimux->audio_pads > 0 && avimux->video_pads > 0)
1746     avimux->avi_hdr.flags |= GST_RIFF_AVIH_ISINTERLEAVED;
1747
1748   /* set rate and everything having to do with that */
1749   avimux->avi_hdr.max_bps = 0;
1750   node = avimux->sinkpads;
1751   while (node) {
1752     GstAviPad *avipad = (GstAviPad *) node->data;
1753
1754     node = node->next;
1755
1756     if (!avipad->is_video) {
1757       GstAviAudioPad *audpad = (GstAviAudioPad *) avipad;
1758
1759       /* calculate bps if needed */
1760       if (!audpad->auds.av_bps) {
1761         if (audpad->audio_time) {
1762           audpad->auds.av_bps =
1763               (GST_SECOND * audpad->audio_size) / audpad->audio_time;
1764           /* round bps to nearest multiple of 8;
1765            * which is much more likely to be the (cbr) bitrate in use;
1766            * which in turn results in better timestamp calculation on playback */
1767           audpad->auds.av_bps = GST_ROUND_UP_8 (audpad->auds.av_bps - 4);
1768         } else {
1769           GST_ELEMENT_WARNING (avimux, STREAM, MUX,
1770               (_("No or invalid input audio, AVI stream will be corrupt.")),
1771               (NULL));
1772           audpad->auds.av_bps = 0;
1773         }
1774       }
1775       gst_avi_mux_audsink_set_fields (avimux, audpad);
1776       avimux->avi_hdr.max_bps += audpad->auds.av_bps;
1777       avipad->hdr.length = gst_util_uint64_scale (audpad->audio_time,
1778           avipad->hdr.rate, avipad->hdr.scale * GST_SECOND);
1779     } else {
1780       GstAviVideoPad *vidpad = (GstAviVideoPad *) avipad;
1781
1782       avimux->avi_hdr.max_bps += ((vidpad->vids.bit_cnt + 7) / 8) *
1783           (1000000. / avimux->avi_hdr.us_frame) * vidpad->vids.image_size;
1784       avipad->hdr.length = avimux->total_frames;
1785     }
1786   }
1787
1788   /* statistics/total_frames/... */
1789   avimux->avi_hdr.tot_frames = avimux->num_frames;
1790
1791   /* seek and rewrite the header */
1792   gst_segment_init (&segment, GST_FORMAT_BYTES);
1793   gst_pad_push_event (avimux->srcpad, gst_event_new_segment (&segment));
1794
1795   /* the first error survives */
1796   header = gst_avi_mux_riff_get_avi_header (avimux);
1797   if (res == GST_FLOW_OK)
1798     res = gst_pad_push (avimux->srcpad, header);
1799   else
1800     gst_pad_push (avimux->srcpad, header);
1801
1802   segment.start = avimux->total_data;
1803   segment.time = avimux->total_data;
1804   gst_pad_push_event (avimux->srcpad, gst_event_new_segment (&segment));
1805
1806   avimux->write_header = TRUE;
1807
1808   return res;
1809 }
1810
1811 static GstFlowReturn
1812 gst_avi_mux_restart_file (GstAviMux * avimux)
1813 {
1814   GstFlowReturn res;
1815
1816   if ((res = gst_avi_mux_stop_file (avimux)) != GST_FLOW_OK)
1817     return res;
1818
1819   gst_pad_push_event (avimux->srcpad, gst_event_new_eos ());
1820
1821   return gst_avi_mux_start_file (avimux);
1822 }
1823
1824 /* handle events (search) */
1825 static gboolean
1826 gst_avi_mux_handle_event (GstCollectPads2 * pads, GstCollectData2 * data,
1827     GstEvent * event, gpointer user_data)
1828 {
1829   GstAviMux *avimux;
1830   gboolean ret = FALSE;
1831
1832   avimux = GST_AVI_MUX (user_data);
1833
1834   switch (GST_EVENT_TYPE (event)) {
1835     case GST_EVENT_CAPS:
1836     {
1837       GstCaps *caps;
1838       GstAviCollectData *collect_pad;
1839       GstAviVideoPad *avipad;
1840
1841       gst_event_parse_caps (event, &caps);
1842
1843       /* find stream data */
1844       collect_pad = (GstAviCollectData *) data;
1845       g_assert (collect_pad);
1846       avipad = (GstAviVideoPad *) collect_pad->avipad;
1847       g_assert (avipad);
1848
1849       if (avipad->parent.is_video) {
1850         ret = gst_avi_mux_vidsink_set_caps (data->pad, caps);
1851       } else {
1852         ret = gst_avi_mux_audsink_set_caps (data->pad, caps);
1853       }
1854       gst_event_unref (event);
1855       break;
1856     }
1857     case GST_EVENT_TAG:{
1858       GstTagList *list;
1859       GstTagSetter *setter = GST_TAG_SETTER (avimux);
1860       const GstTagMergeMode mode = gst_tag_setter_get_tag_merge_mode (setter);
1861
1862       gst_event_parse_tag (event, &list);
1863       gst_tag_setter_merge_tags (setter, list, mode);
1864       gst_event_unref (event);
1865       ret = TRUE;
1866       break;
1867     }
1868     case GST_EVENT_EOS:
1869     case GST_EVENT_SEGMENT:
1870       gst_event_unref (event);
1871       ret = TRUE;
1872       break;
1873     default:
1874       ret = gst_pad_event_default (data->pad, GST_OBJECT (avimux), event);
1875       break;
1876   }
1877
1878   return ret;
1879 }
1880
1881 /* send extra 'padding' data */
1882 static GstFlowReturn
1883 gst_avi_mux_send_pad_data (GstAviMux * avimux, gulong num_bytes)
1884 {
1885   GstBuffer *buffer;
1886
1887   buffer = gst_buffer_new_and_alloc (num_bytes);
1888   gst_buffer_memset (buffer, 0, 0, num_bytes);
1889
1890   return gst_pad_push (avimux->srcpad, buffer);
1891 }
1892
1893 /* do buffer */
1894 static GstFlowReturn
1895 gst_avi_mux_do_buffer (GstAviMux * avimux, GstAviPad * avipad)
1896 {
1897   GstFlowReturn res;
1898   GstBuffer *data, *header;
1899   gulong total_size, pad_bytes = 0;
1900   guint flags;
1901   gsize datasize;
1902
1903   data = gst_collect_pads2_pop (avimux->collect, avipad->collect);
1904   /* arrange downstream running time */
1905   data = gst_buffer_make_writable (data);
1906   GST_BUFFER_TIMESTAMP (data) =
1907       gst_segment_to_running_time (&avipad->collect->segment,
1908       GST_FORMAT_TIME, GST_BUFFER_TIMESTAMP (data));
1909
1910   /* Prepend a special buffer to the first one for some formats */
1911   if (avipad->is_video) {
1912     GstAviVideoPad *vidpad = (GstAviVideoPad *) avipad;
1913
1914     if (vidpad->prepend_buffer) {
1915       GstBuffer *newdata = gst_buffer_merge (vidpad->prepend_buffer, data);
1916       gst_buffer_copy_into (newdata, data, GST_BUFFER_COPY_TIMESTAMPS, 0, -1);
1917       gst_buffer_unref (data);
1918       gst_buffer_unref (vidpad->prepend_buffer);
1919
1920       data = newdata;
1921       vidpad->prepend_buffer = NULL;
1922     }
1923   }
1924
1925   if (avimux->restart) {
1926     if ((res = gst_avi_mux_restart_file (avimux)) != GST_FLOW_OK)
1927       return res;
1928   }
1929
1930   datasize = gst_buffer_get_size (data);
1931
1932   /* need to restart or start a next avix chunk ? */
1933   if ((avimux->is_bigfile ? avimux->datax_size : avimux->data_size) +
1934       datasize > GST_AVI_MAX_SIZE) {
1935     if (avimux->enable_large_avi) {
1936       if ((res = gst_avi_mux_bigfile (avimux, FALSE)) != GST_FLOW_OK)
1937         return res;
1938     } else {
1939       if ((res = gst_avi_mux_restart_file (avimux)) != GST_FLOW_OK)
1940         return res;
1941     }
1942   }
1943
1944   /* get header and record some stats */
1945   if (datasize & 1) {
1946     pad_bytes = 2 - (datasize & 1);
1947   }
1948   header = gst_avi_mux_riff_get_header (avipad, datasize);
1949   total_size = gst_buffer_get_size (header) + datasize + pad_bytes;
1950
1951   if (avimux->is_bigfile) {
1952     avimux->datax_size += total_size;
1953   } else {
1954     avimux->data_size += total_size;
1955   }
1956
1957   if (G_UNLIKELY (avipad->hook))
1958     avipad->hook (avimux, avipad, data);
1959
1960   /* the suggested buffer size is the max frame size */
1961   if (avipad->hdr.bufsize < datasize)
1962     avipad->hdr.bufsize = datasize;
1963
1964   if (avipad->is_video) {
1965     avimux->total_frames++;
1966
1967     if (avimux->is_bigfile) {
1968       avimux->numx_frames++;
1969     } else {
1970       avimux->num_frames++;
1971     }
1972
1973     flags = 0x02;
1974     if (!GST_BUFFER_FLAG_IS_SET (data, GST_BUFFER_FLAG_DELTA_UNIT))
1975       flags |= 0x10;
1976   } else {
1977     GstAviAudioPad *audpad = (GstAviAudioPad *) avipad;
1978
1979     flags = 0;
1980     audpad->audio_size += datasize;
1981     audpad->audio_time += GST_BUFFER_DURATION (data);
1982   }
1983
1984   gst_avi_mux_add_index (avimux, avipad, flags, datasize);
1985
1986   /* send buffers */
1987   GST_LOG_OBJECT (avimux, "pushing buffers: head, data");
1988
1989   if ((res = gst_pad_push (avimux->srcpad, header)) != GST_FLOW_OK)
1990     return res;
1991   if ((res = gst_pad_push (avimux->srcpad, data)) != GST_FLOW_OK)
1992     return res;
1993
1994   if (pad_bytes) {
1995     if ((res = gst_avi_mux_send_pad_data (avimux, pad_bytes)) != GST_FLOW_OK)
1996       return res;
1997   }
1998
1999   /* if any push above fails, we're in trouble with file consistency anyway */
2000   avimux->total_data += total_size;
2001   avimux->idx_offset += total_size;
2002
2003   return res;
2004 }
2005
2006 /* pick the oldest buffer from the pads and push it */
2007 static GstFlowReturn
2008 gst_avi_mux_do_one_buffer (GstAviMux * avimux)
2009 {
2010   GstAviPad *avipad, *best_pad;
2011   GSList *node;
2012   GstBuffer *buffer;
2013   GstClockTime time, best_time, delay;
2014
2015   node = avimux->sinkpads;
2016   best_pad = NULL;
2017   best_time = GST_CLOCK_TIME_NONE;
2018   for (; node; node = node->next) {
2019     avipad = (GstAviPad *) node->data;
2020
2021     if (!avipad->collect)
2022       continue;
2023
2024     if (!avipad->hdr.fcc_handler)
2025       goto not_negotiated;
2026
2027     buffer = gst_collect_pads2_peek (avimux->collect, avipad->collect);
2028     if (!buffer)
2029       continue;
2030     time = GST_BUFFER_TIMESTAMP (buffer);
2031     gst_buffer_unref (buffer);
2032
2033     /* invalid should pass */
2034     if (G_LIKELY (GST_CLOCK_TIME_IS_VALID (time))) {
2035       time = gst_segment_to_running_time (&avipad->collect->segment,
2036           GST_FORMAT_TIME, time);
2037       if (G_UNLIKELY (!GST_CLOCK_TIME_IS_VALID (time))) {
2038         GST_DEBUG_OBJECT (avimux, "clipping buffer on pad %s outside segment",
2039             GST_PAD_NAME (avipad->collect->pad));
2040         buffer = gst_collect_pads2_pop (avimux->collect, avipad->collect);
2041         gst_buffer_unref (buffer);
2042         return GST_FLOW_OK;
2043       }
2044     }
2045
2046     delay = avipad->is_video ? GST_SECOND / 2 : 0;
2047
2048     /* invalid timestamp buffers pass first,
2049      * these are probably initialization buffers */
2050     if (best_pad == NULL || !GST_CLOCK_TIME_IS_VALID (time)
2051         || (GST_CLOCK_TIME_IS_VALID (best_time) && time + delay < best_time)) {
2052       best_pad = avipad;
2053       best_time = time + delay;
2054     }
2055   }
2056
2057   if (best_pad) {
2058     GST_LOG_OBJECT (avimux, "selected pad %s with time %" GST_TIME_FORMAT,
2059         GST_PAD_NAME (best_pad->collect->pad), GST_TIME_ARGS (best_time));
2060
2061     return gst_avi_mux_do_buffer (avimux, best_pad);
2062   } else {
2063     /* simply finish off the file and send EOS */
2064     gst_avi_mux_stop_file (avimux);
2065     gst_pad_push_event (avimux->srcpad, gst_event_new_eos ());
2066     return GST_FLOW_EOS;
2067   }
2068
2069   /* ERRORS */
2070 not_negotiated:
2071   {
2072     GST_ELEMENT_ERROR (avimux, CORE, NEGOTIATION, (NULL),
2073         ("pad %s not negotiated", GST_PAD_NAME (avipad->collect->pad)));
2074     return GST_FLOW_NOT_NEGOTIATED;
2075   }
2076 }
2077
2078 static GstFlowReturn
2079 gst_avi_mux_collect_pads (GstCollectPads2 * pads, GstAviMux * avimux)
2080 {
2081   GstFlowReturn res;
2082
2083   if (G_UNLIKELY (avimux->write_header)) {
2084     if ((res = gst_avi_mux_start_file (avimux)) != GST_FLOW_OK)
2085       return res;
2086   }
2087
2088   return gst_avi_mux_do_one_buffer (avimux);
2089 }
2090
2091
2092 static void
2093 gst_avi_mux_get_property (GObject * object,
2094     guint prop_id, GValue * value, GParamSpec * pspec)
2095 {
2096   GstAviMux *avimux;
2097
2098   avimux = GST_AVI_MUX (object);
2099
2100   switch (prop_id) {
2101     case ARG_BIGFILE:
2102       g_value_set_boolean (value, avimux->enable_large_avi);
2103       break;
2104     default:
2105       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2106       break;
2107   }
2108 }
2109
2110 static void
2111 gst_avi_mux_set_property (GObject * object,
2112     guint prop_id, const GValue * value, GParamSpec * pspec)
2113 {
2114   GstAviMux *avimux;
2115
2116   avimux = GST_AVI_MUX (object);
2117
2118   switch (prop_id) {
2119     case ARG_BIGFILE:
2120       avimux->enable_large_avi = g_value_get_boolean (value);
2121       break;
2122     default:
2123       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2124       break;
2125   }
2126 }
2127
2128 static GstStateChangeReturn
2129 gst_avi_mux_change_state (GstElement * element, GstStateChange transition)
2130 {
2131   GstAviMux *avimux;
2132   GstStateChangeReturn ret;
2133
2134   avimux = GST_AVI_MUX (element);
2135
2136   switch (transition) {
2137     case GST_STATE_CHANGE_READY_TO_PAUSED:
2138       gst_collect_pads2_start (avimux->collect);
2139       break;
2140     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
2141       break;
2142     case GST_STATE_CHANGE_PAUSED_TO_READY:
2143       gst_collect_pads2_stop (avimux->collect);
2144       break;
2145     default:
2146       break;
2147   }
2148
2149   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
2150   if (ret == GST_STATE_CHANGE_FAILURE)
2151     goto done;
2152
2153   switch (transition) {
2154     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
2155       break;
2156     case GST_STATE_CHANGE_PAUSED_TO_READY:
2157       gst_avi_mux_reset (avimux);
2158       break;
2159     case GST_STATE_CHANGE_READY_TO_NULL:
2160       break;
2161     default:
2162       break;
2163   }
2164
2165 done:
2166   return ret;
2167 }