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  *
  27  * flvmux muxes different streams into an FLV file.
  28  *
  29  * <refsect2>
  30  * <title>Example launch line</title>
  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  * </refsect2>
  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->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     GTimeVal tv = { 0, };
1087     time_t secs;
1088     struct tm *tm;
1089     gchar *s;
1090     static const gchar *weekdays[] = {
1091       "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
1092     };
1093     static const gchar *months[] = {
1094       "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
1095       "Aug", "Sep", "Oct", "Nov", "Dec"
1096     };
1097
1098     g_get_current_time (&tv);
1099     secs = tv.tv_sec;
1100     tm = gmtime (&secs);
1101
1102     s = g_strdup_printf ("%s %s %d %02d:%02d:%02d %d", weekdays[tm->tm_wday],
1103         months[tm->tm_mon], tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
1104         tm->tm_year + 1900);
1105
1106     _gst_buffer_new_and_alloc (2 + 12 + 1 + 2 + strlen (s), &tmp, &data);
1107     data[0] = 0;                /* 12 bytes name */
1108     data[1] = 12;
1109     memcpy (&data[2], "creationdate", 12);
1110     data[14] = 2;               /* string */
1111     data[15] = (strlen (s) >> 8) & 0xff;
1112     data[16] = (strlen (s)) & 0xff;
1113     memcpy (&data[17], s, strlen (s));
1114     script_tag = gst_buffer_append (script_tag, tmp);
1115
1116     g_free (s);
1117     tags_written++;
1118   }
1119
1120 end:
1121
1122   if (!tags_written) {
1123     gst_buffer_unref (script_tag);
1124     script_tag = NULL;
1125     goto exit;
1126   }
1127
1128   _gst_buffer_new_and_alloc (2 + 0 + 1, &tmp, &data);
1129   data[0] = 0;                  /* 0 byte size */
1130   data[1] = 0;
1131   data[2] = 9;                  /* end marker */
1132   script_tag = gst_buffer_append (script_tag, tmp);
1133
1134
1135   _gst_buffer_new_and_alloc (4, &tmp, &data);
1136   GST_WRITE_UINT32_BE (data, gst_buffer_get_size (script_tag));
1137   script_tag = gst_buffer_append (script_tag, tmp);
1138
1139   gst_buffer_map (script_tag, &map, GST_MAP_WRITE);
1140   map.data[1] = ((gst_buffer_get_size (script_tag) - 11 - 4) >> 16) & 0xff;
1141   map.data[2] = ((gst_buffer_get_size (script_tag) - 11 - 4) >> 8) & 0xff;
1142   map.data[3] = ((gst_buffer_get_size (script_tag) - 11 - 4) >> 0) & 0xff;
1143
1144   GST_WRITE_UINT32_BE (map.data + 11 + 13 + 1, tags_written);
1145   gst_buffer_unmap (script_tag, &map);
1146
1147 exit:
1148   return script_tag;
1149 }
1150
1151 static GstBuffer *
1152 gst_flv_mux_buffer_to_tag_internal (GstFlvMux * mux, GstBuffer * buffer,
1153     GstFlvMuxPad * pad, gboolean is_codec_data)
1154 {
1155   GstBuffer *tag;
1156   GstMapInfo map;
1157   guint size;
1158   guint32 pts, dts, cts;
1159   guint8 *data, *bdata = NULL;
1160   gsize bsize = 0;
1161
1162   if (!GST_CLOCK_STIME_IS_VALID (pad->dts)) {
1163     pts = dts = pad->last_timestamp / GST_MSECOND;
1164   } else {
1165     pts = pad->pts / GST_MSECOND;
1166     dts = pad->dts / GST_MSECOND;
1167   }
1168
1169   /* We prevent backwards timestamps because they confuse librtmp,
1170    * it expects timestamps to go forward not only inside one stream, but
1171    * also between the audio & video streams.
1172    */
1173   if (dts < mux->last_dts) {
1174     GST_WARNING_OBJECT (pad, "Got backwards dts! (%" GST_TIME_FORMAT
1175         " < %" GST_TIME_FORMAT ")", GST_TIME_ARGS (dts),
1176         GST_TIME_ARGS (mux->last_dts));
1177     dts = mux->last_dts;
1178   }
1179   mux->last_dts = dts;
1180
1181
1182   /* Be safe in case TS are buggy */
1183   if (pts > dts)
1184     cts = pts - dts;
1185   else
1186     cts = 0;
1187
1188   /* Timestamp must start at zero */
1189   if (GST_CLOCK_STIME_IS_VALID (mux->first_timestamp)) {
1190     dts -= mux->first_timestamp / GST_MSECOND;
1191     pts = dts + cts;
1192   }
1193
1194   GST_LOG_OBJECT (mux, "got pts %i dts %i cts %i", pts, dts, cts);
1195
1196   if (buffer != NULL) {
1197     gst_buffer_map (buffer, &map, GST_MAP_READ);
1198     bdata = map.data;
1199     bsize = map.size;
1200   }
1201
1202   size = 11;
1203   if (mux->video_pad == pad) {
1204     size += 1;
1205     if (pad->codec == 7)
1206       size += 4 + bsize;
1207     else
1208       size += bsize;
1209   } else {
1210     size += 1;
1211     if (pad->codec == 10)
1212       size += 1 + bsize;
1213     else
1214       size += bsize;
1215   }
1216   size += 4;
1217
1218   _gst_buffer_new_and_alloc (size, &tag, &data);
1219   memset (data, 0, size);
1220
1221   data[0] = (mux->video_pad == pad) ? 9 : 8;
1222
1223   data[1] = ((size - 11 - 4) >> 16) & 0xff;
1224   data[2] = ((size - 11 - 4) >> 8) & 0xff;
1225   data[3] = ((size - 11 - 4) >> 0) & 0xff;
1226
1227
1228   GST_WRITE_UINT24_BE (data + 4, dts);
1229   data[7] = (((guint) dts) >> 24) & 0xff;
1230
1231   data[8] = data[9] = data[10] = 0;
1232
1233   if (mux->video_pad == pad) {
1234     if (buffer && GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT))
1235       data[11] |= 2 << 4;
1236     else
1237       data[11] |= 1 << 4;
1238
1239     data[11] |= pad->codec & 0x0f;
1240
1241     if (pad->codec == 7) {
1242       if (is_codec_data) {
1243         data[12] = 0;
1244         GST_WRITE_UINT24_BE (data + 13, 0);
1245       } else if (bsize == 0) {
1246         /* AVC end of sequence */
1247         data[12] = 2;
1248         GST_WRITE_UINT24_BE (data + 13, 0);
1249       } else {
1250         /* ACV NALU */
1251         data[12] = 1;
1252         GST_WRITE_UINT24_BE (data + 13, cts);
1253       }
1254       memcpy (data + 11 + 1 + 4, bdata, bsize);
1255     } else {
1256       memcpy (data + 11 + 1, bdata, bsize);
1257     }
1258   } else {
1259     data[11] |= (pad->codec << 4) & 0xf0;
1260     data[11] |= (pad->rate << 2) & 0x0c;
1261     data[11] |= (pad->width << 1) & 0x02;
1262     data[11] |= (pad->channels << 0) & 0x01;
1263
1264     GST_DEBUG_OBJECT (mux, "Creating byte %02x with "
1265         "codec:%d, rate:%d, width:%d, channels:%d",
1266         data[11], pad->codec, pad->rate, pad->width, pad->channels);
1267
1268     if (pad->codec == 10) {
1269       data[12] = is_codec_data ? 0 : 1;
1270
1271       memcpy (data + 11 + 1 + 1, bdata, bsize);
1272     } else {
1273       memcpy (data + 11 + 1, bdata, bsize);
1274     }
1275   }
1276
1277   if (buffer)
1278     gst_buffer_unmap (buffer, &map);
1279
1280   GST_WRITE_UINT32_BE (data + size - 4, size - 4);
1281
1282   GST_BUFFER_PTS (tag) = GST_CLOCK_TIME_NONE;
1283   GST_BUFFER_DTS (tag) = GST_CLOCK_TIME_NONE;
1284   GST_BUFFER_DURATION (tag) = GST_CLOCK_TIME_NONE;
1285
1286   if (buffer) {
1287     /* if we are streamable we copy over timestamps and offsets,
1288        if not just copy the offsets */
1289     if (mux->streamable) {
1290       GstClockTime timestamp = GST_CLOCK_TIME_NONE;
1291
1292       if (gst_segment_to_running_time_full (&GST_AGGREGATOR_PAD (pad)->segment,
1293               GST_FORMAT_TIME, GST_BUFFER_DTS_OR_PTS (buffer),
1294               &timestamp) == 1) {
1295         GST_BUFFER_PTS (tag) = timestamp;
1296         GST_BUFFER_DURATION (tag) = GST_BUFFER_DURATION (buffer);
1297       }
1298       GST_BUFFER_OFFSET (tag) = GST_BUFFER_OFFSET_NONE;
1299       GST_BUFFER_OFFSET_END (tag) = GST_BUFFER_OFFSET_NONE;
1300     } else {
1301       GST_BUFFER_OFFSET (tag) = GST_BUFFER_OFFSET (buffer);
1302       GST_BUFFER_OFFSET_END (tag) = GST_BUFFER_OFFSET_END (buffer);
1303     }
1304
1305     /* mark the buffer if it's an audio buffer and there's also video being muxed
1306      * or it's a video interframe */
1307     if (mux->video_pad == pad &&
1308         GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT))
1309       GST_BUFFER_FLAG_SET (tag, GST_BUFFER_FLAG_DELTA_UNIT);
1310   } else {
1311     GST_BUFFER_FLAG_SET (tag, GST_BUFFER_FLAG_DELTA_UNIT);
1312     GST_BUFFER_OFFSET (tag) = GST_BUFFER_OFFSET_END (tag) =
1313         GST_BUFFER_OFFSET_NONE;
1314   }
1315
1316   return tag;
1317 }
1318
1319 static inline GstBuffer *
1320 gst_flv_mux_buffer_to_tag (GstFlvMux * mux, GstBuffer * buffer,
1321     GstFlvMuxPad * pad)
1322 {
1323   return gst_flv_mux_buffer_to_tag_internal (mux, buffer, pad, FALSE);
1324 }
1325
1326 static inline GstBuffer *
1327 gst_flv_mux_codec_data_buffer_to_tag (GstFlvMux * mux, GstBuffer * buffer,
1328     GstFlvMuxPad * pad)
1329 {
1330   return gst_flv_mux_buffer_to_tag_internal (mux, buffer, pad, TRUE);
1331 }
1332
1333 static inline GstBuffer *
1334 gst_flv_mux_eos_to_tag (GstFlvMux * mux, GstFlvMuxPad * pad)
1335 {
1336   return gst_flv_mux_buffer_to_tag_internal (mux, NULL, pad, FALSE);
1337 }
1338
1339 static void
1340 gst_flv_mux_put_buffer_in_streamheader (GValue * streamheader,
1341     GstBuffer * buffer)
1342 {
1343   GValue value = { 0 };
1344   GstBuffer *buf;
1345
1346   g_value_init (&value, GST_TYPE_BUFFER);
1347   buf = gst_buffer_copy (buffer);
1348   gst_value_set_buffer (&value, buf);
1349   gst_buffer_unref (buf);
1350   gst_value_array_append_value (streamheader, &value);
1351   g_value_unset (&value);
1352 }
1353
1354 static GstCaps *
1355 gst_flv_mux_prepare_src_caps (GstFlvMux * mux, GstBuffer ** header_buf,
1356     GstBuffer ** metadata_buf, GstBuffer ** video_codec_data_buf,
1357     GstBuffer ** audio_codec_data_buf)
1358 {
1359   GstBuffer *header, *metadata;
1360   GstBuffer *video_codec_data, *audio_codec_data;
1361   GstCaps *caps;
1362   GstStructure *structure;
1363   GValue streamheader = { 0 };
1364   GList *l;
1365
1366   header = gst_flv_mux_create_header (mux);
1367   metadata = gst_flv_mux_create_metadata (mux, TRUE);
1368   video_codec_data = NULL;
1369   audio_codec_data = NULL;
1370
1371   for (l = GST_ELEMENT_CAST (mux)->sinkpads; l != NULL; l = l->next) {
1372     GstFlvMuxPad *pad = l->data;
1373
1374     /* Get H.264 and AAC codec data, if present */
1375     if (pad && mux->video_pad == pad && pad->codec == 7) {
1376       if (pad->codec_data == NULL)
1377         GST_WARNING_OBJECT (mux, "Codec data for video stream not found, "
1378             "output might not be playable");
1379       else
1380         video_codec_data =
1381             gst_flv_mux_codec_data_buffer_to_tag (mux, pad->codec_data, pad);
1382     } else if (pad && mux->audio_pad == pad && pad->codec == 10) {
1383       if (pad->codec_data == NULL)
1384         GST_WARNING_OBJECT (mux, "Codec data for audio stream not found, "
1385             "output might not be playable");
1386       else
1387         audio_codec_data =
1388             gst_flv_mux_codec_data_buffer_to_tag (mux, pad->codec_data, pad);
1389     }
1390   }
1391
1392   /* mark buffers that will go in the streamheader */
1393   GST_BUFFER_FLAG_SET (header, GST_BUFFER_FLAG_HEADER);
1394   GST_BUFFER_FLAG_SET (metadata, GST_BUFFER_FLAG_HEADER);
1395   if (video_codec_data != NULL) {
1396     GST_BUFFER_FLAG_SET (video_codec_data, GST_BUFFER_FLAG_HEADER);
1397     /* mark as a delta unit, so downstream will not try to synchronize on that
1398      * buffer - to actually start playback you need a real video keyframe */
1399     GST_BUFFER_FLAG_SET (video_codec_data, GST_BUFFER_FLAG_DELTA_UNIT);
1400   }
1401   if (audio_codec_data != NULL) {
1402     GST_BUFFER_FLAG_SET (audio_codec_data, GST_BUFFER_FLAG_HEADER);
1403   }
1404
1405   /* put buffers in streamheader */
1406   g_value_init (&streamheader, GST_TYPE_ARRAY);
1407   gst_flv_mux_put_buffer_in_streamheader (&streamheader, header);
1408   gst_flv_mux_put_buffer_in_streamheader (&streamheader, metadata);
1409   if (video_codec_data != NULL)
1410     gst_flv_mux_put_buffer_in_streamheader (&streamheader, video_codec_data);
1411   if (audio_codec_data != NULL)
1412     gst_flv_mux_put_buffer_in_streamheader (&streamheader, audio_codec_data);
1413
1414   /* create the caps and put the streamheader in them */
1415   caps = gst_caps_new_empty_simple ("video/x-flv");
1416   structure = gst_caps_get_structure (caps, 0);
1417   gst_structure_set_value (structure, "streamheader", &streamheader);
1418   g_value_unset (&streamheader);
1419
1420   if (header_buf) {
1421     *header_buf = header;
1422   } else {
1423     gst_buffer_unref (header);
1424   }
1425
1426   if (metadata_buf) {
1427     *metadata_buf = metadata;
1428   } else {
1429     gst_buffer_unref (metadata);
1430   }
1431
1432   if (video_codec_data_buf) {
1433     *video_codec_data_buf = video_codec_data;
1434   } else if (video_codec_data) {
1435     gst_buffer_unref (video_codec_data);
1436   }
1437
1438   if (audio_codec_data_buf) {
1439     *audio_codec_data_buf = audio_codec_data;
1440   } else if (audio_codec_data) {
1441     gst_buffer_unref (audio_codec_data);
1442   }
1443
1444   return caps;
1445 }
1446
1447 static GstFlowReturn
1448 gst_flv_mux_write_header (GstFlvMux * mux)
1449 {
1450   GstBuffer *header, *metadata;
1451   GstBuffer *video_codec_data, *audio_codec_data;
1452   GstCaps *caps;
1453   GstFlowReturn ret;
1454
1455   header = metadata = video_codec_data = audio_codec_data = NULL;
1456
1457   /* if not streaming, check if downstream is seekable */
1458   if (!mux->streamable) {
1459     gboolean seekable;
1460     GstQuery *query;
1461
1462     query = gst_query_new_seeking (GST_FORMAT_BYTES);
1463     if (gst_pad_peer_query (mux->srcpad, query)) {
1464       gst_query_parse_seeking (query, NULL, &seekable, NULL, NULL);
1465       GST_INFO_OBJECT (mux, "downstream is %sseekable", seekable ? "" : "not ");
1466     } else {
1467       /* have to assume seeking is supported if query not handled downstream */
1468       GST_WARNING_OBJECT (mux, "downstream did not handle seeking query");
1469       seekable = FALSE;
1470     }
1471     if (!seekable) {
1472       mux->streamable = TRUE;
1473       g_object_notify (G_OBJECT (mux), "streamable");
1474       GST_WARNING_OBJECT (mux, "downstream is not seekable, but "
1475           "streamable=false. Will ignore that and create streamable output "
1476           "instead");
1477     }
1478     gst_query_unref (query);
1479   }
1480
1481   if (!mux->streamable) {
1482     caps = gst_flv_mux_prepare_src_caps (mux,
1483         &header, &metadata, &video_codec_data, &audio_codec_data);
1484   } else {
1485     if (!mux->sent_header) {
1486       caps = gst_flv_mux_prepare_src_caps (mux,
1487           &header, &metadata, &video_codec_data, &audio_codec_data);
1488     } else {
1489       caps = gst_flv_mux_prepare_src_caps (mux,
1490           NULL, NULL,
1491           (mux->video_pad->info_changed ? &video_codec_data : NULL),
1492           (mux->audio_pad->info_changed ? &audio_codec_data : NULL));
1493     }
1494   }
1495
1496   gst_aggregator_set_src_caps (GST_AGGREGATOR_CAST (mux), caps);
1497
1498   gst_caps_unref (caps);
1499
1500   /* push the header buffer, the metadata and the codec info, if any */
1501   if (header != NULL) {
1502     ret = gst_flv_mux_push (mux, header);
1503     if (ret != GST_FLOW_OK)
1504       goto failure_header;
1505     mux->sent_header = TRUE;
1506   }
1507   if (metadata != NULL) {
1508     ret = gst_flv_mux_push (mux, metadata);
1509     if (ret != GST_FLOW_OK)
1510       goto failure_metadata;
1511   }
1512   if (video_codec_data != NULL) {
1513     ret = gst_flv_mux_push (mux, video_codec_data);
1514     if (ret != GST_FLOW_OK)
1515       goto failure_video_codec_data;
1516     mux->video_pad->info_changed = FALSE;
1517   }
1518   if (audio_codec_data != NULL) {
1519     ret = gst_flv_mux_push (mux, audio_codec_data);
1520     if (ret != GST_FLOW_OK)
1521       goto failure_audio_codec_data;
1522     mux->audio_pad->info_changed = FALSE;
1523   }
1524   return GST_FLOW_OK;
1525
1526 failure_header:
1527   gst_buffer_unref (metadata);
1528
1529 failure_metadata:
1530   if (video_codec_data != NULL)
1531     gst_buffer_unref (video_codec_data);
1532
1533 failure_video_codec_data:
1534   if (audio_codec_data != NULL)
1535     gst_buffer_unref (audio_codec_data);
1536
1537 failure_audio_codec_data:
1538   return ret;
1539 }
1540
1541 static GstClockTime
1542 gst_flv_mux_segment_to_running_time (const GstSegment * segment, GstClockTime t)
1543 {
1544   /* we can get a dts before the segment, if dts < pts and pts is inside
1545    * the segment, so we consider early times as 0 */
1546   if (t < segment->start)
1547     return 0;
1548   return gst_segment_to_running_time (segment, GST_FORMAT_TIME, t);
1549 }
1550
1551 static void
1552 gst_flv_mux_update_index (GstFlvMux * mux, GstBuffer * buffer,
1553     GstFlvMuxPad * pad)
1554 {
1555   /*
1556    * Add the tag byte offset and to the index if it's a valid seek point, which
1557    * means it's either a video keyframe or if there is no video pad (in that
1558    * case every FLV tag is a valid seek point)
1559    */
1560   if (mux->video_pad == pad &&
1561       GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT))
1562     return;
1563
1564   if (GST_BUFFER_PTS_IS_VALID (buffer)) {
1565     GstFlvMuxIndexEntry *entry = g_slice_new (GstFlvMuxIndexEntry);
1566     GstClockTime pts =
1567         gst_flv_mux_segment_to_running_time (&GST_AGGREGATOR_PAD
1568         (pad)->segment, GST_BUFFER_PTS (buffer));
1569     entry->position = mux->byte_count;
1570     entry->time = gst_guint64_to_gdouble (pts) / GST_SECOND;
1571     mux->index = g_list_prepend (mux->index, entry);
1572   }
1573 }
1574
1575 static GstFlowReturn
1576 gst_flv_mux_write_buffer (GstFlvMux * mux, GstFlvMuxPad * pad,
1577     GstBuffer * buffer)
1578 {
1579   GstBuffer *tag;
1580   GstFlowReturn ret;
1581   GstClockTime dts =
1582       gst_flv_mux_segment_to_running_time (&GST_AGGREGATOR_PAD (pad)->segment,
1583       GST_BUFFER_DTS (buffer));
1584
1585   /* clipping function arranged for running_time */
1586
1587   if (!mux->streamable)
1588     gst_flv_mux_update_index (mux, buffer, pad);
1589
1590   tag = gst_flv_mux_buffer_to_tag (mux, buffer, pad);
1591
1592   gst_buffer_unref (buffer);
1593
1594   ret = gst_flv_mux_push (mux, tag);
1595
1596   if (ret == GST_FLOW_OK && GST_CLOCK_TIME_IS_VALID (dts))
1597     pad->last_timestamp = dts;
1598
1599
1600   return ret;
1601 }
1602
1603 static guint64
1604 gst_flv_mux_determine_duration (GstFlvMux * mux)
1605 {
1606   GList *l;
1607   GstClockTime duration = GST_CLOCK_TIME_NONE;
1608
1609   GST_DEBUG_OBJECT (mux, "trying to determine the duration "
1610       "from pad timestamps");
1611
1612   for (l = GST_ELEMENT_CAST (mux)->sinkpads; l != NULL; l = l->next) {
1613     GstFlvMuxPad *pad = GST_FLV_MUX_PAD (l->data);
1614
1615     if (pad && (pad->last_timestamp != GST_CLOCK_TIME_NONE)) {
1616       if (duration == GST_CLOCK_TIME_NONE)
1617         duration = pad->last_timestamp;
1618       else
1619         duration = MAX (duration, pad->last_timestamp);
1620     }
1621   }
1622
1623   return duration;
1624 }
1625
1626 static gboolean
1627 gst_flv_mux_are_all_pads_eos (GstFlvMux * mux)
1628 {
1629   GList *l;
1630
1631   for (l = GST_ELEMENT_CAST (mux)->sinkpads; l; l = l->next) {
1632     GstFlvMuxPad *pad = GST_FLV_MUX_PAD (l->data);
1633
1634     if (!gst_aggregator_pad_is_eos (GST_AGGREGATOR_PAD (pad)))
1635       return FALSE;
1636   }
1637   return TRUE;
1638 }
1639
1640 static GstFlowReturn
1641 gst_flv_mux_write_eos (GstFlvMux * mux)
1642 {
1643   GstBuffer *tag;
1644
1645   if (mux->video_pad == NULL)
1646     return GST_FLOW_OK;
1647
1648   tag = gst_flv_mux_eos_to_tag (mux, mux->video_pad);
1649
1650   return gst_flv_mux_push (mux, tag);
1651 }
1652
1653 static GstFlowReturn
1654 gst_flv_mux_rewrite_header (GstFlvMux * mux)
1655 {
1656   GstBuffer *rewrite, *index, *tmp;
1657   GstEvent *event;
1658   guint8 *data;
1659   gdouble d;
1660   GList *l;
1661   guint32 index_len, allocate_size;
1662   guint32 i, index_skip;
1663   GstSegment segment;
1664   GstClockTime dur;
1665
1666   if (mux->streamable)
1667     return GST_FLOW_OK;
1668
1669   /* seek back to the preallocated index space */
1670   gst_segment_init (&segment, GST_FORMAT_BYTES);
1671   segment.start = segment.time = 13 + 29;
1672   event = gst_event_new_segment (&segment);
1673   if (!gst_pad_push_event (mux->srcpad, event)) {
1674     GST_WARNING_OBJECT (mux, "Seek to rewrite header failed");
1675     return GST_FLOW_OK;
1676   }
1677
1678   /* determine duration now based on our own timestamping,
1679    * so that it is likely many times better and consistent
1680    * than whatever obtained by some query */
1681   dur = gst_flv_mux_determine_duration (mux);
1682   if (dur != GST_CLOCK_TIME_NONE)
1683     mux->duration = dur;
1684
1685   /* rewrite the duration tag */
1686   d = gst_guint64_to_gdouble (mux->duration);
1687   d /= (gdouble) GST_SECOND;
1688
1689   GST_DEBUG_OBJECT (mux, "determined the final duration to be %f", d);
1690
1691   rewrite = gst_flv_mux_create_number_script_value ("duration", d);
1692
1693   /* rewrite the filesize tag */
1694   d = gst_guint64_to_gdouble (mux->byte_count);
1695
1696   GST_DEBUG_OBJECT (mux, "putting total filesize %f in the metadata", d);
1697
1698   tmp = gst_flv_mux_create_number_script_value ("filesize", d);
1699   rewrite = gst_buffer_append (rewrite, tmp);
1700
1701   if (!mux->index) {
1702     /* no index, so push buffer and return */
1703     return gst_flv_mux_push (mux, rewrite);
1704   }
1705
1706   /* rewrite the index */
1707   mux->index = g_list_reverse (mux->index);
1708   index_len = g_list_length (mux->index);
1709
1710   /* We write at most MAX_INDEX_ENTRIES elements */
1711   if (index_len > MAX_INDEX_ENTRIES) {
1712     index_skip = 1 + index_len / MAX_INDEX_ENTRIES;
1713     index_len = (index_len + index_skip - 1) / index_skip;
1714   } else {
1715     index_skip = 1;
1716   }
1717
1718   GST_DEBUG_OBJECT (mux, "Index length is %d", index_len);
1719   /* see size calculation in gst_flv_mux_preallocate_index */
1720   allocate_size = 11 + 8 + 22 + 10 + index_len * 18;
1721   GST_DEBUG_OBJECT (mux, "Allocating %d bytes for index", allocate_size);
1722   _gst_buffer_new_and_alloc (allocate_size, &index, &data);
1723
1724   GST_WRITE_UINT16_BE (data, 9);        /* the 'keyframes' key */
1725   memcpy (data + 2, "keyframes", 9);
1726   GST_WRITE_UINT8 (data + 11, 8);       /* nested ECMA array */
1727   GST_WRITE_UINT32_BE (data + 12, 2);   /* two elements */
1728   GST_WRITE_UINT16_BE (data + 16, 5);   /* first string key: 'times' */
1729   memcpy (data + 18, "times", 5);
1730   GST_WRITE_UINT8 (data + 23, 10);      /* strict array */
1731   GST_WRITE_UINT32_BE (data + 24, index_len);
1732   data += 28;
1733
1734   /* the keyframes' times */
1735   for (i = 0, l = mux->index; l; l = l->next, i++) {
1736     GstFlvMuxIndexEntry *entry = l->data;
1737
1738     if (i % index_skip != 0)
1739       continue;
1740     GST_WRITE_UINT8 (data, 0);  /* numeric (aka double) */
1741     GST_WRITE_DOUBLE_BE (data + 1, entry->time);
1742     data += 9;
1743   }
1744
1745   GST_WRITE_UINT16_BE (data, 13);       /* second string key: 'filepositions' */
1746   memcpy (data + 2, "filepositions", 13);
1747   GST_WRITE_UINT8 (data + 15, 10);      /* strict array */
1748   GST_WRITE_UINT32_BE (data + 16, index_len);
1749   data += 20;
1750
1751   /* the keyframes' file positions */
1752   for (i = 0, l = mux->index; l; l = l->next, i++) {
1753     GstFlvMuxIndexEntry *entry = l->data;
1754
1755     if (i % index_skip != 0)
1756       continue;
1757     GST_WRITE_UINT8 (data, 0);
1758     GST_WRITE_DOUBLE_BE (data + 1, entry->position);
1759     data += 9;
1760   }
1761
1762   GST_WRITE_UINT24_BE (data, 9);        /* finish the ECMA array */
1763
1764   /* If there is space left in the prefilled area, reinsert the filler.
1765      There is at least 18  bytes free, so it will always fit. */
1766   if (index_len < MAX_INDEX_ENTRIES) {
1767     GstBuffer *tmp;
1768     guint8 *data;
1769     guint32 remaining_filler_size;
1770
1771     _gst_buffer_new_and_alloc (14, &tmp, &data);
1772     GST_WRITE_UINT16_BE (data, 9);
1773     memcpy (data + 2, "gstfiller", 9);
1774     GST_WRITE_UINT8 (data + 11, 2);     /* string */
1775
1776     /* There is 18 bytes per remaining index entry minus what is used for
1777      * the'gstfiller' key. The rest is already filled with spaces, so just need
1778      * to update length. */
1779     remaining_filler_size = (MAX_INDEX_ENTRIES - index_len) * 18 - 14;
1780     GST_DEBUG_OBJECT (mux, "Remaining filler size is %d bytes",
1781         remaining_filler_size);
1782     GST_WRITE_UINT16_BE (data + 12, remaining_filler_size);
1783     index = gst_buffer_append (index, tmp);
1784   }
1785
1786   rewrite = gst_buffer_append (rewrite, index);
1787
1788   return gst_flv_mux_push (mux, rewrite);
1789 }
1790
1791 static GstFlvMuxPad *
1792 gst_flv_mux_find_best_pad (GstAggregator * aggregator, GstClockTime * ts)
1793 {
1794   GstAggregatorPad *apad;
1795   GstFlvMuxPad *pad, *best = NULL;
1796   GList *l;
1797   GstBuffer *buffer;
1798   GstClockTime best_ts = GST_CLOCK_TIME_NONE;
1799
1800   for (l = GST_ELEMENT_CAST (aggregator)->sinkpads; l; l = l->next) {
1801     apad = GST_AGGREGATOR_PAD (l->data);
1802     pad = GST_FLV_MUX_PAD (l->data);
1803     buffer = gst_aggregator_pad_peek_buffer (GST_AGGREGATOR_PAD (pad));
1804     if (!buffer)
1805       continue;
1806     if (best_ts == GST_CLOCK_TIME_NONE) {
1807       best = pad;
1808       best_ts = gst_flv_mux_segment_to_running_time (&apad->segment,
1809           GST_BUFFER_DTS_OR_PTS (buffer));
1810     } else if (GST_BUFFER_DTS_OR_PTS (buffer) != GST_CLOCK_TIME_NONE) {
1811       gint64 t = gst_flv_mux_segment_to_running_time (&apad->segment,
1812           GST_BUFFER_DTS_OR_PTS (buffer));
1813       if (t < best_ts) {
1814         best = pad;
1815         best_ts = t;
1816       }
1817     }
1818     gst_buffer_unref (buffer);
1819   }
1820   GST_DEBUG_OBJECT (aggregator,
1821       "Best pad found with %" GST_TIME_FORMAT ": %" GST_PTR_FORMAT,
1822       GST_TIME_ARGS (best_ts), best);
1823   if (ts)
1824     *ts = best_ts;
1825   return best;
1826 }
1827
1828 static GstFlowReturn
1829 gst_flv_mux_aggregate (GstAggregator * aggregator, gboolean timeout)
1830 {
1831   GstFlvMux *mux = GST_FLV_MUX (aggregator);
1832   GstFlvMuxPad *best;
1833   gint64 best_time = GST_CLOCK_STIME_NONE;
1834   GstFlowReturn ret;
1835   GstClockTime ts;
1836   GstBuffer *buffer = NULL;
1837
1838   if (mux->state == GST_FLV_MUX_STATE_HEADER) {
1839     if (GST_ELEMENT_CAST (mux)->sinkpads == NULL) {
1840       GST_ELEMENT_ERROR (mux, STREAM, MUX, (NULL),
1841           ("No input streams configured"));
1842       return GST_FLOW_ERROR;
1843     }
1844
1845     ret = gst_flv_mux_write_header (mux);
1846     if (ret != GST_FLOW_OK)
1847       return ret;
1848     mux->state = GST_FLV_MUX_STATE_DATA;
1849
1850     best = gst_flv_mux_find_best_pad (aggregator, &ts);
1851
1852     if (!mux->streamable || mux->first_timestamp == GST_CLOCK_STIME_NONE) {
1853       if (best && GST_CLOCK_STIME_IS_VALID (ts))
1854         mux->first_timestamp = ts;
1855       else
1856         mux->first_timestamp = 0;
1857     }
1858   } else {
1859     best = gst_flv_mux_find_best_pad (aggregator, &ts);
1860   }
1861
1862   if (mux->new_tags) {
1863     GstBuffer *buf = gst_flv_mux_create_metadata (mux, FALSE);
1864     if (buf)
1865       gst_flv_mux_push (mux, buf);
1866     mux->new_tags = FALSE;
1867   }
1868
1869   if (best) {
1870     buffer = gst_aggregator_pad_pop_buffer (GST_AGGREGATOR_PAD (best));
1871     g_assert (buffer);
1872     best->dts =
1873         gst_flv_mux_segment_to_running_time (&GST_AGGREGATOR_PAD
1874         (best)->segment, GST_BUFFER_DTS_OR_PTS (buffer));
1875
1876     if (GST_CLOCK_STIME_IS_VALID (best->dts))
1877       best_time = best->dts - mux->first_timestamp;
1878
1879     if (GST_BUFFER_PTS_IS_VALID (buffer))
1880       best->pts =
1881           gst_flv_mux_segment_to_running_time (&GST_AGGREGATOR_PAD
1882           (best)->segment, GST_BUFFER_PTS (buffer));
1883     else
1884       best->pts = best->dts;
1885
1886     GST_LOG_OBJECT (best, "got buffer PTS %" GST_TIME_FORMAT " DTS %"
1887         GST_STIME_FORMAT, GST_TIME_ARGS (best->pts),
1888         GST_STIME_ARGS (best->dts));
1889   } else {
1890     best_time = GST_CLOCK_STIME_NONE;
1891   }
1892
1893   /* The FLV timestamp is an int32 field. For non-live streams error out if a
1894      bigger timestamp is seen, for live the timestamp will get wrapped in
1895      gst_flv_mux_buffer_to_tag */
1896   if (!mux->streamable && (GST_CLOCK_STIME_IS_VALID (best_time))
1897       && best_time / GST_MSECOND > G_MAXINT32) {
1898     GST_WARNING_OBJECT (mux, "Timestamp larger than FLV supports - EOS");
1899     if (buffer) {
1900       gst_buffer_unref (buffer);
1901       buffer = NULL;
1902     }
1903     best = NULL;
1904   }
1905
1906   if (best) {
1907     return gst_flv_mux_write_buffer (mux, best, buffer);
1908   } else {
1909     if (gst_flv_mux_are_all_pads_eos (mux)) {
1910       gst_flv_mux_write_eos (mux);
1911       gst_flv_mux_rewrite_header (mux);
1912       return GST_FLOW_EOS;
1913     }
1914     return GST_FLOW_OK;
1915   }
1916 }
1917
1918 static void
1919 gst_flv_mux_get_property (GObject * object,
1920     guint prop_id, GValue * value, GParamSpec * pspec)
1921 {
1922   GstFlvMux *mux = GST_FLV_MUX (object);
1923
1924   switch (prop_id) {
1925     case PROP_STREAMABLE:
1926       g_value_set_boolean (value, mux->streamable);
1927       break;
1928     case PROP_METADATACREATOR:
1929       g_value_set_string (value, mux->metadatacreator);
1930       break;
1931     case PROP_ENCODER:
1932       g_value_set_string (value, mux->encoder);
1933       break;
1934     default:
1935       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1936       break;
1937   }
1938 }
1939
1940 static void
1941 gst_flv_mux_set_property (GObject * object,
1942     guint prop_id, const GValue * value, GParamSpec * pspec)
1943 {
1944   GstFlvMux *mux = GST_FLV_MUX (object);
1945
1946   switch (prop_id) {
1947     case PROP_STREAMABLE:
1948       mux->streamable = g_value_get_boolean (value);
1949       if (mux->streamable)
1950         gst_tag_setter_set_tag_merge_mode (GST_TAG_SETTER (mux),
1951             GST_TAG_MERGE_REPLACE);
1952       else
1953         gst_tag_setter_set_tag_merge_mode (GST_TAG_SETTER (mux),
1954             GST_TAG_MERGE_KEEP);
1955       break;
1956     case PROP_METADATACREATOR:
1957       g_free (mux->metadatacreator);
1958       if (!g_value_get_string (value)) {
1959         GST_WARNING_OBJECT (mux, "metadatacreator property can not be NULL");
1960         mux->metadatacreator = g_strdup (DEFAULT_METADATACREATOR);
1961       } else {
1962         mux->metadatacreator = g_value_dup_string (value);
1963       }
1964       break;
1965     case PROP_ENCODER:
1966       g_free (mux->encoder);
1967       if (!g_value_get_string (value)) {
1968         GST_WARNING_OBJECT (mux, "encoder property can not be NULL");
1969         mux->encoder = g_strdup (DEFAULT_METADATACREATOR);
1970       } else {
1971         mux->encoder = g_value_dup_string (value);
1972       }
1973       break;
1974     default:
1975       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1976       break;
1977   }
1978 }
1979
1980 static GstClockTime
1981 gst_flv_mux_get_next_time (GstAggregator * aggregator)
1982 {
1983   GstFlvMux *mux = GST_FLV_MUX (aggregator);
1984   GstAggregatorPad *agg_audio_pad = GST_AGGREGATOR_PAD_CAST (mux->audio_pad);
1985   GstAggregatorPad *agg_video_pad = GST_AGGREGATOR_PAD_CAST (mux->video_pad);
1986
1987   GST_OBJECT_LOCK (aggregator);
1988   if (mux->state == GST_FLV_MUX_STATE_HEADER &&
1989       ((mux->audio_pad && mux->audio_pad->codec == G_MAXUINT) ||
1990           (mux->video_pad && mux->video_pad->codec == G_MAXUINT)))
1991     goto wait_for_data;
1992
1993   if (!((agg_audio_pad && gst_aggregator_pad_has_buffer (agg_audio_pad)) ||
1994           (agg_video_pad && gst_aggregator_pad_has_buffer (agg_video_pad))))
1995     goto wait_for_data;
1996   GST_OBJECT_UNLOCK (aggregator);
1997
1998   return gst_aggregator_simple_get_next_time (aggregator);
1999
2000 wait_for_data:
2001   GST_OBJECT_UNLOCK (aggregator);
2002   return GST_CLOCK_TIME_NONE;
2003 }
2004
2005 static GstFlowReturn
2006 gst_flv_mux_update_src_caps (GstAggregator * aggregator,
2007     GstCaps * caps, GstCaps ** ret)
2008 {
2009   GstFlvMux *mux = GST_FLV_MUX (aggregator);
2010
2011   *ret = gst_flv_mux_prepare_src_caps (mux, NULL, NULL, NULL, NULL);
2012
2013   return GST_FLOW_OK;
2014 }