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-yuv,format=(fourcc)I420,width=320,height=240,framerate=(fraction)25/1' \

    39  * ! queue ! mux. \

    40  * audiotestsrc num-buffers=440 ! audioconvert \

    41  * ! 'audio/x-raw-int,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-yuv,format=(fourcc)I420,width=320,height=240,framerate=(fraction)25/1' \

    49  * ! xvidenc ! queue ! mux. \

    50  * audiotestsrc num-buffers=440 ! audioconvert ! 'audio/x-raw-int,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 <stdlib.h>

    65 #include <string.h>

    66 

    67 #include <gst/video/video.h>

    68 

    69 #include "gstavimux.h"

    70 

    71 GST_DEBUG_CATEGORY_STATIC (avimux_debug);

    72 #define GST_CAT_DEFAULT avimux_debug

    73 

    74 enum

    75 {

    76   ARG_0,

    77   ARG_BIGFILE

    78 };

    79 

    80 #define DEFAULT_BIGFILE TRUE

    81 

    82 static const GstElementDetails gst_avi_mux_details =

    83 GST_ELEMENT_DETAILS ("Avi muxer",

    84     "Codec/Muxer",

    85     "Muxes audio and video into an avi stream",

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

    87 

    88 static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",

    89     GST_PAD_SRC,

    90     GST_PAD_ALWAYS,

    91     GST_STATIC_CAPS ("video/x-msvideo")

    92     );

    93 

    94 static GstStaticPadTemplate video_sink_factory =

    95     GST_STATIC_PAD_TEMPLATE ("video_%d",

    96     GST_PAD_SINK,

    97     GST_PAD_REQUEST,

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

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

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

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

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

   103         "image/jpeg, "

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

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

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

   107         "video/x-divx, "

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

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

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

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

   112         "video/x-xvid, "

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

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

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

   116         "video/x-3ivx, "

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

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

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

   120         "video/x-msmpeg, "

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

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

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

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

   125         "video/mpeg, "

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

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

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

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

   130         "systemstream = (boolean) FALSE; "

   131         "video/x-h263, "

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

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

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

   135         "video/x-h264, "

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

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

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

   139         "video/x-dv, "

   140         "width = (int) 720, "

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

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

   143         "systemstream = (boolean) FALSE; "

   144         "video/x-huffyuv, "

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

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

   147         "video/x-dirac, "

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

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

   150         "video/x-wmv, "

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

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

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

   154     );

   155 

   156 static GstStaticPadTemplate audio_sink_factory =

   157     GST_STATIC_PAD_TEMPLATE ("audio_%d",

   158     GST_PAD_SINK,

   159     GST_PAD_REQUEST,

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

   161         "endianness = (int) LITTLE_ENDIAN, "

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

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

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

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

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

   167         "audio/mpeg, "

   168         "mpegversion = (int) 1, "

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

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

   171         "audio/mpeg, "

   172         "mpegversion = (int) 4, "

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

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

   175         "audio/x-vorbis, "

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

   177 #endif*/

   178         "audio/x-ac3, "

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

   180         "audio/x-alaw, "

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

   182         "audio/x-mulaw, "

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

   184         "audio/x-wma, "

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

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

   187     );

   188 

   189 static void gst_avi_mux_base_init (gpointer g_class);

   190 static void gst_avi_mux_class_init (GstAviMuxClass * klass);

   191 static void gst_avi_mux_init (GstAviMux * avimux);

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

   193 

   194 static GstFlowReturn gst_avi_mux_collect_pads (GstCollectPads * pads,

   195     GstAviMux * avimux);

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

   197 static GstPad *gst_avi_mux_request_new_pad (GstElement * element,

   198     GstPadTemplate * templ, const gchar * name);

   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 static GstElementClass *parent_class = NULL;

   208 

   209 GType

   210 gst_avi_mux_get_type (void)

   211 {

   212   static GType avimux_type = 0;

   213 

   214   if (!avimux_type) {

   215     static const GTypeInfo avimux_info = {

   216       sizeof (GstAviMuxClass),

   217       gst_avi_mux_base_init,

   218       NULL,

   219       (GClassInitFunc) gst_avi_mux_class_init,

   220       NULL,

   221       NULL,

   222       sizeof (GstAviMux),

   223       0,

   224       (GInstanceInitFunc) gst_avi_mux_init,

   225     };

   226     static const GInterfaceInfo tag_setter_info = {

   227       NULL,

   228       NULL,

   229       NULL

   230     };

   231 

   232     avimux_type =

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

   234     g_type_add_interface_static (avimux_type, GST_TYPE_TAG_SETTER,

   235         &tag_setter_info);

   236   }

   237   return avimux_type;

   238 }

   239 

   240 static void

   241 gst_avi_mux_base_init (gpointer g_class)

   242 {

   243   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

   244 

   245   gst_element_class_add_pad_template (element_class,

   246       gst_static_pad_template_get (&src_factory));

   247   gst_element_class_add_pad_template (element_class,

   248       gst_static_pad_template_get (&audio_sink_factory));

   249   gst_element_class_add_pad_template (element_class,

   250       gst_static_pad_template_get (&video_sink_factory));

   251 

   252   gst_element_class_set_details (element_class, &gst_avi_mux_details);

   253 

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

   255 }

   256 

   257 static void

   258 gst_avi_mux_finalize (GObject * object)

   259 {

   260   GstAviMux *mux = GST_AVI_MUX (object);

   261   GSList *node;

   262 

   263   /* completely free each sinkpad */

   264   node = mux->sinkpads;

   265   while (node) {

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

   267 

   268     node = node->next;

   269 

   270     gst_avi_mux_pad_reset (avipad, TRUE);

   271     g_free (avipad);

   272   }

   273   g_slist_free (mux->sinkpads);

   274   mux->sinkpads = NULL;

   275 

   276   g_free (mux->idx);

   277   mux->idx = NULL;

   278 

   279   gst_object_unref (mux->collect);

   280 

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

   282 }

   283 

   284 static void

   285 gst_avi_mux_class_init (GstAviMuxClass * klass)

   286 {

   287   GObjectClass *gobject_class;

   288   GstElementClass *gstelement_class;

   289 

   290   gobject_class = (GObjectClass *) klass;

   291   gstelement_class = (GstElementClass *) klass;

   292 

   293   parent_class = g_type_class_peek_parent (klass);

   294 

   295   gobject_class->get_property = gst_avi_mux_get_property;

   296   gobject_class->set_property = gst_avi_mux_set_property;

   297   gobject_class->finalize = gst_avi_mux_finalize;

   298 

   299   g_object_class_install_property (gobject_class, ARG_BIGFILE,

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

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

   302           G_PARAM_READWRITE));

   303 

   304   gstelement_class->request_new_pad =

   305       GST_DEBUG_FUNCPTR (gst_avi_mux_request_new_pad);

   306   gstelement_class->release_pad = GST_DEBUG_FUNCPTR (gst_avi_mux_release_pad);

   307   gstelement_class->change_state = GST_DEBUG_FUNCPTR (gst_avi_mux_change_state);

   308 }

   309 

   310 /* reset pad to initial state

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

   312 static void

   313 gst_avi_mux_pad_reset (GstAviPad * avipad, gboolean free)

   314 {

   315   /* generic part */

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

   317 

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

   319 

   320   if (free) {

   321     g_free (avipad->tag);

   322     avipad->tag = NULL;

   323     g_free (avipad->idx_tag);

   324     avipad->idx_tag = NULL;

   325   }

   326 

   327   if (avipad->is_video) {

   328     GstAviVideoPad *vidpad = (GstAviVideoPad *) avipad;

   329 

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

   331     if (vidpad->vids_codec_data) {

   332       gst_buffer_unref (vidpad->vids_codec_data);

   333       vidpad->vids_codec_data = NULL;

   334     }

   335 

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

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

   338   } else {

   339     GstAviAudioPad *audpad = (GstAviAudioPad *) avipad;

   340 

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

   342     if (audpad->auds_codec_data) {

   343       gst_buffer_unref (audpad->auds_codec_data);

   344       audpad->auds_codec_data = NULL;

   345     }

   346 

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

   348   }

   349 }

   350 

   351 static void

   352 gst_avi_mux_reset (GstAviMux * avimux)

   353 {

   354   GSList *node, *newlist = NULL;

   355 

   356   /* free and reset each sinkpad */

   357   node = avimux->sinkpads;

   358   while (node) {

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

   360 

   361     node = node->next;

   362 

   363     gst_avi_mux_pad_reset (avipad, FALSE);

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

   365     if (avipad->collect)

   366       newlist = g_slist_append (newlist, avipad);

   367     else {

   368       gst_avi_mux_pad_reset (avipad, TRUE);

   369       g_free (avipad);

   370     }

   371   }

   372 

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

   374   g_slist_free (avimux->sinkpads);

   375   avimux->sinkpads = newlist;

   376 

   377   /* avi data */

   378   avimux->num_frames = 0;

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

   380   avimux->avi_hdr.max_bps = 10000000;

   381   avimux->codec_data_size = 0;

   382 

   383   if (avimux->tags_snap) {

   384     gst_tag_list_free (avimux->tags_snap);

   385     avimux->tags_snap = NULL;

   386   }

   387 

   388   g_free (avimux->idx);

   389   avimux->idx = NULL;

   390 

   391   /* state info */

   392   avimux->write_header = TRUE;

   393 

   394   /* tags */

   395   gst_tag_setter_reset_tags (GST_TAG_SETTER (avimux));

   396 }

   397 

   398 static void

   399 gst_avi_mux_init (GstAviMux * avimux)

   400 {

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

   402   gst_pad_use_fixed_caps (avimux->srcpad);

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

   404 

   405   /* property */

   406   avimux->enable_large_avi = DEFAULT_BIGFILE;

   407 

   408   avimux->collect = gst_collect_pads_new ();

   409   gst_collect_pads_set_function (avimux->collect,

   410       (GstCollectPadsFunction) (GST_DEBUG_FUNCPTR (gst_avi_mux_collect_pads)),

   411       avimux);

   412 

   413   /* set to clean state */

   414   gst_avi_mux_reset (avimux);

   415 }

   416 

   417 static gboolean

   418 gst_avi_mux_vidsink_set_caps (GstPad * pad, GstCaps * vscaps)

   419 {

   420   GstAviMux *avimux;

   421   GstAviVideoPad *avipad;

   422   GstAviCollectData *collect_pad;

   423   GstStructure *structure;

   424   const gchar *mimetype;

   425   const GValue *fps, *par;

   426   const GValue *codec_data;

   427   gint width, height;

   428   gint par_n, par_d;

   429 

   430   avimux = GST_AVI_MUX (gst_pad_get_parent (pad));

   431 

   432   /* find stream data */

   433   collect_pad = (GstAviCollectData *) gst_pad_get_element_private (pad);

   434   g_assert (collect_pad);

   435   avipad = (GstAviVideoPad *) collect_pad->avipad;

   436   g_assert (avipad);

   437   g_assert (avipad->parent.is_video);

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

   439 

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

   441       GST_DEBUG_PAD_NAME (pad), vscaps);

   442 

   443   structure = gst_caps_get_structure (vscaps, 0);

   444   mimetype = gst_structure_get_name (structure);

   445 

   446   /* global */

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

   448   avipad->vids.planes = 1;

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

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

   451     goto refuse_caps;

   452   }

   453 

   454   avipad->vids.width = width;

   455   avipad->vids.height = height;

   456 

   457   fps = gst_structure_get_value (structure, "framerate");

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

   459     goto refuse_caps;

   460 

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

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

   463 

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

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

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

   467   if (par && GST_VALUE_HOLDS_FRACTION (par) &&

   468       ((par_n = gst_value_get_fraction_numerator (par)) !=

   469           (par_d = gst_value_get_fraction_denominator (par)))) {

   470     GValue to_ratio = { 0, };

   471     guint ratio_n, ratio_d;

   472 

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

   474     g_value_init (&to_ratio, GST_TYPE_FRACTION);

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

   476     ratio_n = gst_value_get_fraction_numerator (&to_ratio);

   477     ratio_d = gst_value_get_fraction_denominator (&to_ratio);

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

   479         ratio_n, ratio_d);

   480     /* simply fill in */

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

   482     avipad->vprp.hor_t_total = width;

   483     avipad->vprp.vert_lines = height;

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

   485     avipad->vprp.width = width;

   486     avipad->vprp.height = height;

   487     avipad->vprp.fields = 1;

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

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

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

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

   492   }

   493 

   494   /* codec initialization data, if any */

   495   codec_data = gst_structure_get_value (structure, "codec_data");

   496   if (codec_data) {

   497     avipad->vids_codec_data = gst_value_get_buffer (codec_data);

   498     gst_buffer_ref (avipad->vids_codec_data);

   499     /* keep global track of size */

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

   501   }

   502 

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

   504     guint32 format;

   505 

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

   507     avipad->vids.compression = format;

   508     switch (format) {

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

   510         avipad->vids.bit_cnt = 16;

   511         break;

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

   513         avipad->vids.bit_cnt = 12;

   514         break;

   515     }

   516   } else {

   517     avipad->vids.bit_cnt = 24;

   518     avipad->vids.compression = 0;

   519 

   520     /* find format */

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

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

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

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

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

   526       gint divxversion;

   527 

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

   529       switch (divxversion) {

   530         case 3:

   531           avipad->vids.compression = GST_MAKE_FOURCC ('D', 'I', 'V', '3');

   532           break;

   533         case 4:

   534           avipad->vids.compression = GST_MAKE_FOURCC ('D', 'I', 'V', 'X');

   535           break;

   536         case 5:

   537           avipad->vids.compression = GST_MAKE_FOURCC ('D', 'X', '5', '0');

   538           break;

   539       }

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

   541       avipad->vids.compression = GST_MAKE_FOURCC ('X', 'V', 'I', 'D');

   542     } else if (!strcmp (mimetype, "video/x-3ivx")) {

   543       avipad->vids.compression = GST_MAKE_FOURCC ('3', 'I', 'V', '2');

   544     } else if (gst_structure_has_name (structure, "video/x-msmpeg")) {

   545       gint msmpegversion;

   546 

   547       gst_structure_get_int (structure, "msmpegversion", &msmpegversion);

   548       switch (msmpegversion) {

   549         case 41:

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

   551           break;

   552         case 42:

   553           avipad->vids.compression = GST_MAKE_FOURCC ('M', 'P', '4', '2');

   554           break;

   555         case 43:

   556           avipad->vids.compression = GST_MAKE_FOURCC ('M', 'P', '4', '3');

   557           break;

   558         default:

   559           GST_INFO ("unhandled msmpegversion : %d, fall back to fourcc=MPEG",

   560               msmpegversion);

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

   562           break;

   563       }

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

   565       avipad->vids.compression = GST_MAKE_FOURCC ('D', 'V', 'S', 'D');

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

   567       avipad->vids.compression = GST_MAKE_FOURCC ('H', '2', '6', '3');

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

   569       avipad->vids.compression = GST_MAKE_FOURCC ('H', '2', '6', '4');

   570     } else if (!strcmp (mimetype, "video/mpeg")) {

   571       gint mpegversion;

   572 

   573       gst_structure_get_int (structure, "mpegversion", &mpegversion);

   574 

   575       switch (mpegversion) {

   576         case 2:

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

   578           break;

   579         case 4:

   580           /* mplayer/ffmpeg might not work with DIVX, but with FMP4 */

   581           avipad->vids.compression = GST_MAKE_FOURCC ('D', 'I', 'V', 'X');

   582           break;

   583         default:

   584           GST_INFO ("unhandled mpegversion : %d, fall back to fourcc=MPEG",

   585               mpegversion);

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

   587           break;

   588       }

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

   590       avipad->vids.compression = GST_MAKE_FOURCC ('d', 'r', 'a', 'c');

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

   592       gint wmvversion;

   593 

   594       if (gst_structure_get_int (structure, "wmvversion", &wmvversion)) {

   595         switch (wmvversion) {

   596           case 1:

   597             avipad->vids.compression = GST_MAKE_FOURCC ('W', 'M', 'V', '1');

   598             break;

   599           case 2:

   600             avipad->vids.compression = GST_MAKE_FOURCC ('W', 'M', 'V', '2');

   601             break;

   602           case 3:

   603             avipad->vids.compression = GST_MAKE_FOURCC ('W', 'M', 'V', '3');

   604           default:

   605             break;

   606         }

   607       }

   608     }

   609 

   610     if (!avipad->vids.compression)

   611       goto refuse_caps;

   612   }

   613 

   614   avipad->parent.hdr.fcc_handler = avipad->vids.compression;

   615   avipad->vids.image_size = avipad->vids.height * avipad->vids.width;

   616   /* hm, maybe why avi only handles one stream well ... */

   617   avimux->avi_hdr.width = avipad->vids.width;

   618   avimux->avi_hdr.height = avipad->vids.height;

   619   avimux->avi_hdr.us_frame = 1000000. * avipad->parent.hdr.scale /

   620       avipad->parent.hdr.rate;

   621 

   622   gst_object_unref (avimux);

   623   return TRUE;

   624 

   625 refuse_caps:

   626   {

   627     GST_WARNING_OBJECT (avimux, "refused caps %" GST_PTR_FORMAT, vscaps);

   628     gst_object_unref (avimux);

   629     return FALSE;

   630   }

   631 }

   632 

   633 static gboolean

   634 gst_avi_mux_audsink_set_caps (GstPad * pad, GstCaps * vscaps)

   635 {

   636   GstAviMux *avimux;

   637   GstAviAudioPad *avipad;

   638   GstAviCollectData *collect_pad;

   639   GstStructure *structure;

   640   const gchar *mimetype;

   641   const GValue *codec_data;

   642   gint channels, rate;

   643 

   644   avimux = GST_AVI_MUX (gst_pad_get_parent (pad));

   645 

   646   /* find stream data */

   647   collect_pad = (GstAviCollectData *) gst_pad_get_element_private (pad);

   648   g_assert (collect_pad);

   649   avipad = (GstAviAudioPad *) collect_pad->avipad;

   650   g_assert (avipad);

   651   g_assert (!avipad->parent.is_video);

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

   653 

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

   655       GST_DEBUG_PAD_NAME (pad), vscaps);

   656 

   657   structure = gst_caps_get_structure (vscaps, 0);

   658   mimetype = gst_structure_get_name (structure);

   659 

   660   /* we want these for all */

   661   if (!gst_structure_get_int (structure, "channels", &channels) ||

   662       !gst_structure_get_int (structure, "rate", &rate)) {

   663     goto refuse_caps;

   664   }

   665 

   666   avipad->auds.channels = channels;

   667   avipad->auds.rate = rate;

   668 

   669   /* codec initialization data, if any */

   670   codec_data = gst_structure_get_value (structure, "codec_data");

   671   if (codec_data) {

   672     avipad->auds_codec_data = gst_value_get_buffer (codec_data);

   673     gst_buffer_ref (avipad->auds_codec_data);

   674     /* keep global track of size */

   675     avimux->codec_data_size += GST_BUFFER_SIZE (avipad->auds_codec_data);

   676   }

   677 

   678   if (!strcmp (mimetype, "audio/x-raw-int")) {

   679     gint width, depth;

   680     gboolean signedness;

   681 

   682     avipad->auds.format = GST_RIFF_WAVE_FORMAT_PCM;

   683 

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

   685         !gst_structure_get_int (structure, "depth", &depth) ||

   686         !gst_structure_get_boolean (structure, "signed", &signedness)) {

   687       GST_DEBUG_OBJECT (avimux,

   688           "broken caps, width/depth/signed field missing");

   689       goto refuse_caps;

   690     }

   691 

   692     /* no clear place to put different values for these while keeping to spec */

   693     if (width != depth) {

   694       GST_DEBUG_OBJECT (avimux, "width must be same as depth!");

   695       goto refuse_caps;

   696     }

   697 

   698     /* because that's the way the caps will be recreated from riff data */

   699     if ((width == 8 && signedness) || (width == 16 && !signedness)) {

   700       GST_DEBUG_OBJECT (avimux,

   701           "8-bit PCM must be unsigned, 16-bit PCM signed");

   702       goto refuse_caps;

   703     }

   704 

   705     avipad->auds.blockalign = width;

   706     avipad->auds.size = (width == 8) ? 8 : depth;

   707 

   708     /* set some more info straight */

   709     avipad->auds.blockalign /= 8;

   710     avipad->auds.blockalign *= avipad->auds.channels;

   711     avipad->auds.av_bps = avipad->auds.blockalign * avipad->auds.rate;

   712   } else {

   713     avipad->auds.format = 0;

   714     /* set some defaults */

   715     avipad->auds.blockalign = 1;

   716     avipad->auds.av_bps = 0;

   717     avipad->auds.size = 16;

   718 

   719     if (!strcmp (mimetype, "audio/mpeg")) {

   720       gint mpegversion;

   721 

   722       gst_structure_get_int (structure, "mpegversion", &mpegversion);

   723       switch (mpegversion) {

   724         case 1:{

   725           gint layer = 3;

   726 

   727           gst_structure_get_int (structure, "layer", &layer);

   728           switch (layer) {

   729             case 3:

   730               avipad->auds.format = GST_RIFF_WAVE_FORMAT_MPEGL3;

   731               break;

   732             case 1:

   733             case 2:

   734               avipad->auds.format = GST_RIFF_WAVE_FORMAT_MPEGL12;

   735               break;

   736           }

   737           break;

   738         }

   739         case 4:

   740           GST_WARNING ("AAC");

   741           avipad->auds.format = GST_RIFF_WAVE_FORMAT_AAC;

   742           break;

   743       }

   744     } else if (!strcmp (mimetype, "audio/x-vorbis")) {

   745       avipad->auds.format = GST_RIFF_WAVE_FORMAT_VORBIS3;

   746     } else if (!strcmp (mimetype, "audio/x-ac3")) {

   747       avipad->auds.format = GST_RIFF_WAVE_FORMAT_A52;

   748     } else if (!strcmp (mimetype, "audio/x-alaw")) {

   749       avipad->auds.format = GST_RIFF_WAVE_FORMAT_ALAW;

   750       avipad->auds.size = 8;

   751       avipad->auds.blockalign = avipad->auds.channels;

   752       avipad->auds.av_bps = avipad->auds.blockalign * avipad->auds.rate;

   753     } else if (!strcmp (mimetype, "audio/x-mulaw")) {

   754       avipad->auds.format = GST_RIFF_WAVE_FORMAT_MULAW;

   755       avipad->auds.size = 8;

   756       avipad->auds.blockalign = avipad->auds.channels;

   757       avipad->auds.av_bps = avipad->auds.blockalign * avipad->auds.rate;

   758     } else if (!strcmp (mimetype, "audio/x-wma")) {

   759       gint version;

   760       gint bitrate;

   761       gint block_align;

   762 

   763       if (gst_structure_get_int (structure, "wmaversion", &version)) {

   764         switch (version) {

   765           case 1:

   766             avipad->auds.format = GST_RIFF_WAVE_FORMAT_WMAV1;

   767             break;

   768           case 2:

   769             avipad->auds.format = GST_RIFF_WAVE_FORMAT_WMAV2;

   770             break;

   771           default:

   772             break;

   773         }

   774       }

   775 

   776       if (avipad->auds.format != 0) {

   777         if (gst_structure_get_int (structure, "block_align", &block_align)) {

   778           avipad->auds.blockalign = block_align;

   779         }

   780         if (gst_structure_get_int (structure, "bitrate", &bitrate)) {

   781           avipad->auds.av_bps = bitrate / 8;

   782         }

   783       }

   784     }

   785   }

   786 

   787   if (!avipad->auds.format)

   788     goto refuse_caps;

   789 

   790   /* by spec, hdr.rate is av_bps related, is calculated that way in stop_file,

   791    * and reduces to sample rate in PCM like cases */

   792   avipad->parent.hdr.rate = avipad->auds.av_bps / avipad->auds.blockalign;

   793   avipad->parent.hdr.samplesize = avipad->auds.blockalign;

   794   avipad->parent.hdr.scale = 1;

   795 

   796   gst_object_unref (avimux);

   797   return TRUE;

   798 

   799 refuse_caps:

   800   {

   801     GST_WARNING_OBJECT (avimux, "refused caps %" GST_PTR_FORMAT, vscaps);

   802     gst_object_unref (avimux);

   803     return FALSE;

   804   }

   805 }

   806 

   807 

   808 static GstPad *

   809 gst_avi_mux_request_new_pad (GstElement * element,

   810     GstPadTemplate * templ, const gchar * req_name)

   811 {

   812   GstAviMux *avimux;

   813   GstPad *newpad;

   814   GstAviPad *avipad;

   815   GstElementClass *klass;

   816 

   817   g_return_val_if_fail (templ != NULL, NULL);

   818 

   819   if (templ->direction != GST_PAD_SINK)

   820     goto wrong_direction;

   821 

   822   g_return_val_if_fail (GST_IS_AVI_MUX (element), NULL);

   823   avimux = GST_AVI_MUX (element);

   824 

   825   if (!avimux->write_header)

   826     goto too_late;

   827 

   828   klass = GST_ELEMENT_GET_CLASS (element);

   829 

   830   if (templ == gst_element_class_get_pad_template (klass, "audio_%d")) {

   831     gchar *name;

   832 

   833     /* setup pad */

   834     name = g_strdup_printf ("audio_%02d", avimux->audio_pads);

   835     GST_DEBUG_OBJECT (avimux, "adding new pad: %s", name);

   836     newpad = gst_pad_new_from_template (templ, name);

   837     g_free (name);

   838     gst_pad_set_setcaps_function (newpad,

   839         GST_DEBUG_FUNCPTR (gst_avi_mux_audsink_set_caps));

   840 

   841     /* init pad specific data */

   842     avipad = g_malloc0 (sizeof (GstAviAudioPad));

   843     avipad->is_video = FALSE;

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

   845     avimux->audio_pads++;

   846     /* audio goes last */

   847     avimux->sinkpads = g_slist_append (avimux->sinkpads, avipad);

   848   } else if (templ == gst_element_class_get_pad_template (klass, "video_%d")) {

   849     /* though streams are pretty generic and relatively self-contained,

   850      * some video info goes in a single avi header -and therefore mux struct-

   851      * so video restricted to one stream */

   852     if (avimux->video_pads > 0)

   853       return NULL;

   854     /* setup pad */

   855     GST_DEBUG_OBJECT (avimux, "adding new pad: video_00");

   856     newpad = gst_pad_new_from_template (templ, "video_00");

   857     gst_pad_set_setcaps_function (newpad,

   858         GST_DEBUG_FUNCPTR (gst_avi_mux_vidsink_set_caps));

   859     avipad = g_malloc0 (sizeof (GstAviVideoPad));

   860 

   861     /* init pad specific data */

   862     avipad->is_video = TRUE;

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

   864     avimux->video_pads++;

   865     /* video goes first */

   866     avimux->sinkpads = g_slist_prepend (avimux->sinkpads, avipad);

   867   } else

   868     goto wrong_template;

   869 

   870   avipad->collect = gst_collect_pads_add_pad (avimux->collect,

   871       newpad, sizeof (GstAviCollectData));

   872   ((GstAviCollectData *) (avipad->collect))->avipad = avipad;

   873   /* FIXME: hacked way to override/extend the event function of

   874    * GstCollectPads; because it sets its own event function giving the

   875    * element no access to events */

   876   avimux->collect_event = (GstPadEventFunction) GST_PAD_EVENTFUNC (newpad);

   877   gst_pad_set_event_function (newpad,

   878       GST_DEBUG_FUNCPTR (gst_avi_mux_handle_event));

   879 

   880   gst_element_add_pad (element, newpad);

   881 

   882   return newpad;

   883 

   884   /* ERRORS */

   885 wrong_direction:

   886   {

   887     g_warning ("avimux: request pad that is not a SINK pad\n");

   888     return NULL;

   889   }

   890 too_late:

   891   {

   892     g_warning ("avimux: request pad cannot be added after streaming started\n");

   893     return NULL;

   894   }

   895 wrong_template:

   896   {

   897     g_warning ("avimuxx: this is not our template!\n");

   898     return NULL;

   899   }

   900 }

   901 

   902 static void

   903 gst_avi_mux_release_pad (GstElement * element, GstPad * pad)

   904 {

   905   GstAviMux *avimux = GST_AVI_MUX (element);

   906   GSList *node;

   907 

   908   node = avimux->sinkpads;

   909   while (node) {

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

   911 

   912     if (avipad->collect->pad == pad) {

   913       /* pad count should not be adjusted,

   914        * as it also represent number of streams present */

   915       avipad->collect = NULL;

   916       GST_DEBUG_OBJECT (avimux, "removed pad '%s'", GST_PAD_NAME (pad));

   917       gst_collect_pads_remove_pad (avimux->collect, pad);

   918       gst_element_remove_pad (element, pad);

   919       /* if not started yet, we can remove any sign this pad ever existed */

   920       /* in this case _start will take care of the real pad count */

   921       if (avimux->write_header) {

   922         avimux->sinkpads = g_slist_remove (avimux->sinkpads, avipad);

   923         gst_avi_mux_pad_reset (avipad, TRUE);

   924         g_free (avipad);

   925       }

   926       return;

   927     }

   928 

   929     node = node->next;

   930   }

   931 

   932   g_warning ("Unknown pad %s", GST_PAD_NAME (pad));

   933 }

   934 

   935 /* maybe some of these functions should be moved to riff.h? */

   936 

   937 /* DISCLAIMER: this function is fairly ugly. So be it (i.e. it makes the rest easier)

   938  * so is this struct */

   939 

   940 typedef struct _GstMarkedBuffer

   941 {

   942   guint *highmark;

   943   GstBuffer *buffer;

   944 } GstMarkedBuffer;

   945 

   946 static void

   947 gst_avi_mux_write_tag (const GstTagList * list, const gchar * tag,

   948     gpointer data)

   949 {

   950   const struct

   951   {

   952     guint32 fcc;

   953     gchar *tag;

   954   } rifftags[] = {

   955     {

   956     GST_RIFF_INFO_IARL, GST_TAG_LOCATION}, {

   957     GST_RIFF_INFO_IART, GST_TAG_ARTIST}, {

   958     GST_RIFF_INFO_ICMT, GST_TAG_COMMENT}, {

   959     GST_RIFF_INFO_ICOP, GST_TAG_COPYRIGHT}, {

   960     GST_RIFF_INFO_ICRD, GST_TAG_DATE}, {

   961     GST_RIFF_INFO_IGNR, GST_TAG_GENRE}, {

   962     GST_RIFF_INFO_IKEY, GST_TAG_KEYWORDS}, {

   963     GST_RIFF_INFO_INAM, GST_TAG_TITLE}, {

   964     GST_RIFF_INFO_ISFT, GST_TAG_ENCODER}, {

   965     GST_RIFF_INFO_ISRC, GST_TAG_ISRC}, {

   966     0, NULL}

   967   };

   968   gint n, len, plen;

   969   GstBuffer *buf = ((GstMarkedBuffer *) data)->buffer;

   970   guint *highmark = ((GstMarkedBuffer *) data)->highmark;

   971   guint8 *buffdata = GST_BUFFER_DATA (buf) + *highmark;

   972   gchar *str;

   973 

   974   for (n = 0; rifftags[n].fcc != 0; n++) {

   975     if (!strcmp (rifftags[n].tag, tag) &&

   976         gst_tag_list_get_string (list, tag, &str) && str) {

   977       len = strlen (str);

   978       plen = len + 1;

   979       if (plen & 1)

   980         plen++;

   981       if (GST_BUFFER_SIZE (buf) >= *highmark + 8 + plen) {

   982         GST_WRITE_UINT32_LE (buffdata, rifftags[n].fcc);

   983         GST_WRITE_UINT32_LE (buffdata + 4, len + 1);

   984         memcpy (buffdata + 8, str, len);

   985         buffdata[8 + len] = 0;

   986         *highmark += 8 + plen;

   987         GST_DEBUG ("writing tag in buffer %p, highmark at %d", buf, *highmark);

   988       }

   989       g_free (str);

   990       break;

   991     }

   992   }

   993 }

   994 

   995 #define ODML_SUPERINDEX_SIZE    \

   996     (32 + GST_AVI_SUPERINDEX_COUNT * sizeof (gst_avi_superindex_entry))

   997 

   998 static GstBuffer *

   999 gst_avi_mux_riff_get_avi_header (GstAviMux * avimux)

  1000 {

  1001   const GstTagList *tags;

  1002   GstBuffer *buffer;

  1003   guint8 *buffdata;

  1004   guint size = 0;

  1005   guint highmark = 0;

  1006 

  1007   /* pointer to list size field */

  1008   guint8 *riff_size, *hdrl_size;

  1009   GSList *node;

  1010 

  1011   GST_DEBUG_OBJECT (avimux, "creating avi header, data_size %u, idx_size %u",

  1012       avimux->data_size, avimux->idx_size);

  1013 

  1014   if (avimux->tags_snap)

  1015     tags = avimux->tags_snap;

  1016   else {

  1017     /* need to make snapshot of current state of tags to ensure the same set

  1018      * is used next time around during header rewrite at the end */

  1019     tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (avimux));

  1020     if (tags)

  1021       tags = avimux->tags_snap = gst_tag_list_copy (tags);

  1022   }

  1023   if (tags) {

  1024     /* that should be the strlen of all tags + header sizes

  1025      * not all of tags end up in a avi, still this is a good estimate

  1026      */

  1027     gchar *str = gst_structure_to_string (tags);

  1028     size += strlen (str) + 8 * gst_structure_n_fields (tags);

  1029     g_free (str);

  1030   }

  1031 

  1032   /* allocate the buffer, starting with some wild/safe upper bound */

  1033   size += avimux->codec_data_size + 100 + sizeof (gst_riff_avih)

  1034       + (g_slist_length (avimux->sinkpads) * (100 + sizeof (gst_riff_strh_full)

  1035           + sizeof (gst_riff_strf_vids)

  1036           + sizeof (gst_riff_vprp)

  1037           + sizeof (gst_riff_vprp_video_field_desc) * 2

  1038           + sizeof (gst_riff_strf_auds) + 2 + ODML_SUPERINDEX_SIZE));

  1039   buffer = gst_buffer_new_and_alloc (size);

  1040   buffdata = GST_BUFFER_DATA (buffer);

  1041   highmark = 0;

  1042   GST_DEBUG_OBJECT (avimux, "creating buffer %p, size %d, highmark at 0",

  1043       buffer, GST_BUFFER_SIZE (buffer));

  1044 

  1045   /* avi header metadata */

  1046   memcpy (buffdata + 0, "RIFF", 4);

  1047   /* fill in RIFF size later */

  1048   riff_size = buffdata + 4;

  1049   memcpy (buffdata + 8, "AVI ", 4);

  1050   memcpy (buffdata + 12, "LIST", 4);

  1051   /* fill in header size later */

  1052   hdrl_size = buffdata + 16;

  1053   memcpy (buffdata + 20, "hdrl", 4);

  1054   memcpy (buffdata + 24, "avih", 4);

  1055   GST_WRITE_UINT32_LE (buffdata + 28, sizeof (gst_riff_avih));

  1056   buffdata += 32;

  1057   highmark += 32;

  1058 

  1059   /* the AVI header itself */

  1060   GST_WRITE_UINT32_LE (buffdata + 0, avimux->avi_hdr.us_frame);

  1061   GST_WRITE_UINT32_LE (buffdata + 4, avimux->avi_hdr.max_bps);

  1062   GST_WRITE_UINT32_LE (buffdata + 8, avimux->avi_hdr.pad_gran);

  1063   GST_WRITE_UINT32_LE (buffdata + 12, avimux->avi_hdr.flags);

  1064   GST_WRITE_UINT32_LE (buffdata + 16, avimux->avi_hdr.tot_frames);

  1065   GST_WRITE_UINT32_LE (buffdata + 20, avimux->avi_hdr.init_frames);

  1066   GST_WRITE_UINT32_LE (buffdata + 24, avimux->avi_hdr.streams);

  1067   GST_WRITE_UINT32_LE (buffdata + 28, avimux->avi_hdr.bufsize);

  1068   GST_WRITE_UINT32_LE (buffdata + 32, avimux->avi_hdr.width);

  1069   GST_WRITE_UINT32_LE (buffdata + 36, avimux->avi_hdr.height);

  1070   GST_WRITE_UINT32_LE (buffdata + 40, avimux->avi_hdr.scale);

  1071   GST_WRITE_UINT32_LE (buffdata + 44, avimux->avi_hdr.rate);

  1072   GST_WRITE_UINT32_LE (buffdata + 48, avimux->avi_hdr.start);

  1073   GST_WRITE_UINT32_LE (buffdata + 52, avimux->avi_hdr.length);

  1074   buffdata += 56;

  1075   highmark += 56;

  1076 

  1077   /* stream data */

  1078   node = avimux->sinkpads;

  1079   while (node) {

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

  1081     GstAviVideoPad *vidpad = (GstAviVideoPad *) avipad;

  1082     GstAviAudioPad *audpad = (GstAviAudioPad *) avipad;

  1083     guint codec_size = 0, strl_size = 0, vprp_size = 0;

  1084 

  1085     if (avipad->is_video) {

  1086       if (vidpad->vids_codec_data)

  1087         codec_size = GST_BUFFER_SIZE (vidpad->vids_codec_data);

  1088       strl_size = sizeof (gst_riff_strh_full) + sizeof (gst_riff_strf_vids)

  1089           + GST_ROUND_UP_2 (codec_size) + 4 * 5 + ODML_SUPERINDEX_SIZE;

  1090       if (vidpad->vprp.aspect) {

  1091         /* let's be on the safe side */

  1092         vidpad->vprp.fields = MIN (vidpad->vprp.fields,

  1093             GST_RIFF_VPRP_VIDEO_FIELDS);

  1094         vprp_size = G_STRUCT_OFFSET (gst_riff_vprp, field_info)

  1095             + (vidpad->vprp.fields * sizeof (gst_riff_vprp_video_field_desc));

  1096         strl_size += 4 * 2 + vprp_size;

  1097       }

  1098     } else {

  1099       if (audpad->auds_codec_data)

  1100         codec_size = GST_BUFFER_SIZE (audpad->auds_codec_data);

  1101       /* +2 is codec_size field, not part of gst_riff_strf_auds */

  1102       strl_size = sizeof (gst_riff_strh_full) + sizeof (gst_riff_strf_auds) + 2

  1103           + GST_ROUND_UP_2 (codec_size) + 4 * 5 + ODML_SUPERINDEX_SIZE;

  1104     }

  1105 

  1106     /* stream list metadata */

  1107     memcpy (buffdata + 0, "LIST", 4);

  1108     GST_WRITE_UINT32_LE (buffdata + 4, strl_size);

  1109     memcpy (buffdata + 8, "strl", 4);

  1110     /* generic header */

  1111     memcpy (buffdata + 12, "strh", 4);

  1112     GST_WRITE_UINT32_LE (buffdata + 16, sizeof (gst_riff_strh_full));

  1113     /* the actual header */

  1114     GST_WRITE_UINT32_LE (buffdata + 20, avipad->hdr.type);

  1115     GST_WRITE_UINT32_LE (buffdata + 24, avipad->hdr.fcc_handler);

  1116     GST_WRITE_UINT32_LE (buffdata + 28, avipad->hdr.flags);

  1117     GST_WRITE_UINT32_LE (buffdata + 32, avipad->hdr.priority);

  1118     GST_WRITE_UINT32_LE (buffdata + 36, avipad->hdr.init_frames);

  1119     GST_WRITE_UINT32_LE (buffdata + 40, avipad->hdr.scale);

  1120     GST_WRITE_UINT32_LE (buffdata + 44, avipad->hdr.rate);

  1121     GST_WRITE_UINT32_LE (buffdata + 48, avipad->hdr.start);

  1122     GST_WRITE_UINT32_LE (buffdata + 52, avipad->hdr.length);

  1123     GST_WRITE_UINT32_LE (buffdata + 56, avipad->hdr.bufsize);

  1124     GST_WRITE_UINT32_LE (buffdata + 60, avipad->hdr.quality);

  1125     GST_WRITE_UINT32_LE (buffdata + 64, avipad->hdr.samplesize);

  1126     GST_WRITE_UINT16_LE (buffdata + 68, 0);

  1127     GST_WRITE_UINT16_LE (buffdata + 70, 0);

  1128     GST_WRITE_UINT16_LE (buffdata + 72, 0);

  1129     GST_WRITE_UINT16_LE (buffdata + 74, 0);

  1130     buffdata += 76;

  1131     highmark += 76;

  1132 

  1133     if (avipad->is_video) {

  1134       /* the video header */