gst/matroska/matroska-mux.c

   1 /* GStreamer Matroska muxer/demuxer
   2  * (c) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
   3  * (c) 2005 Michal Benes <michal.benes@xeris.cz>
   4  * (c) 2008 Sebastian Dröge <sebastian.droege@collabora.co.uk>
   5  * (c) 2011 Mark Nauwelaerts <mark.nauwelaerts@collabora.co.uk>
   6  *
   7  * matroska-mux.c: matroska file/stream muxer
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 /* TODO: - check everywhere that we don't write invalid values
  26  *       - make sure timestamps are correctly scaled everywhere
  27  */
  28
  29 /**
  30  * SECTION:element-matroskamux
  31  *
  32  * matroskamux muxes different input streams into a Matroska file.
  33  *
  34  * <refsect2>
  35  * <title>Example launch line</title>
  36  * |[
  37  * gst-launch -v filesrc location=/path/to/mp3 ! mp3parse ! matroskamux name=mux ! filesink location=test.mkv  filesrc location=/path/to/theora.ogg ! oggdemux ! theoraparse ! mux.
  38  * ]| This pipeline muxes an MP3 file and a Ogg Theora video into a Matroska file.
  39  * |[
  40  * gst-launch -v audiotestsrc num-buffers=100 ! audioconvert ! vorbisenc ! matroskamux ! filesink location=test.mka
  41  * ]| This pipeline muxes a 440Hz sine wave encoded with the Vorbis codec into a Matroska file.
  42  * </refsect2>
  43  */
  44
  45 #ifdef HAVE_CONFIG_H
  46 #include "config.h"
  47 #endif
  48
  49 #include <math.h>
  50 #include <stdio.h>
  51 #include <string.h>
  52
  53 #include <gst/audio/audio.h>
  54 #include <gst/riff/riff-media.h>
  55 #include <gst/tag/tag.h>
  56
  57 #include "matroska-mux.h"
  58 #include "matroska-ids.h"
  59
  60 GST_DEBUG_CATEGORY_STATIC (matroskamux_debug);
  61 #define GST_CAT_DEFAULT matroskamux_debug
  62
  63 enum
  64 {
  65   ARG_0,
  66   ARG_WRITING_APP,
  67   ARG_DOCTYPE_VERSION,
  68   ARG_MIN_INDEX_INTERVAL,
  69   ARG_STREAMABLE
  70 };
  71
  72 #define  DEFAULT_DOCTYPE_VERSION         2
  73 #define  DEFAULT_WRITING_APP             "GStreamer Matroska muxer"
  74 #define  DEFAULT_MIN_INDEX_INTERVAL      0
  75 #define  DEFAULT_STREAMABLE              FALSE
  76
  77 /* WAVEFORMATEX is gst_riff_strf_auds + an extra guint16 extension size */
  78 #define WAVEFORMATEX_SIZE  (2 + sizeof (gst_riff_strf_auds))
  79
  80 static GstStaticPadTemplate src_templ = GST_STATIC_PAD_TEMPLATE ("src",
  81     GST_PAD_SRC,
  82     GST_PAD_ALWAYS,
  83     GST_STATIC_CAPS ("video/x-matroska")
  84     );
  85
  86 #define COMMON_VIDEO_CAPS \
  87   "width = (int) [ 16, 4096 ], " \
  88   "height = (int) [ 16, 4096 ], " \
  89   "framerate = (fraction) [ 0, MAX ]"
  90
  91 #define COMMON_VIDEO_CAPS_NO_FRAMERATE \
  92   "width = (int) [ 16, 4096 ], " \
  93   "height = (int) [ 16, 4096 ] "
  94
  95 /* FIXME:
  96  * * require codec data, etc as needed
  97  */
  98
  99 static GstStaticPadTemplate videosink_templ =
 100     GST_STATIC_PAD_TEMPLATE ("video_%u",
 101     GST_PAD_SINK,
 102     GST_PAD_REQUEST,
 103     GST_STATIC_CAPS ("video/mpeg, "
 104         "mpegversion = (int) { 1, 2, 4 }, "
 105         "systemstream = (boolean) false, "
 106         COMMON_VIDEO_CAPS "; "
 107         "video/x-h264, stream-format=avc, alignment=au, "
 108         COMMON_VIDEO_CAPS "; "
 109         "video/x-divx, "
 110         COMMON_VIDEO_CAPS "; "
 111         "video/x-xvid, "
 112         COMMON_VIDEO_CAPS "; "
 113         "video/x-huffyuv, "
 114         COMMON_VIDEO_CAPS "; "
 115         "video/x-dv, "
 116         COMMON_VIDEO_CAPS "; "
 117         "video/x-h263, "
 118         COMMON_VIDEO_CAPS "; "
 119         "video/x-msmpeg, "
 120         COMMON_VIDEO_CAPS "; "
 121         "image/jpeg, "
 122         COMMON_VIDEO_CAPS_NO_FRAMERATE "; "
 123         "video/x-theora; "
 124         "video/x-dirac, "
 125         COMMON_VIDEO_CAPS "; "
 126         "video/x-pn-realvideo, "
 127         "rmversion = (int) [1, 4], "
 128         COMMON_VIDEO_CAPS "; "
 129         "video/x-vp8, "
 130         COMMON_VIDEO_CAPS "; "
 131         "video/x-raw, "
 132         "format = (string) { YUY2, I420, YV12, UYVY, AYUV }, "
 133         COMMON_VIDEO_CAPS "; "
 134         "video/x-wmv, " "wmvversion = (int) [ 1, 3 ], " COMMON_VIDEO_CAPS)
 135     );
 136
 137 #define COMMON_AUDIO_CAPS \
 138   "channels = (int) [ 1, MAX ], " \
 139   "rate = (int) [ 1, MAX ]"
 140
 141 /* FIXME:
 142  * * require codec data, etc as needed
 143  */
 144 static GstStaticPadTemplate audiosink_templ =
 145     GST_STATIC_PAD_TEMPLATE ("audio_%u",
 146     GST_PAD_SINK,
 147     GST_PAD_REQUEST,
 148     GST_STATIC_CAPS ("audio/mpeg, "
 149         "mpegversion = (int) 1, "
 150         "layer = (int) [ 1, 3 ], "
 151         COMMON_AUDIO_CAPS "; "
 152         "audio/mpeg, "
 153         "mpegversion = (int) { 2, 4 }, "
 154         "stream-format = (string) raw, "
 155         COMMON_AUDIO_CAPS "; "
 156         "audio/x-ac3, "
 157         COMMON_AUDIO_CAPS "; "
 158         "audio/x-eac3, "
 159         COMMON_AUDIO_CAPS "; "
 160         "audio/x-dts, "
 161         COMMON_AUDIO_CAPS "; "
 162         "audio/x-vorbis, "
 163         COMMON_AUDIO_CAPS "; "
 164         "audio/x-flac, "
 165         COMMON_AUDIO_CAPS "; "
 166         "audio/x-speex, "
 167         COMMON_AUDIO_CAPS "; "
 168         "audio/x-raw, "
 169         "format = (string) { U8, S16BE, S16LE, S24BE, S24LE, S32BE, S32LE, F32LE, F64LE }, "
 170         "layout = (string) interleaved, "
 171         COMMON_AUDIO_CAPS ";"
 172         "audio/x-tta, "
 173         "width = (int) { 8, 16, 24 }, "
 174         "channels = (int) { 1, 2 }, " "rate = (int) [ 8000, 96000 ]; "
 175         "audio/x-pn-realaudio, "
 176         "raversion = (int) { 1, 2, 8 }, " COMMON_AUDIO_CAPS "; "
 177         "audio/x-wma, " "wmaversion = (int) [ 1, 3 ], "
 178         "block_align = (int) [ 0, 65535 ], bitrate = (int) [ 0, 524288 ], "
 179         COMMON_AUDIO_CAPS ";"
 180         "audio/x-alaw, "
 181         "channels = (int) {1, 2}, " "rate = (int) [ 8000, 192000 ]; "
 182         "audio/x-mulaw, "
 183         "channels = (int) {1, 2}, " "rate = (int) [ 8000, 192000 ]")
 184     );
 185
 186 static GstStaticPadTemplate subtitlesink_templ =
 187     GST_STATIC_PAD_TEMPLATE ("subtitle_%d",
 188     GST_PAD_SINK,
 189     GST_PAD_REQUEST,
 190     GST_STATIC_CAPS ("subtitle/x-kate; "
 191         "text/plain; application/x-ssa; application/x-ass; "
 192         "application/x-usf; video/x-dvd-subpicture; "
 193         "application/x-subtitle-unknown")
 194     );
 195
 196 static GArray *used_uids;
 197 G_LOCK_DEFINE_STATIC (used_uids);
 198
 199 #define parent_class gst_matroska_mux_parent_class
 200 G_DEFINE_TYPE_WITH_CODE (GstMatroskaMux, gst_matroska_mux, GST_TYPE_ELEMENT,
 201     G_IMPLEMENT_INTERFACE (GST_TYPE_TAG_SETTER, NULL));
 202
 203 /* Matroska muxer destructor */
 204 static void gst_matroska_mux_finalize (GObject * object);
 205
 206 /* Pads collected callback */
 207 static GstFlowReturn gst_matroska_mux_handle_buffer (GstCollectPads2 * pads,
 208     GstCollectData2 * data, GstBuffer * buf, gpointer user_data);
 209 static gboolean gst_matroska_mux_handle_sink_event (GstCollectPads2 * pads,
 210     GstCollectData2 * data, GstEvent * event, gpointer user_data);
 211
 212 /* pad functions */
 213 static gboolean gst_matroska_mux_handle_src_event (GstPad * pad,
 214     GstObject * parent, GstEvent * event);
 215 static GstPad *gst_matroska_mux_request_new_pad (GstElement * element,
 216     GstPadTemplate * templ, const gchar * name, const GstCaps * caps);
 217 static void gst_matroska_mux_release_pad (GstElement * element, GstPad * pad);
 218
 219 /* gst internal change state handler */
 220 static GstStateChangeReturn
 221 gst_matroska_mux_change_state (GstElement * element, GstStateChange transition);
 222
 223 /* gobject bla bla */
 224 static void gst_matroska_mux_set_property (GObject * object,
 225     guint prop_id, const GValue * value, GParamSpec * pspec);
 226 static void gst_matroska_mux_get_property (GObject * object,
 227     guint prop_id, GValue * value, GParamSpec * pspec);
 228
 229 /* reset muxer */
 230 static void gst_matroska_mux_reset (GstElement * element);
 231
 232 /* uid generation */
 233 static guint64 gst_matroska_mux_create_uid ();
 234
 235 static gboolean theora_streamheader_to_codecdata (const GValue * streamheader,
 236     GstMatroskaTrackContext * context);
 237 static gboolean vorbis_streamheader_to_codecdata (const GValue * streamheader,
 238     GstMatroskaTrackContext * context);
 239 static gboolean speex_streamheader_to_codecdata (const GValue * streamheader,
 240     GstMatroskaTrackContext * context);
 241 static gboolean kate_streamheader_to_codecdata (const GValue * streamheader,
 242     GstMatroskaTrackContext * context);
 243 static gboolean flac_streamheader_to_codecdata (const GValue * streamheader,
 244     GstMatroskaTrackContext * context);
 245 static void
 246 gst_matroska_mux_write_simple_tag (const GstTagList * list, const gchar * tag,
 247     gpointer data);
 248
 249 static void
 250 gst_matroska_mux_class_init (GstMatroskaMuxClass * klass)
 251 {
 252   GObjectClass *gobject_class;
 253   GstElementClass *gstelement_class;
 254
 255   gobject_class = (GObjectClass *) klass;
 256   gstelement_class = (GstElementClass *) klass;
 257
 258   gst_element_class_add_pad_template (gstelement_class,
 259       gst_static_pad_template_get (&videosink_templ));
 260   gst_element_class_add_pad_template (gstelement_class,
 261       gst_static_pad_template_get (&audiosink_templ));
 262   gst_element_class_add_pad_template (gstelement_class,
 263       gst_static_pad_template_get (&subtitlesink_templ));
 264   gst_element_class_add_pad_template (gstelement_class,
 265       gst_static_pad_template_get (&src_templ));
 266   gst_element_class_set_details_simple (gstelement_class, "Matroska muxer",
 267       "Codec/Muxer",
 268       "Muxes video/audio/subtitle streams into a matroska stream",
 269       "GStreamer maintainers <gstreamer-devel@lists.sourceforge.net>");
 270
 271   GST_DEBUG_CATEGORY_INIT (matroskamux_debug, "matroskamux", 0,
 272       "Matroska muxer");
 273
 274   gobject_class->finalize = gst_matroska_mux_finalize;
 275
 276   gobject_class->get_property = gst_matroska_mux_get_property;
 277   gobject_class->set_property = gst_matroska_mux_set_property;
 278
 279   g_object_class_install_property (gobject_class, ARG_WRITING_APP,
 280       g_param_spec_string ("writing-app", "Writing application.",
 281           "The name the application that creates the matroska file.",
 282           NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 283   g_object_class_install_property (gobject_class, ARG_DOCTYPE_VERSION,
 284       g_param_spec_int ("version", "DocType version",
 285           "This parameter determines what Matroska features can be used.",
 286           1, 2, DEFAULT_DOCTYPE_VERSION,
 287           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 288   g_object_class_install_property (gobject_class, ARG_MIN_INDEX_INTERVAL,
 289       g_param_spec_int64 ("min-index-interval", "Minimum time between index "
 290           "entries", "An index entry is created every so many nanoseconds.",
 291           0, G_MAXINT64, DEFAULT_MIN_INDEX_INTERVAL,
 292           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 293   g_object_class_install_property (gobject_class, ARG_STREAMABLE,
 294       g_param_spec_boolean ("streamable", "Determines whether output should "
 295           "be streamable", "If set to true, the output should be as if it is "
 296           "to be streamed and hence no indexes written or duration written.",
 297           DEFAULT_STREAMABLE,
 298           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_STATIC_STRINGS));
 299
 300   gstelement_class->change_state =
 301       GST_DEBUG_FUNCPTR (gst_matroska_mux_change_state);
 302   gstelement_class->request_new_pad =
 303       GST_DEBUG_FUNCPTR (gst_matroska_mux_request_new_pad);
 304   gstelement_class->release_pad =
 305       GST_DEBUG_FUNCPTR (gst_matroska_mux_release_pad);
 306 }
 307
 308 /**
 309  * Start of pad option handler code
 310  */
 311 #define DEFAULT_PAD_FRAME_DURATION TRUE
 312 #define DEFAULT_PAD_FRAME_DURATION_VP8 FALSE
 313
 314 enum
 315 {
 316   PROP_PAD_0,
 317   PROP_PAD_FRAME_DURATION
 318 };
 319
 320 typedef struct
 321 {
 322   GstPad parent;
 323   gboolean frame_duration;
 324   gboolean frame_duration_user;
 325 } GstMatroskamuxPad;
 326
 327 static void gst_matroskamux_pad_class_init (GstPadClass * klass);
 328
 329 static GType
 330 gst_matroskamux_pad_get_type (void)
 331 {
 332   static GType type = 0;
 333
 334   if (G_UNLIKELY (type == 0)) {
 335     type = g_type_register_static_simple (GST_TYPE_PAD,
 336         g_intern_static_string ("GstMatroskamuxPad"), sizeof (GstPadClass),
 337         (GClassInitFunc) gst_matroskamux_pad_class_init,
 338         sizeof (GstMatroskamuxPad), NULL, 0);
 339   }
 340   return type;
 341 }
 342
 343 #define GST_TYPE_MATROSKAMUX_PAD (gst_matroskamux_pad_get_type())
 344 #define GST_MATROSKAMUX_PAD(pad) (G_TYPE_CHECK_INSTANCE_CAST((pad),GST_TYPE_MATROSKAMUX_PAD,GstMatroskamuxPad))
 345 #define GST_MATROSKAMUX_PAD_CAST(pad) ((GstMatroskamuxPad *) pad)
 346 #define GST_IS_MATROSKAMUX_PAD(pad) (G_TYPE_CHECK_INSTANCE_TYPE((pad),GST_TYPE_MATROSKAMUX_PAD))
 347
 348 static void
 349 gst_matroskamux_pad_get_property (GObject * object, guint prop_id,
 350     GValue * value, GParamSpec * pspec)
 351 {
 352   GstMatroskamuxPad *pad = GST_MATROSKAMUX_PAD (object);
 353
 354   switch (prop_id) {
 355     case PROP_PAD_FRAME_DURATION:
 356       g_value_set_boolean (value, pad->frame_duration);
 357       break;
 358     default:
 359       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 360       break;
 361   }
 362 }
 363
 364 static void
 365 gst_matroskamux_pad_set_property (GObject * object, guint prop_id,
 366     const GValue * value, GParamSpec * pspec)
 367 {
 368   GstMatroskamuxPad *pad = GST_MATROSKAMUX_PAD (object);
 369
 370   switch (prop_id) {
 371     case PROP_PAD_FRAME_DURATION:
 372       pad->frame_duration = g_value_get_boolean (value);
 373       pad->frame_duration_user = TRUE;
 374       break;
 375     default:
 376       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 377       break;
 378   }
 379 }
 380
 381 static void
 382 gst_matroskamux_pad_class_init (GstPadClass * klass)
 383 {
 384   GObjectClass *gobject_class = (GObjectClass *) klass;
 385
 386   gobject_class->set_property = gst_matroskamux_pad_set_property;
 387   gobject_class->get_property = gst_matroskamux_pad_get_property;
 388
 389   g_object_class_install_property (gobject_class, PROP_PAD_FRAME_DURATION,
 390       g_param_spec_boolean ("frame-duration", "Frame duration",
 391           "Default frame duration", DEFAULT_PAD_FRAME_DURATION,
 392           G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS));
 393 }
 394
 395 static void
 396 gst_matroskamux_pad_init (GstMatroskamuxPad * pad)
 397 {
 398   pad->frame_duration = DEFAULT_PAD_FRAME_DURATION;
 399   pad->frame_duration_user = FALSE;
 400 }
 401
 402 /*
 403  * End of pad option handler code
 404  **/
 405
 406 /**
 407  * gst_matroska_mux_init:
 408  * @mux: #GstMatroskaMux that should be initialized.
 409  * @g_class: Class of the muxer.
 410  *
 411  * Matroska muxer constructor.
 412  */
 413 static void
 414 gst_matroska_mux_init (GstMatroskaMux * mux)
 415 {
 416   GstPadTemplate *templ;
 417
 418   templ =
 419       gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (mux), "src");
 420   mux->srcpad = gst_pad_new_from_template (templ, "src");
 421
 422   gst_pad_set_event_function (mux->srcpad, gst_matroska_mux_handle_src_event);
 423   gst_element_add_pad (GST_ELEMENT (mux), mux->srcpad);
 424
 425   mux->collect = gst_collect_pads2_new ();
 426   gst_collect_pads2_set_clip_function (mux->collect,
 427       GST_DEBUG_FUNCPTR (gst_collect_pads2_clip_running_time), mux);
 428   gst_collect_pads2_set_buffer_function (mux->collect,
 429       GST_DEBUG_FUNCPTR (gst_matroska_mux_handle_buffer), mux);
 430   gst_collect_pads2_set_event_function (mux->collect,
 431       GST_DEBUG_FUNCPTR (gst_matroska_mux_handle_sink_event), mux);
 432
 433   mux->ebml_write = gst_ebml_write_new (mux->srcpad);
 434   mux->doctype = GST_MATROSKA_DOCTYPE_MATROSKA;
 435
 436   /* property defaults */
 437   mux->doctype_version = DEFAULT_DOCTYPE_VERSION;
 438   mux->writing_app = g_strdup (DEFAULT_WRITING_APP);
 439   mux->min_index_interval = DEFAULT_MIN_INDEX_INTERVAL;
 440   mux->streamable = DEFAULT_STREAMABLE;
 441
 442   /* initialize internal variables */
 443   mux->index = NULL;
 444   mux->num_streams = 0;
 445   mux->num_a_streams = 0;
 446   mux->num_t_streams = 0;
 447   mux->num_v_streams = 0;
 448
 449   /* initialize remaining variables */
 450   gst_matroska_mux_reset (GST_ELEMENT (mux));
 451 }
 452
 453
 454 /**
 455  * gst_matroska_mux_finalize:
 456  * @object: #GstMatroskaMux that should be finalized.
 457  *
 458  * Finalize matroska muxer.
 459  */
 460 static void
 461 gst_matroska_mux_finalize (GObject * object)
 462 {
 463   GstMatroskaMux *mux = GST_MATROSKA_MUX (object);
 464
 465   gst_event_replace (&mux->force_key_unit_event, NULL);
 466
 467   gst_object_unref (mux->collect);
 468   gst_object_unref (mux->ebml_write);
 469   if (mux->writing_app)
 470     g_free (mux->writing_app);
 471
 472   G_OBJECT_CLASS (parent_class)->finalize (object);
 473 }
 474
 475
 476 /**
 477  * gst_matroska_mux_create_uid:
 478  *
 479  * Generate new unused track UID.
 480  *
 481  * Returns: New track UID.
 482  */
 483 static guint64
 484 gst_matroska_mux_create_uid (void)
 485 {
 486   guint64 uid = 0;
 487
 488   G_LOCK (used_uids);
 489
 490   if (!used_uids)
 491     used_uids = g_array_sized_new (FALSE, FALSE, sizeof (guint64), 10);
 492
 493   while (!uid) {
 494     guint i;
 495
 496     uid = (((guint64) g_random_int ()) << 32) | g_random_int ();
 497     for (i = 0; i < used_uids->len; i++) {
 498       if (g_array_index (used_uids, guint64, i) == uid) {
 499         uid = 0;
 500         break;
 501       }
 502     }
 503     g_array_append_val (used_uids, uid);
 504   }
 505
 506   G_UNLOCK (used_uids);
 507   return uid;
 508 }
 509
 510
 511 /**
 512  * gst_matroska_pad_reset:
 513  * @collect_pad: the #GstMatroskaPad
 514  *
 515  * Reset and/or release resources of a matroska collect pad.
 516  */
 517 static void
 518 gst_matroska_pad_reset (GstMatroskaPad * collect_pad, gboolean full)
 519 {
 520   gchar *name = NULL;
 521   GstMatroskaTrackType type = 0;
 522
 523   /* free track information */
 524   if (collect_pad->track != NULL) {
 525     /* retrieve for optional later use */
 526     name = collect_pad->track->name;
 527     type = collect_pad->track->type;
 528     /* extra for video */
 529     if (type == GST_MATROSKA_TRACK_TYPE_VIDEO) {
 530       GstMatroskaTrackVideoContext *ctx =
 531           (GstMatroskaTrackVideoContext *) collect_pad->track;
 532
 533       if (ctx->dirac_unit) {
 534         gst_buffer_unref (ctx->dirac_unit);
 535         ctx->dirac_unit = NULL;
 536       }
 537     }
 538     g_free (collect_pad->track->codec_id);
 539     g_free (collect_pad->track->codec_name);
 540     if (full)
 541       g_free (collect_pad->track->name);
 542     g_free (collect_pad->track->language);
 543     g_free (collect_pad->track->codec_priv);
 544     g_free (collect_pad->track);
 545     collect_pad->track = NULL;
 546   }
 547
 548   if (!full && type != 0) {
 549     GstMatroskaTrackContext *context;
 550
 551     /* create a fresh context */
 552     switch (type) {
 553       case GST_MATROSKA_TRACK_TYPE_VIDEO:
 554         context = (GstMatroskaTrackContext *)
 555             g_new0 (GstMatroskaTrackVideoContext, 1);
 556         break;
 557       case GST_MATROSKA_TRACK_TYPE_AUDIO:
 558         context = (GstMatroskaTrackContext *)
 559             g_new0 (GstMatroskaTrackAudioContext, 1);
 560         break;
 561       case GST_MATROSKA_TRACK_TYPE_SUBTITLE:
 562         context = (GstMatroskaTrackContext *)
 563             g_new0 (GstMatroskaTrackSubtitleContext, 1);
 564         break;
 565       default:
 566         g_assert_not_reached ();
 567         return;
 568     }
 569
 570     context->type = type;
 571     context->name = name;
 572     /* TODO: check default values for the context */
 573     context->flags = GST_MATROSKA_TRACK_ENABLED | GST_MATROSKA_TRACK_DEFAULT;
 574     collect_pad->track = context;
 575     collect_pad->duration = 0;
 576     collect_pad->start_ts = GST_CLOCK_TIME_NONE;
 577     collect_pad->end_ts = GST_CLOCK_TIME_NONE;
 578   }
 579 }
 580
 581 /**
 582  * gst_matroska_pad_free:
 583  * @collect_pad: the #GstMatroskaPad
 584  *
 585  * Release resources of a matroska collect pad.
 586  */
 587 static void
 588 gst_matroska_pad_free (GstPad * collect_pad)
 589 {
 590   gst_matroska_pad_reset ((GstMatroskaPad *) collect_pad, TRUE);
 591 }
 592
 593
 594 /**
 595  * gst_matroska_mux_reset:
 596  * @element: #GstMatroskaMux that should be reseted.
 597  *
 598  * Reset matroska muxer back to initial state.
 599  */
 600 static void
 601 gst_matroska_mux_reset (GstElement * element)
 602 {
 603   GstMatroskaMux *mux = GST_MATROSKA_MUX (element);
 604   GSList *walk;
 605
 606   /* reset EBML write */
 607   gst_ebml_write_reset (mux->ebml_write);
 608
 609   /* reset input */
 610   mux->state = GST_MATROSKA_MUX_STATE_START;
 611
 612   /* clean up existing streams */
 613
 614   for (walk = mux->collect->data; walk; walk = g_slist_next (walk)) {
 615     GstMatroskaPad *collect_pad;
 616
 617     collect_pad = (GstMatroskaPad *) walk->data;
 618
 619     /* reset collect pad to pristine state */
 620     gst_matroska_pad_reset (collect_pad, FALSE);
 621   }
 622
 623   /* reset indexes */
 624   mux->num_indexes = 0;
 625   g_free (mux->index);
 626   mux->index = NULL;
 627
 628   /* reset timers */
 629   mux->time_scale = GST_MSECOND;
 630   mux->max_cluster_duration = G_MAXINT16 * mux->time_scale;
 631   mux->duration = 0;
 632
 633   /* reset cluster */
 634   mux->cluster = 0;
 635   mux->cluster_time = 0;
 636   mux->cluster_pos = 0;
 637   mux->prev_cluster_size = 0;
 638
 639   /* reset tags */
 640   gst_tag_setter_reset_tags (GST_TAG_SETTER (mux));
 641 }
 642
 643 /**
 644  * gst_matroska_mux_handle_src_event:
 645  * @pad: Pad which received the event.
 646  * @event: Received event.
 647  *
 648  * handle events - copied from oggmux without understanding
 649  *
 650  * Returns: #TRUE on success.
 651  */
 652 static gboolean
 653 gst_matroska_mux_handle_src_event (GstPad * pad, GstObject * parent,
 654     GstEvent * event)
 655 {
 656   GstEventType type;
 657
 658   type = event ? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;
 659
 660   switch (type) {
 661     case GST_EVENT_SEEK:
 662       /* disable seeking for now */
 663       return FALSE;
 664     default:
 665       break;
 666   }
 667
 668   return gst_pad_event_default (pad, parent, event);
 669 }
 670
 671
 672 static void
 673 gst_matroska_mux_free_codec_priv (GstMatroskaTrackContext * context)
 674 {
 675   if (context->codec_priv != NULL) {
 676     g_free (context->codec_priv);
 677     context->codec_priv = NULL;
 678     context->codec_priv_size = 0;
 679   }
 680 }
 681
 682 static void
 683 gst_matroska_mux_build_vobsub_private (GstMatroskaTrackContext * context,
 684     const guint * clut)
 685 {
 686   gchar *clutv[17];
 687   gchar *sclut;
 688   gint i;
 689   guint32 col;
 690   gdouble y, u, v;
 691   guint8 r, g, b;
 692
 693   /* produce comma-separated list in hex format */
 694   for (i = 0; i < 16; ++i) {
 695     col = clut[i];
 696     /* replicate vobsub's slightly off RGB conversion calculation */
 697     y = (((col >> 16) & 0xff) - 16) * 255 / 219;
 698     u = ((col >> 8) & 0xff) - 128;
 699     v = (col & 0xff) - 128;
 700     r = CLAMP (1.0 * y + 1.4022 * u, 0, 255);
 701     g = CLAMP (1.0 * y - 0.3456 * u - 0.7145 * v, 0, 255);
 702     b = CLAMP (1.0 * y + 1.7710 * v, 0, 255);
 703     clutv[i] = g_strdup_printf ("%02x%02x%02x", r, g, b);
 704   }
 705   clutv[i] = NULL;
 706   sclut = g_strjoinv (",", clutv);
 707
 708   /* build codec private; only palette for now */
 709   gst_matroska_mux_free_codec_priv (context);
 710   context->codec_priv = (guint8 *) g_strdup_printf ("palette: %s", sclut);
 711   /* include terminating 0 */
 712   context->codec_priv_size = strlen ((gchar *) context->codec_priv) + 1;
 713   g_free (sclut);
 714   for (i = 0; i < 16; ++i) {
 715     g_free (clutv[i]);
 716   }
 717 }
 718
 719
 720 /**
 721  * gst_matroska_mux_handle_sink_event:
 722  * @pad: Pad which received the event.
 723  * @event: Received event.
 724  *
 725  * handle events - informational ones like tags
 726  *
 727  * Returns: #TRUE on success.
 728  */
 729 static gboolean
 730 gst_matroska_mux_handle_sink_event (GstCollectPads2 * pads,
 731     GstCollectData2 * data, GstEvent * event, gpointer user_data)
 732 {
 733   GstMatroskaPad *collect_pad;
 734   GstMatroskaTrackContext *context;
 735   GstMatroskaMux *mux;
 736   GstPad *pad;
 737   GstTagList *list;
 738   gboolean ret = FALSE;
 739
 740   mux = GST_MATROSKA_MUX (user_data);
 741   collect_pad = (GstMatroskaPad *) data;
 742   pad = data->pad;
 743   context = collect_pad->track;
 744   g_assert (context);
 745
 746   switch (GST_EVENT_TYPE (event)) {
 747     case GST_EVENT_CAPS:{
 748       GstCaps *caps;
 749
 750       collect_pad = (GstMatroskaPad *) gst_pad_get_element_private (pad);
 751       gst_event_parse_caps (event, &caps);
 752
 753       ret = collect_pad->capsfunc (pad, caps);
 754       gst_event_unref (event);
 755       event = NULL;
 756       break;
 757     }
 758     case GST_EVENT_TAG:{
 759       gchar *lang = NULL;
 760
 761       GST_DEBUG_OBJECT (mux, "received tag event");
 762       gst_event_parse_tag (event, &list);
 763
 764       /* Matroska wants ISO 639-2B code, taglist most likely contains 639-1 */
 765       if (gst_tag_list_get_string (list, GST_TAG_LANGUAGE_CODE, &lang)) {
 766         const gchar *lang_code;
 767
 768         lang_code = gst_tag_get_language_code_iso_639_2B (lang);
 769         if (lang_code) {
 770           GST_INFO_OBJECT (pad, "Setting language to '%s'", lang_code);
 771           context->language = g_strdup (lang_code);
 772         } else {
 773           GST_WARNING_OBJECT (pad, "Did not get language code for '%s'", lang);
 774         }
 775         g_free (lang);
 776       }
 777
 778       /* FIXME: what about stream-specific tags? */
 779       gst_tag_setter_merge_tags (GST_TAG_SETTER (mux), list,
 780           gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (mux)));
 781
 782       gst_event_unref (event);
 783       /* handled this, don't want collectpads to forward it downstream */
 784       event = NULL;
 785       ret = TRUE;
 786       break;
 787     }
 788     case GST_EVENT_SEGMENT:{
 789       const GstSegment *segment;
 790
 791       gst_event_parse_segment (event, &segment);
 792       if (segment->format != GST_FORMAT_TIME) {
 793         ret = FALSE;
 794       }
 795       gst_event_unref (event);
 796       event = NULL;
 797       ret = TRUE;
 798       break;
 799     }
 800     case GST_EVENT_CUSTOM_DOWNSTREAM:{
 801       const GstStructure *structure;
 802
 803       structure = gst_event_get_structure (event);
 804       if (gst_structure_has_name (structure, "GstForceKeyUnit")) {
 805         gst_event_replace (&mux->force_key_unit_event, NULL);
 806         mux->force_key_unit_event = event;
 807         event = NULL;
 808       } else if (gst_structure_has_name (structure, "application/x-gst-dvd") &&
 809           !strcmp ("dvd-spu-clut-change",
 810               gst_structure_get_string (structure, "event"))) {
 811         gchar name[16];
 812         gint i, value;
 813         guint clut[16];
 814
 815         GST_DEBUG_OBJECT (pad, "New DVD colour table received");
 816         if (context->type != GST_MATROSKA_TRACK_TYPE_SUBTITLE) {
 817           GST_DEBUG_OBJECT (pad, "... discarding");
 818           break;
 819         }
 820         /* first transform event data into table form */
 821         for (i = 0; i < 16; i++) {
 822           g_snprintf (name, sizeof (name), "clut%02d", i);
 823           if (!gst_structure_get_int (structure, name, &value)) {
 824             GST_ERROR_OBJECT (mux, "dvd-spu-clut-change event did not "
 825                 "contain %s field", name);
 826             break;
 827           }
 828           clut[i] = value;
 829         }
 830
 831         /* transform into private data for stream; text form */
 832         gst_matroska_mux_build_vobsub_private (context, clut);
 833       }
 834     }
 835       /* fall through */
 836     default:
 837       ret = gst_pad_event_default (data->pad, GST_OBJECT (mux), event);
 838       break;
 839     case GST_EVENT_EOS:
 840       gst_event_unref (event);
 841       ret = TRUE;
 842       break;
 843   }
 844
 845   return ret;
 846 }
 847
 848 static void
 849 gst_matroska_mux_set_codec_id (GstMatroskaTrackContext * context,
 850     const char *id)
 851 {
 852   g_assert (context && id);
 853   if (context->codec_id)
 854     g_free (context->codec_id);
 855   context->codec_id = g_strdup (id);
 856 }
 857
 858 /**
 859  * gst_matroska_mux_video_pad_setcaps:
 860  * @pad: Pad which got the caps.
 861  * @caps: New caps.
 862  *
 863  * Setcaps function for video sink pad.
 864  *
 865  * Returns: #TRUE on success.
 866  */
 867 static gboolean
 868 gst_matroska_mux_video_pad_setcaps (GstPad * pad, GstCaps * caps)
 869 {
 870   GstMatroskaTrackContext *context = NULL;
 871   GstMatroskaTrackVideoContext *videocontext;
 872   GstMatroskaMux *mux;
 873   GstMatroskaPad *collect_pad;
 874   GstStructure *structure;
 875   const gchar *mimetype;
 876   const GValue *value = NULL;
 877   GstBuffer *codec_buf = NULL;
 878   gint width, height, pixel_width, pixel_height;
 879   gint fps_d, fps_n;
 880   gboolean interlaced = FALSE;
 881
 882   mux = GST_MATROSKA_MUX (GST_PAD_PARENT (pad));
 883
 884   /* find context */
 885   collect_pad = (GstMatroskaPad *) gst_pad_get_element_private (pad);
 886   g_assert (collect_pad);
 887   context = collect_pad->track;
 888   g_assert (context);
 889   g_assert (context->type == GST_MATROSKA_TRACK_TYPE_VIDEO);
 890   videocontext = (GstMatroskaTrackVideoContext *) context;
 891
 892   /* gst -> matroska ID'ing */
 893   structure = gst_caps_get_structure (caps, 0);
 894
 895   mimetype = gst_structure_get_name (structure);
 896
 897   if (gst_structure_get_boolean (structure, "interlaced", &interlaced)
 898       && interlaced)
 899     context->flags |= GST_MATROSKA_VIDEOTRACK_INTERLACED;
 900
 901   if (!strcmp (mimetype, "video/x-theora")) {
 902     /* we'll extract the details later from the theora identification header */
 903     goto skip_details;
 904   }
 905
 906   /* get general properties */
 907   /* spec says it is mandatory */
 908   if (!gst_structure_get_int (structure, "width", &width) ||
 909       !gst_structure_get_int (structure, "height", &height))
 910     goto refuse_caps;
 911
 912   videocontext->pixel_width = width;
 913   videocontext->pixel_height = height;
 914
 915   /* set vp8 defaults or let user override it */
 916   if (GST_MATROSKAMUX_PAD_CAST (pad)->frame_duration_user == FALSE
 917       && (!strcmp (mimetype, "video/x-vp8")))
 918     GST_MATROSKAMUX_PAD_CAST (pad)->frame_duration =
 919         DEFAULT_PAD_FRAME_DURATION_VP8;
 920
 921   if (GST_MATROSKAMUX_PAD_CAST (pad)->frame_duration
 922       && gst_structure_get_fraction (structure, "framerate", &fps_n, &fps_d)
 923       && fps_n > 0) {
 924     context->default_duration =
 925         gst_util_uint64_scale_int (GST_SECOND, fps_d, fps_n);
 926     GST_LOG_OBJECT (pad, "default duration = %" GST_TIME_FORMAT,
 927         GST_TIME_ARGS (context->default_duration));
 928   } else {
 929     context->default_duration = 0;
 930   }
 931   if (gst_structure_get_fraction (structure, "pixel-aspect-ratio",
 932           &pixel_width, &pixel_height)) {
 933     if (pixel_width > pixel_height) {
 934       videocontext->display_width = width * pixel_width / pixel_height;
 935       videocontext->display_height = height;
 936     } else if (pixel_width < pixel_height) {
 937       videocontext->display_width = width;
 938       videocontext->display_height = height * pixel_height / pixel_width;
 939     } else {
 940       videocontext->display_width = 0;
 941       videocontext->display_height = 0;
 942     }
 943   } else {
 944     videocontext->display_width = 0;
 945     videocontext->display_height = 0;
 946   }
 947
 948 skip_details:
 949
 950   videocontext->asr_mode = GST_MATROSKA_ASPECT_RATIO_MODE_FREE;
 951   videocontext->fourcc = 0;
 952
 953   /* TODO: - check if we handle all codecs by the spec, i.e. codec private
 954    *         data and other settings
 955    *       - add new formats
 956    */
 957
 958   /* extract codec_data, may turn out needed */
 959   value = gst_structure_get_value (structure, "codec_data");
 960   if (value)
 961     codec_buf = (GstBuffer *) gst_value_get_buffer (value);
 962
 963   /* find type */
 964   if (!strcmp (mimetype, "video/x-raw")) {
 965     const gchar *fstr;
 966     gst_matroska_mux_set_codec_id (context,
 967         GST_MATROSKA_CODEC_ID_VIDEO_UNCOMPRESSED);
 968     fstr = gst_structure_get_string (structure, "format");
 969     if (fstr && strlen (fstr) == 4)
 970       videocontext->fourcc = GST_STR_FOURCC (fstr);
 971   } else if (!strcmp (mimetype, "image/jpeg")) {
 972     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_VIDEO_MJPEG);
 973   } else if (!strcmp (mimetype, "video/x-xvid") /* MS/VfW compatibility cases */
 974       ||!strcmp (mimetype, "video/x-huffyuv")
 975       || !strcmp (mimetype, "video/x-divx")
 976       || !strcmp (mimetype, "video/x-dv")
 977       || !strcmp (mimetype, "video/x-h263")
 978       || !strcmp (mimetype, "video/x-msmpeg")
 979       || !strcmp (mimetype, "video/x-wmv")
 980       || !strcmp (mimetype, "image/jpeg")) {
 981     gst_riff_strf_vids *bih;
 982     gint size = sizeof (gst_riff_strf_vids);
 983     guint32 fourcc = 0;
 984
 985     if (!strcmp (mimetype, "video/x-xvid"))
 986       fourcc = GST_MAKE_FOURCC ('X', 'V', 'I', 'D');
 987     else if (!strcmp (mimetype, "video/x-huffyuv"))
 988       fourcc = GST_MAKE_FOURCC ('H', 'F', 'Y', 'U');
 989     else if (!strcmp (mimetype, "video/x-dv"))
 990       fourcc = GST_MAKE_FOURCC ('D', 'V', 'S', 'D');
 991     else if (!strcmp (mimetype, "video/x-h263"))
 992       fourcc = GST_MAKE_FOURCC ('H', '2', '6', '3');
 993     else if (!strcmp (mimetype, "video/x-divx")) {
 994       gint divxversion;
 995
 996       gst_structure_get_int (structure, "divxversion", &divxversion);
 997       switch (divxversion) {
 998         case 3:
 999           fourcc = GST_MAKE_FOURCC ('D', 'I', 'V', '3');
1000           break;
1001         case 4:
1002           fourcc = GST_MAKE_FOURCC ('D', 'I', 'V', 'X');
1003           break;
1004         case 5:
1005           fourcc = GST_MAKE_FOURCC ('D', 'X', '5', '0');
1006           break;
1007       }
1008     } else if (!strcmp (mimetype, "video/x-msmpeg")) {
1009       gint msmpegversion;
1010
1011       gst_structure_get_int (structure, "msmpegversion", &msmpegversion);
1012       switch (msmpegversion) {
1013         case 41:
1014           fourcc = GST_MAKE_FOURCC ('M', 'P', 'G', '4');
1015           break;
1016         case 42:
1017           fourcc = GST_MAKE_FOURCC ('M', 'P', '4', '2');
1018           break;
1019         case 43:
1020           goto msmpeg43;
1021           break;
1022       }
1023     } else if (!strcmp (mimetype, "video/x-wmv")) {
1024       gint wmvversion;
1025       const gchar *fstr;
1026
1027       fstr = gst_structure_get_string (structure, "format");
1028       if (fstr && strlen (fstr) == 4) {
1029         fourcc = GST_STR_FOURCC (fstr);
1030       } else if (gst_structure_get_int (structure, "wmvversion", &wmvversion)) {
1031         if (wmvversion == 2) {
1032           fourcc = GST_MAKE_FOURCC ('W', 'M', 'V', '2');
1033         } else if (wmvversion == 1) {
1034           fourcc = GST_MAKE_FOURCC ('W', 'M', 'V', '1');
1035         } else if (wmvversion == 3) {
1036           fourcc = GST_MAKE_FOURCC ('W', 'M', 'V', '3');
1037         }
1038       }
1039     } else if (!strcmp (mimetype, "image/jpeg")) {
1040       fourcc = GST_MAKE_FOURCC ('M', 'J', 'P', 'G');
1041     }
1042
1043     if (!fourcc)
1044       goto refuse_caps;
1045
1046     bih = g_new0 (gst_riff_strf_vids, 1);
1047     GST_WRITE_UINT32_LE (&bih->size, size);
1048     GST_WRITE_UINT32_LE (&bih->width, videocontext->pixel_width);
1049     GST_WRITE_UINT32_LE (&bih->height, videocontext->pixel_height);
1050     GST_WRITE_UINT32_LE (&bih->compression, fourcc);
1051     GST_WRITE_UINT16_LE (&bih->planes, (guint16) 1);
1052     GST_WRITE_UINT16_LE (&bih->bit_cnt, (guint16) 24);
1053     GST_WRITE_UINT32_LE (&bih->image_size, videocontext->pixel_width *
1054         videocontext->pixel_height * 3);
1055
1056     /* process codec private/initialization data, if any */
1057     if (codec_buf) {
1058       size += gst_buffer_get_size (codec_buf);
1059       bih = g_realloc (bih, size);
1060       GST_WRITE_UINT32_LE (&bih->size, size);
1061       gst_buffer_extract (codec_buf, 0,
1062           (guint8 *) bih + sizeof (gst_riff_strf_vids), -1);
1063     }
1064
1065     gst_matroska_mux_set_codec_id (context,
1066         GST_MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC);
1067     gst_matroska_mux_free_codec_priv (context);
1068     context->codec_priv = (gpointer) bih;
1069     context->codec_priv_size = size;
1070   } else if (!strcmp (mimetype, "video/x-h264")) {
1071     gst_matroska_mux_set_codec_id (context,
1072         GST_MATROSKA_CODEC_ID_VIDEO_MPEG4_AVC);
1073     gst_matroska_mux_free_codec_priv (context);
1074     /* Create avcC header */
1075     if (codec_buf != NULL) {
1076       context->codec_priv_size = gst_buffer_get_size (codec_buf);
1077       context->codec_priv = g_malloc0 (context->codec_priv_size);
1078       gst_buffer_extract (codec_buf, 0, context->codec_priv, -1);
1079     }
1080   } else if (!strcmp (mimetype, "video/x-theora")) {
1081     const GValue *streamheader;
1082
1083     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_VIDEO_THEORA);
1084
1085     gst_matroska_mux_free_codec_priv (context);
1086
1087     streamheader = gst_structure_get_value (structure, "streamheader");
1088     if (!theora_streamheader_to_codecdata (streamheader, context)) {
1089       GST_ELEMENT_ERROR (mux, STREAM, MUX, (NULL),
1090           ("theora stream headers missing or malformed"));
1091       goto refuse_caps;
1092     }
1093   } else if (!strcmp (mimetype, "video/x-dirac")) {
1094     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_VIDEO_DIRAC);
1095   } else if (!strcmp (mimetype, "video/x-vp8")) {
1096     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_VIDEO_VP8);
1097   } else if (!strcmp (mimetype, "video/mpeg")) {
1098     gint mpegversion;
1099
1100     gst_structure_get_int (structure, "mpegversion", &mpegversion);
1101     switch (mpegversion) {
1102       case 1:
1103         gst_matroska_mux_set_codec_id (context,
1104             GST_MATROSKA_CODEC_ID_VIDEO_MPEG1);
1105         break;
1106       case 2:
1107         gst_matroska_mux_set_codec_id (context,
1108             GST_MATROSKA_CODEC_ID_VIDEO_MPEG2);
1109         break;
1110       case 4:
1111         gst_matroska_mux_set_codec_id (context,
1112             GST_MATROSKA_CODEC_ID_VIDEO_MPEG4_ASP);
1113         break;
1114       default:
1115         goto refuse_caps;
1116     }
1117
1118     /* global headers may be in codec data */
1119     if (codec_buf != NULL) {
1120       gst_matroska_mux_free_codec_priv (context);
1121       context->codec_priv_size = gst_buffer_get_size (codec_buf);
1122       context->codec_priv = g_malloc0 (context->codec_priv_size);
1123       gst_buffer_extract (codec_buf, 0, context->codec_priv, -1);
1124     }
1125   } else if (!strcmp (mimetype, "video/x-msmpeg")) {
1126   msmpeg43:
1127     /* can only make it here if preceding case verified it was version 3 */
1128     context->codec_id = g_strdup (GST_MATROSKA_CODEC_ID_VIDEO_MSMPEG4V3);
1129   } else if (!strcmp (mimetype, "video/x-pn-realvideo")) {
1130     gint rmversion;
1131     const GValue *mdpr_data;
1132
1133     gst_structure_get_int (structure, "rmversion", &rmversion);
1134     switch (rmversion) {
1135       case 1:
1136         gst_matroska_mux_set_codec_id (context,
1137             GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO1);
1138         break;
1139       case 2:
1140         gst_matroska_mux_set_codec_id (context,
1141             GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO2);
1142         break;
1143       case 3:
1144         gst_matroska_mux_set_codec_id (context,
1145             GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO3);
1146         break;
1147       case 4:
1148         gst_matroska_mux_set_codec_id (context,
1149             GST_MATROSKA_CODEC_ID_VIDEO_REALVIDEO4);
1150         break;
1151       default:
1152         goto refuse_caps;
1153     }
1154
1155     mdpr_data = gst_structure_get_value (structure, "mdpr_data");
1156     if (mdpr_data != NULL) {
1157       guint8 *priv_data = NULL;
1158       guint priv_data_size = 0;
1159
1160       GstBuffer *codec_data_buf = g_value_peek_pointer (mdpr_data);
1161
1162       priv_data_size = gst_buffer_get_size (codec_data_buf);
1163       priv_data = g_malloc0 (priv_data_size);
1164
1165       gst_buffer_extract (codec_data_buf, 0, priv_data, -1);
1166
1167       gst_matroska_mux_free_codec_priv (context);
1168       context->codec_priv = priv_data;
1169       context->codec_priv_size = priv_data_size;
1170     }
1171   }
1172
1173   return TRUE;
1174
1175   /* ERRORS */
1176 refuse_caps:
1177   {
1178     GST_WARNING_OBJECT (mux, "pad %s refused caps %" GST_PTR_FORMAT,
1179         GST_PAD_NAME (pad), caps);
1180     return FALSE;
1181   }
1182 }
1183
1184 /* N > 0 to expect a particular number of headers, negative if the
1185    number of headers is variable */
1186 static gboolean
1187 xiphN_streamheader_to_codecdata (const GValue * streamheader,
1188     GstMatroskaTrackContext * context, GstBuffer ** p_buf0, int N)
1189 {
1190   GstBuffer **buf = NULL;
1191   GArray *bufarr;
1192   guint8 *priv_data;
1193   guint bufi, i, offset, priv_data_size;
1194
1195   if (streamheader == NULL)
1196     goto no_stream_headers;
1197
1198   if (G_VALUE_TYPE (streamheader) != GST_TYPE_ARRAY)
1199     goto wrong_type;
1200
1201   bufarr = g_value_peek_pointer (streamheader);
1202   if (bufarr->len <= 0 || bufarr->len > 255)    /* at least one header, and count stored in a byte */
1203     goto wrong_count;
1204   if (N > 0 && bufarr->len != N)
1205     goto wrong_count;
1206
1207   context->xiph_headers_to_skip = bufarr->len;
1208
1209   buf = (GstBuffer **) g_malloc0 (sizeof (GstBuffer *) * bufarr->len);
1210   for (i = 0; i < bufarr->len; i++) {
1211     GValue *bufval = &g_array_index (bufarr, GValue, i);
1212
1213     if (G_VALUE_TYPE (bufval) != GST_TYPE_BUFFER) {
1214       g_free (buf);
1215       goto wrong_content_type;
1216     }
1217
1218     buf[i] = g_value_peek_pointer (bufval);
1219   }
1220
1221   priv_data_size = 1;
1222   if (bufarr->len > 0) {
1223     for (i = 0; i < bufarr->len - 1; i++) {
1224       priv_data_size += gst_buffer_get_size (buf[i]) / 0xff + 1;
1225     }
1226   }
1227
1228   for (i = 0; i < bufarr->len; ++i) {
1229     priv_data_size += gst_buffer_get_size (buf[i]);
1230   }
1231
1232   priv_data = g_malloc0 (priv_data_size);
1233
1234   priv_data[0] = bufarr->len - 1;
1235   offset = 1;
1236
1237   if (bufarr->len > 0) {
1238     for (bufi = 0; bufi < bufarr->len - 1; bufi++) {
1239       for (i = 0; i < gst_buffer_get_size (buf[bufi]) / 0xff; ++i) {
1240         priv_data[offset++] = 0xff;
1241       }
1242       priv_data[offset++] = gst_buffer_get_size (buf[bufi]) % 0xff;
1243     }
1244   }
1245
1246   for (i = 0; i < bufarr->len; ++i) {
1247     gst_buffer_extract (buf[i], 0, priv_data + offset, -1);
1248     offset += gst_buffer_get_size (buf[i]);
1249   }
1250
1251   gst_matroska_mux_free_codec_priv (context);
1252   context->codec_priv = priv_data;
1253   context->codec_priv_size = priv_data_size;
1254
1255   if (p_buf0)
1256     *p_buf0 = gst_buffer_ref (buf[0]);
1257
1258   g_free (buf);
1259
1260   return TRUE;
1261
1262 /* ERRORS */
1263 no_stream_headers:
1264   {
1265     GST_WARNING ("required streamheaders missing in sink caps!");
1266     return FALSE;
1267   }
1268 wrong_type:
1269   {
1270     GST_WARNING ("streamheaders are not a GST_TYPE_ARRAY, but a %s",
1271         G_VALUE_TYPE_NAME (streamheader));
1272     return FALSE;
1273   }
1274 wrong_count:
1275   {
1276     GST_WARNING ("got %u streamheaders, not %d as expected", bufarr->len, N);
1277     return FALSE;
1278   }
1279 wrong_content_type:
1280   {
1281     GST_WARNING ("streamheaders array does not contain GstBuffers");
1282     return FALSE;
1283   }
1284 }
1285
1286 static gboolean
1287 vorbis_streamheader_to_codecdata (const GValue * streamheader,
1288     GstMatroskaTrackContext * context)
1289 {
1290   GstBuffer *buf0 = NULL;
1291
1292   if (!xiphN_streamheader_to_codecdata (streamheader, context, &buf0, 3))
1293     return FALSE;
1294
1295   if (buf0 == NULL || gst_buffer_get_size (buf0) < 1 + 6 + 4) {
1296     GST_WARNING ("First vorbis header too small, ignoring");
1297   } else {
1298     if (gst_buffer_memcmp (buf0, 1, "vorbis", 6) == 0) {
1299       GstMatroskaTrackAudioContext *audiocontext;
1300       GstMapInfo map;
1301       guint8 *hdr;
1302
1303       gst_buffer_map (buf0, &map, GST_MAP_READ);
1304       hdr = map.data + 1 + 6 + 4;
1305       audiocontext = (GstMatroskaTrackAudioContext *) context;
1306       audiocontext->channels = GST_READ_UINT8 (hdr);
1307       audiocontext->samplerate = GST_READ_UINT32_LE (hdr + 1);
1308       gst_buffer_unmap (buf0, &map);
1309     }
1310   }
1311
1312   if (buf0)
1313     gst_buffer_unref (buf0);
1314
1315   return TRUE;
1316 }
1317
1318 static gboolean
1319 theora_streamheader_to_codecdata (const GValue * streamheader,
1320     GstMatroskaTrackContext * context)
1321 {
1322   GstBuffer *buf0 = NULL;
1323
1324   if (!xiphN_streamheader_to_codecdata (streamheader, context, &buf0, 3))
1325     return FALSE;
1326
1327   if (buf0 == NULL || gst_buffer_get_size (buf0) < 1 + 6 + 26) {
1328     GST_WARNING ("First theora header too small, ignoring");
1329   } else if (gst_buffer_memcmp (buf0, 0, "\200theora\003\002", 9) != 0) {
1330     GST_WARNING ("First header not a theora identification header, ignoring");
1331   } else {
1332     GstMatroskaTrackVideoContext *videocontext;
1333     guint fps_num, fps_denom, par_num, par_denom;
1334     GstMapInfo map;
1335     guint8 *hdr;
1336
1337     gst_buffer_map (buf0, &map, GST_MAP_READ);
1338     hdr = map.data + 1 + 6 + 3 + 2 + 2;
1339
1340     videocontext = (GstMatroskaTrackVideoContext *) context;
1341     videocontext->pixel_width = GST_READ_UINT32_BE (hdr) >> 8;
1342     videocontext->pixel_height = GST_READ_UINT32_BE (hdr + 3) >> 8;
1343     hdr += 3 + 3 + 1 + 1;
1344     fps_num = GST_READ_UINT32_BE (hdr);
1345     fps_denom = GST_READ_UINT32_BE (hdr + 4);
1346     context->default_duration = gst_util_uint64_scale_int (GST_SECOND,
1347         fps_denom, fps_num);
1348     hdr += 4 + 4;
1349     par_num = GST_READ_UINT32_BE (hdr) >> 8;
1350     par_denom = GST_READ_UINT32_BE (hdr + 3) >> 8;
1351     if (par_num > 0 && par_num > 0) {
1352       if (par_num > par_denom) {
1353         videocontext->display_width =
1354             videocontext->pixel_width * par_num / par_denom;
1355         videocontext->display_height = videocontext->pixel_height;
1356       } else if (par_num < par_denom) {
1357         videocontext->display_width = videocontext->pixel_width;
1358         videocontext->display_height =
1359             videocontext->pixel_height * par_denom / par_num;
1360       } else {
1361         videocontext->display_width = 0;
1362         videocontext->display_height = 0;
1363       }
1364     } else {
1365       videocontext->display_width = 0;
1366       videocontext->display_height = 0;
1367     }
1368     hdr += 3 + 3;
1369
1370     gst_buffer_unmap (buf0, &map);
1371   }
1372
1373   if (buf0)
1374     gst_buffer_unref (buf0);
1375
1376   return TRUE;
1377 }
1378
1379 static gboolean
1380 kate_streamheader_to_codecdata (const GValue * streamheader,
1381     GstMatroskaTrackContext * context)
1382 {
1383   GstBuffer *buf0 = NULL;
1384
1385   if (!xiphN_streamheader_to_codecdata (streamheader, context, &buf0, -1))
1386     return FALSE;
1387
1388   if (buf0 == NULL || gst_buffer_get_size (buf0) < 64) {        /* Kate ID header is 64 bytes */
1389     GST_WARNING ("First kate header too small, ignoring");
1390   } else if (gst_buffer_memcmp (buf0, 0, "\200kate\0\0\0", 8) != 0) {
1391     GST_WARNING ("First header not a kate identification header, ignoring");
1392   }
1393
1394   if (buf0)
1395     gst_buffer_unref (buf0);
1396
1397   return TRUE;
1398 }
1399
1400 static gboolean
1401 flac_streamheader_to_codecdata (const GValue * streamheader,
1402     GstMatroskaTrackContext * context)
1403 {
1404   GArray *bufarr;
1405   gint i;
1406   GValue *bufval;
1407   GstBuffer *buffer;
1408
1409   if (streamheader == NULL || G_VALUE_TYPE (streamheader) != GST_TYPE_ARRAY) {
1410     GST_WARNING ("No or invalid streamheader field in the caps");
1411     return FALSE;
1412   }
1413
1414   bufarr = g_value_peek_pointer (streamheader);
1415   if (bufarr->len < 2) {
1416     GST_WARNING ("Too few headers in streamheader field");
1417     return FALSE;
1418   }
1419
1420   context->xiph_headers_to_skip = bufarr->len + 1;
1421
1422   bufval = &g_array_index (bufarr, GValue, 0);
1423   if (G_VALUE_TYPE (bufval) != GST_TYPE_BUFFER) {
1424     GST_WARNING ("streamheaders array does not contain GstBuffers");
1425     return FALSE;
1426   }
1427
1428   buffer = g_value_peek_pointer (bufval);
1429
1430   /* Need at least OggFLAC mapping header, fLaC marker and STREAMINFO block */
1431   if (gst_buffer_get_size (buffer) < 9 + 4 + 4 + 34
1432       || gst_buffer_memcmp (buffer, 1, "FLAC", 4) != 0
1433       || gst_buffer_memcmp (buffer, 9, "fLaC", 4) != 0) {
1434     GST_WARNING ("Invalid streamheader for FLAC");
1435     return FALSE;
1436   }
1437
1438   gst_matroska_mux_free_codec_priv (context);
1439   context->codec_priv_size = gst_buffer_get_size (buffer) - 9;
1440   context->codec_priv = g_malloc (context->codec_priv_size);
1441   gst_buffer_extract (buffer, 9, context->codec_priv, -1);
1442
1443   for (i = 1; i < bufarr->len; i++) {
1444     guint old_size;
1445     bufval = &g_array_index (bufarr, GValue, i);
1446
1447     if (G_VALUE_TYPE (bufval) != GST_TYPE_BUFFER) {
1448       gst_matroska_mux_free_codec_priv (context);
1449       GST_WARNING ("streamheaders array does not contain GstBuffers");
1450       return FALSE;
1451     }
1452
1453     buffer = g_value_peek_pointer (bufval);
1454
1455     old_size = context->codec_priv_size;
1456     context->codec_priv_size += gst_buffer_get_size (buffer);
1457
1458     context->codec_priv = g_realloc (context->codec_priv,
1459         context->codec_priv_size);
1460     gst_buffer_extract (buffer, 0,
1461         (guint8 *) context->codec_priv + old_size, -1);
1462   }
1463
1464   return TRUE;
1465 }
1466
1467 static gboolean
1468 speex_streamheader_to_codecdata (const GValue * streamheader,
1469     GstMatroskaTrackContext * context)
1470 {
1471   GArray *bufarr;
1472   GValue *bufval;
1473   GstBuffer *buffer;
1474   guint old_size;
1475
1476   if (streamheader == NULL || G_VALUE_TYPE (streamheader) != GST_TYPE_ARRAY) {
1477     GST_WARNING ("No or invalid streamheader field in the caps");
1478     return FALSE;
1479   }
1480
1481   bufarr = g_value_peek_pointer (streamheader);
1482   if (bufarr->len != 2) {
1483     GST_WARNING ("Too few headers in streamheader field");
1484     return FALSE;
1485   }
1486
1487   context->xiph_headers_to_skip = bufarr->len + 1;
1488
1489   bufval = &g_array_index (bufarr, GValue, 0);
1490   if (G_VALUE_TYPE (bufval) != GST_TYPE_BUFFER) {
1491     GST_WARNING ("streamheaders array does not contain GstBuffers");
1492     return FALSE;
1493   }
1494
1495   buffer = g_value_peek_pointer (bufval);
1496
1497   if (gst_buffer_get_size (buffer) < 80
1498       || gst_buffer_memcmp (buffer, 0, "Speex   ", 8) != 0) {
1499     GST_WARNING ("Invalid streamheader for Speex");
1500     return FALSE;
1501   }
1502
1503   gst_matroska_mux_free_codec_priv (context);
1504   context->codec_priv_size = gst_buffer_get_size (buffer);
1505   context->codec_priv = g_malloc (context->codec_priv_size);
1506   gst_buffer_extract (buffer, 0, context->codec_priv, -1);
1507
1508   bufval = &g_array_index (bufarr, GValue, 1);
1509
1510   if (G_VALUE_TYPE (bufval) != GST_TYPE_BUFFER) {
1511     gst_matroska_mux_free_codec_priv (context);
1512     GST_WARNING ("streamheaders array does not contain GstBuffers");
1513     return FALSE;
1514   }
1515
1516   buffer = g_value_peek_pointer (bufval);
1517
1518   old_size = context->codec_priv_size;
1519   context->codec_priv_size += gst_buffer_get_size (buffer);
1520   context->codec_priv = g_realloc (context->codec_priv,
1521       context->codec_priv_size);
1522   gst_buffer_extract (buffer, 0, (guint8 *) context->codec_priv + old_size, -1);
1523
1524   return TRUE;
1525 }
1526
1527 static const gchar *
1528 aac_codec_data_to_codec_id (GstBuffer * buf)
1529 {
1530   const gchar *result;
1531   guint8 profile;
1532
1533   /* default to MAIN */
1534   profile = 1;
1535
1536   if (gst_buffer_get_size (buf) >= 2) {
1537     gst_buffer_extract (buf, 0, &profile, 1);
1538     profile >>= 3;
1539   }
1540
1541   switch (profile) {
1542     case 1:
1543       result = "MAIN";
1544       break;
1545     case 2:
1546       result = "LC";
1547       break;
1548     case 3:
1549       result = "SSR";
1550       break;
1551     case 4:
1552       result = "LTP";
1553       break;
1554     default:
1555       GST_WARNING ("unknown AAC profile, defaulting to MAIN");
1556       result = "MAIN";
1557       break;
1558   }
1559
1560   return result;
1561 }
1562
1563 /**
1564  * gst_matroska_mux_audio_pad_setcaps:
1565  * @pad: Pad which got the caps.
1566  * @caps: New caps.
1567  *
1568  * Setcaps function for audio sink pad.
1569  *
1570  * Returns: #TRUE on success.
1571  */
1572 static gboolean
1573 gst_matroska_mux_audio_pad_setcaps (GstPad * pad, GstCaps * caps)
1574 {
1575   GstMatroskaTrackContext *context = NULL;
1576   GstMatroskaTrackAudioContext *audiocontext;
1577   GstMatroskaMux *mux;
1578   GstMatroskaPad *collect_pad;
1579   const gchar *mimetype;
1580   gint samplerate = 0, channels = 0;
1581   GstStructure *structure;
1582   const GValue *codec_data = NULL;
1583   GstBuffer *buf = NULL;
1584   const gchar *stream_format = NULL;
1585
1586   mux = GST_MATROSKA_MUX (GST_PAD_PARENT (pad));
1587
1588   /* find context */
1589   collect_pad = (GstMatroskaPad *) gst_pad_get_element_private (pad);
1590   g_assert (collect_pad);
1591   context = collect_pad->track;
1592   g_assert (context);
1593   g_assert (context->type == GST_MATROSKA_TRACK_TYPE_AUDIO);
1594   audiocontext = (GstMatroskaTrackAudioContext *) context;
1595
1596   structure = gst_caps_get_structure (caps, 0);
1597   mimetype = gst_structure_get_name (structure);
1598
1599   /* general setup */
1600   gst_structure_get_int (structure, "rate", &samplerate);
1601   gst_structure_get_int (structure, "channels", &channels);
1602
1603   audiocontext->samplerate = samplerate;
1604   audiocontext->channels = channels;
1605   audiocontext->bitdepth = 0;
1606   context->default_duration = 0;
1607
1608   codec_data = gst_structure_get_value (structure, "codec_data");
1609   if (codec_data)
1610     buf = gst_value_get_buffer (codec_data);
1611
1612   /* TODO: - check if we handle all codecs by the spec, i.e. codec private
1613    *         data and other settings
1614    *       - add new formats
1615    */
1616
1617   if (!strcmp (mimetype, "audio/mpeg")) {
1618     gint mpegversion = 0;
1619
1620     gst_structure_get_int (structure, "mpegversion", &mpegversion);
1621     switch (mpegversion) {
1622       case 1:{
1623         gint layer;
1624         gint version = 1;
1625         gint spf;
1626
1627         gst_structure_get_int (structure, "layer", &layer);
1628
1629         if (!gst_structure_get_int (structure, "mpegaudioversion", &version)) {
1630           GST_WARNING_OBJECT (mux,
1631               "Unable to determine MPEG audio version, assuming 1");
1632           version = 1;
1633         }
1634
1635         if (layer == 1)
1636           spf = 384;
1637         else if (layer == 2)
1638           spf = 1152;
1639         else if (version == 2)
1640           spf = 576;
1641         else
1642           spf = 1152;
1643
1644         context->default_duration =
1645             gst_util_uint64_scale (GST_SECOND, spf, audiocontext->samplerate);
1646
1647         switch (layer) {
1648           case 1:
1649             gst_matroska_mux_set_codec_id (context,
1650                 GST_MATROSKA_CODEC_ID_AUDIO_MPEG1_L1);
1651             break;
1652           case 2:
1653             gst_matroska_mux_set_codec_id (context,
1654                 GST_MATROSKA_CODEC_ID_AUDIO_MPEG1_L2);
1655             break;
1656           case 3:
1657             gst_matroska_mux_set_codec_id (context,
1658                 GST_MATROSKA_CODEC_ID_AUDIO_MPEG1_L3);
1659             break;
1660           default:
1661             goto refuse_caps;
1662         }
1663         break;
1664       }
1665       case 2:
1666       case 4:
1667         stream_format = gst_structure_get_string (structure, "stream-format");
1668         /* check this is raw aac */
1669         if (stream_format) {
1670           if (strcmp (stream_format, "raw") != 0) {
1671             GST_WARNING_OBJECT (mux, "AAC stream-format must be 'raw', not %s",
1672                 stream_format);
1673           }
1674         } else {
1675           GST_WARNING_OBJECT (mux, "AAC stream-format not specified, "
1676               "assuming 'raw'");
1677         }
1678
1679         if (buf) {
1680           if (mpegversion == 2)
1681             context->codec_id =
1682                 g_strdup_printf (GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG2 "%s",
1683                 aac_codec_data_to_codec_id (buf));
1684           else if (mpegversion == 4)
1685             context->codec_id =
1686                 g_strdup_printf (GST_MATROSKA_CODEC_ID_AUDIO_AAC_MPEG4 "%s",
1687                 aac_codec_data_to_codec_id (buf));
1688           else
1689             g_assert_not_reached ();
1690         } else {
1691           GST_DEBUG_OBJECT (mux, "no AAC codec_data; not packetized");
1692           goto refuse_caps;
1693         }
1694         break;
1695       default:
1696         goto refuse_caps;
1697     }
1698   } else if (!strcmp (mimetype, "audio/x-raw")) {
1699     GstAudioInfo info;
1700
1701     gst_audio_info_init (&info);
1702     if (!gst_audio_info_from_caps (&info, caps)) {
1703       GST_DEBUG_OBJECT (mux,
1704           "broken caps, rejected by gst_audio_info_from_caps");
1705       goto refuse_caps;
1706     }
1707
1708     switch (GST_AUDIO_INFO_FORMAT (&info)) {
1709       case GST_AUDIO_FORMAT_U8:
1710       case GST_AUDIO_FORMAT_S16BE:
1711       case GST_AUDIO_FORMAT_S16LE:
1712       case GST_AUDIO_FORMAT_S24BE:
1713       case GST_AUDIO_FORMAT_S24LE:
1714       case GST_AUDIO_FORMAT_S32BE:
1715       case GST_AUDIO_FORMAT_S32LE:
1716         if (GST_AUDIO_INFO_WIDTH (&info) != GST_AUDIO_INFO_DEPTH (&info)) {
1717           GST_DEBUG_OBJECT (mux, "width must be same as depth!");
1718           goto refuse_caps;
1719         }
1720         if (GST_AUDIO_INFO_IS_BIG_ENDIAN (&info))
1721           gst_matroska_mux_set_codec_id (context,
1722               GST_MATROSKA_CODEC_ID_AUDIO_PCM_INT_BE);
1723         else
1724           gst_matroska_mux_set_codec_id (context,
1725               GST_MATROSKA_CODEC_ID_AUDIO_PCM_INT_LE);
1726         break;
1727       case GST_AUDIO_FORMAT_F32LE:
1728       case GST_AUDIO_FORMAT_F64LE:
1729         gst_matroska_mux_set_codec_id (context,
1730             GST_MATROSKA_CODEC_ID_AUDIO_PCM_FLOAT);
1731         break;
1732
1733       default:
1734         GST_DEBUG_OBJECT (mux, "wrong format in raw audio caps");
1735         goto refuse_caps;
1736     }
1737
1738     audiocontext->bitdepth = GST_AUDIO_INFO_WIDTH (&info);
1739   } else if (!strcmp (mimetype, "audio/x-vorbis")) {
1740     const GValue *streamheader;
1741
1742     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_AUDIO_VORBIS);
1743
1744     gst_matroska_mux_free_codec_priv (context);
1745
1746     streamheader = gst_structure_get_value (structure, "streamheader");
1747     if (!vorbis_streamheader_to_codecdata (streamheader, context)) {
1748       GST_ELEMENT_ERROR (mux, STREAM, MUX, (NULL),
1749           ("vorbis stream headers missing or malformed"));
1750       goto refuse_caps;
1751     }
1752   } else if (!strcmp (mimetype, "audio/x-flac")) {
1753     const GValue *streamheader;
1754
1755     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_AUDIO_FLAC);
1756
1757     gst_matroska_mux_free_codec_priv (context);
1758
1759     streamheader = gst_structure_get_value (structure, "streamheader");
1760     if (!flac_streamheader_to_codecdata (streamheader, context)) {
1761       GST_ELEMENT_ERROR (mux, STREAM, MUX, (NULL),
1762           ("flac stream headers missing or malformed"));
1763       goto refuse_caps;
1764     }
1765   } else if (!strcmp (mimetype, "audio/x-speex")) {
1766     const GValue *streamheader;
1767
1768     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_AUDIO_SPEEX);
1769     gst_matroska_mux_free_codec_priv (context);
1770
1771     streamheader = gst_structure_get_value (structure, "streamheader");
1772     if (!speex_streamheader_to_codecdata (streamheader, context)) {
1773       GST_ELEMENT_ERROR (mux, STREAM, MUX, (NULL),
1774           ("speex stream headers missing or malformed"));
1775       goto refuse_caps;
1776     }
1777   } else if (!strcmp (mimetype, "audio/x-ac3")) {
1778     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_AUDIO_AC3);
1779   } else if (!strcmp (mimetype, "audio/x-eac3")) {
1780     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_AUDIO_EAC3);
1781   } else if (!strcmp (mimetype, "audio/x-dts")) {
1782     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_AUDIO_DTS);
1783   } else if (!strcmp (mimetype, "audio/x-tta")) {
1784     gint width;
1785
1786     /* TTA frame duration */
1787     context->default_duration = 1.04489795918367346939 * GST_SECOND;
1788
1789     gst_structure_get_int (structure, "width", &width);
1790     audiocontext->bitdepth = width;
1791     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_AUDIO_TTA);
1792
1793   } else if (!strcmp (mimetype, "audio/x-pn-realaudio")) {
1794     gint raversion;
1795     const GValue *mdpr_data;
1796
1797     gst_structure_get_int (structure, "raversion", &raversion);
1798     switch (raversion) {
1799       case 1:
1800         gst_matroska_mux_set_codec_id (context,
1801             GST_MATROSKA_CODEC_ID_AUDIO_REAL_14_4);
1802         break;
1803       case 2:
1804         gst_matroska_mux_set_codec_id (context,
1805             GST_MATROSKA_CODEC_ID_AUDIO_REAL_28_8);
1806         break;
1807       case 8:
1808         gst_matroska_mux_set_codec_id (context,
1809             GST_MATROSKA_CODEC_ID_AUDIO_REAL_COOK);
1810         break;
1811       default:
1812         goto refuse_caps;
1813     }
1814
1815     mdpr_data = gst_structure_get_value (structure, "mdpr_data");
1816     if (mdpr_data != NULL) {
1817       guint8 *priv_data = NULL;
1818       guint priv_data_size = 0;
1819
1820       GstBuffer *codec_data_buf = g_value_peek_pointer (mdpr_data);
1821
1822       priv_data_size = gst_buffer_get_size (codec_data_buf);
1823       priv_data = g_malloc0 (priv_data_size);
1824
1825       gst_buffer_extract (codec_data_buf, 0, priv_data, -1);
1826
1827       gst_matroska_mux_free_codec_priv (context);
1828
1829       context->codec_priv = priv_data;
1830       context->codec_priv_size = priv_data_size;
1831     }
1832
1833   } else if (!strcmp (mimetype, "audio/x-wma")
1834       || !strcmp (mimetype, "audio/x-alaw")
1835       || !strcmp (mimetype, "audio/x-mulaw")) {
1836     guint8 *codec_priv;
1837     guint codec_priv_size;
1838     guint16 format = 0;
1839     gint block_align;
1840     gint bitrate;
1841
1842     if (samplerate == 0 || channels == 0) {
1843       GST_WARNING_OBJECT (mux, "Missing channels/samplerate on caps");
1844       goto refuse_caps;
1845     }
1846
1847     if (!strcmp (mimetype, "audio/x-wma")) {
1848       gint wmaversion;
1849       gint depth;
1850
1851       if (!gst_structure_get_int (structure, "wmaversion", &wmaversion)
1852           || !gst_structure_get_int (structure, "block_align", &block_align)
1853           || !gst_structure_get_int (structure, "bitrate", &bitrate)) {
1854         GST_WARNING_OBJECT (mux, "Missing wmaversion/block_align/bitrate"
1855             " on WMA caps");
1856         goto refuse_caps;
1857       }
1858
1859       switch (wmaversion) {
1860         case 1:
1861           format = GST_RIFF_WAVE_FORMAT_WMAV1;
1862           break;
1863         case 2:
1864           format = GST_RIFF_WAVE_FORMAT_WMAV2;
1865           break;
1866         case 3:
1867           format = GST_RIFF_WAVE_FORMAT_WMAV3;
1868           break;
1869         default:
1870           GST_WARNING_OBJECT (mux, "Unexpected WMA version: %d", wmaversion);
1871           goto refuse_caps;
1872       }
1873
1874       if (gst_structure_get_int (structure, "depth", &depth))
1875         audiocontext->bitdepth = depth;
1876     } else if (!strcmp (mimetype, "audio/x-alaw")
1877         || !strcmp (mimetype, "audio/x-mulaw")) {
1878       audiocontext->bitdepth = 8;
1879       if (!strcmp (mimetype, "audio/x-alaw"))
1880         format = GST_RIFF_WAVE_FORMAT_ALAW;
1881       else
1882         format = GST_RIFF_WAVE_FORMAT_MULAW;
1883
1884       block_align = channels;
1885       bitrate = block_align * samplerate;
1886     }
1887     g_assert (format != 0);
1888
1889     codec_priv_size = WAVEFORMATEX_SIZE;
1890     if (buf)
1891       codec_priv_size += gst_buffer_get_size (buf);
1892
1893     /* serialize waveformatex structure */
1894     codec_priv = g_malloc0 (codec_priv_size);
1895     GST_WRITE_UINT16_LE (codec_priv, format);
1896     GST_WRITE_UINT16_LE (codec_priv + 2, channels);
1897     GST_WRITE_UINT32_LE (codec_priv + 4, samplerate);
1898     GST_WRITE_UINT32_LE (codec_priv + 8, bitrate / 8);
1899     GST_WRITE_UINT16_LE (codec_priv + 12, block_align);
1900     GST_WRITE_UINT16_LE (codec_priv + 14, 0);
1901     if (buf)
1902       GST_WRITE_UINT16_LE (codec_priv + 16, gst_buffer_get_size (buf));
1903     else
1904       GST_WRITE_UINT16_LE (codec_priv + 16, 0);
1905
1906     /* process codec private/initialization data, if any */
1907     if (buf) {
1908       gst_buffer_extract (buf, 0,
1909           (guint8 *) codec_priv + WAVEFORMATEX_SIZE, -1);
1910     }
1911
1912     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_AUDIO_ACM);
1913     gst_matroska_mux_free_codec_priv (context);
1914     context->codec_priv = (gpointer) codec_priv;
1915     context->codec_priv_size = codec_priv_size;
1916   }
1917
1918   return TRUE;
1919
1920   /* ERRORS */
1921 refuse_caps:
1922   {
1923     GST_WARNING_OBJECT (mux, "pad %s refused caps %" GST_PTR_FORMAT,
1924         GST_PAD_NAME (pad), caps);
1925     return FALSE;
1926   }
1927 }
1928
1929 /* we probably don't have the data at start,
1930  * so have to reserve (a maximum) space to write this at the end.
1931  * bit spacy, but some formats can hold quite some */
1932 #define SUBTITLE_MAX_CODEC_PRIVATE   2048       /* must be > 128 */
1933
1934 /**
1935  * gst_matroska_mux_subtitle_pad_setcaps:
1936  * @pad: Pad which got the caps.
1937  * @caps: New caps.
1938  *
1939  * Setcaps function for subtitle sink pad.
1940  *
1941  * Returns: #TRUE on success.
1942  */
1943 static gboolean
1944 gst_matroska_mux_subtitle_pad_setcaps (GstPad * pad, GstCaps * caps)
1945 {
1946   /* There is now (at least) one such alement (kateenc), and I'm going
1947      to handle it here and claim it works when it can be piped back
1948      through GStreamer and VLC */
1949
1950   GstMatroskaTrackContext *context = NULL;
1951   GstMatroskaTrackSubtitleContext *scontext;
1952   GstMatroskaMux *mux;
1953   GstMatroskaPad *collect_pad;
1954   const gchar *mimetype;
1955   GstStructure *structure;
1956   const GValue *value = NULL;
1957   GstBuffer *buf = NULL;
1958   gboolean ret = TRUE;
1959
1960   mux = GST_MATROSKA_MUX (GST_PAD_PARENT (pad));
1961
1962   /* find context */
1963   collect_pad = (GstMatroskaPad *) gst_pad_get_element_private (pad);
1964   g_assert (collect_pad);
1965   context = collect_pad->track;
1966   g_assert (context);
1967   g_assert (context->type == GST_MATROSKA_TRACK_TYPE_SUBTITLE);
1968   scontext = (GstMatroskaTrackSubtitleContext *) context;
1969
1970   structure = gst_caps_get_structure (caps, 0);
1971   mimetype = gst_structure_get_name (structure);
1972
1973   /* general setup */
1974   scontext->check_utf8 = 1;
1975   scontext->invalid_utf8 = 0;
1976   context->default_duration = 0;
1977
1978   if (!strcmp (mimetype, "subtitle/x-kate")) {
1979     const GValue *streamheader;
1980
1981     gst_matroska_mux_set_codec_id (context,
1982         GST_MATROSKA_CODEC_ID_SUBTITLE_KATE);
1983
1984     gst_matroska_mux_free_codec_priv (context);
1985
1986     streamheader = gst_structure_get_value (structure, "streamheader");
1987     if (!kate_streamheader_to_codecdata (streamheader, context)) {
1988       GST_ELEMENT_ERROR (mux, STREAM, MUX, (NULL),
1989           ("kate stream headers missing or malformed"));
1990       ret = FALSE;
1991       goto exit;
1992     }
1993   } else if (!strcmp (mimetype, "text/plain")) {
1994     gst_matroska_mux_set_codec_id (context,
1995         GST_MATROSKA_CODEC_ID_SUBTITLE_UTF8);
1996   } else if (!strcmp (mimetype, "application/x-ssa")) {
1997     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_SUBTITLE_SSA);
1998   } else if (!strcmp (mimetype, "application/x-ass")) {
1999     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_SUBTITLE_ASS);
2000   } else if (!strcmp (mimetype, "application/x-usf")) {
2001     gst_matroska_mux_set_codec_id (context, GST_MATROSKA_CODEC_ID_SUBTITLE_USF);
2002   } else if (!strcmp (mimetype, "video/x-dvd-subpicture")) {
2003     gst_matroska_mux_set_codec_id (context,
2004         GST_MATROSKA_CODEC_ID_SUBTITLE_VOBSUB);
2005   } else {
2006     ret = FALSE;
2007     goto exit;
2008   }
2009
2010   /* maybe some private data, e.g. vobsub */
2011   value = gst_structure_get_value (structure, "codec_data");
2012   if (value)
2013     buf = gst_value_get_buffer (value);
2014   if (buf != NULL) {
2015     GstMapInfo map;
2016     guint8 *priv_data = NULL;
2017
2018     gst_buffer_map (buf, &map, GST_MAP_READ);
2019
2020     if (map.size > SUBTITLE_MAX_CODEC_PRIVATE) {
2021       GST_WARNING_OBJECT (mux, "pad %" GST_PTR_FORMAT " subtitle private data"
2022           " exceeded maximum (%d); discarding", pad,
2023           SUBTITLE_MAX_CODEC_PRIVATE);
2024       gst_buffer_unmap (buf, &map);
2025       return TRUE;
2026     }
2027
2028     gst_matroska_mux_free_codec_priv (context);
2029
2030     priv_data = g_malloc0 (map.size);
2031     memcpy (priv_data, map.data, map.size);
2032     context->codec_priv = priv_data;
2033     context->codec_priv_size = map.size;
2034     gst_buffer_unmap (buf, &map);
2035   }
2036
2037   GST_DEBUG_OBJECT (pad, "codec_id %s, codec data size %" G_GSIZE_FORMAT,
2038       GST_STR_NULL (context->codec_id), context->codec_priv_size);
2039
2040 exit:
2041
2042   return ret;
2043 }
2044
2045
2046 /**
2047  * gst_matroska_mux_request_new_pad:
2048  * @element: #GstMatroskaMux.
2049  * @templ: #GstPadTemplate.
2050  * @pad_name: New pad name.
2051  *
2052  * Request pad function for sink templates.
2053  *
2054  * Returns: New #GstPad.
2055  */
2056 static GstPad *
2057 gst_matroska_mux_request_new_pad (GstElement * element,
2058     GstPadTemplate * templ, const gchar * req_name, const GstCaps * caps)
2059 {
2060   GstElementClass *klass = GST_ELEMENT_GET_CLASS (element);
2061   GstMatroskaMux *mux = GST_MATROSKA_MUX (element);
2062   GstMatroskaPad *collect_pad;
2063   GstMatroskamuxPad *newpad;
2064   gchar *name = NULL;
2065   const gchar *pad_name = NULL;
2066   GstMatroskaCapsFunc capsfunc = NULL;
2067   GstMatroskaTrackContext *context = NULL;
2068   gint pad_id;
2069   gboolean locked = TRUE;
2070   gchar *id = NULL;
2071
2072   if (templ == gst_element_class_get_pad_template (klass, "audio_%u")) {
2073     /* don't mix named and unnamed pads, if the pad already exists we fail when
2074      * trying to add it */
2075     if (req_name != NULL && sscanf (req_name, "audio_%u", &pad_id) == 1) {
2076       pad_name = req_name;
2077     } else {
2078       name = g_strdup_printf ("audio_%u", mux->num_a_streams++);
2079       pad_name = name;
2080     }
2081     capsfunc = GST_DEBUG_FUNCPTR (gst_matroska_mux_audio_pad_setcaps);
2082     context = (GstMatroskaTrackContext *)
2083         g_new0 (GstMatroskaTrackAudioContext, 1);
2084     context->type = GST_MATROSKA_TRACK_TYPE_AUDIO;
2085     context->name = g_strdup ("Audio");
2086   } else if (templ == gst_element_class_get_pad_template (klass, "video_%u")) {
2087     /* don't mix named and unnamed pads, if the pad already exists we fail when
2088      * trying to add it */
2089     if (req_name != NULL && sscanf (req_name, "video_%u", &pad_id) == 1) {
2090       pad_name = req_name;
2091     } else {
2092       name = g_strdup_printf ("video_%u", mux->num_v_streams++);
2093       pad_name = name;
2094     }
2095     capsfunc = GST_DEBUG_FUNCPTR (gst_matroska_mux_video_pad_setcaps);
2096     context = (GstMatroskaTrackContext *)
2097         g_new0 (GstMatroskaTrackVideoContext, 1);
2098     context->type = GST_MATROSKA_TRACK_TYPE_VIDEO;
2099     context->name = g_strdup ("Video");
2100   } else if (templ == gst_element_class_get_pad_template (klass, "subtitle_%u")) {
2101     /* don't mix named and unnamed pads, if the pad already exists we fail when
2102      * trying to add it */
2103     if (req_name != NULL && sscanf (req_name, "subtitle_%u", &pad_id) == 1) {
2104       pad_name = req_name;
2105     } else {
2106       name = g_strdup_printf ("subtitle_%u", mux->num_t_streams++);
2107       pad_name = name;
2108     }
2109     capsfunc = GST_DEBUG_FUNCPTR (gst_matroska_mux_subtitle_pad_setcaps);
2110     context = (GstMatroskaTrackContext *)
2111         g_new0 (GstMatroskaTrackSubtitleContext, 1);
2112     context->type = GST_MATROSKA_TRACK_TYPE_SUBTITLE;
2113     context->name = g_strdup ("Subtitle");
2114     /* setcaps may only provide proper one a lot later */
2115     id = g_strdup ("S_SUB_UNKNOWN");
2116     locked = FALSE;
2117   } else {
2118     GST_WARNING_OBJECT (mux, "This is not our template!");
2119     return NULL;
2120   }
2121
2122   newpad = g_object_new (GST_TYPE_MATROSKAMUX_PAD,
2123       "name", pad_name, "direction", templ->direction, "template", templ, NULL);
2124   g_free (name);
2125
2126   gst_matroskamux_pad_init (newpad);
2127   collect_pad = (GstMatroskaPad *)
2128       gst_collect_pads2_add_pad_full (mux->collect, GST_PAD (newpad),
2129       sizeof (GstMatroskamuxPad),
2130       (GstCollectData2DestroyNotify) gst_matroska_pad_free, locked);
2131
2132   collect_pad->track = context;
2133   gst_matroska_pad_reset (collect_pad, FALSE);
2134   collect_pad->track->codec_id = id;
2135
2136   collect_pad->capsfunc = capsfunc;
2137   gst_pad_set_active (GST_PAD (newpad), TRUE);
2138   if (!gst_element_add_pad (element, GST_PAD (newpad)))
2139     goto pad_add_failed;
2140
2141   mux->num_streams++;
2142
2143   GST_DEBUG_OBJECT (newpad, "Added new request pad");
2144
2145   return GST_PAD (newpad);
2146
2147   /* ERROR cases */
2148 pad_add_failed:
2149   {
2150     GST_WARNING_OBJECT (mux, "Adding the new pad '%s' failed", pad_name);
2151     gst_object_unref (newpad);
2152     return NULL;
2153   }
2154 }
2155
2156 /**
2157  * gst_matroska_mux_release_pad:
2158  * @element: #GstMatroskaMux.
2159  * @pad: Pad to release.
2160  *
2161  * Release a previously requested pad.
2162 */
2163 static void
2164 gst_matroska_mux_release_pad (GstElement * element, GstPad * pad)
2165 {
2166   GstMatroskaMux *mux;
2167   GSList *walk;
2168
2169   mux = GST_MATROSKA_MUX (GST_PAD_PARENT (pad));
2170
2171   for (walk = mux->collect->data; walk; walk = g_slist_next (walk)) {
2172     GstCollectData2 *cdata = (GstCollectData2 *) walk->data;
2173     GstMatroskaPad *collect_pad = (GstMatroskaPad *) cdata;
2174
2175     if (cdata->pad == pad) {
2176       GstClockTime min_dur;     /* observed minimum duration */
2177
2178       if (GST_CLOCK_TIME_IS_VALID (collect_pad->start_ts) &&
2179           GST_CLOCK_TIME_IS_VALID (collect_pad->end_ts)) {
2180         min_dur = GST_CLOCK_DIFF (collect_pad->start_ts, collect_pad->end_ts);
2181         if (collect_pad->duration < min_dur)
2182           collect_pad->duration = min_dur;
2183       }
2184
2185       if (GST_CLOCK_TIME_IS_VALID (collect_pad->duration) &&
2186           mux->duration < collect_pad->duration)
2187         mux->duration = collect_pad->duration;
2188
2189       break;
2190     }
2191   }
2192
2193   gst_collect_pads2_remove_pad (mux->collect, pad);
2194   if (gst_element_remove_pad (element, pad))
2195     mux->num_streams--;
2196 }
2197
2198
2199 /**
2200  * gst_matroska_mux_track_header:
2201  * @mux: #GstMatroskaMux
2202  * @context: Tack context.
2203  *
2204  * Write a track header.
2205  */
2206 static void
2207 gst_matroska_mux_track_header (GstMatroskaMux * mux,
2208     GstMatroskaTrackContext * context)
2209 {
2210   GstEbmlWrite *ebml = mux->ebml_write;
2211   guint64 master;
2212
2213   /* TODO: check if everything necessary is written and check default values */
2214
2215   /* track type goes before the type-specific stuff */
2216   gst_ebml_write_uint (ebml, GST_MATROSKA_ID_TRACKNUMBER, context->num);
2217   gst_ebml_write_uint (ebml, GST_MATROSKA_ID_TRACKTYPE, context->type);
2218
2219   gst_ebml_write_uint (ebml, GST_MATROSKA_ID_TRACKUID,
2220       gst_matroska_mux_create_uid ());
2221   if (context->default_duration) {
2222     gst_ebml_write_uint (ebml, GST_MATROSKA_ID_TRACKDEFAULTDURATION,
2223         context->default_duration);
2224   }
2225   if (context->language) {
2226     gst_ebml_write_utf8 (ebml, GST_MATROSKA_ID_TRACKLANGUAGE,
2227         context->language);
2228   }
2229
2230   /* FIXME: until we have a nice way of getting the codecname
2231    * out of the caps, I'm not going to enable this. Too much
2232    * (useless, double, boring) work... */
2233   /* TODO: Use value from tags if any */
2234   /*gst_ebml_write_utf8 (ebml, GST_MATROSKA_ID_CODECNAME,
2235      context->codec_name); */
2236   gst_ebml_write_utf8 (ebml, GST_MATROSKA_ID_TRACKNAME, context->name);
2237
2238   /* type-specific stuff */
2239   switch (context->type) {
2240     case GST_MATROSKA_TRACK_TYPE_VIDEO:{
2241       GstMatroskaTrackVideoContext *videocontext =
2242           (GstMatroskaTrackVideoContext *) context;
2243
2244       master = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_TRACKVIDEO);
2245       gst_ebml_write_uint (ebml, GST_MATROSKA_ID_VIDEOPIXELWIDTH,
2246           videocontext->pixel_width);
2247       gst_ebml_write_uint (ebml, GST_MATROSKA_ID_VIDEOPIXELHEIGHT,
2248           videocontext->pixel_height);
2249       if (videocontext->display_width && videocontext->display_height) {
2250         gst_ebml_write_uint (ebml, GST_MATROSKA_ID_VIDEODISPLAYWIDTH,
2251             videocontext->display_width);
2252         gst_ebml_write_uint (ebml, GST_MATROSKA_ID_VIDEODISPLAYHEIGHT,
2253             videocontext->display_height);
2254       }
2255       if (context->flags & GST_MATROSKA_VIDEOTRACK_INTERLACED)
2256         gst_ebml_write_uint (ebml, GST_MATROSKA_ID_VIDEOFLAGINTERLACED, 1);
2257       if (videocontext->fourcc) {
2258         guint32 fcc_le = GUINT32_TO_LE (videocontext->fourcc);
2259
2260         gst_ebml_write_binary (ebml, GST_MATROSKA_ID_VIDEOCOLOURSPACE,
2261             (gpointer) & fcc_le, 4);
2262       }
2263       gst_ebml_write_master_finish (ebml, master);
2264
2265       break;
2266     }
2267
2268     case GST_MATROSKA_TRACK_TYPE_AUDIO:{
2269       GstMatroskaTrackAudioContext *audiocontext =
2270           (GstMatroskaTrackAudioContext *) context;
2271
2272       master = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_TRACKAUDIO);
2273       if (audiocontext->samplerate != 8000)
2274         gst_ebml_write_float (ebml, GST_MATROSKA_ID_AUDIOSAMPLINGFREQ,
2275             audiocontext->samplerate);
2276       if (audiocontext->channels != 1)
2277         gst_ebml_write_uint (ebml, GST_MATROSKA_ID_AUDIOCHANNELS,
2278             audiocontext->channels);
2279       if (audiocontext->bitdepth) {
2280         gst_ebml_write_uint (ebml, GST_MATROSKA_ID_AUDIOBITDEPTH,
2281             audiocontext->bitdepth);
2282       }
2283       gst_ebml_write_master_finish (ebml, master);
2284
2285       break;
2286     }
2287
2288       /* this is what we write for now and must be filled
2289        * and remainder void'ed later on */
2290 #define SUBTITLE_DUMMY_SIZE   (1 + 1 + 14 + 1 + 2 + SUBTITLE_MAX_CODEC_PRIVATE)
2291
2292     case GST_MATROSKA_TRACK_TYPE_SUBTITLE:{
2293       gpointer buf;
2294
2295       context->pos = ebml->pos;
2296       /* CodecID is mandatory ... */
2297       gst_ebml_write_ascii (ebml, GST_MATROSKA_ID_CODECID, "S_SUB_UNKNOWN");
2298       /* reserve space */
2299       buf = g_malloc0 (SUBTITLE_MAX_CODEC_PRIVATE);
2300       gst_ebml_write_binary (ebml, GST_EBML_ID_VOID, buf,
2301           SUBTITLE_MAX_CODEC_PRIVATE);
2302       g_free (buf);
2303       /* real data has to be written at finish */
2304       return;
2305     }
2306     default:
2307       /* doesn't need type-specific data */
2308       break;
2309   }
2310
2311   gst_ebml_write_ascii (ebml, GST_MATROSKA_ID_CODECID, context->codec_id);
2312   if (context->codec_priv)
2313     gst_ebml_write_binary (ebml, GST_MATROSKA_ID_CODECPRIVATE,
2314         context->codec_priv, context->codec_priv_size);
2315 }
2316
2317
2318 /**
2319  * gst_matroska_mux_start:
2320  * @mux: #GstMatroskaMux
2321  *
2322  * Start a new matroska file (write headers etc...)
2323  */
2324 static void
2325 gst_matroska_mux_start (GstMatroskaMux * mux)
2326 {
2327   GstEbmlWrite *ebml = mux->ebml_write;
2328   const gchar *doctype;
2329   guint32 seekhead_id[] = { GST_MATROSKA_ID_SEGMENTINFO,
2330     GST_MATROSKA_ID_TRACKS,
2331     GST_MATROSKA_ID_CUES,
2332     GST_MATROSKA_ID_TAGS,
2333     0
2334   };
2335   guint64 master, child;
2336   GSList *collected;
2337   int i;
2338   guint tracknum = 1;
2339   GstClockTime duration = 0;
2340   guint32 segment_uid[4];
2341   GTimeVal time = { 0, 0 };
2342
2343   /* if not streaming, check if downstream is seekable */
2344   if (!mux->streamable) {
2345     gboolean seekable;
2346     GstQuery *query;
2347
2348     query = gst_query_new_seeking (GST_FORMAT_BYTES);
2349     if (gst_pad_peer_query (mux->srcpad, query)) {
2350       gst_query_parse_seeking (query, NULL, &seekable, NULL, NULL);
2351       GST_INFO_OBJECT (mux, "downstream is %sseekable", seekable ? "" : "not ");
2352     } else {
2353       /* have to assume seeking is supported if query not handled downstream */
2354       GST_WARNING_OBJECT (mux, "downstream did not handle seeking query");
2355       seekable = FALSE;
2356     }
2357     if (!seekable) {
2358       mux->streamable = TRUE;
2359       g_object_notify (G_OBJECT (mux), "streamable");
2360       GST_WARNING_OBJECT (mux, "downstream is not seekable, but "
2361           "streamable=false. Will ignore that and create streamable output "
2362           "instead");
2363     }
2364   }
2365
2366   if (!strcmp (mux->doctype, GST_MATROSKA_DOCTYPE_WEBM)) {
2367     ebml->caps = gst_caps_new_empty_simple ("video/webm");
2368   } else {
2369     ebml->caps = gst_caps_new_empty_simple ("video/x-matroska");
2370   }
2371   /* we start with a EBML header */
2372   doctype = mux->doctype;
2373   GST_INFO_OBJECT (ebml, "DocType: %s, Version: %d",
2374       doctype, mux->doctype_version);
2375   gst_ebml_write_header (ebml, doctype, mux->doctype_version);
2376
2377   /* the rest of the header is cached */
2378   gst_ebml_write_set_cache (ebml, 0x1000);
2379
2380   /* start a segment */
2381   mux->segment_pos =
2382       gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_SEGMENT);
2383   mux->segment_master = ebml->pos;
2384
2385   if (!mux->streamable) {
2386     /* seekhead (table of contents) - we set the positions later */
2387     mux->seekhead_pos = ebml->pos;
2388     master = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_SEEKHEAD);
2389     for (i = 0; seekhead_id[i] != 0; i++) {
2390       child = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_SEEKENTRY);
2391       gst_ebml_write_uint (ebml, GST_MATROSKA_ID_SEEKID, seekhead_id[i]);
2392       gst_ebml_write_uint (ebml, GST_MATROSKA_ID_SEEKPOSITION, -1);
2393       gst_ebml_write_master_finish (ebml, child);
2394     }
2395     gst_ebml_write_master_finish (ebml, master);
2396   }
2397
2398   if (mux->streamable) {
2399     const GstTagList *tags;
2400
2401     /* tags */
2402     tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (mux));
2403
2404     if (tags != NULL && !gst_tag_list_is_empty (tags)) {
2405       guint64 master_tags, master_tag;
2406
2407       GST_DEBUG_OBJECT (mux, "Writing tags");
2408
2409       /* TODO: maybe limit via the TARGETS id by looking at the source pad */
2410       mux->tags_pos = ebml->pos;
2411       master_tags = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_TAGS);
2412       master_tag = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_TAG);
2413       gst_tag_list_foreach (tags, gst_matroska_mux_write_simple_tag, ebml);
2414       gst_ebml_write_master_finish (ebml, master_tag);
2415       gst_ebml_write_master_finish (ebml, master_tags);
2416     }
2417   }
2418
2419   /* segment info */
2420   mux->info_pos = ebml->pos;
2421   master = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_SEGMENTINFO);
2422   for (i = 0; i < 4; i++) {
2423     segment_uid[i] = g_random_int ();
2424   }
2425   gst_ebml_write_binary (ebml, GST_MATROSKA_ID_SEGMENTUID,
2426       (guint8 *) segment_uid, 16);
2427   gst_ebml_write_uint (ebml, GST_MATROSKA_ID_TIMECODESCALE, mux->time_scale);
2428   mux->duration_pos = ebml->pos;
2429   /* get duration */
2430   if (!mux->streamable) {
2431     for (collected = mux->collect->data; collected;
2432         collected = g_slist_next (collected)) {
2433       GstMatroskaPad *collect_pad;
2434       GstPad *thepad;
2435       gint64 trackduration;
2436
2437       collect_pad = (GstMatroskaPad *) collected->data;
2438       thepad = collect_pad->collect.pad;
2439
2440       /* Query the total length of the track. */
2441       GST_DEBUG_OBJECT (thepad, "querying peer duration");
2442       if (gst_pad_peer_query_duration (thepad, GST_FORMAT_TIME, &trackduration)) {
2443         GST_DEBUG_OBJECT (thepad, "duration: %" GST_TIME_FORMAT,
2444             GST_TIME_ARGS (trackduration));
2445         if (trackduration != GST_CLOCK_TIME_NONE && trackduration > duration) {
2446           duration = (GstClockTime) trackduration;
2447         }
2448       }
2449     }
2450     gst_ebml_write_float (ebml, GST_MATROSKA_ID_DURATION,
2451         gst_guint64_to_gdouble (duration) /
2452         gst_guint64_to_gdouble (mux->time_scale));
2453   }
2454   gst_ebml_write_utf8 (ebml, GST_MATROSKA_ID_MUXINGAPP,
2455       "GStreamer plugin version " PACKAGE_VERSION);
2456   if (mux->writing_app && mux->writing_app[0]) {
2457     gst_ebml_write_utf8 (ebml, GST_MATROSKA_ID_WRITINGAPP, mux->writing_app);
2458   }
2459   g_get_current_time (&time);
2460   gst_ebml_write_date (ebml, GST_MATROSKA_ID_DATEUTC, time.tv_sec);
2461   gst_ebml_write_master_finish (ebml, master);
2462
2463   /* tracks */
2464   mux->tracks_pos = ebml->pos;
2465   master = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_TRACKS);
2466
2467   for (collected = mux->collect->data; collected;
2468       collected = g_slist_next (collected)) {
2469     GstMatroskaPad *collect_pad;
2470     GstPad *thepad;
2471
2472     collect_pad = (GstMatroskaPad *) collected->data;
2473     thepad = collect_pad->collect.pad;
2474
2475     if (gst_pad_is_linked (thepad) && gst_pad_is_active (thepad) &&
2476         collect_pad->track->codec_id != 0) {
2477       collect_pad->track->num = tracknum++;
2478       child = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_TRACKENTRY);
2479       gst_matroska_mux_track_header (mux, collect_pad->track);
2480       gst_ebml_write_master_finish (ebml, child);
2481       /* some remaining pad/track setup */
2482       collect_pad->default_duration_scaled =
2483           gst_util_uint64_scale (collect_pad->track->default_duration,
2484           1, mux->time_scale);
2485     }
2486   }
2487   gst_ebml_write_master_finish (ebml, master);
2488
2489   /* lastly, flush the cache */
2490   gst_ebml_write_flush_cache (ebml, FALSE, 0);
2491 }
2492
2493 static void
2494 gst_matroska_mux_write_simple_tag (const GstTagList * list, const gchar * tag,
2495     gpointer data)
2496 {
2497   /* TODO: more sensible tag mappings */
2498   static const struct
2499   {
2500     const gchar *matroska_tagname;
2501     const gchar *gstreamer_tagname;
2502   }
2503   tag_conv[] = {
2504     {
2505     GST_MATROSKA_TAG_ID_TITLE, GST_TAG_TITLE}, {
2506     GST_MATROSKA_TAG_ID_ARTIST, GST_TAG_ARTIST}, {
2507     GST_MATROSKA_TAG_ID_ALBUM, GST_TAG_ALBUM}, {
2508     GST_MATROSKA_TAG_ID_COMMENTS, GST_TAG_COMMENT}, {
2509     GST_MATROSKA_TAG_ID_BITSPS, GST_TAG_BITRATE}, {
2510     GST_MATROSKA_TAG_ID_BPS, GST_TAG_BITRATE}, {
2511     GST_MATROSKA_TAG_ID_ENCODER, GST_TAG_ENCODER}, {
2512     GST_MATROSKA_TAG_ID_DATE, GST_TAG_DATE}, {
2513     GST_MATROSKA_TAG_ID_ISRC, GST_TAG_ISRC}, {
2514     GST_MATROSKA_TAG_ID_COPYRIGHT, GST_TAG_COPYRIGHT}, {
2515     GST_MATROSKA_TAG_ID_BPM, GST_TAG_BEATS_PER_MINUTE}, {
2516     GST_MATROSKA_TAG_ID_TERMS_OF_USE, GST_TAG_LICENSE}, {
2517     GST_MATROSKA_TAG_ID_COMPOSER, GST_TAG_COMPOSER}, {
2518     GST_MATROSKA_TAG_ID_LEAD_PERFORMER, GST_TAG_PERFORMER}, {
2519     GST_MATROSKA_TAG_ID_GENRE, GST_TAG_GENRE}
2520   };
2521   GstEbmlWrite *ebml = (GstEbmlWrite *) data;
2522   guint i;
2523   guint64 simpletag_master;
2524
2525   for (i = 0; i < G_N_ELEMENTS (tag_conv); i++) {
2526     const gchar *tagname_gst = tag_conv[i].gstreamer_tagname;
2527     const gchar *tagname_mkv = tag_conv[i].matroska_tagname;
2528
2529     if (strcmp (tagname_gst, tag) == 0) {
2530       GValue src = { 0, };
2531       gchar *dest;
2532
2533       if (!gst_tag_list_copy_value (&src, list, tag))
2534         break;
2535       if ((dest = gst_value_serialize (&src))) {
2536
2537         simpletag_master = gst_ebml_write_master_start (ebml,
2538             GST_MATROSKA_ID_SIMPLETAG);
2539         gst_ebml_write_ascii (ebml, GST_MATROSKA_ID_TAGNAME, tagname_mkv);
2540         gst_ebml_write_utf8 (ebml, GST_MATROSKA_ID_TAGSTRING, dest);
2541         gst_ebml_write_master_finish (ebml, simpletag_master);
2542         g_free (dest);
2543       } else {
2544         GST_WARNING ("Can't transform tag '%s' to string", tagname_mkv);
2545       }
2546       g_value_unset (&src);
2547       break;
2548     }
2549   }
2550 }
2551
2552
2553 /**
2554  * gst_matroska_mux_finish:
2555  * @mux: #GstMatroskaMux
2556  *
2557  * Finish a new matroska file (write index etc...)
2558  */
2559 static void
2560 gst_matroska_mux_finish (GstMatroskaMux * mux)
2561 {
2562   GstEbmlWrite *ebml = mux->ebml_write;
2563   guint64 pos;
2564   guint64 duration = 0;
2565   GSList *collected;
2566   const GstTagList *tags;
2567
2568   /* finish last cluster */
2569   if (mux->cluster) {
2570     gst_ebml_write_master_finish (ebml, mux->cluster);
2571   }
2572
2573   /* cues */
2574   if (mux->index != NULL) {
2575     guint n;
2576     guint64 master, pointentry_master, trackpos_master;
2577
2578     mux->cues_pos = ebml->pos;
2579     gst_ebml_write_set_cache (ebml, 12 + 41 * mux->num_indexes);
2580     master = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_CUES);
2581
2582     for (n = 0; n < mux->num_indexes; n++) {
2583       GstMatroskaIndex *idx = &mux->index[n];
2584
2585       pointentry_master = gst_ebml_write_master_start (ebml,
2586           GST_MATROSKA_ID_POINTENTRY);
2587       gst_ebml_write_uint (ebml, GST_MATROSKA_ID_CUETIME,
2588           idx->time / mux->time_scale);
2589       trackpos_master = gst_ebml_write_master_start (ebml,
2590           GST_MATROSKA_ID_CUETRACKPOSITIONS);
2591       gst_ebml_write_uint (ebml, GST_MATROSKA_ID_CUETRACK, idx->track);
2592       gst_ebml_write_uint (ebml, GST_MATROSKA_ID_CUECLUSTERPOSITION,
2593           idx->pos - mux->segment_master);
2594       gst_ebml_write_master_finish (ebml, trackpos_master);
2595       gst_ebml_write_master_finish (ebml, pointentry_master);
2596     }
2597
2598     gst_ebml_write_master_finish (ebml, master);
2599     gst_ebml_write_flush_cache (ebml, FALSE, GST_CLOCK_TIME_NONE);
2600   }
2601
2602   /* tags */
2603   tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (mux));
2604
2605   if (tags != NULL && !gst_tag_list_is_empty (tags)) {
2606     guint64 master_tags, master_tag;
2607
2608     GST_DEBUG_OBJECT (mux, "Writing tags");
2609
2610     /* TODO: maybe limit via the TARGETS id by looking at the source pad */
2611     mux->tags_pos = ebml->pos;
2612     master_tags = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_TAGS);
2613     master_tag = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_TAG);
2614     gst_tag_list_foreach (tags, gst_matroska_mux_write_simple_tag, ebml);
2615     gst_ebml_write_master_finish (ebml, master_tag);
2616     gst_ebml_write_master_finish (ebml, master_tags);
2617   }
2618
2619   /* update seekhead. We know that:
2620    * - a seekhead contains 4 entries.
2621    * - order of entries is as above.
2622    * - a seekhead has a 4-byte header + 8-byte length
2623    * - each entry is 2-byte master, 2-byte ID pointer,
2624    *     2-byte length pointer, all 8/1-byte length, 4-
2625    *     byte ID and 8-byte length pointer, where the
2626    *     length pointer starts at 20.
2627    * - all entries are local to the segment (so pos - segment_master).
2628    * - so each entry is at 12 + 20 + num * 28. */
2629   gst_ebml_replace_uint (ebml, mux->seekhead_pos + 32,
2630       mux->info_pos - mux->segment_master);
2631   gst_ebml_replace_uint (ebml, mux->seekhead_pos + 60,
2632       mux->tracks_pos - mux->segment_master);
2633   if (mux->index != NULL) {
2634     gst_ebml_replace_uint (ebml, mux->seekhead_pos + 88,
2635         mux->cues_pos - mux->segment_master);
2636   } else {
2637     /* void'ify */
2638     guint64 my_pos = ebml->pos;
2639
2640     gst_ebml_write_seek (ebml, mux->seekhead_pos + 68);
2641     gst_ebml_write_buffer_header (ebml, GST_EBML_ID_VOID, 26);
2642     gst_ebml_write_seek (ebml, my_pos);
2643   }
2644   if (tags != NULL) {
2645     gst_ebml_replace_uint (ebml, mux->seekhead_pos + 116,
2646         mux->tags_pos - mux->segment_master);
2647   } else {
2648     /* void'ify */
2649     guint64 my_pos = ebml->pos;
2650
2651     gst_ebml_write_seek (ebml, mux->seekhead_pos + 96);
2652     gst_ebml_write_buffer_header (ebml, GST_EBML_ID_VOID, 26);
2653     gst_ebml_write_seek (ebml, my_pos);
2654   }
2655
2656   /* loop tracks:
2657    * - first get the overall duration
2658    *   (a released track may have left a duration in here)
2659    * - write some track header data for subtitles
2660    */
2661   duration = mux->duration;
2662   pos = ebml->pos;
2663   for (collected = mux->collect->data; collected;
2664       collected = g_slist_next (collected)) {
2665     GstMatroskaPad *collect_pad;
2666     GstClockTime min_duration;  /* observed minimum duration */
2667     GstMatroskaTrackContext *context;
2668     gint voidleft = 0, fill = 0;
2669     gpointer codec_id;
2670
2671     collect_pad = (GstMatroskaPad *) collected->data;
2672     context = collect_pad->track;
2673
2674     GST_DEBUG_OBJECT (mux,
2675         "Pad %" GST_PTR_FORMAT " start ts %" GST_TIME_FORMAT
2676         " end ts %" GST_TIME_FORMAT, collect_pad,
2677         GST_TIME_ARGS (collect_pad->start_ts),
2678         GST_TIME_ARGS (collect_pad->end_ts));
2679
2680     if (GST_CLOCK_TIME_IS_VALID (collect_pad->start_ts) &&
2681         GST_CLOCK_TIME_IS_VALID (collect_pad->end_ts)) {
2682       min_duration =
2683           GST_CLOCK_DIFF (collect_pad->start_ts, collect_pad->end_ts);
2684       if (collect_pad->duration < min_duration)
2685         collect_pad->duration = min_duration;
2686       GST_DEBUG_OBJECT (collect_pad,
2687           "final track duration: %" GST_TIME_FORMAT,
2688           GST_TIME_ARGS (collect_pad->duration));
2689     }
2690
2691     if (GST_CLOCK_TIME_IS_VALID (collect_pad->duration) &&
2692         duration < collect_pad->duration)
2693       duration = collect_pad->duration;
2694
2695     if (context->type != GST_MATROSKA_TRACK_TYPE_SUBTITLE || !context->pos)
2696       continue;
2697
2698   again:
2699     /* write subtitle type and possible private data */
2700     gst_ebml_write_seek (ebml, context->pos);
2701     /* complex way to write ascii to account for extra filling */
2702     codec_id = g_malloc0 (strlen (context->codec_id) + 1 + fill);
2703     strcpy (codec_id, context->codec_id);
2704     gst_ebml_write_binary (ebml, GST_MATROSKA_ID_CODECID,
2705         codec_id, strlen (context->codec_id) + 1 + fill);
2706     g_free (codec_id);
2707     if (context->codec_priv)
2708       gst_ebml_write_binary (ebml, GST_MATROSKA_ID_CODECPRIVATE,
2709           context->codec_priv, context->codec_priv_size);
2710     voidleft = SUBTITLE_DUMMY_SIZE - (ebml->pos - context->pos);
2711     /* void'ify; sigh, variable sized length field */
2712     if (voidleft == 1) {
2713       fill = 1;
2714       goto again;
2715     } else if (voidleft && voidleft <= 128)
2716       gst_ebml_write_buffer_header (ebml, GST_EBML_ID_VOID, voidleft - 2);
2717     else if (voidleft >= 130)
2718       gst_ebml_write_buffer_header (ebml, GST_EBML_ID_VOID, voidleft - 3);
2719     else if (voidleft == 129) {
2720       gst_ebml_write_buffer_header (ebml, GST_EBML_ID_VOID, 64);
2721       gst_ebml_write_buffer_header (ebml, GST_EBML_ID_VOID, 63);
2722     }
2723   }
2724
2725   /* seek back (optional, but do anyway) */
2726   gst_ebml_write_seek (ebml, pos);
2727
2728   /* update duration */
2729   if (duration != 0) {
2730     GST_DEBUG_OBJECT (mux, "final total duration: %" GST_TIME_FORMAT,
2731         GST_TIME_ARGS (duration));
2732     pos = mux->ebml_write->pos;
2733     gst_ebml_write_seek (ebml, mux->duration_pos);
2734     gst_ebml_write_float (ebml, GST_MATROSKA_ID_DURATION,
2735         gst_guint64_to_gdouble (duration) /
2736         gst_guint64_to_gdouble (mux->time_scale));
2737     gst_ebml_write_seek (ebml, pos);
2738   } else {
2739     /* void'ify */
2740     guint64 my_pos = ebml->pos;
2741
2742     gst_ebml_write_seek (ebml, mux->duration_pos);
2743     gst_ebml_write_buffer_header (ebml, GST_EBML_ID_VOID, 8);
2744     gst_ebml_write_seek (ebml, my_pos);
2745   }
2746   GST_DEBUG_OBJECT (mux, "finishing segment");
2747   /* finish segment - this also writes element length */
2748   gst_ebml_write_master_finish (ebml, mux->segment_pos);
2749 }
2750
2751 /**
2752  * gst_matroska_mux_buffer_header:
2753  * @track: Track context.
2754  * @relative_timestamp: relative timestamp of the buffer
2755  * @flags: Buffer flags.
2756  *
2757  * Create a buffer containing buffer header.
2758  *
2759  * Returns: New buffer.
2760  */
2761 static GstBuffer *
2762 gst_matroska_mux_create_buffer_header (GstMatroskaTrackContext * track,
2763     gint16 relative_timestamp, int flags)
2764 {
2765   GstBuffer *hdr;
2766   guint8 *data = g_malloc (4);
2767
2768   hdr = gst_buffer_new_wrapped (data, 4);
2769   /* track num - FIXME: what if num >= 0x80 (unlikely)? */
2770   data[0] = track->num | 0x80;
2771   /* time relative to clustertime */
2772   GST_WRITE_UINT16_BE (data + 1, relative_timestamp);
2773
2774   /* flags */
2775   data[3] = flags;
2776
2777   return hdr;
2778 }
2779
2780 #define DIRAC_PARSE_CODE_SEQUENCE_HEADER 0x00
2781 #define DIRAC_PARSE_CODE_END_OF_SEQUENCE 0x10
2782 #define DIRAC_PARSE_CODE_IS_PICTURE(x) ((x & 0x08) != 0)
2783
2784 static GstBuffer *
2785 gst_matroska_mux_handle_dirac_packet (GstMatroskaMux * mux,
2786     GstMatroskaPad * collect_pad, GstBuffer * buf)
2787 {
2788   GstMatroskaTrackVideoContext *ctx =
2789       (GstMatroskaTrackVideoContext *) collect_pad->track;
2790   GstMapInfo map;
2791   guint8 *data;
2792   gsize size;
2793   guint8 parse_code;
2794   guint32 next_parse_offset;
2795   GstBuffer *ret = NULL;
2796   gboolean is_muxing_unit = FALSE;
2797
2798   gst_buffer_map (buf, &map, GST_MAP_READ);
2799   data = map.data;
2800   size = map.size;
2801
2802   if (size < 13) {
2803     gst_buffer_unmap (buf, &map);
2804     gst_buffer_unref (buf);
2805     return ret;
2806   }
2807
2808   /* Check if this buffer contains a picture or end-of-sequence packet */
2809   while (size >= 13) {
2810     if (GST_READ_UINT32_BE (data) != 0x42424344 /* 'BBCD' */ ) {
2811       gst_buffer_unmap (buf, &map);
2812       gst_buffer_unref (buf);
2813       return ret;
2814     }
2815
2816     parse_code = GST_READ_UINT8 (data + 4);
2817     if (parse_code == DIRAC_PARSE_CODE_SEQUENCE_HEADER) {
2818       if (ctx->dirac_unit) {
2819         gst_buffer_unref (ctx->dirac_unit);
2820         ctx->dirac_unit = NULL;
2821       }
2822     } else if (DIRAC_PARSE_CODE_IS_PICTURE (parse_code) ||
2823         parse_code == DIRAC_PARSE_CODE_END_OF_SEQUENCE) {
2824       is_muxing_unit = TRUE;
2825       break;
2826     }
2827
2828     next_parse_offset = GST_READ_UINT32_BE (data + 5);
2829
2830     if (G_UNLIKELY (next_parse_offset == 0 || next_parse_offset > size))
2831       break;
2832
2833     data += next_parse_offset;
2834     size -= next_parse_offset;
2835   }
2836
2837   if (ctx->dirac_unit)
2838     ctx->dirac_unit = gst_buffer_join (ctx->dirac_unit, gst_buffer_ref (buf));
2839   else
2840     ctx->dirac_unit = gst_buffer_ref (buf);
2841
2842   gst_buffer_unmap (buf, &map);
2843
2844   if (is_muxing_unit) {
2845     ret = gst_buffer_make_writable (ctx->dirac_unit);
2846     ctx->dirac_unit = NULL;
2847     gst_buffer_copy_into (ret, buf,
2848         GST_BUFFER_COPY_FLAGS | GST_BUFFER_COPY_TIMESTAMPS, 0, -1);
2849     gst_buffer_unref (buf);
2850   } else {
2851     gst_buffer_unref (buf);
2852     ret = NULL;
2853   }
2854
2855   return ret;
2856 }
2857
2858 static void
2859 gst_matroska_mux_stop_streamheader (GstMatroskaMux * mux)
2860 {
2861   GstCaps *caps;
2862   GstStructure *s;
2863   GValue streamheader = { 0 };
2864   GValue bufval = { 0 };
2865   GstBuffer *streamheader_buffer;
2866   GstEbmlWrite *ebml = mux->ebml_write;
2867
2868   streamheader_buffer = gst_ebml_stop_streamheader (ebml);
2869   if (!strcmp (mux->doctype, GST_MATROSKA_DOCTYPE_WEBM)) {
2870     caps = gst_caps_new_empty_simple ("video/webm");
2871   } else {
2872     caps = gst_caps_new_empty_simple ("video/x-matroska");
2873   }
2874   s = gst_caps_get_structure (caps, 0);
2875   g_value_init (&streamheader, GST_TYPE_ARRAY);
2876   g_value_init (&bufval, GST_TYPE_BUFFER);
2877   GST_BUFFER_FLAG_SET (streamheader_buffer, GST_BUFFER_FLAG_HEADER);
2878   gst_value_set_buffer (&bufval, streamheader_buffer);
2879   gst_value_array_append_value (&streamheader, &bufval);
2880   g_value_unset (&bufval);
2881   gst_structure_set_value (s, "streamheader", &streamheader);
2882   g_value_unset (&streamheader);
2883   gst_caps_replace (&ebml->caps, caps);
2884   gst_buffer_unref (streamheader_buffer);
2885   gst_caps_unref (caps);
2886 }
2887
2888 /**
2889  * gst_matroska_mux_write_data:
2890  * @mux: #GstMatroskaMux
2891  * @collect_pad: #GstMatroskaPad with the data
2892  *
2893  * Write collected data (called from gst_matroska_mux_collected).
2894  *
2895  * Returns: Result of the gst_pad_push issued to write the data.
2896  */
2897 static GstFlowReturn
2898 gst_matroska_mux_write_data (GstMatroskaMux * mux, GstMatroskaPad * collect_pad,
2899     GstBuffer * buf)
2900 {
2901   GstEbmlWrite *ebml = mux->ebml_write;
2902   GstBuffer *hdr;
2903   guint64 blockgroup;
2904   gboolean write_duration;
2905   gint16 relative_timestamp;
2906   gint64 relative_timestamp64;
2907   guint64 block_duration;
2908   gboolean is_video_keyframe = FALSE;
2909   GstMatroskamuxPad *pad;
2910
2911   /* write data */
2912   pad = GST_MATROSKAMUX_PAD_CAST (collect_pad->collect.pad);
2913
2914   /* vorbis/theora headers are retrieved from caps and put in CodecPrivate */
2915   if (collect_pad->track->xiph_headers_to_skip > 0) {
2916     GST_LOG_OBJECT (collect_pad->collect.pad, "dropping streamheader buffer");
2917     gst_buffer_unref (buf);
2918     --collect_pad->track->xiph_headers_to_skip;
2919     return GST_FLOW_OK;
2920   }
2921
2922   /* for dirac we have to queue up everything up to a picture unit */
2923   if (collect_pad->track->codec_id != NULL &&
2924       strcmp (collect_pad->track->codec_id,
2925           GST_MATROSKA_CODEC_ID_VIDEO_DIRAC) == 0) {
2926     buf = gst_matroska_mux_handle_dirac_packet (mux, collect_pad, buf);
2927     if (!buf)
2928       return GST_FLOW_OK;
2929   }
2930
2931   /* hm, invalid timestamp (due to --to be fixed--- element upstream);
2932    * this would wreak havoc with time stored in matroska file */
2933   /* TODO: maybe calculate a timestamp by using the previous timestamp
2934    * and default duration */
2935   if (!GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
2936     GST_WARNING_OBJECT (collect_pad->collect.pad,
2937         "Invalid buffer timestamp; dropping buffer");
2938     gst_buffer_unref (buf);
2939     return GST_FLOW_OK;
2940   }
2941
2942   /* set the timestamp for outgoing buffers */
2943   ebml->timestamp = GST_BUFFER_TIMESTAMP (buf);
2944
2945   if (collect_pad->track->type == GST_MATROSKA_TRACK_TYPE_VIDEO &&
2946       !GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT)) {
2947     GST_LOG_OBJECT (mux, "have video keyframe, ts=%" GST_TIME_FORMAT,
2948         GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
2949     is_video_keyframe = TRUE;
2950   }
2951
2952   if (mux->cluster) {
2953     /* start a new cluster at every keyframe, at every GstForceKeyUnit event,
2954      * or when we may be reaching the limit of the relative timestamp */
2955     if (mux->cluster_time +
2956         mux->max_cluster_duration < GST_BUFFER_TIMESTAMP (buf)
2957         || is_video_keyframe || mux->force_key_unit_event) {
2958       if (!mux->streamable)
2959         gst_ebml_write_master_finish (ebml, mux->cluster);
2960
2961       /* Forward the GstForceKeyUnit event after finishing the cluster */
2962       if (mux->force_key_unit_event) {
2963         gst_pad_push_event (mux->srcpad, mux->force_key_unit_event);
2964         mux->force_key_unit_event = NULL;
2965       }
2966
2967       mux->prev_cluster_size = ebml->pos - mux->cluster_pos;
2968       mux->cluster_pos = ebml->pos;
2969       gst_ebml_write_set_cache (ebml, 0x20);
2970       mux->cluster =
2971           gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_CLUSTER);
2972       gst_ebml_write_uint (ebml, GST_MATROSKA_ID_CLUSTERTIMECODE,
2973           gst_util_uint64_scale (GST_BUFFER_TIMESTAMP (buf), 1,
2974               mux->time_scale));
2975       GST_LOG_OBJECT (mux, "cluster timestamp %" G_GUINT64_FORMAT,
2976           gst_util_uint64_scale (GST_BUFFER_TIMESTAMP (buf), 1,
2977               mux->time_scale));
2978       gst_ebml_write_flush_cache (ebml, TRUE, GST_BUFFER_TIMESTAMP (buf));
2979       mux->cluster_time = GST_BUFFER_TIMESTAMP (buf);
2980       gst_ebml_write_uint (ebml, GST_MATROSKA_ID_PREVSIZE,
2981           mux->prev_cluster_size);
2982     }
2983   } else {
2984     /* first cluster */
2985
2986     mux->cluster_pos = ebml->pos;
2987     gst_ebml_write_set_cache (ebml, 0x20);
2988     mux->cluster = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_CLUSTER);
2989     gst_ebml_write_uint (ebml, GST_MATROSKA_ID_CLUSTERTIMECODE,
2990         gst_util_uint64_scale (GST_BUFFER_TIMESTAMP (buf), 1, mux->time_scale));
2991     gst_ebml_write_flush_cache (ebml, TRUE, GST_BUFFER_TIMESTAMP (buf));
2992     mux->cluster_time = GST_BUFFER_TIMESTAMP (buf);
2993   }
2994
2995   /* update duration of this track */
2996   if (GST_BUFFER_DURATION_IS_VALID (buf))
2997     collect_pad->duration += GST_BUFFER_DURATION (buf);
2998
2999   /* We currently write index entries for all video tracks or for the audio
3000    * track in a single-track audio file.  This could be improved by keeping the
3001    * index only for the *first* video track. */
3002
3003   /* TODO: index is useful for every track, should contain the number of
3004    * the block in the cluster which contains the timestamp, should also work
3005    * for files with multiple audio tracks.
3006    */
3007   if (!mux->streamable &&
3008       (is_video_keyframe ||
3009           ((collect_pad->track->type == GST_MATROSKA_TRACK_TYPE_AUDIO) &&
3010               (mux->num_streams == 1)))) {
3011     gint last_idx = -1;
3012
3013     if (mux->min_index_interval != 0) {
3014       for (last_idx = mux->num_indexes - 1; last_idx >= 0; last_idx--) {
3015         if (mux->index[last_idx].track == collect_pad->track->num)
3016           break;
3017       }
3018     }
3019
3020     if (last_idx < 0 || mux->min_index_interval == 0 ||
3021         (GST_CLOCK_DIFF (mux->index[last_idx].time, GST_BUFFER_TIMESTAMP (buf))
3022             >= mux->min_index_interval)) {
3023       GstMatroskaIndex *idx;
3024
3025       if (mux->num_indexes % 32 == 0) {
3026         mux->index = g_renew (GstMatroskaIndex, mux->index,
3027             mux->num_indexes + 32);
3028       }
3029       idx = &mux->index[mux->num_indexes++];
3030
3031       idx->pos = mux->cluster_pos;
3032       idx->time = GST_BUFFER_TIMESTAMP (buf);
3033       idx->track = collect_pad->track->num;
3034     }
3035   }
3036
3037   /* Check if the duration differs from the default duration. */
3038   write_duration = FALSE;
3039   block_duration = 0;
3040   if (pad->frame_duration && GST_BUFFER_DURATION_IS_VALID (buf)) {
3041     block_duration = gst_util_uint64_scale (GST_BUFFER_DURATION (buf),
3042         1, mux->time_scale);
3043
3044     /* small difference should be ok. */
3045     if (block_duration > collect_pad->default_duration_scaled + 1 ||
3046         block_duration < collect_pad->default_duration_scaled - 1) {
3047       write_duration = TRUE;
3048     }
3049   }
3050
3051   /* write the block, for doctype v2 use SimpleBlock if possible
3052    * one slice (*breath*).
3053    * FIXME: Need to do correct lacing! */
3054   relative_timestamp64 = GST_BUFFER_TIMESTAMP (buf) - mux->cluster_time;
3055   if (relative_timestamp64 >= 0) {
3056     /* round the timestamp */
3057     relative_timestamp64 += gst_util_uint64_scale (mux->time_scale, 1, 2);
3058   } else {
3059     /* round the timestamp */
3060     relative_timestamp64 -= gst_util_uint64_scale (mux->time_scale, 1, 2);
3061   }
3062   relative_timestamp = gst_util_uint64_scale (relative_timestamp64, 1,
3063       mux->time_scale);
3064   if (mux->doctype_version > 1 && !write_duration) {
3065     int flags =
3066         GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT) ? 0 : 0x80;
3067
3068     hdr =
3069         gst_matroska_mux_create_buffer_header (collect_pad->track,
3070         relative_timestamp, flags);
3071     gst_ebml_write_set_cache (ebml, 0x40);
3072     gst_ebml_write_buffer_header (ebml, GST_MATROSKA_ID_SIMPLEBLOCK,
3073         gst_buffer_get_size (buf) + gst_buffer_get_size (hdr));
3074     gst_ebml_write_buffer (ebml, hdr);
3075     gst_ebml_write_flush_cache (ebml, FALSE, GST_BUFFER_TIMESTAMP (buf));
3076     gst_ebml_write_buffer (ebml, buf);
3077
3078     return gst_ebml_last_write_result (ebml);
3079   } else {
3080     gst_ebml_write_set_cache (ebml, gst_buffer_get_size (buf) * 2);
3081     /* write and call order slightly unnatural,
3082      * but avoids seek and minizes pushing */
3083     blockgroup = gst_ebml_write_master_start (ebml, GST_MATROSKA_ID_BLOCKGROUP);
3084     hdr =
3085         gst_matroska_mux_create_buffer_header (collect_pad->track,
3086         relative_timestamp, 0);
3087     if (write_duration)
3088       gst_ebml_write_uint (ebml, GST_MATROSKA_ID_BLOCKDURATION, block_duration);
3089     gst_ebml_write_buffer_header (ebml, GST_MATROSKA_ID_BLOCK,
3090         gst_buffer_get_size (buf) + gst_buffer_get_size (hdr));
3091     gst_ebml_write_buffer (ebml, hdr);
3092     gst_ebml_write_master_finish_full (ebml, blockgroup,
3093         gst_buffer_get_size (buf));
3094     gst_ebml_write_flush_cache (ebml, FALSE, GST_BUFFER_TIMESTAMP (buf));
3095     gst_ebml_write_buffer (ebml, buf);
3096
3097     return gst_ebml_last_write_result (ebml);
3098   }
3099 }
3100
3101 /**
3102  * gst_matroska_mux_handle_buffer:
3103  * @pads: #GstCollectPads2
3104  * @uuser_data: #GstMatroskaMux
3105  *
3106  * Collectpads callback.
3107  *
3108  * Returns: #GstFlowReturn
3109  */
3110 static GstFlowReturn
3111 gst_matroska_mux_handle_buffer (GstCollectPads2 * pads, GstCollectData2 * data,
3112     GstBuffer * buf, gpointer user_data)
3113 {
3114   GstMatroskaMux *mux = GST_MATROSKA_MUX (user_data);
3115   GstEbmlWrite *ebml = mux->ebml_write;
3116   GstMatroskaPad *best;
3117   GstFlowReturn ret = GST_FLOW_OK;
3118
3119   GST_DEBUG_OBJECT (mux, "Collected pads");
3120
3121   /* start with a header */
3122   if (mux->state == GST_MATROSKA_MUX_STATE_START) {
3123     if (mux->collect->data == NULL) {
3124       GST_ELEMENT_ERROR (mux, STREAM, MUX, (NULL),
3125           ("No input streams configured"));
3126       return GST_FLOW_ERROR;
3127     }
3128     mux->state = GST_MATROSKA_MUX_STATE_HEADER;
3129     gst_ebml_start_streamheader (ebml);
3130     gst_matroska_mux_start (mux);
3131     gst_matroska_mux_stop_streamheader (mux);
3132     mux->state = GST_MATROSKA_MUX_STATE_DATA;
3133   }
3134
3135   /* provided with stream to write from */
3136   best = (GstMatroskaPad *) data;
3137
3138   /* if there is no best pad, we have reached EOS */
3139   if (best == NULL) {
3140     GST_DEBUG_OBJECT (mux, "No best pad finishing...");
3141     if (!mux->streamable) {
3142       gst_matroska_mux_finish (mux);
3143     } else {
3144       GST_DEBUG_OBJECT (mux, "... but streamable, nothing to finish");
3145     }
3146     gst_pad_push_event (mux->srcpad, gst_event_new_eos ());
3147     ret = GST_FLOW_EOS;
3148     goto exit;
3149   }
3150
3151   /* if we have a best stream, should also have a buffer */
3152   g_assert (buf);
3153
3154   GST_DEBUG_OBJECT (best->collect.pad, "best pad - buffer ts %"
3155       GST_TIME_FORMAT " dur %" GST_TIME_FORMAT,
3156       GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)),
3157       GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
3158
3159   /* make note of first and last encountered timestamps, so we can calculate
3160    * the actual duration later when we send an updated header on eos */
3161   if (GST_BUFFER_TIMESTAMP_IS_VALID (buf)) {
3162     GstClockTime start_ts = GST_BUFFER_TIMESTAMP (buf);
3163     GstClockTime end_ts = start_ts;
3164
3165     if (GST_BUFFER_DURATION_IS_VALID (buf))
3166       end_ts += GST_BUFFER_DURATION (buf);
3167     else if (best->track->default_duration)
3168       end_ts += best->track->default_duration;
3169
3170     if (!GST_CLOCK_TIME_IS_VALID (best->end_ts) || end_ts > best->end_ts)
3171       best->end_ts = end_ts;
3172
3173     if (G_UNLIKELY (best->start_ts == GST_CLOCK_TIME_NONE ||
3174             start_ts < best->start_ts))
3175       best->start_ts = start_ts;
3176   }
3177
3178   /* write one buffer */
3179   ret = gst_matroska_mux_write_data (mux, best, buf);
3180
3181 exit:
3182   return ret;
3183 }
3184
3185
3186 /**
3187  * gst_matroska_mux_change_state:
3188  * @element: #GstMatroskaMux
3189  * @transition: State change transition.
3190  *
3191  * Change the muxer state.
3192  *
3193  * Returns: #GstStateChangeReturn
3194  */
3195 static GstStateChangeReturn
3196 gst_matroska_mux_change_state (GstElement * element, GstStateChange transition)
3197 {
3198   GstStateChangeReturn ret;
3199   GstMatroskaMux *mux = GST_MATROSKA_MUX (element);
3200
3201   switch (transition) {
3202     case GST_STATE_CHANGE_NULL_TO_READY:
3203       break;
3204     case GST_STATE_CHANGE_READY_TO_PAUSED:
3205       gst_collect_pads2_start (mux->collect);
3206       break;
3207     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
3208       break;
3209     case GST_STATE_CHANGE_PAUSED_TO_READY:
3210       gst_collect_pads2_stop (mux->collect);
3211       break;
3212     default:
3213       break;
3214   }
3215
3216   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
3217
3218   switch (transition) {
3219     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
3220       break;
3221     case GST_STATE_CHANGE_PAUSED_TO_READY:
3222       gst_matroska_mux_reset (GST_ELEMENT (mux));
3223       break;
3224     case GST_STATE_CHANGE_READY_TO_NULL:
3225       break;
3226     default:
3227       break;
3228   }
3229
3230   return ret;
3231 }
3232
3233 static void
3234 gst_matroska_mux_set_property (GObject * object,
3235     guint prop_id, const GValue * value, GParamSpec * pspec)
3236 {
3237   GstMatroskaMux *mux;
3238
3239   g_return_if_fail (GST_IS_MATROSKA_MUX (object));
3240   mux = GST_MATROSKA_MUX (object);
3241
3242   switch (prop_id) {
3243     case ARG_WRITING_APP:
3244       if (!g_value_get_string (value)) {
3245         GST_WARNING_OBJECT (mux, "writing-app property can not be NULL");
3246         break;
3247       }
3248       g_free (mux->writing_app);
3249       mux->writing_app = g_value_dup_string (value);
3250       break;
3251     case ARG_DOCTYPE_VERSION:
3252       mux->doctype_version = g_value_get_int (value);
3253       break;
3254     case ARG_MIN_INDEX_INTERVAL:
3255       mux->min_index_interval = g_value_get_int64 (value);
3256       break;
3257     case ARG_STREAMABLE:
3258       mux->streamable = g_value_get_boolean (value);
3259       break;
3260     default:
3261       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
3262       break;
3263   }
3264 }
3265
3266 static void
3267 gst_matroska_mux_get_property (GObject * object,
3268     guint prop_id, GValue * value, GParamSpec * pspec)
3269 {
3270   GstMatroskaMux *mux;
3271
3272   g_return_if_fail (GST_IS_MATROSKA_MUX (object));
3273   mux = GST_MATROSKA_MUX (object);
3274
3275   switch (prop_id) {
3276     case ARG_WRITING_APP:
3277       g_value_set_string (value, mux->writing_app);
3278       break;
3279     case ARG_DOCTYPE_VERSION:
3280       g_value_set_int (value, mux->doctype_version);
3281       break;
3282     case ARG_MIN_INDEX_INTERVAL:
3283       g_value_set_int64 (value, mux->min_index_interval);
3284       break;
3285     case ARG_STREAMABLE:
3286       g_value_set_boolean (value, mux->streamable);
3287       break;
3288     default:
3289       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
3290       break;
3291   }
3292 }