gst/flv/gstflvmux.c

   1 /* GStreamer
   2  *
   3  * Copyright (c) 2008,2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>
   4  * Copyright (c) 2008-2017 Collabora Ltd
   5  *  @author: Sebastian Dröge <sebastian.droege@collabora.co.uk>
   6  *  @author: Vincent Penquerc'h <vincent.penquerch@collabora.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 /**
  25  * SECTION:element-flvmux
  26  * @title: flvmux
  27  *
  28  * flvmux muxes different streams into an FLV file.
  29  *
  30  * ## Example launch line
  31  * |[
  32  * gst-launch-1.0 -v flvmux name=mux ! filesink location=test.flv  audiotestsrc samplesperbuffer=44100 num-buffers=10 ! faac ! mux.  videotestsrc num-buffers=250 ! video/x-raw,framerate=25/1 ! x264enc ! mux.
  33  * ]| This pipeline encodes a test audio and video stream and muxes both into an FLV file.
  34  *
  35  */
  36
  37 #ifdef HAVE_CONFIG_H
  38 #include "config.h"
  39 #endif
  40
  41 #include <math.h>
  42 #include <string.h>
  43
  44 #include <gst/audio/audio.h>
  45
  46 #include "gstflvmux.h"
  47 #include "amfdefs.h"
  48
  49 GST_DEBUG_CATEGORY_STATIC (flvmux_debug);
  50 #define GST_CAT_DEFAULT flvmux_debug
  51
  52 enum
  53 {
  54   PROP_0,
  55   PROP_STREAMABLE,
  56   PROP_METADATACREATOR,
  57   PROP_ENCODER
  58 };
  59
  60 #define DEFAULT_STREAMABLE FALSE
  61 #define MAX_INDEX_ENTRIES 128
  62 #define DEFAULT_METADATACREATOR "GStreamer " PACKAGE_VERSION " FLV muxer"
  63
  64 static GstStaticPadTemplate src_templ = GST_STATIC_PAD_TEMPLATE ("src",
  65     GST_PAD_SRC,
  66     GST_PAD_ALWAYS,
  67     GST_STATIC_CAPS ("video/x-flv")
  68     );
  69
  70 static GstStaticPadTemplate videosink_templ = GST_STATIC_PAD_TEMPLATE ("video",
  71     GST_PAD_SINK,
  72     GST_PAD_REQUEST,
  73     GST_STATIC_CAPS ("video/x-flash-video; "
  74         "video/x-flash-screen; "
  75         "video/x-vp6-flash; " "video/x-vp6-alpha; "
  76         "video/x-h264, stream-format=avc;")
  77     );
  78
  79 static GstStaticPadTemplate audiosink_templ = GST_STATIC_PAD_TEMPLATE ("audio",
  80     GST_PAD_SINK,
  81     GST_PAD_REQUEST,
  82     GST_STATIC_CAPS
  83     ("audio/x-adpcm, layout = (string) swf, channels = (int) { 1, 2 }, rate = (int) { 5512, 11025, 22050, 44100 }; "
  84         "audio/mpeg, mpegversion = (int) 1, layer = (int) 3, channels = (int) { 1, 2 }, rate = (int) { 5512, 8000, 11025, 22050, 44100 }, parsed = (boolean) TRUE; "
  85         "audio/mpeg, mpegversion = (int) { 4, 2 }, stream-format = (string) raw; "
  86         "audio/x-nellymoser, channels = (int) { 1, 2 }, rate = (int) { 5512, 8000, 11025, 16000, 22050, 44100 }; "
  87         "audio/x-raw, format = (string) { U8, S16LE}, layout = (string) interleaved, channels = (int) { 1, 2 }, rate = (int) { 5512, 11025, 22050, 44100 }; "
  88         "audio/x-alaw, channels = (int) { 1, 2 }, rate = (int) 8000; "
  89         "audio/x-mulaw, channels = (int) { 1, 2 }, rate = (int) 8000; "
  90         "audio/x-speex, channels = (int) 1, rate = (int) 16000;")
  91     );
  92
  93 G_DEFINE_TYPE (GstFlvMuxPad, gst_flv_mux_pad, GST_TYPE_AGGREGATOR_PAD);
  94
  95 #define gst_flv_mux_parent_class parent_class
  96 G_DEFINE_TYPE_WITH_CODE (GstFlvMux, gst_flv_mux, GST_TYPE_AGGREGATOR,
  97     G_IMPLEMENT_INTERFACE (GST_TYPE_TAG_SETTER, NULL));
  98
  99 static GstFlowReturn
 100 gst_flv_mux_aggregate (GstAggregator * aggregator, gboolean timeout);
 101 static gboolean
 102 gst_flv_mux_sink_event (GstAggregator * aggregator, GstAggregatorPad * pad,
 103     GstEvent * event);
 104
 105 static GstAggregatorPad *gst_flv_mux_create_new_pad (GstAggregator * agg,
 106     GstPadTemplate * templ, const gchar * req_name, const GstCaps * caps);
 107 static void gst_flv_mux_release_pad (GstElement * element, GstPad * pad);
 108
 109 static gboolean gst_flv_mux_video_pad_setcaps (GstFlvMuxPad * pad,
 110     GstCaps * caps);
 111 static gboolean gst_flv_mux_audio_pad_setcaps (GstFlvMuxPad * pad,
 112     GstCaps * caps);
 113
 114 static void gst_flv_mux_get_property (GObject * object,
 115     guint prop_id, GValue * value, GParamSpec * pspec);
 116 static void gst_flv_mux_set_property (GObject * object,
 117     guint prop_id, const GValue * value, GParamSpec * pspec);
 118 static void gst_flv_mux_finalize (GObject * object);
 119
 120 static void gst_flv_mux_reset (GstElement * element);
 121 static void gst_flv_mux_reset_pad (GstFlvMuxPad * pad);
 122
 123 static void gst_flv_mux_pad_finalize (GObject * object);
 124
 125 static gboolean gst_flv_mux_start (GstAggregator * aggregator);
 126 static GstFlowReturn gst_flv_mux_flush (GstAggregator * aggregator);
 127 static GstClockTime gst_flv_mux_get_next_time (GstAggregator * aggregator);
 128 static GstFlowReturn gst_flv_mux_write_eos (GstFlvMux * mux);
 129 static GstFlowReturn gst_flv_mux_write_header (GstFlvMux * mux);
 130 static GstFlowReturn gst_flv_mux_rewrite_header (GstFlvMux * mux);
 131 static gboolean gst_flv_mux_are_all_pads_eos (GstFlvMux * mux);
 132 static GstFlowReturn gst_flv_mux_update_src_caps (GstAggregator * aggregator,
 133     GstCaps * caps, GstCaps ** ret);
 134
 135 static GstFlowReturn
 136 gst_flv_mux_pad_flush (GstAggregatorPad * pad, GstAggregator * aggregator)
 137 {
 138   GstFlvMuxPad *flvpad = GST_FLV_MUX_PAD (pad);
 139
 140   flvpad->last_timestamp = 0;
 141   flvpad->pts = GST_CLOCK_STIME_NONE;
 142   flvpad->dts = GST_CLOCK_STIME_NONE;
 143
 144   return GST_FLOW_OK;
 145 }
 146
 147 static void
 148 gst_flv_mux_pad_class_init (GstFlvMuxPadClass * klass)
 149 {
 150   GstAggregatorPadClass *aggregatorpad_class = (GstAggregatorPadClass *) klass;
 151   GObjectClass *gobject_class = (GObjectClass *) klass;
 152
 153   gobject_class->finalize = gst_flv_mux_pad_finalize;
 154
 155   aggregatorpad_class->flush = GST_DEBUG_FUNCPTR (gst_flv_mux_pad_flush);
 156 }
 157
 158 static void
 159 gst_flv_mux_pad_init (GstFlvMuxPad * pad)
 160 {
 161   gst_flv_mux_reset_pad (pad);
 162 }
 163
 164 typedef struct
 165 {
 166   gdouble position;
 167   gdouble time;
 168 } GstFlvMuxIndexEntry;
 169
 170 static void
 171 gst_flv_mux_index_entry_free (GstFlvMuxIndexEntry * entry)
 172 {
 173   g_slice_free (GstFlvMuxIndexEntry, entry);
 174 }
 175
 176 static GstBuffer *
 177 _gst_buffer_new_wrapped (gpointer mem, gsize size, GFreeFunc free_func)
 178 {
 179   GstBuffer *buf;
 180
 181   buf = gst_buffer_new ();
 182   gst_buffer_append_memory (buf,
 183       gst_memory_new_wrapped (free_func ? 0 : GST_MEMORY_FLAG_READONLY,
 184           mem, size, 0, size, mem, free_func));
 185
 186   return buf;
 187 }
 188
 189 static void
 190 _gst_buffer_new_and_alloc (gsize size, GstBuffer ** buffer, guint8 ** data)
 191 {
 192   g_return_if_fail (data != NULL);
 193   g_return_if_fail (buffer != NULL);
 194
 195   *data = g_malloc (size);
 196   *buffer = _gst_buffer_new_wrapped (*data, size, g_free);
 197 }
 198
 199 static void
 200 gst_flv_mux_class_init (GstFlvMuxClass * klass)
 201 {
 202   GObjectClass *gobject_class;
 203   GstElementClass *gstelement_class;
 204   GstAggregatorClass *gstaggregator_class;
 205
 206   GST_DEBUG_CATEGORY_INIT (flvmux_debug, "flvmux", 0, "FLV muxer");
 207
 208   gobject_class = (GObjectClass *) klass;
 209   gstelement_class = (GstElementClass *) klass;
 210   gstaggregator_class = (GstAggregatorClass *) klass;
 211
 212   gobject_class->get_property = gst_flv_mux_get_property;
 213   gobject_class->set_property = gst_flv_mux_set_property;
 214   gobject_class->finalize = gst_flv_mux_finalize;
 215
 216   /* FIXME: ideally the right mode of operation should be detected
 217    * automatically using queries when parameter not specified. */
 218   /**
 219    * GstFlvMux:streamable
 220    *
 221    * If True, the output will be streaming friendly. (ie without indexes and
 222    * duration)
 223    */
 224   g_object_class_install_property (gobject_class, PROP_STREAMABLE,
 225       g_param_spec_boolean ("streamable", "streamable",
 226           "If set to true, the output should be as if it is to be streamed "
 227           "and hence no indexes written or duration written.",
 228           DEFAULT_STREAMABLE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 229   g_object_class_install_property (gobject_class, PROP_METADATACREATOR,
 230       g_param_spec_string ("metadatacreator", "metadatacreator",
 231           "The value of metadatacreator in the meta packet.",
 232           NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 233
 234   g_object_class_install_property (gobject_class, PROP_ENCODER,
 235       g_param_spec_string ("encoder", "encoder",
 236           "The value of encoder in the meta packet.",
 237           NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 238
 239   gstaggregator_class->create_new_pad =
 240       GST_DEBUG_FUNCPTR (gst_flv_mux_create_new_pad);
 241   gstelement_class->release_pad = GST_DEBUG_FUNCPTR (gst_flv_mux_release_pad);
 242
 243   gstaggregator_class->start = GST_DEBUG_FUNCPTR (gst_flv_mux_start);
 244   gstaggregator_class->aggregate = GST_DEBUG_FUNCPTR (gst_flv_mux_aggregate);
 245   gstaggregator_class->sink_event = GST_DEBUG_FUNCPTR (gst_flv_mux_sink_event);
 246   gstaggregator_class->flush = GST_DEBUG_FUNCPTR (gst_flv_mux_flush);
 247   gstaggregator_class->get_next_time =
 248       GST_DEBUG_FUNCPTR (gst_flv_mux_get_next_time);
 249   gstaggregator_class->update_src_caps =
 250       GST_DEBUG_FUNCPTR (gst_flv_mux_update_src_caps);
 251
 252   gst_element_class_add_static_pad_template_with_gtype (gstelement_class,
 253       &videosink_templ, GST_TYPE_FLV_MUX_PAD);
 254   gst_element_class_add_static_pad_template_with_gtype (gstelement_class,
 255       &audiosink_templ, GST_TYPE_FLV_MUX_PAD);
 256   gst_element_class_add_static_pad_template_with_gtype (gstelement_class,
 257       &src_templ, GST_TYPE_AGGREGATOR_PAD);
 258   gst_element_class_set_static_metadata (gstelement_class, "FLV muxer",
 259       "Codec/Muxer",
 260       "Muxes video/audio streams into a FLV stream",
 261       "Sebastian Dröge <sebastian.droege@collabora.co.uk>");
 262
 263   GST_DEBUG_CATEGORY_INIT (flvmux_debug, "flvmux", 0, "FLV muxer");
 264 }
 265
 266 static void
 267 gst_flv_mux_init (GstFlvMux * mux)
 268 {
 269   mux->srcpad = GST_AGGREGATOR_CAST (mux)->srcpad;
 270
 271   /* property */
 272   mux->streamable = DEFAULT_STREAMABLE;
 273   mux->metadatacreator = g_strdup (DEFAULT_METADATACREATOR);
 274   mux->encoder = g_strdup (DEFAULT_METADATACREATOR);
 275
 276   mux->new_tags = FALSE;
 277
 278   gst_flv_mux_reset (GST_ELEMENT (mux));
 279 }
 280
 281 static void
 282 gst_flv_mux_finalize (GObject * object)
 283 {
 284   GstFlvMux *mux = GST_FLV_MUX (object);
 285
 286   gst_flv_mux_reset (GST_ELEMENT (object));
 287   g_free (mux->metadatacreator);
 288   g_free (mux->encoder);
 289
 290   G_OBJECT_CLASS (gst_flv_mux_parent_class)->finalize (object);
 291 }
 292
 293 static void
 294 gst_flv_mux_pad_finalize (GObject * object)
 295 {
 296   GstFlvMuxPad *pad = GST_FLV_MUX_PAD (object);
 297
 298   gst_flv_mux_reset_pad (pad);
 299
 300   G_OBJECT_CLASS (gst_flv_mux_pad_parent_class)->finalize (object);
 301 }
 302
 303 static GstFlowReturn
 304 gst_flv_mux_flush (GstAggregator * aggregator)
 305 {
 306   /* TODO: What is the right behaviour on flush? Should we just ignore it ?
 307    * This still needs to be defined. */
 308
 309   gst_flv_mux_reset (GST_ELEMENT (aggregator));
 310   return GST_FLOW_OK;
 311 }
 312
 313 static gboolean
 314 gst_flv_mux_start (GstAggregator * aggregator)
 315 {
 316   gst_flv_mux_reset (GST_ELEMENT (aggregator));
 317   return TRUE;
 318 }
 319
 320 static void
 321 gst_flv_mux_reset (GstElement * element)
 322 {
 323   GstFlvMux *mux = GST_FLV_MUX (element);
 324
 325   g_list_foreach (mux->index, (GFunc) gst_flv_mux_index_entry_free, NULL);
 326   g_list_free (mux->index);
 327   mux->index = NULL;
 328   mux->byte_count = 0;
 329
 330   mux->duration = GST_CLOCK_TIME_NONE;
 331   mux->new_tags = FALSE;
 332   mux->first_timestamp = GST_CLOCK_STIME_NONE;
 333   mux->last_dts = 0;
 334
 335   mux->state = GST_FLV_MUX_STATE_HEADER;
 336   mux->sent_header = FALSE;
 337
 338   /* tags */
 339   gst_tag_setter_reset_tags (GST_TAG_SETTER (mux));
 340 }
 341
 342 /* Extract per-codec relevant tags for
 343  * insertion into the metadata later - ie bitrate,
 344  * but maybe others in the future */
 345 static void
 346 gst_flv_mux_store_codec_tags (GstFlvMux * mux,
 347     GstFlvMuxPad * flvpad, GstTagList * list)
 348 {
 349   /* Look for a bitrate as either nominal or actual bitrate tag */
 350   if (gst_tag_list_get_uint (list, GST_TAG_NOMINAL_BITRATE, &flvpad->bitrate)
 351       || gst_tag_list_get_uint (list, GST_TAG_BITRATE, &flvpad->bitrate)) {
 352     GST_DEBUG_OBJECT (mux, "Stored bitrate for pad %" GST_PTR_FORMAT " = %u",
 353         flvpad, flvpad->bitrate);
 354   }
 355 }
 356
 357 static gboolean
 358 gst_flv_mux_sink_event (GstAggregator * aggregator, GstAggregatorPad * pad,
 359     GstEvent * event)
 360 {
 361   GstFlvMux *mux = GST_FLV_MUX (aggregator);
 362   GstFlvMuxPad *flvpad = (GstFlvMuxPad *) pad;
 363   gboolean ret = TRUE;
 364
 365   switch (GST_EVENT_TYPE (event)) {
 366     case GST_EVENT_CAPS:
 367     {
 368       GstCaps *caps;
 369
 370       gst_event_parse_caps (event, &caps);
 371
 372       if (mux->video_pad == flvpad) {
 373         ret = gst_flv_mux_video_pad_setcaps (flvpad, caps);
 374       } else if (mux->audio_pad == flvpad) {
 375         ret = gst_flv_mux_audio_pad_setcaps (flvpad, caps);
 376       } else {
 377         g_assert_not_reached ();
 378       }
 379       break;
 380     }
 381     case GST_EVENT_TAG:{
 382       GstTagList *list;
 383       GstTagSetter *setter = GST_TAG_SETTER (mux);
 384       const GstTagMergeMode mode = gst_tag_setter_get_tag_merge_mode (setter);
 385
 386       gst_event_parse_tag (event, &list);
 387       gst_tag_setter_merge_tags (setter, list, mode);
 388       gst_flv_mux_store_codec_tags (mux, flvpad, list);
 389       mux->new_tags = TRUE;
 390       ret = TRUE;
 391       break;
 392     }
 393     default:
 394       break;
 395   }
 396
 397   if (!ret)
 398     return FALSE;
 399
 400   return GST_AGGREGATOR_CLASS (parent_class)->sink_event (aggregator, pad,
 401       event);;
 402 }
 403
 404 static gboolean
 405 gst_flv_mux_video_pad_setcaps (GstFlvMuxPad * pad, GstCaps * caps)
 406 {
 407   GstFlvMux *mux = GST_FLV_MUX (gst_pad_get_parent (pad));
 408   gboolean ret = TRUE;
 409   GstStructure *s;
 410   guint old_codec;
 411   GstBuffer *old_codec_data = NULL;
 412
 413   old_codec = pad->codec;
 414   if (pad->codec_data)
 415     old_codec_data = gst_buffer_ref (pad->codec_data);
 416
 417   s = gst_caps_get_structure (caps, 0);
 418
 419   if (strcmp (gst_structure_get_name (s), "video/x-flash-video") == 0) {
 420     pad->codec = 2;
 421   } else if (strcmp (gst_structure_get_name (s), "video/x-flash-screen") == 0) {
 422     pad->codec = 3;
 423   } else if (strcmp (gst_structure_get_name (s), "video/x-vp6-flash") == 0) {
 424     pad->codec = 4;
 425   } else if (strcmp (gst_structure_get_name (s), "video/x-vp6-alpha") == 0) {
 426     pad->codec = 5;
 427   } else if (strcmp (gst_structure_get_name (s), "video/x-h264") == 0) {
 428     pad->codec = 7;
 429   } else {
 430     ret = FALSE;
 431   }
 432
 433   if (ret && gst_structure_has_field (s, "codec_data")) {
 434     const GValue *val = gst_structure_get_value (s, "codec_data");
 435
 436     if (val)
 437       gst_buffer_replace (&pad->codec_data, gst_value_get_buffer (val));
 438     else if (!val && pad->codec_data)
 439       gst_buffer_unref (pad->codec_data);
 440   }
 441
 442   if (ret && mux->streamable && mux->state != GST_FLV_MUX_STATE_HEADER) {
 443     if (old_codec != pad->codec) {
 444       pad->info_changed = TRUE;
 445     }
 446
 447     if (old_codec_data && pad->codec_data) {
 448       GstMapInfo map;
 449
 450       gst_buffer_map (old_codec_data, &map, GST_MAP_READ);
 451       if (map.size != gst_buffer_get_size (pad->codec_data) ||
 452           gst_buffer_memcmp (pad->codec_data, 0, map.data, map.size))
 453         pad->info_changed = TRUE;
 454
 455       gst_buffer_unmap (old_codec_data, &map);
 456     } else if (!old_codec_data && pad->codec_data) {
 457       pad->info_changed = TRUE;
 458     }
 459
 460     if (pad->info_changed)
 461       mux->state = GST_FLV_MUX_STATE_HEADER;
 462   }
 463
 464   if (old_codec_data)
 465     gst_buffer_unref (old_codec_data);
 466
 467   gst_object_unref (mux);
 468
 469   return ret;
 470 }
 471
 472 static gboolean
 473 gst_flv_mux_audio_pad_setcaps (GstFlvMuxPad * pad, GstCaps * caps)
 474 {
 475   GstFlvMux *mux = GST_FLV_MUX (gst_pad_get_parent (pad));
 476   gboolean ret = TRUE;
 477   GstStructure *s;
 478   guint old_codec, old_rate, old_width, old_channels;
 479   GstBuffer *old_codec_data = NULL;
 480
 481   old_codec = pad->codec;
 482   old_rate = pad->rate;
 483   old_width = pad->width;
 484   old_channels = pad->channels;
 485   if (pad->codec_data)
 486     old_codec_data = gst_buffer_ref (pad->codec_data);
 487
 488   s = gst_caps_get_structure (caps, 0);
 489
 490   if (strcmp (gst_structure_get_name (s), "audio/x-adpcm") == 0) {
 491     const gchar *layout = gst_structure_get_string (s, "layout");
 492     if (layout && strcmp (layout, "swf") == 0) {
 493       pad->codec = 1;
 494     } else {
 495       ret = FALSE;
 496     }
 497   } else if (strcmp (gst_structure_get_name (s), "audio/mpeg") == 0) {
 498     gint mpegversion;
 499
 500     if (gst_structure_get_int (s, "mpegversion", &mpegversion)) {
 501       if (mpegversion == 1) {
 502         gint layer;
 503
 504         if (gst_structure_get_int (s, "layer", &layer) && layer == 3) {
 505           gint rate;
 506
 507           if (gst_structure_get_int (s, "rate", &rate) && rate == 8000)
 508             pad->codec = 14;
 509           else
 510             pad->codec = 2;
 511         } else {
 512           ret = FALSE;
 513         }
 514       } else if (mpegversion == 4 || mpegversion == 2) {
 515         pad->codec = 10;
 516       } else {
 517         ret = FALSE;
 518       }
 519     } else {
 520       ret = FALSE;
 521     }
 522   } else if (strcmp (gst_structure_get_name (s), "audio/x-nellymoser") == 0) {
 523     gint rate, channels;
 524
 525     if (gst_structure_get_int (s, "rate", &rate)
 526         && gst_structure_get_int (s, "channels", &channels)) {
 527       if (channels == 1 && rate == 16000)
 528         pad->codec = 4;
 529       else if (channels == 1 && rate == 8000)
 530         pad->codec = 5;
 531       else
 532         pad->codec = 6;
 533     } else {
 534       pad->codec = 6;
 535     }
 536   } else if (strcmp (gst_structure_get_name (s), "audio/x-raw") == 0) {
 537     GstAudioInfo info;
 538
 539     if (gst_audio_info_from_caps (&info, caps)) {
 540       pad->codec = 3;
 541
 542       if (GST_AUDIO_INFO_WIDTH (&info) == 8)
 543         pad->width = 0;
 544       else if (GST_AUDIO_INFO_WIDTH (&info) == 16)
 545         pad->width = 1;
 546       else
 547         ret = FALSE;
 548     } else
 549       ret = FALSE;
 550   } else if (strcmp (gst_structure_get_name (s), "audio/x-alaw") == 0) {
 551     pad->codec = 7;
 552   } else if (strcmp (gst_structure_get_name (s), "audio/x-mulaw") == 0) {
 553     pad->codec = 8;
 554   } else if (strcmp (gst_structure_get_name (s), "audio/x-speex") == 0) {
 555     pad->codec = 11;
 556   } else {
 557     ret = FALSE;
 558   }
 559
 560   if (ret) {
 561     gint rate, channels;
 562
 563     if (gst_structure_get_int (s, "rate", &rate)) {
 564       if (pad->codec == 10)
 565         pad->rate = 3;
 566       else if (rate == 5512)
 567         pad->rate = 0;
 568       else if (rate == 11025)
 569         pad->rate = 1;
 570       else if (rate == 22050)
 571         pad->rate = 2;
 572       else if (rate == 44100)
 573         pad->rate = 3;
 574       else if (rate == 8000 && (pad->codec == 5 || pad->codec == 14
 575               || pad->codec == 7 || pad->codec == 8))
 576         pad->rate = 0;
 577       else if (rate == 16000 && (pad->codec == 4 || pad->codec == 11))
 578         pad->rate = 0;
 579       else
 580         ret = FALSE;
 581     } else if (pad->codec == 10) {
 582       pad->rate = 3;
 583     } else {
 584       ret = FALSE;
 585     }
 586
 587     if (gst_structure_get_int (s, "channels", &channels)) {
 588       if (pad->codec == 4 || pad->codec == 5
 589           || pad->codec == 6 || pad->codec == 11)
 590         pad->channels = 0;
 591       else if (pad->codec == 10)
 592         pad->channels = 1;
 593       else if (channels == 1)
 594         pad->channels = 0;
 595       else if (channels == 2)
 596         pad->channels = 1;
 597       else
 598         ret = FALSE;
 599     } else if (pad->codec == 4 || pad->codec == 5 || pad->codec == 6) {
 600       pad->channels = 0;
 601     } else if (pad->codec == 10) {
 602       pad->channels = 1;
 603     } else {
 604       ret = FALSE;
 605     }
 606
 607     if (pad->codec != 3)
 608       pad->width = 1;
 609   }
 610
 611   if (ret && gst_structure_has_field (s, "codec_data")) {
 612     const GValue *val = gst_structure_get_value (s, "codec_data");
 613
 614     if (val)
 615       gst_buffer_replace (&pad->codec_data, gst_value_get_buffer (val));
 616     else if (!val && pad->codec_data)
 617       gst_buffer_unref (pad->codec_data);
 618   }
 619
 620   if (ret && mux->streamable && mux->state != GST_FLV_MUX_STATE_HEADER) {
 621     if (old_codec != pad->codec || old_rate != pad->rate ||
 622         old_width != pad->width || old_channels != pad->channels) {
 623       pad->info_changed = TRUE;
 624     }
 625
 626     if (old_codec_data && pad->codec_data) {
 627       GstMapInfo map;
 628
 629       gst_buffer_map (old_codec_data, &map, GST_MAP_READ);
 630       if (map.size != gst_buffer_get_size (pad->codec_data) ||
 631           gst_buffer_memcmp (pad->codec_data, 0, map.data, map.size))
 632         pad->info_changed = TRUE;
 633
 634       gst_buffer_unmap (old_codec_data, &map);
 635     } else if (!old_codec_data && pad->codec_data) {
 636       pad->info_changed = TRUE;
 637     }
 638
 639     if (pad->info_changed)
 640       mux->state = GST_FLV_MUX_STATE_HEADER;
 641   }
 642
 643   if (old_codec_data)
 644     gst_buffer_unref (old_codec_data);
 645
 646   gst_object_unref (mux);
 647
 648   return ret;
 649 }
 650
 651 static void
 652 gst_flv_mux_reset_pad (GstFlvMuxPad * pad)
 653 {
 654   GST_DEBUG_OBJECT (pad, "resetting pad");
 655
 656   if (pad->codec_data)
 657     gst_buffer_unref (pad->codec_data);
 658   pad->codec_data = NULL;
 659   pad->codec = G_MAXUINT;
 660   pad->rate = G_MAXUINT;
 661   pad->width = G_MAXUINT;
 662   pad->channels = G_MAXUINT;
 663   pad->info_changed = FALSE;
 664
 665   gst_flv_mux_pad_flush (GST_AGGREGATOR_PAD_CAST (pad), NULL);
 666 }
 667
 668 static GstAggregatorPad *
 669 gst_flv_mux_create_new_pad (GstAggregator * agg,
 670     GstPadTemplate * templ, const gchar * req_name, const GstCaps * caps)
 671 {
 672   GstElementClass *klass = GST_ELEMENT_GET_CLASS (agg);
 673   GstAggregatorPad *aggpad;
 674   GstFlvMux *mux = GST_FLV_MUX (agg);
 675   GstFlvMuxPad *pad = NULL;
 676   const gchar *name = NULL;
 677   gboolean video;
 678
 679   if (mux->state != GST_FLV_MUX_STATE_HEADER) {
 680     GST_WARNING_OBJECT (mux, "Can't request pads after writing header");
 681     return NULL;
 682   }
 683
 684   if (templ == gst_element_class_get_pad_template (klass, "audio")) {
 685     if (mux->audio_pad) {
 686       GST_WARNING_OBJECT (mux, "Already have an audio pad");
 687       return NULL;
 688     }
 689     name = "audio";
 690     video = FALSE;
 691   } else if (templ == gst_element_class_get_pad_template (klass, "video")) {
 692     if (mux->video_pad) {
 693       GST_WARNING_OBJECT (mux, "Already have a video pad");
 694       return NULL;
 695     }
 696     name = "video";
 697     video = TRUE;
 698   } else {
 699     GST_WARNING_OBJECT (mux, "Invalid template");
 700     return NULL;
 701   }
 702
 703   aggpad =
 704       GST_AGGREGATOR_CLASS (gst_flv_mux_parent_class)->create_new_pad (agg,
 705       templ, name, caps);
 706   if (aggpad == NULL)
 707     return NULL;
 708
 709   pad = GST_FLV_MUX_PAD (aggpad);
 710
 711   gst_flv_mux_reset_pad (pad);
 712
 713   if (video)
 714     mux->video_pad = pad;
 715   else
 716     mux->audio_pad = pad;
 717
 718   return aggpad;
 719 }
 720
 721 static void
 722 gst_flv_mux_release_pad (GstElement * element, GstPad * pad)
 723 {
 724   GstFlvMux *mux = GST_FLV_MUX (element);
 725   GstFlvMuxPad *flvpad = GST_FLV_MUX_PAD (pad);
 726
 727   gst_pad_set_active (pad, FALSE);
 728   gst_flv_mux_reset_pad (flvpad);
 729
 730   if (flvpad == mux->video_pad) {
 731     mux->video_pad = NULL;
 732   } else if (flvpad == mux->audio_pad) {
 733     mux->audio_pad = NULL;
 734   } else {
 735     GST_WARNING_OBJECT (pad, "Pad is not known audio or video pad");
 736   }
 737
 738   gst_element_remove_pad (element, pad);
 739 }
 740
 741 static GstFlowReturn
 742 gst_flv_mux_push (GstFlvMux * mux, GstBuffer * buffer)
 743 {
 744   GstAggregator *agg = GST_AGGREGATOR (mux);
 745   GstAggregatorPad *srcpad = GST_AGGREGATOR_PAD (agg->srcpad);
 746
 747   if (GST_BUFFER_PTS_IS_VALID (buffer))
 748     srcpad->segment.position = GST_BUFFER_PTS (buffer);
 749
 750   /* pushing the buffer that rewrites the header will make it no longer be the
 751    * total output size in bytes, but it doesn't matter at that point */
 752   mux->byte_count += gst_buffer_get_size (buffer);
 753
 754   return gst_aggregator_finish_buffer (GST_AGGREGATOR_CAST (mux), buffer);
 755 }
 756
 757 static GstBuffer *
 758 gst_flv_mux_create_header (GstFlvMux * mux)
 759 {
 760   GstBuffer *header;
 761   guint8 *data;
 762   gboolean have_audio;
 763   gboolean have_video;
 764
 765   _gst_buffer_new_and_alloc (9 + 4, &header, &data);
 766
 767   data[0] = 'F';
 768   data[1] = 'L';
 769   data[2] = 'V';
 770   data[3] = 0x01;               /* Version */
 771
 772   have_audio = (mux->audio_pad && mux->audio_pad->codec != G_MAXUINT);
 773   have_video = (mux->video_pad && mux->video_pad->codec != G_MAXUINT);
 774
 775   data[4] = (have_audio << 2) | have_video;     /* flags */
 776   GST_WRITE_UINT32_BE (data + 5, 9);    /* data offset */
 777   GST_WRITE_UINT32_BE (data + 9, 0);    /* previous tag size */
 778
 779   return header;
 780 }
 781
 782 static GstBuffer *
 783 gst_flv_mux_preallocate_index (GstFlvMux * mux)
 784 {
 785   GstBuffer *tmp;
 786   guint8 *data;
 787   gint preallocate_size;
 788
 789   /* preallocate index of size:
 790    *  - 'keyframes' ECMA array key: 2 + 9 = 11 bytes
 791    *  - nested ECMA array header, length and end marker: 8 bytes
 792    *  - 'times' and 'filepositions' keys: 22 bytes
 793    *  - two strict arrays headers and lengths: 10 bytes
 794    *  - each index entry: 18 bytes
 795    */
 796   preallocate_size = 11 + 8 + 22 + 10 + MAX_INDEX_ENTRIES * 18;
 797   GST_DEBUG_OBJECT (mux, "preallocating %d bytes for the index",
 798       preallocate_size);
 799
 800   _gst_buffer_new_and_alloc (preallocate_size, &tmp, &data);
 801
 802   /* prefill the space with a gstfiller: <spaces> script tag variable */
 803   GST_WRITE_UINT16_BE (data, 9);        /* 9 characters */
 804   memcpy (data + 2, "gstfiller", 9);
 805   GST_WRITE_UINT8 (data + 11, AMF0_STRING_MARKER);      /* a string value */
 806   GST_WRITE_UINT16_BE (data + 12, preallocate_size - 14);
 807   memset (data + 14, ' ', preallocate_size - 14);       /* the rest is spaces */
 808   return tmp;
 809 }
 810
 811 static GstBuffer *
 812 gst_flv_mux_create_number_script_value (const gchar * name, gdouble value)
 813 {
 814   GstBuffer *tmp;
 815   guint8 *data;
 816   gsize len = strlen (name);
 817
 818   _gst_buffer_new_and_alloc (2 + len + 1 + 8, &tmp, &data);
 819
 820   GST_WRITE_UINT16_BE (data, len);
 821   data += 2;                    /* name length */
 822   memcpy (data, name, len);
 823   data += len;
 824   *data++ = AMF0_NUMBER_MARKER; /* double type */
 825   GST_WRITE_DOUBLE_BE (data, value);
 826
 827   return tmp;
 828 }
 829
 830 static GstBuffer *
 831 gst_flv_mux_create_metadata (GstFlvMux * mux, gboolean full)
 832 {
 833   const GstTagList *tags;
 834   GstBuffer *script_tag, *tmp;
 835   GstMapInfo map;
 836   guint8 *data;
 837   gint i, n_tags, tags_written = 0;
 838
 839   tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (mux));
 840
 841   GST_DEBUG_OBJECT (mux, "tags = %" GST_PTR_FORMAT, tags);
 842
 843   /* FIXME perhaps some bytewriter'ing here ... */
 844
 845   _gst_buffer_new_and_alloc (11, &script_tag, &data);
 846
 847   data[0] = 18;
 848
 849   /* Data size, unknown for now */
 850   data[1] = 0;
 851   data[2] = 0;
 852   data[3] = 0;
 853
 854   /* Timestamp */
 855   data[4] = data[5] = data[6] = data[7] = 0;
 856
 857   /* Stream ID */
 858   data[8] = data[9] = data[10] = 0;
 859
 860   _gst_buffer_new_and_alloc (13, &tmp, &data);
 861   data[0] = AMF0_STRING_MARKER; /* string */
 862   data[1] = 0;
 863   data[2] = 10;                 /* length 10 */
 864   memcpy (&data[3], "onMetaData", 10);
 865
 866   script_tag = gst_buffer_append (script_tag, tmp);
 867
 868   n_tags = (tags) ? gst_tag_list_n_tags (tags) : 0;
 869   _gst_buffer_new_and_alloc (5, &tmp, &data);
 870   data[0] = 8;                  /* ECMA array */
 871   GST_WRITE_UINT32_BE (data + 1, n_tags);
 872   script_tag = gst_buffer_append (script_tag, tmp);
 873
 874   if (!full)
 875     goto tags;
 876
 877   /* Some players expect the 'duration' to be always set. Fill it out later,
 878      after querying the pads or after getting EOS */
 879   if (!mux->streamable) {
 880     tmp = gst_flv_mux_create_number_script_value ("duration", 86400);
 881     script_tag = gst_buffer_append (script_tag, tmp);
 882     tags_written++;
 883
 884     /* Sometimes the information about the total file size is useful for the
 885        player. It will be filled later, after getting EOS */
 886     tmp = gst_flv_mux_create_number_script_value ("filesize", 0);
 887     script_tag = gst_buffer_append (script_tag, tmp);
 888     tags_written++;
 889
 890     /* Preallocate space for the index to be written at EOS */
 891     tmp = gst_flv_mux_preallocate_index (mux);
 892     script_tag = gst_buffer_append (script_tag, tmp);
 893   } else {
 894     GST_DEBUG_OBJECT (mux, "not preallocating index, streamable mode");
 895   }
 896
 897 tags:
 898   for (i = 0; tags && i < n_tags; i++) {
 899     const gchar *tag_name = gst_tag_list_nth_tag_name (tags, i);
 900     if (!strcmp (tag_name, GST_TAG_DURATION)) {
 901       guint64 dur;
 902
 903       if (!gst_tag_list_get_uint64 (tags, GST_TAG_DURATION, &dur))
 904         continue;
 905       mux->duration = dur;
 906     } else if (!strcmp (tag_name, GST_TAG_ARTIST) ||
 907         !strcmp (tag_name, GST_TAG_TITLE)) {
 908       gchar *s;
 909       const gchar *t = NULL;
 910
 911       if (!strcmp (tag_name, GST_TAG_ARTIST))
 912         t = "creator";
 913       else if (!strcmp (tag_name, GST_TAG_TITLE))
 914         t = "title";
 915
 916       if (!gst_tag_list_get_string (tags, tag_name, &s))
 917         continue;
 918
 919       _gst_buffer_new_and_alloc (2 + strlen (t) + 1 + 2 + strlen (s),
 920           &tmp, &data);
 921       data[0] = 0;              /* tag name length */
 922       data[1] = strlen (t);
 923       memcpy (&data[2], t, strlen (t));
 924       data[2 + strlen (t)] = 2; /* string */
 925       data[3 + strlen (t)] = (strlen (s) >> 8) & 0xff;
 926       data[4 + strlen (t)] = (strlen (s)) & 0xff;
 927       memcpy (&data[5 + strlen (t)], s, strlen (s));
 928       script_tag = gst_buffer_append (script_tag, tmp);
 929
 930       g_free (s);
 931       tags_written++;
 932     }
 933   }
 934
 935   if (!full)
 936     goto end;
 937
 938   if (!mux->streamable && mux->duration == GST_CLOCK_TIME_NONE) {
 939     GList *l;
 940     guint64 dur;
 941
 942     for (l = GST_ELEMENT_CAST (mux)->sinkpads; l; l = l->next) {
 943       GstFlvMuxPad *pad = GST_FLV_MUX_PAD (l->data);
 944
 945       if (gst_pad_peer_query_duration (GST_PAD (pad), GST_FORMAT_TIME,
 946               (gint64 *) & dur) && dur != GST_CLOCK_TIME_NONE) {
 947         if (mux->duration == GST_CLOCK_TIME_NONE)
 948           mux->duration = dur;
 949         else
 950           mux->duration = MAX (dur, mux->duration);
 951       }
 952     }
 953   }
 954
 955   if (!mux->streamable && mux->duration != GST_CLOCK_TIME_NONE) {
 956     gdouble d;
 957     GstMapInfo map;
 958
 959     d = gst_guint64_to_gdouble (mux->duration);
 960     d /= (gdouble) GST_SECOND;
 961
 962     GST_DEBUG_OBJECT (mux, "determined the duration to be %f", d);
 963     gst_buffer_map (script_tag, &map, GST_MAP_WRITE);
 964     GST_WRITE_DOUBLE_BE (map.data + 29 + 2 + 8 + 1, d);
 965     gst_buffer_unmap (script_tag, &map);
 966   }
 967
 968   if (mux->video_pad && mux->video_pad->codec != G_MAXUINT) {
 969     GstCaps *caps = NULL;
 970
 971     if (mux->video_pad)
 972       caps = gst_pad_get_current_caps (GST_PAD (mux->video_pad));
 973
 974     if (caps != NULL) {
 975       GstStructure *s;
 976       gint size;
 977       gint num, den;
 978
 979       GST_DEBUG_OBJECT (mux, "putting videocodecid %d in the metadata",
 980           mux->video_pad->codec);
 981
 982       tmp = gst_flv_mux_create_number_script_value ("videocodecid",
 983           mux->video_pad->codec);
 984       script_tag = gst_buffer_append (script_tag, tmp);
 985       tags_written++;
 986
 987       s = gst_caps_get_structure (caps, 0);
 988       gst_caps_unref (caps);
 989
 990       if (gst_structure_get_int (s, "width", &size)) {
 991         GST_DEBUG_OBJECT (mux, "putting width %d in the metadata", size);
 992
 993         tmp = gst_flv_mux_create_number_script_value ("width", size);
 994         script_tag = gst_buffer_append (script_tag, tmp);
 995         tags_written++;
 996       }
 997
 998       if (gst_structure_get_int (s, "height", &size)) {
 999         GST_DEBUG_OBJECT (mux, "putting height %d in the metadata", size);
1000
1001         tmp = gst_flv_mux_create_number_script_value ("height", size);
1002         script_tag = gst_buffer_append (script_tag, tmp);
1003         tags_written++;
1004       }
1005
1006       if (gst_structure_get_fraction (s, "pixel-aspect-ratio", &num, &den)) {
1007         gdouble d;
1008
1009         d = num;
1010         GST_DEBUG_OBJECT (mux, "putting AspectRatioX %f in the metadata", d);
1011
1012         tmp = gst_flv_mux_create_number_script_value ("AspectRatioX", d);
1013         script_tag = gst_buffer_append (script_tag, tmp);
1014         tags_written++;
1015
1016         d = den;
1017         GST_DEBUG_OBJECT (mux, "putting AspectRatioY %f in the metadata", d);
1018
1019         tmp = gst_flv_mux_create_number_script_value ("AspectRatioY", d);
1020         script_tag = gst_buffer_append (script_tag, tmp);
1021         tags_written++;
1022       }
1023
1024       if (gst_structure_get_fraction (s, "framerate", &num, &den)) {
1025         gdouble d;
1026
1027         gst_util_fraction_to_double (num, den, &d);
1028         GST_DEBUG_OBJECT (mux, "putting framerate %f in the metadata", d);
1029
1030         tmp = gst_flv_mux_create_number_script_value ("framerate", d);
1031         script_tag = gst_buffer_append (script_tag, tmp);
1032         tags_written++;
1033       }
1034
1035       GST_DEBUG_OBJECT (mux, "putting videodatarate %u KB/s in the metadata",
1036           mux->video_pad->bitrate / 1024);
1037       tmp = gst_flv_mux_create_number_script_value ("videodatarate",
1038           mux->video_pad->bitrate / 1024);
1039       script_tag = gst_buffer_append (script_tag, tmp);
1040       tags_written++;
1041     }
1042   }
1043
1044   if (mux->audio_pad && mux->audio_pad->codec != G_MAXUINT) {
1045     GST_DEBUG_OBJECT (mux, "putting audiocodecid %d in the metadata",
1046         mux->audio_pad->codec);
1047
1048     tmp = gst_flv_mux_create_number_script_value ("audiocodecid",
1049         mux->audio_pad->codec);
1050     script_tag = gst_buffer_append (script_tag, tmp);
1051     tags_written++;
1052
1053     GST_DEBUG_OBJECT (mux, "putting audiodatarate %u KB/s in the metadata",
1054         mux->audio_pad->bitrate / 1024);
1055     tmp = gst_flv_mux_create_number_script_value ("audiodatarate",
1056         mux->audio_pad->bitrate / 1024);
1057     script_tag = gst_buffer_append (script_tag, tmp);
1058     tags_written++;
1059   }
1060
1061   _gst_buffer_new_and_alloc (2 + 15 + 1 + 2 + strlen (mux->metadatacreator),
1062       &tmp, &data);
1063   data[0] = 0;                  /* 15 bytes name */
1064   data[1] = 15;
1065   memcpy (&data[2], "metadatacreator", 15);
1066   data[17] = 2;                 /* string */
1067   data[18] = (strlen (mux->metadatacreator) >> 8) & 0xff;
1068   data[19] = (strlen (mux->metadatacreator)) & 0xff;
1069   memcpy (&data[20], mux->metadatacreator, strlen (mux->metadatacreator));
1070   script_tag = gst_buffer_append (script_tag, tmp);
1071   tags_written++;
1072
1073   _gst_buffer_new_and_alloc (2 + 7 + 1 + 2 + strlen (mux->encoder),
1074       &tmp, &data);
1075   data[0] = 0;                  /* 7 bytes name */
1076   data[1] = 7;
1077   memcpy (&data[2], "encoder", 7);
1078   data[9] = 2;                  /* string */
1079   data[10] = (strlen (mux->encoder) >> 8) & 0xff;
1080   data[11] = (strlen (mux->encoder)) & 0xff;
1081   memcpy (&data[12], mux->encoder, strlen (mux->encoder));
1082   script_tag = gst_buffer_append (script_tag, tmp);
1083   tags_written++;
1084
1085   {
1086     time_t secs;
1087     struct tm *tm;
1088     gchar *s;
1089     static const gchar *weekdays[] = {
1090       "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
1091     };
1092     static const gchar *months[] = {
1093       "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
1094       "Aug", "Sep", "Oct", "Nov", "Dec"
1095     };
1096
1097     secs = g_get_real_time () / G_USEC_PER_SEC;
1098     tm = gmtime (&secs);
1099
1100     s = g_strdup_printf ("%s %s %d %02d:%02d:%02d %d", weekdays[tm->tm_wday],
1101         months[tm->tm_mon], tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
1102         tm->tm_year + 1900);
1103
1104     _gst_buffer_new_and_alloc (2 + 12 + 1 + 2 + strlen (s), &tmp, &data);
1105     data[0] = 0;                /* 12 bytes name */
1106     data[1] = 12;
1107     memcpy (&data[2], "creationdate", 12);
1108     data[14] = 2;               /* string */
1109     data[15] = (strlen (s) >> 8) & 0xff;
1110     data[16] = (strlen (s)) & 0xff;
1111     memcpy (&data[17], s, strlen (s));
1112     script_tag = gst_buffer_append (script_tag, tmp);
1113
1114     g_free (s);
1115     tags_written++;
1116   }
1117
1118 end:
1119
1120   if (!tags_written) {
1121     gst_buffer_unref (script_tag);
1122     script_tag = NULL;
1123     goto exit;
1124   }
1125
1126   _gst_buffer_new_and_alloc (2 + 0 + 1, &tmp, &data);
1127   data[0] = 0;                  /* 0 byte size */
1128   data[1] = 0;
1129   data[2] = 9;                  /* end marker */
1130   script_tag = gst_buffer_append (script_tag, tmp);
1131
1132
1133   _gst_buffer_new_and_alloc (4, &tmp, &data);
1134   GST_WRITE_UINT32_BE (data, gst_buffer_get_size (script_tag));
1135   script_tag = gst_buffer_append (script_tag, tmp);
1136
1137   gst_buffer_map (script_tag, &map, GST_MAP_WRITE);
1138   map.data[1] = ((gst_buffer_get_size (script_tag) - 11 - 4) >> 16) & 0xff;
1139   map.data[2] = ((gst_buffer_get_size (script_tag) - 11 - 4) >> 8) & 0xff;
1140   map.data[3] = ((gst_buffer_get_size (script_tag) - 11 - 4) >> 0) & 0xff;
1141
1142   GST_WRITE_UINT32_BE (map.data + 11 + 13 + 1, tags_written);
1143   gst_buffer_unmap (script_tag, &map);
1144
1145 exit:
1146   return script_tag;
1147 }
1148
1149 static GstBuffer *
1150 gst_flv_mux_buffer_to_tag_internal (GstFlvMux * mux, GstBuffer * buffer,
1151     GstFlvMuxPad * pad, gboolean is_codec_data)
1152 {
1153   GstBuffer *tag;
1154   GstMapInfo map;
1155   guint size;
1156   guint32 pts, dts, cts;
1157   guint8 *data, *bdata = NULL;
1158   gsize bsize = 0;
1159
1160   if (!GST_CLOCK_STIME_IS_VALID (pad->dts)) {
1161     pts = dts = pad->last_timestamp / GST_MSECOND;
1162   } else {
1163     pts = pad->pts / GST_MSECOND;
1164     dts = pad->dts / GST_MSECOND;
1165   }
1166
1167   /* We prevent backwards timestamps because they confuse librtmp,
1168    * it expects timestamps to go forward not only inside one stream, but
1169    * also between the audio & video streams.
1170    */
1171   if (dts < mux->last_dts) {
1172     GST_WARNING_OBJECT (pad, "Got backwards dts! (%" GST_TIME_FORMAT
1173         " < %" GST_TIME_FORMAT ")", GST_TIME_ARGS (dts * GST_MSECOND),
1174         GST_TIME_ARGS (mux->last_dts * GST_MSECOND));
1175     dts = mux->last_dts;
1176   }
1177   mux->last_dts = dts;
1178
1179
1180   /* Be safe in case TS are buggy */
1181   if (pts > dts)
1182     cts = pts - dts;
1183   else
1184     cts = 0;
1185
1186   /* Timestamp must start at zero */
1187   if (GST_CLOCK_STIME_IS_VALID (mux->first_timestamp)) {
1188     dts -= mux->first_timestamp / GST_MSECOND;
1189     pts = dts + cts;
1190   }
1191
1192   GST_LOG_OBJECT (mux, "got pts %i dts %i cts %i", pts, dts, cts);
1193
1194   if (buffer != NULL) {
1195     gst_buffer_map (buffer, &map, GST_MAP_READ);
1196     bdata = map.data;
1197     bsize = map.size;
1198   }
1199
1200   size = 11;
1201   if (mux->video_pad == pad) {
1202     size += 1;
1203     if (pad->codec == 7)
1204       size += 4 + bsize;
1205     else
1206       size += bsize;
1207   } else {
1208     size += 1;
1209     if (pad->codec == 10)
1210       size += 1 + bsize;
1211     else
1212       size += bsize;
1213   }
1214   size += 4;
1215
1216   _gst_buffer_new_and_alloc (size, &tag, &data);
1217   memset (data, 0, size);
1218
1219   data[0] = (mux->video_pad == pad) ? 9 : 8;
1220
1221   data[1] = ((size - 11 - 4) >> 16) & 0xff;
1222   data[2] = ((size - 11 - 4) >> 8) & 0xff;
1223   data[3] = ((size - 11 - 4) >> 0) & 0xff;
1224
1225
1226   GST_WRITE_UINT24_BE (data + 4, dts);
1227   data[7] = (((guint) dts) >> 24) & 0xff;
1228
1229   data[8] = data[9] = data[10] = 0;
1230
1231   if (mux->video_pad == pad) {
1232     if (buffer && GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT))
1233       data[11] |= 2 << 4;
1234     else
1235       data[11] |= 1 << 4;
1236
1237     data[11] |= pad->codec & 0x0f;
1238
1239     if (pad->codec == 7) {
1240       if (is_codec_data) {
1241         data[12] = 0;
1242         GST_WRITE_UINT24_BE (data + 13, 0);
1243       } else if (bsize == 0) {
1244         /* AVC end of sequence */
1245         data[12] = 2;
1246         GST_WRITE_UINT24_BE (data + 13, 0);
1247       } else {
1248         /* ACV NALU */
1249         data[12] = 1;
1250         GST_WRITE_UINT24_BE (data + 13, cts);
1251       }
1252       memcpy (data + 11 + 1 + 4, bdata, bsize);
1253     } else {
1254       memcpy (data + 11 + 1, bdata, bsize);
1255     }
1256   } else {
1257     data[11] |= (pad->codec << 4) & 0xf0;
1258     data[11] |= (pad->rate << 2) & 0x0c;
1259     data[11] |= (pad->width << 1) & 0x02;
1260     data[11] |= (pad->channels << 0) & 0x01;
1261
1262     GST_DEBUG_OBJECT (mux, "Creating byte %02x with "
1263         "codec:%d, rate:%d, width:%d, channels:%d",
1264         data[11], pad->codec, pad->rate, pad->width, pad->channels);
1265
1266     if (pad->codec == 10) {
1267       data[12] = is_codec_data ? 0 : 1;
1268
1269       memcpy (data + 11 + 1 + 1, bdata, bsize);
1270     } else {
1271       memcpy (data + 11 + 1, bdata, bsize);
1272     }
1273   }
1274
1275   if (buffer)
1276     gst_buffer_unmap (buffer, &map);
1277
1278   GST_WRITE_UINT32_BE (data + size - 4, size - 4);
1279
1280   GST_BUFFER_PTS (tag) = GST_CLOCK_TIME_NONE;
1281   GST_BUFFER_DTS (tag) = GST_CLOCK_TIME_NONE;
1282   GST_BUFFER_DURATION (tag) = GST_CLOCK_TIME_NONE;
1283
1284   if (buffer) {
1285     /* if we are streamable we copy over timestamps and offsets,
1286        if not just copy the offsets */
1287     if (mux->streamable) {
1288       GstClockTime timestamp = GST_CLOCK_TIME_NONE;
1289
1290       if (gst_segment_to_running_time_full (&GST_AGGREGATOR_PAD (pad)->segment,
1291               GST_FORMAT_TIME, GST_BUFFER_DTS_OR_PTS (buffer),
1292               &timestamp) == 1) {
1293         GST_BUFFER_PTS (tag) = timestamp;
1294         GST_BUFFER_DURATION (tag) = GST_BUFFER_DURATION (buffer);
1295       }
1296       GST_BUFFER_OFFSET (tag) = GST_BUFFER_OFFSET_NONE;
1297       GST_BUFFER_OFFSET_END (tag) = GST_BUFFER_OFFSET_NONE;
1298     } else {
1299       GST_BUFFER_OFFSET (tag) = GST_BUFFER_OFFSET (buffer);
1300       GST_BUFFER_OFFSET_END (tag) = GST_BUFFER_OFFSET_END (buffer);
1301     }
1302
1303     /* mark the buffer if it's an audio buffer and there's also video being muxed
1304      * or it's a video interframe */
1305     if (mux->video_pad == pad &&
1306         GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT))
1307       GST_BUFFER_FLAG_SET (tag, GST_BUFFER_FLAG_DELTA_UNIT);
1308   } else {
1309     GST_BUFFER_FLAG_SET (tag, GST_BUFFER_FLAG_DELTA_UNIT);
1310     GST_BUFFER_OFFSET (tag) = GST_BUFFER_OFFSET_END (tag) =
1311         GST_BUFFER_OFFSET_NONE;
1312   }
1313
1314   return tag;
1315 }
1316
1317 static inline GstBuffer *
1318 gst_flv_mux_buffer_to_tag (GstFlvMux * mux, GstBuffer * buffer,
1319     GstFlvMuxPad * pad)
1320 {
1321   return gst_flv_mux_buffer_to_tag_internal (mux, buffer, pad, FALSE);
1322 }
1323
1324 static inline GstBuffer *
1325 gst_flv_mux_codec_data_buffer_to_tag (GstFlvMux * mux, GstBuffer * buffer,
1326     GstFlvMuxPad * pad)
1327 {
1328   return gst_flv_mux_buffer_to_tag_internal (mux, buffer, pad, TRUE);
1329 }
1330
1331 static inline GstBuffer *
1332 gst_flv_mux_eos_to_tag (GstFlvMux * mux, GstFlvMuxPad * pad)
1333 {
1334   return gst_flv_mux_buffer_to_tag_internal (mux, NULL, pad, FALSE);
1335 }
1336
1337 static void
1338 gst_flv_mux_put_buffer_in_streamheader (GValue * streamheader,
1339     GstBuffer * buffer)
1340 {
1341   GValue value = { 0 };
1342   GstBuffer *buf;
1343
1344   g_value_init (&value, GST_TYPE_BUFFER);
1345   buf = gst_buffer_copy (buffer);
1346   gst_value_set_buffer (&value, buf);
1347   gst_buffer_unref (buf);
1348   gst_value_array_append_value (streamheader, &value);
1349   g_value_unset (&value);
1350 }
1351
1352 static GstCaps *
1353 gst_flv_mux_prepare_src_caps (GstFlvMux * mux, GstBuffer ** header_buf,
1354     GstBuffer ** metadata_buf, GstBuffer ** video_codec_data_buf,
1355     GstBuffer ** audio_codec_data_buf)
1356 {
1357   GstBuffer *header, *metadata;
1358   GstBuffer *video_codec_data, *audio_codec_data;
1359   GstCaps *caps;
1360   GstStructure *structure;
1361   GValue streamheader = { 0 };
1362   GList *l;
1363
1364   header = gst_flv_mux_create_header (mux);
1365   metadata = gst_flv_mux_create_metadata (mux, TRUE);
1366   video_codec_data = NULL;
1367   audio_codec_data = NULL;
1368
1369   for (l = GST_ELEMENT_CAST (mux)->sinkpads; l != NULL; l = l->next) {
1370     GstFlvMuxPad *pad = l->data;
1371
1372     /* Get H.264 and AAC codec data, if present */
1373     if (pad && mux->video_pad == pad && pad->codec == 7) {
1374       if (pad->codec_data == NULL)
1375         GST_WARNING_OBJECT (mux, "Codec data for video stream not found, "
1376             "output might not be playable");
1377       else
1378         video_codec_data =
1379             gst_flv_mux_codec_data_buffer_to_tag (mux, pad->codec_data, pad);
1380     } else if (pad && mux->audio_pad == pad && pad->codec == 10) {
1381       if (pad->codec_data == NULL)
1382         GST_WARNING_OBJECT (mux, "Codec data for audio stream not found, "
1383             "output might not be playable");
1384       else
1385         audio_codec_data =
1386             gst_flv_mux_codec_data_buffer_to_tag (mux, pad->codec_data, pad);
1387     }
1388   }
1389
1390   /* mark buffers that will go in the streamheader */
1391   GST_BUFFER_FLAG_SET (header, GST_BUFFER_FLAG_HEADER);
1392   GST_BUFFER_FLAG_SET (metadata, GST_BUFFER_FLAG_HEADER);
1393   if (video_codec_data != NULL) {
1394     GST_BUFFER_FLAG_SET (video_codec_data, GST_BUFFER_FLAG_HEADER);
1395     /* mark as a delta unit, so downstream will not try to synchronize on that
1396      * buffer - to actually start playback you need a real video keyframe */
1397     GST_BUFFER_FLAG_SET (video_codec_data, GST_BUFFER_FLAG_DELTA_UNIT);
1398   }
1399   if (audio_codec_data != NULL) {
1400     GST_BUFFER_FLAG_SET (audio_codec_data, GST_BUFFER_FLAG_HEADER);
1401   }
1402
1403   /* put buffers in streamheader */
1404   g_value_init (&streamheader, GST_TYPE_ARRAY);
1405   gst_flv_mux_put_buffer_in_streamheader (&streamheader, header);
1406   gst_flv_mux_put_buffer_in_streamheader (&streamheader, metadata);
1407   if (video_codec_data != NULL)
1408     gst_flv_mux_put_buffer_in_streamheader (&streamheader, video_codec_data);
1409   if (audio_codec_data != NULL)
1410     gst_flv_mux_put_buffer_in_streamheader (&streamheader, audio_codec_data);
1411
1412   /* create the caps and put the streamheader in them */
1413   caps = gst_caps_new_empty_simple ("video/x-flv");
1414   structure = gst_caps_get_structure (caps, 0);
1415   gst_structure_set_value (structure, "streamheader", &streamheader);
1416   g_value_unset (&streamheader);
1417
1418   if (header_buf) {
1419     *header_buf = header;
1420   } else {
1421     gst_buffer_unref (header);
1422   }
1423
1424   if (metadata_buf) {
1425     *metadata_buf = metadata;
1426   } else {
1427     gst_buffer_unref (metadata);
1428   }
1429
1430   if (video_codec_data_buf) {
1431     *video_codec_data_buf = video_codec_data;
1432   } else if (video_codec_data) {
1433     gst_buffer_unref (video_codec_data);
1434   }
1435
1436   if (audio_codec_data_buf) {
1437     *audio_codec_data_buf = audio_codec_data;
1438   } else if (audio_codec_data) {
1439     gst_buffer_unref (audio_codec_data);
1440   }
1441
1442   return caps;
1443 }
1444
1445 static GstFlowReturn
1446 gst_flv_mux_write_header (GstFlvMux * mux)
1447 {
1448   GstBuffer *header, *metadata;
1449   GstBuffer *video_codec_data, *audio_codec_data;
1450   GstCaps *caps;
1451   GstFlowReturn ret;
1452
1453   header = metadata = video_codec_data = audio_codec_data = NULL;
1454
1455   /* if not streaming, check if downstream is seekable */
1456   if (!mux->streamable) {
1457     gboolean seekable;
1458     GstQuery *query;
1459
1460     query = gst_query_new_seeking (GST_FORMAT_BYTES);
1461     if (gst_pad_peer_query (mux->srcpad, query)) {
1462       gst_query_parse_seeking (query, NULL, &seekable, NULL, NULL);
1463       GST_INFO_OBJECT (mux, "downstream is %sseekable", seekable ? "" : "not ");
1464     } else {
1465       /* have to assume seeking is supported if query not handled downstream */
1466       GST_WARNING_OBJECT (mux, "downstream did not handle seeking query");
1467       seekable = FALSE;
1468     }
1469     if (!seekable) {
1470       mux->streamable = TRUE;
1471       g_object_notify (G_OBJECT (mux), "streamable");
1472       GST_WARNING_OBJECT (mux, "downstream is not seekable, but "
1473           "streamable=false. Will ignore that and create streamable output "
1474           "instead");
1475     }
1476     gst_query_unref (query);
1477   }
1478
1479   if (mux->streamable && mux->sent_header) {
1480     GstBuffer **video_codec_data_p = NULL, **audio_codec_data_p = NULL;
1481
1482     if (mux->video_pad && mux->video_pad->info_changed)
1483       video_codec_data_p = &video_codec_data;
1484     if (mux->audio_pad && mux->audio_pad->info_changed)
1485       audio_codec_data_p = &audio_codec_data;
1486
1487     caps = gst_flv_mux_prepare_src_caps (mux,
1488         NULL, NULL, video_codec_data_p, audio_codec_data_p);
1489   } else {
1490     caps = gst_flv_mux_prepare_src_caps (mux,
1491         &header, &metadata, &video_codec_data, &audio_codec_data);
1492   }
1493
1494   gst_aggregator_set_src_caps (GST_AGGREGATOR_CAST (mux), caps);
1495
1496   gst_caps_unref (caps);
1497
1498   /* push the header buffer, the metadata and the codec info, if any */
1499   if (header != NULL) {
1500     ret = gst_flv_mux_push (mux, header);
1501     if (ret != GST_FLOW_OK)
1502       goto failure_header;
1503     mux->sent_header = TRUE;
1504   }
1505   if (metadata != NULL) {
1506     ret = gst_flv_mux_push (mux, metadata);
1507     if (ret != GST_FLOW_OK)
1508       goto failure_metadata;
1509     mux->new_tags = FALSE;
1510   }
1511   if (video_codec_data != NULL) {
1512     ret = gst_flv_mux_push (mux, video_codec_data);
1513     if (ret != GST_FLOW_OK)
1514       goto failure_video_codec_data;
1515     mux->video_pad->info_changed = FALSE;
1516   }
1517   if (audio_codec_data != NULL) {
1518     ret = gst_flv_mux_push (mux, audio_codec_data);
1519     if (ret != GST_FLOW_OK)
1520       goto failure_audio_codec_data;
1521     mux->audio_pad->info_changed = FALSE;
1522   }
1523   return GST_FLOW_OK;
1524
1525 failure_header:
1526   gst_buffer_unref (metadata);
1527
1528 failure_metadata:
1529   if (video_codec_data != NULL)
1530     gst_buffer_unref (video_codec_data);
1531
1532 failure_video_codec_data:
1533   if (audio_codec_data != NULL)
1534     gst_buffer_unref (audio_codec_data);
1535
1536 failure_audio_codec_data:
1537   return ret;
1538 }
1539
1540 static GstClockTime
1541 gst_flv_mux_segment_to_running_time (const GstSegment * segment, GstClockTime t)
1542 {
1543   /* we can get a dts before the segment, if dts < pts and pts is inside
1544    * the segment, so we consider early times as 0 */
1545   if (t < segment->start)
1546     return 0;
1547   return gst_segment_to_running_time (segment, GST_FORMAT_TIME, t);
1548 }
1549
1550 static void
1551 gst_flv_mux_update_index (GstFlvMux * mux, GstBuffer * buffer,
1552     GstFlvMuxPad * pad)
1553 {
1554   /*
1555    * Add the tag byte offset and to the index if it's a valid seek point, which
1556    * means it's either a video keyframe or if there is no video pad (in that
1557    * case every FLV tag is a valid seek point)
1558    */
1559   if (mux->video_pad == pad &&
1560       GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT))
1561     return;
1562
1563   if (GST_BUFFER_PTS_IS_VALID (buffer)) {
1564     GstFlvMuxIndexEntry *entry = g_slice_new (GstFlvMuxIndexEntry);
1565     GstClockTime pts =
1566         gst_flv_mux_segment_to_running_time (&GST_AGGREGATOR_PAD
1567         (pad)->segment, GST_BUFFER_PTS (buffer));
1568     entry->position = mux->byte_count;
1569     entry->time = gst_guint64_to_gdouble (pts) / GST_SECOND;
1570     mux->index = g_list_prepend (mux->index, entry);
1571   }
1572 }
1573
1574 static GstFlowReturn
1575 gst_flv_mux_write_buffer (GstFlvMux * mux, GstFlvMuxPad * pad,
1576     GstBuffer * buffer)
1577 {
1578   GstBuffer *tag;
1579   GstFlowReturn ret;
1580   GstClockTime dts =
1581       gst_flv_mux_segment_to_running_time (&GST_AGGREGATOR_PAD (pad)->segment,
1582       GST_BUFFER_DTS (buffer));
1583
1584   /* clipping function arranged for running_time */
1585
1586   if (!mux->streamable)
1587     gst_flv_mux_update_index (mux, buffer, pad);
1588
1589   tag = gst_flv_mux_buffer_to_tag (mux, buffer, pad);
1590
1591   gst_buffer_unref (buffer);
1592
1593   ret = gst_flv_mux_push (mux, tag);
1594
1595   if (ret == GST_FLOW_OK && GST_CLOCK_TIME_IS_VALID (dts))
1596     pad->last_timestamp = dts;
1597
1598
1599   return ret;
1600 }
1601
1602 static guint64
1603 gst_flv_mux_determine_duration (GstFlvMux * mux)
1604 {
1605   GList *l;
1606   GstClockTime duration = GST_CLOCK_TIME_NONE;
1607
1608   GST_DEBUG_OBJECT (mux, "trying to determine the duration "
1609       "from pad timestamps");
1610
1611   for (l = GST_ELEMENT_CAST (mux)->sinkpads; l != NULL; l = l->next) {
1612     GstFlvMuxPad *pad = GST_FLV_MUX_PAD (l->data);
1613
1614     if (pad && (pad->last_timestamp != GST_CLOCK_TIME_NONE)) {
1615       if (duration == GST_CLOCK_TIME_NONE)
1616         duration = pad->last_timestamp;
1617       else
1618         duration = MAX (duration, pad->last_timestamp);
1619     }
1620   }
1621
1622   return duration;
1623 }
1624
1625 static gboolean
1626 gst_flv_mux_are_all_pads_eos (GstFlvMux * mux)
1627 {
1628   GList *l;
1629
1630   for (l = GST_ELEMENT_CAST (mux)->sinkpads; l; l = l->next) {
1631     GstFlvMuxPad *pad = GST_FLV_MUX_PAD (l->data);
1632
1633     if (!gst_aggregator_pad_is_eos (GST_AGGREGATOR_PAD (pad)))
1634       return FALSE;
1635   }
1636   return TRUE;
1637 }
1638
1639 static GstFlowReturn
1640 gst_flv_mux_write_eos (GstFlvMux * mux)
1641 {
1642   GstBuffer *tag;
1643
1644   if (mux->video_pad == NULL)
1645     return GST_FLOW_OK;
1646
1647   tag = gst_flv_mux_eos_to_tag (mux, mux->video_pad);
1648
1649   return gst_flv_mux_push (mux, tag);
1650 }
1651
1652 static GstFlowReturn
1653 gst_flv_mux_rewrite_header (GstFlvMux * mux)
1654 {
1655   GstBuffer *rewrite, *index, *tmp;
1656   GstEvent *event;
1657   guint8 *data;
1658   gdouble d;
1659   GList *l;
1660   guint32 index_len, allocate_size;
1661   guint32 i, index_skip;
1662   GstSegment segment;
1663   GstClockTime dur;
1664
1665   if (mux->streamable)
1666     return GST_FLOW_OK;
1667
1668   /* seek back to the preallocated index space */
1669   gst_segment_init (&segment, GST_FORMAT_BYTES);
1670   segment.start = segment.time = 13 + 29;
1671   event = gst_event_new_segment (&segment);
1672   if (!gst_pad_push_event (mux->srcpad, event)) {
1673     GST_WARNING_OBJECT (mux, "Seek to rewrite header failed");
1674     return GST_FLOW_OK;
1675   }
1676
1677   /* determine duration now based on our own timestamping,
1678    * so that it is likely many times better and consistent
1679    * than whatever obtained by some query */
1680   dur = gst_flv_mux_determine_duration (mux);
1681   if (dur != GST_CLOCK_TIME_NONE)
1682     mux->duration = dur;
1683
1684   /* rewrite the duration tag */
1685   d = gst_guint64_to_gdouble (mux->duration);
1686   d /= (gdouble) GST_SECOND;
1687
1688   GST_DEBUG_OBJECT (mux, "determined the final duration to be %f", d);
1689
1690   rewrite = gst_flv_mux_create_number_script_value ("duration", d);
1691
1692   /* rewrite the filesize tag */
1693   d = gst_guint64_to_gdouble (mux->byte_count);
1694
1695   GST_DEBUG_OBJECT (mux, "putting total filesize %f in the metadata", d);
1696
1697   tmp = gst_flv_mux_create_number_script_value ("filesize", d);
1698   rewrite = gst_buffer_append (rewrite, tmp);
1699
1700   if (!mux->index) {
1701     /* no index, so push buffer and return */
1702     return gst_flv_mux_push (mux, rewrite);
1703   }
1704
1705   /* rewrite the index */
1706   mux->index = g_list_reverse (mux->index);
1707   index_len = g_list_length (mux->index);
1708
1709   /* We write at most MAX_INDEX_ENTRIES elements */
1710   if (index_len > MAX_INDEX_ENTRIES) {
1711     index_skip = 1 + index_len / MAX_INDEX_ENTRIES;
1712     index_len = (index_len + index_skip - 1) / index_skip;
1713   } else {
1714     index_skip = 1;
1715   }
1716
1717   GST_DEBUG_OBJECT (mux, "Index length is %d", index_len);
1718   /* see size calculation in gst_flv_mux_preallocate_index */
1719   allocate_size = 11 + 8 + 22 + 10 + index_len * 18;
1720   GST_DEBUG_OBJECT (mux, "Allocating %d bytes for index", allocate_size);
1721   _gst_buffer_new_and_alloc (allocate_size, &index, &data);
1722
1723   GST_WRITE_UINT16_BE (data, 9);        /* the 'keyframes' key */
1724   memcpy (data + 2, "keyframes", 9);
1725   GST_WRITE_UINT8 (data + 11, 8);       /* nested ECMA array */
1726   GST_WRITE_UINT32_BE (data + 12, 2);   /* two elements */
1727   GST_WRITE_UINT16_BE (data + 16, 5);   /* first string key: 'times' */
1728   memcpy (data + 18, "times", 5);
1729   GST_WRITE_UINT8 (data + 23, 10);      /* strict array */
1730   GST_WRITE_UINT32_BE (data + 24, index_len);
1731   data += 28;
1732
1733   /* the keyframes' times */
1734   for (i = 0, l = mux->index; l; l = l->next, i++) {
1735     GstFlvMuxIndexEntry *entry = l->data;
1736
1737     if (i % index_skip != 0)
1738       continue;
1739     GST_WRITE_UINT8 (data, 0);  /* numeric (aka double) */
1740     GST_WRITE_DOUBLE_BE (data + 1, entry->time);
1741     data += 9;
1742   }
1743
1744   GST_WRITE_UINT16_BE (data, 13);       /* second string key: 'filepositions' */
1745   memcpy (data + 2, "filepositions", 13);
1746   GST_WRITE_UINT8 (data + 15, 10);      /* strict array */
1747   GST_WRITE_UINT32_BE (data + 16, index_len);
1748   data += 20;
1749
1750   /* the keyframes' file positions */
1751   for (i = 0, l = mux->index; l; l = l->next, i++) {
1752     GstFlvMuxIndexEntry *entry = l->data;
1753
1754     if (i % index_skip != 0)
1755       continue;
1756     GST_WRITE_UINT8 (data, 0);
1757     GST_WRITE_DOUBLE_BE (data + 1, entry->position);
1758     data += 9;
1759   }
1760
1761   GST_WRITE_UINT24_BE (data, 9);        /* finish the ECMA array */
1762
1763   /* If there is space left in the prefilled area, reinsert the filler.
1764      There is at least 18  bytes free, so it will always fit. */
1765   if (index_len < MAX_INDEX_ENTRIES) {
1766     GstBuffer *tmp;
1767     guint8 *data;
1768     guint32 remaining_filler_size;
1769
1770     _gst_buffer_new_and_alloc (14, &tmp, &data);
1771     GST_WRITE_UINT16_BE (data, 9);
1772     memcpy (data + 2, "gstfiller", 9);
1773     GST_WRITE_UINT8 (data + 11, 2);     /* string */
1774
1775     /* There is 18 bytes per remaining index entry minus what is used for
1776      * the'gstfiller' key. The rest is already filled with spaces, so just need
1777      * to update length. */
1778     remaining_filler_size = (MAX_INDEX_ENTRIES - index_len) * 18 - 14;
1779     GST_DEBUG_OBJECT (mux, "Remaining filler size is %d bytes",
1780         remaining_filler_size);
1781     GST_WRITE_UINT16_BE (data + 12, remaining_filler_size);
1782     index = gst_buffer_append (index, tmp);
1783   }
1784
1785   rewrite = gst_buffer_append (rewrite, index);
1786
1787   return gst_flv_mux_push (mux, rewrite);
1788 }
1789
1790 static GstFlvMuxPad *
1791 gst_flv_mux_find_best_pad (GstAggregator * aggregator, GstClockTime * ts)
1792 {
1793   GstAggregatorPad *apad;
1794   GstFlvMuxPad *pad, *best = NULL;
1795   GList *l;
1796   GstBuffer *buffer;
1797   GstClockTime best_ts = GST_CLOCK_TIME_NONE;
1798
1799   for (l = GST_ELEMENT_CAST (aggregator)->sinkpads; l; l = l->next) {
1800     apad = GST_AGGREGATOR_PAD (l->data);
1801     pad = GST_FLV_MUX_PAD (l->data);
1802     buffer = gst_aggregator_pad_peek_buffer (GST_AGGREGATOR_PAD (pad));
1803     if (!buffer)
1804       continue;
1805     if (best_ts == GST_CLOCK_TIME_NONE) {
1806       best = pad;
1807       best_ts = gst_flv_mux_segment_to_running_time (&apad->segment,
1808           GST_BUFFER_DTS_OR_PTS (buffer));
1809     } else if (GST_BUFFER_DTS_OR_PTS (buffer) != GST_CLOCK_TIME_NONE) {
1810       gint64 t = gst_flv_mux_segment_to_running_time (&apad->segment,
1811           GST_BUFFER_DTS_OR_PTS (buffer));
1812       if (t < best_ts) {
1813         best = pad;
1814         best_ts = t;
1815       }
1816     }
1817     gst_buffer_unref (buffer);
1818   }
1819   GST_DEBUG_OBJECT (aggregator,
1820       "Best pad found with %" GST_TIME_FORMAT ": %" GST_PTR_FORMAT,
1821       GST_TIME_ARGS (best_ts), best);
1822   if (ts)
1823     *ts = best_ts;
1824   return best;
1825 }
1826
1827 static GstFlowReturn
1828 gst_flv_mux_aggregate (GstAggregator * aggregator, gboolean timeout)
1829 {
1830   GstFlvMux *mux = GST_FLV_MUX (aggregator);
1831   GstFlvMuxPad *best;
1832   gint64 best_time = GST_CLOCK_STIME_NONE;
1833   GstFlowReturn ret;
1834   GstClockTime ts;
1835   GstBuffer *buffer = NULL;
1836
1837   if (mux->state == GST_FLV_MUX_STATE_HEADER) {
1838     if (GST_ELEMENT_CAST (mux)->sinkpads == NULL) {
1839       GST_ELEMENT_ERROR (mux, STREAM, MUX, (NULL),
1840           ("No input streams configured"));
1841       return GST_FLOW_ERROR;
1842     }
1843
1844     ret = gst_flv_mux_write_header (mux);
1845     if (ret != GST_FLOW_OK)
1846       return ret;
1847     mux->state = GST_FLV_MUX_STATE_DATA;
1848
1849     best = gst_flv_mux_find_best_pad (aggregator, &ts);
1850
1851     if (!mux->streamable || mux->first_timestamp == GST_CLOCK_STIME_NONE) {
1852       if (best && GST_CLOCK_STIME_IS_VALID (ts))
1853         mux->first_timestamp = ts;
1854       else
1855         mux->first_timestamp = 0;
1856     }
1857   } else {
1858     best = gst_flv_mux_find_best_pad (aggregator, &ts);
1859   }
1860
1861   if (mux->new_tags) {
1862     GstBuffer *buf = gst_flv_mux_create_metadata (mux, FALSE);
1863     if (buf)
1864       gst_flv_mux_push (mux, buf);
1865     mux->new_tags = FALSE;
1866   }
1867
1868   if (best) {
1869     buffer = gst_aggregator_pad_pop_buffer (GST_AGGREGATOR_PAD (best));
1870     g_assert (buffer);
1871     best->dts =
1872         gst_flv_mux_segment_to_running_time (&GST_AGGREGATOR_PAD
1873         (best)->segment, GST_BUFFER_DTS_OR_PTS (buffer));
1874
1875     if (GST_CLOCK_STIME_IS_VALID (best->dts))
1876       best_time = best->dts - mux->first_timestamp;
1877
1878     if (GST_BUFFER_PTS_IS_VALID (buffer))
1879       best->pts =
1880           gst_flv_mux_segment_to_running_time (&GST_AGGREGATOR_PAD
1881           (best)->segment, GST_BUFFER_PTS (buffer));
1882     else
1883       best->pts = best->dts;
1884
1885     GST_LOG_OBJECT (best, "got buffer PTS %" GST_TIME_FORMAT " DTS %"
1886         GST_STIME_FORMAT, GST_TIME_ARGS (best->pts),
1887         GST_STIME_ARGS (best->dts));
1888   } else {
1889     best_time = GST_CLOCK_STIME_NONE;
1890   }
1891
1892   /* The FLV timestamp is an int32 field. For non-live streams error out if a
1893      bigger timestamp is seen, for live the timestamp will get wrapped in
1894      gst_flv_mux_buffer_to_tag */
1895   if (!mux->streamable && (GST_CLOCK_STIME_IS_VALID (best_time))
1896       && best_time / GST_MSECOND > G_MAXINT32) {
1897     GST_WARNING_OBJECT (mux, "Timestamp larger than FLV supports - EOS");
1898     if (buffer) {
1899       gst_buffer_unref (buffer);
1900       buffer = NULL;
1901     }
1902     best = NULL;
1903   }
1904
1905   if (best) {
1906     return gst_flv_mux_write_buffer (mux, best, buffer);
1907   } else {
1908     if (gst_flv_mux_are_all_pads_eos (mux)) {
1909       gst_flv_mux_write_eos (mux);
1910       gst_flv_mux_rewrite_header (mux);
1911       return GST_FLOW_EOS;
1912     }
1913     return GST_FLOW_OK;
1914   }
1915 }
1916
1917 static void
1918 gst_flv_mux_get_property (GObject * object,
1919     guint prop_id, GValue * value, GParamSpec * pspec)
1920 {
1921   GstFlvMux *mux = GST_FLV_MUX (object);
1922
1923   switch (prop_id) {
1924     case PROP_STREAMABLE:
1925       g_value_set_boolean (value, mux->streamable);
1926       break;
1927     case PROP_METADATACREATOR:
1928       g_value_set_string (value, mux->metadatacreator);
1929       break;
1930     case PROP_ENCODER:
1931       g_value_set_string (value, mux->encoder);
1932       break;
1933     default:
1934       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1935       break;
1936   }
1937 }
1938
1939 static void
1940 gst_flv_mux_set_property (GObject * object,
1941     guint prop_id, const GValue * value, GParamSpec * pspec)
1942 {
1943   GstFlvMux *mux = GST_FLV_MUX (object);
1944
1945   switch (prop_id) {
1946     case PROP_STREAMABLE:
1947       mux->streamable = g_value_get_boolean (value);
1948       if (mux->streamable)
1949         gst_tag_setter_set_tag_merge_mode (GST_TAG_SETTER (mux),
1950             GST_TAG_MERGE_REPLACE);
1951       else
1952         gst_tag_setter_set_tag_merge_mode (GST_TAG_SETTER (mux),
1953             GST_TAG_MERGE_KEEP);
1954       break;
1955     case PROP_METADATACREATOR:
1956       g_free (mux->metadatacreator);
1957       if (!g_value_get_string (value)) {
1958         GST_WARNING_OBJECT (mux, "metadatacreator property can not be NULL");
1959         mux->metadatacreator = g_strdup (DEFAULT_METADATACREATOR);
1960       } else {
1961         mux->metadatacreator = g_value_dup_string (value);
1962       }
1963       break;
1964     case PROP_ENCODER:
1965       g_free (mux->encoder);
1966       if (!g_value_get_string (value)) {
1967         GST_WARNING_OBJECT (mux, "encoder property can not be NULL");
1968         mux->encoder = g_strdup (DEFAULT_METADATACREATOR);
1969       } else {
1970         mux->encoder = g_value_dup_string (value);
1971       }
1972       break;
1973     default:
1974       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1975       break;
1976   }
1977 }
1978
1979 static GstClockTime
1980 gst_flv_mux_get_next_time (GstAggregator * aggregator)
1981 {
1982   GstFlvMux *mux = GST_FLV_MUX (aggregator);
1983   GstAggregatorPad *agg_audio_pad = GST_AGGREGATOR_PAD_CAST (mux->audio_pad);
1984   GstAggregatorPad *agg_video_pad = GST_AGGREGATOR_PAD_CAST (mux->video_pad);
1985
1986   GST_OBJECT_LOCK (aggregator);
1987   if (mux->state == GST_FLV_MUX_STATE_HEADER &&
1988       ((mux->audio_pad && mux->audio_pad->codec == G_MAXUINT) ||
1989           (mux->video_pad && mux->video_pad->codec == G_MAXUINT)))
1990     goto wait_for_data;
1991
1992   if (!((agg_audio_pad && gst_aggregator_pad_has_buffer (agg_audio_pad)) ||
1993           (agg_video_pad && gst_aggregator_pad_has_buffer (agg_video_pad))))
1994     goto wait_for_data;
1995   GST_OBJECT_UNLOCK (aggregator);
1996
1997   return gst_aggregator_simple_get_next_time (aggregator);
1998
1999 wait_for_data:
2000   GST_OBJECT_UNLOCK (aggregator);
2001   return GST_CLOCK_TIME_NONE;
2002 }
2003
2004 static GstFlowReturn
2005 gst_flv_mux_update_src_caps (GstAggregator * aggregator,
2006     GstCaps * caps, GstCaps ** ret)
2007 {
2008   GstFlvMux *mux = GST_FLV_MUX (aggregator);
2009
2010   *ret = gst_flv_mux_prepare_src_caps (mux, NULL, NULL, NULL, NULL);
2011
2012   return GST_FLOW_OK;
2013 }